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;
306 :
Stmt(SC), Kind(K), StartLoc(
std::move(StartLoc)),
307 EndLoc(
std::move(EndLoc)) {}
309 template <
typename T,
typename... Params>
311 Stmt *AssociatedStmt,
unsigned NumChildren,
314 C.Allocate(
sizeof(T) + OMPChildren::size(Clauses.size(), AssociatedStmt,
318 auto *
Data = OMPChildren::Create(
reinterpret_cast<T *
>(Mem) + 1, Clauses,
319 AssociatedStmt, NumChildren);
320 auto *Inst =
new (Mem) T(std::forward<Params>(
P)...);
325 template <
typename T,
typename... Params>
327 bool HasAssociatedStmt,
unsigned NumChildren,
330 C.Allocate(
sizeof(T) + OMPChildren::size(NumClauses, HasAssociatedStmt,
334 OMPChildren::CreateEmpty(
reinterpret_cast<T *
>(Mem) + 1, NumClauses,
335 HasAssociatedStmt, NumChildren);
336 auto *Inst =
new (Mem) T(std::forward<Params>(
P)...);
341 template <
typename T>
343 bool HasAssociatedStmt =
false,
344 unsigned NumChildren = 0) {
346 C.Allocate(
sizeof(T) + OMPChildren::size(NumClauses, HasAssociatedStmt,
350 OMPChildren::CreateEmpty(
reinterpret_cast<T *
>(Mem) + 1, NumClauses,
351 HasAssociatedStmt, NumChildren);
352 auto *Inst =
new (Mem) T;
358 PrevMappedDirective = MappedDirective;
364 :
public llvm::iterator_adaptor_base<
365 used_clauses_child_iterator, ArrayRef<OMPClause *>::iterator,
366 std::forward_iterator_tag, Stmt *, ptrdiff_t, Stmt *, Stmt *> {
371 if (ChildI != ChildEnd)
373 while (this->I != End) {
375 if (this->I != End) {
376 ChildI = (*this->I)->used_children().begin();
377 ChildEnd = (*this->I)->used_children().end();
378 if (ChildI != ChildEnd)
388 if (this->I != End) {
389 ChildI = (*this->I)->used_children().begin();
390 ChildEnd = (*this->I)->used_children().end();
399 if (ChildI != ChildEnd)
401 if (this->I != End) {
403 if (this->I != End) {
404 ChildI = (*this->I)->used_children().begin();
405 ChildEnd = (*this->I)->used_children().end();
413 static llvm::iterator_range<used_clauses_child_iterator>
424 template <
typename SpecificClause>
426 :
public llvm::iterator_adaptor_base<
427 specific_clause_iterator<SpecificClause>,
428 ArrayRef<OMPClause *>::const_iterator, std::forward_iterator_tag,
429 const SpecificClause *, ptrdiff_t, const SpecificClause *,
430 const SpecificClause *> {
433 void SkipToNextClause() {
434 while (this->I != End && !isa<SpecificClause>(*this->I))
446 return cast<SpecificClause>(*this->I);
457 template <
typename SpecificClause>
458 static llvm::iterator_range<specific_clause_iterator<SpecificClause>>
465 template <
typename SpecificClause>
466 llvm::iterator_range<specific_clause_iterator<SpecificClause>>
468 return getClausesOfKind<SpecificClause>(
clauses());
476 template <
typename SpecificClause>
478 auto ClausesOfKind = getClausesOfKind<SpecificClause>(Clauses);
480 if (ClausesOfKind.begin() != ClausesOfKind.end()) {
481 assert(std::next(ClausesOfKind.begin()) == ClausesOfKind.end() &&
482 "There are at least 2 clauses of the specified kind");
483 return *ClausesOfKind.begin();
488 template <
typename SpecificClause>
490 return getSingleClause<SpecificClause>(
clauses());
495 template <
typename SpecificClause>
497 auto Clauses = getClausesOfKind<SpecificClause>();
498 return Clauses.begin() != Clauses.end();
539 "Expected directive with the associated statement.");
549 "Expected directive with the associated statement.");
558 "Expected directive with the associated statement.");
572 return S->getStmtClass() >= firstOMPExecutableDirectiveConstant &&
573 S->getStmtClass() <= lastOMPExecutableDirectiveConstant;
611 "Expected directive with the associated statement.");
631 bool HasCancel =
false;
640 llvm::omp::OMPD_parallel, StartLoc, EndLoc) {}
653 void setHasCancel(
bool Has) { HasCancel = Has; }
667 static OMPParallelDirective *
668 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
669 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
677 static OMPParallelDirective *
CreateEmpty(
const ASTContext &
C,
678 unsigned NumClauses, EmptyShell);
833 Cond !=
nullptr &&
Init !=
nullptr &&
Inc !=
nullptr;
868 for (
unsigned I = 0; I < Size; ++I) {
899 bool TryImperfectlyNestedLoops);
901 bool TryImperfectlyNestedLoops) {
903 TryImperfectlyNestedLoops);
911 llvm::function_ref<
bool(
unsigned,
Stmt *)> Callback,
913 OnTransformationCallback);
917 llvm::function_ref<
bool(
unsigned,
const Stmt *)> Callback,
919 OnTransformationCallback) {
920 auto &&NewCallback = [Callback](
unsigned Cnt,
Stmt *CurStmt) {
921 return Callback(Cnt, CurStmt);
923 auto &&NewTransformCb =
925 OnTransformationCallback(A);
928 NumLoops, NewCallback, NewTransformCb);
936 llvm::function_ref<
bool(
unsigned,
Stmt *)> Callback) {
938 return doForAllLoops(CurStmt, TryImperfectlyNestedLoops, NumLoops, Callback,
944 llvm::function_ref<
bool(
unsigned,
const Stmt *)> Callback) {
945 auto &&NewCallback = [Callback](
unsigned Cnt,
const Stmt *CurStmt) {
946 return Callback(Cnt, CurStmt);
949 NumLoops, NewCallback);
955 Stmt *CurStmt,
bool TryImperfectlyNestedLoops,
unsigned NumLoops,
956 llvm::function_ref<
void(
unsigned,
Stmt *,
Stmt *)> Callback);
958 const Stmt *CurStmt,
bool TryImperfectlyNestedLoops,
unsigned NumLoops,
959 llvm::function_ref<
void(
unsigned,
const Stmt *,
const Stmt *)> Callback) {
960 auto &&NewCallback = [Callback](
unsigned Cnt,
Stmt *
Loop,
Stmt *Body) {
961 Callback(Cnt,
Loop, Body);
964 NumLoops, NewCallback);
968 if (
auto *D = dyn_cast<OMPExecutableDirective>(T))
979 unsigned NumGeneratedLoops = 0;
1038 IterationVariableOffset = 0,
1039 LastIterationOffset = 1,
1040 CalcLastIterationOffset = 2,
1041 PreConditionOffset = 3,
1052 IsLastIterVariableOffset = 8,
1053 LowerBoundVariableOffset = 9,
1054 UpperBoundVariableOffset = 10,
1055 StrideVariableOffset = 11,
1056 EnsureUpperBoundOffset = 12,
1057 NextLowerBoundOffset = 13,
1058 NextUpperBoundOffset = 14,
1059 NumIterationsOffset = 15,
1061 WorksharingEnd = 16,
1062 PrevLowerBoundVariableOffset = 16,
1063 PrevUpperBoundVariableOffset = 17,
1065 PrevEnsureUpperBoundOffset = 19,
1066 CombinedLowerBoundVariableOffset = 20,
1067 CombinedUpperBoundVariableOffset = 21,
1068 CombinedEnsureUpperBoundOffset = 22,
1069 CombinedInitOffset = 23,
1070 CombinedConditionOffset = 24,
1071 CombinedNextLowerBoundOffset = 25,
1072 CombinedNextUpperBoundOffset = 26,
1073 CombinedDistConditionOffset = 27,
1074 CombinedParForInDistConditionOffset = 28,
1078 CombinedDistributeEnd = 29,
1083 auto **Storage =
reinterpret_cast<Expr **
>(
1089 MutableArrayRef<Expr *> getPrivateCounters() {
1090 auto **Storage =
reinterpret_cast<Expr **
>(
1097 MutableArrayRef<Expr *> getInits() {
1098 auto **Storage =
reinterpret_cast<Expr **
>(
1105 MutableArrayRef<Expr *> getUpdates() {
1106 auto **Storage =
reinterpret_cast<Expr **
>(
1113 MutableArrayRef<Expr *> getFinals() {
1114 auto **Storage =
reinterpret_cast<Expr **
>(
1121 MutableArrayRef<Expr *> getDependentCounters() {
1122 auto **Storage =
reinterpret_cast<Expr **
>(
1129 MutableArrayRef<Expr *> getDependentInits() {
1130 auto **Storage =
reinterpret_cast<Expr **
>(
1137 MutableArrayRef<Expr *> getFinalsConditions() {
1138 auto **Storage =
reinterpret_cast<Expr **
>(
1155 unsigned CollapsedNum)
1161 return CombinedDistributeEnd;
1164 return WorksharingEnd;
1198 "expected worksharing loop directive");
1206 "expected worksharing loop directive");
1214 "expected worksharing loop directive");
1222 "expected worksharing loop directive");
1230 "expected worksharing loop directive");
1238 "expected worksharing loop directive");
1246 "expected worksharing loop directive");
1254 "expected worksharing loop 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 sharing directive");
1304 "expected loop bound sharing directive");
1309 "expected loop bound sharing directive");
1314 "expected loop bound distribute sharing directive");
1319 "expected loop bound distribute sharing directive");
1321 CombParForInDistCond;
1357 "expected worksharing loop directive");
1365 "expected worksharing loop directive");
1373 "expected worksharing loop directive");
1381 "expected worksharing loop directive");
1389 "expected worksharing loop directive");
1397 "expected worksharing loop directive");
1405 "expected worksharing loop directive");
1413 "expected worksharing loop directive");
1418 "expected loop bound sharing directive");
1423 "expected loop bound sharing directive");
1428 "expected loop bound sharing directive");
1433 "expected loop bound sharing directive");
1438 "expected loop bound sharing directive");
1439 return cast<Expr>(
Data->
getChildren()[CombinedLowerBoundVariableOffset]);
1443 "expected loop bound sharing directive");
1444 return cast<Expr>(
Data->
getChildren()[CombinedUpperBoundVariableOffset]);
1448 "expected loop bound sharing directive");
1449 return cast<Expr>(
Data->
getChildren()[CombinedEnsureUpperBoundOffset]);
1453 "expected loop bound sharing directive");
1458 "expected loop bound sharing directive");
1463 "expected loop bound sharing directive");
1468 "expected loop bound sharing directive");
1473 "expected loop bound distribute sharing directive");
1478 "expected loop bound distribute sharing directive");
1479 return cast<Expr>(
Data->
getChildren()[CombinedParForInDistConditionOffset]);
1539 T->
getStmtClass() == OMPParallelForSimdDirectiveClass ||
1542 T->
getStmtClass() == OMPMaskedTaskLoopDirectiveClass ||
1543 T->
getStmtClass() == OMPMaskedTaskLoopSimdDirectiveClass ||
1544 T->
getStmtClass() == OMPMasterTaskLoopDirectiveClass ||
1545 T->
getStmtClass() == OMPMasterTaskLoopSimdDirectiveClass ||
1547 T->
getStmtClass() == OMPTeamsGenericLoopDirectiveClass ||
1548 T->
getStmtClass() == OMPTargetTeamsGenericLoopDirectiveClass ||
1549 T->
getStmtClass() == OMPParallelGenericLoopDirectiveClass ||
1550 T->
getStmtClass() == OMPTargetParallelGenericLoopDirectiveClass ||
1551 T->
getStmtClass() == OMPParallelMaskedTaskLoopDirectiveClass ||
1552 T->
getStmtClass() == OMPParallelMaskedTaskLoopSimdDirectiveClass ||
1553 T->
getStmtClass() == OMPParallelMasterTaskLoopDirectiveClass ||
1554 T->
getStmtClass() == OMPParallelMasterTaskLoopSimdDirectiveClass ||
1556 T->
getStmtClass() == OMPTargetParallelForDirectiveClass ||
1557 T->
getStmtClass() == OMPDistributeParallelForDirectiveClass ||
1558 T->
getStmtClass() == OMPDistributeParallelForSimdDirectiveClass ||
1559 T->
getStmtClass() == OMPDistributeSimdDirectiveClass ||
1560 T->
getStmtClass() == OMPTargetParallelForSimdDirectiveClass ||
1562 T->
getStmtClass() == OMPTeamsDistributeDirectiveClass ||
1563 T->
getStmtClass() == OMPTeamsDistributeSimdDirectiveClass ||
1565 OMPTeamsDistributeParallelForSimdDirectiveClass ||
1566 T->
getStmtClass() == OMPTeamsDistributeParallelForDirectiveClass ||
1568 OMPTargetTeamsDistributeParallelForDirectiveClass ||
1570 OMPTargetTeamsDistributeParallelForSimdDirectiveClass ||
1571 T->
getStmtClass() == OMPTargetTeamsDistributeDirectiveClass ||
1572 T->
getStmtClass() == OMPTargetTeamsDistributeSimdDirectiveClass;
1595 unsigned CollapsedNum)
1597 EndLoc, CollapsedNum) {}
1618 static OMPSimdDirective *
Create(
const ASTContext &
C, SourceLocation StartLoc,
1619 SourceLocation EndLoc,
unsigned CollapsedNum,
1620 ArrayRef<OMPClause *> Clauses,
1621 Stmt *AssociatedStmt,
1622 const HelperExprs &Exprs,
1632 static OMPSimdDirective *
CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
1633 unsigned CollapsedNum, EmptyShell);
1653 bool HasCancel =
false;
1662 unsigned CollapsedNum)
1664 EndLoc, CollapsedNum) {}
1675 void setTaskReductionRefExpr(Expr *E) {
1677 llvm::omp::OMPD_for)] = E;
1681 void setHasCancel(
bool Has) { HasCancel = Has; }
1697 static OMPForDirective *
Create(
const ASTContext &
C, SourceLocation StartLoc,
1698 SourceLocation EndLoc,
unsigned CollapsedNum,
1699 ArrayRef<OMPClause *> Clauses,
1700 Stmt *AssociatedStmt,
const HelperExprs &Exprs,
1701 Expr *TaskRedRef,
bool HasCancel,
1711 static OMPForDirective *
CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
1712 unsigned CollapsedNum, EmptyShell);
1750 unsigned CollapsedNum)
1752 StartLoc, EndLoc, CollapsedNum) {}
1773 static OMPForSimdDirective *
1774 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
1775 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
1776 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
1785 static OMPForSimdDirective *
CreateEmpty(
const ASTContext &
C,
1786 unsigned NumClauses,
1787 unsigned CollapsedNum, EmptyShell);
1808 bool HasCancel =
false;
1817 llvm::omp::OMPD_sections, StartLoc, EndLoc) {}
1830 void setHasCancel(
bool Has) { HasCancel = Has; }
1844 static OMPSectionsDirective *
1845 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
1846 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
1855 static OMPSectionsDirective *
CreateEmpty(
const ASTContext &
C,
1856 unsigned NumClauses, EmptyShell);
1885 bool HasCancel =
false;
1894 llvm::omp::OMPD_section, StartLoc, EndLoc) {}
1912 static OMPSectionDirective *
Create(
const ASTContext &
C,
1913 SourceLocation StartLoc,
1914 SourceLocation EndLoc,
1915 Stmt *AssociatedStmt,
bool HasCancel);
1921 static OMPSectionDirective *
CreateEmpty(
const ASTContext &
C, EmptyShell);
1952 StartLoc, EndLoc) {}
1968 static OMPScopeDirective *
Create(
const ASTContext &
C, SourceLocation StartLoc,
1969 SourceLocation EndLoc,
1970 ArrayRef<OMPClause *> Clauses,
1971 Stmt *AssociatedStmt);
1977 static OMPScopeDirective *
CreateEmpty(
const ASTContext &
C,
1978 unsigned NumClauses, EmptyShell);
2003 StartLoc, EndLoc) {}
2020 static OMPSingleDirective *
2021 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2022 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
2030 static OMPSingleDirective *
CreateEmpty(
const ASTContext &
C,
2031 unsigned NumClauses, EmptyShell);
2054 StartLoc, EndLoc) {}
2070 static OMPMasterDirective *
Create(
const ASTContext &
C,
2071 SourceLocation StartLoc,
2072 SourceLocation EndLoc,
2073 Stmt *AssociatedStmt);
2079 static OMPMasterDirective *
CreateEmpty(
const ASTContext &
C, EmptyShell);
2106 llvm::omp::OMPD_critical, StartLoc, EndLoc),
2120 void setDirectiveName(
const DeclarationNameInfo &Name) { DirName = Name; }
2132 static OMPCriticalDirective *
2133 Create(
const ASTContext &
C,
const DeclarationNameInfo &Name,
2134 SourceLocation StartLoc, SourceLocation EndLoc,
2135 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
2142 static OMPCriticalDirective *
CreateEmpty(
const ASTContext &
C,
2143 unsigned NumClauses, EmptyShell);
2168 bool HasCancel =
false;
2177 unsigned CollapsedNum)
2179 llvm::omp::OMPD_parallel_for, StartLoc, EndLoc,
2192 void setTaskReductionRefExpr(Expr *E) {
2194 llvm::omp::OMPD_parallel_for)] = E;
2198 void setHasCancel(
bool Has) { HasCancel = Has; }
2214 static OMPParallelForDirective *
2215 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2216 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
2217 Stmt *AssociatedStmt,
const HelperExprs &Exprs, Expr *TaskRedRef,
2227 static OMPParallelForDirective *
CreateEmpty(
const ASTContext &
C,
2228 unsigned NumClauses,
2229 unsigned CollapsedNum,
2246 return T->
getStmtClass() == OMPParallelForDirectiveClass;
2270 unsigned CollapsedNum)
2272 llvm::omp::OMPD_parallel_for_simd, StartLoc, EndLoc,
2295 static OMPParallelForSimdDirective *
2296 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2297 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
2298 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
2307 static OMPParallelForSimdDirective *
CreateEmpty(
const ASTContext &
C,
2308 unsigned NumClauses,
2309 unsigned CollapsedNum,
2313 return T->
getStmtClass() == OMPParallelForSimdDirectiveClass;
2331 llvm::omp::OMPD_parallel_master, StartLoc,
2336 llvm::omp::OMPD_parallel_master,
2353 static OMPParallelMasterDirective *
2354 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2355 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef);
2363 static OMPParallelMasterDirective *
2364 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses, EmptyShell);
2376 return T->
getStmtClass() == OMPParallelMasterDirectiveClass;
2394 llvm::omp::OMPD_parallel_masked, StartLoc,
2399 llvm::omp::OMPD_parallel_masked,
2416 static OMPParallelMaskedDirective *
2417 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2418 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef);
2426 static OMPParallelMaskedDirective *
2427 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses, EmptyShell);
2439 return T->
getStmtClass() == OMPParallelMaskedDirectiveClass;
2457 bool HasCancel =
false;
2466 llvm::omp::OMPD_parallel_sections, StartLoc,
2473 llvm::omp::OMPD_parallel_sections,
2480 void setHasCancel(
bool Has) { HasCancel = Has; }
2494 static OMPParallelSectionsDirective *
2495 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2496 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
2505 static OMPParallelSectionsDirective *
2506 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses, EmptyShell);
2521 return T->
getStmtClass() == OMPParallelSectionsDirectiveClass;
2537 bool HasCancel =
false;
2546 StartLoc, EndLoc) {}
2555 void setHasCancel(
bool Has) { HasCancel = Has; }
2567 static OMPTaskDirective *
Create(
const ASTContext &
C, SourceLocation StartLoc,
2568 SourceLocation EndLoc,
2569 ArrayRef<OMPClause *> Clauses,
2570 Stmt *AssociatedStmt,
bool HasCancel);
2578 static OMPTaskDirective *
CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
2605 llvm::omp::OMPD_taskyield, StartLoc, EndLoc) {}
2621 static OMPTaskyieldDirective *
2622 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc);
2628 static OMPTaskyieldDirective *
CreateEmpty(
const ASTContext &
C, EmptyShell);
2631 return T->
getStmtClass() == OMPTaskyieldDirectiveClass;
2651 llvm::omp::OMPD_barrier, StartLoc, EndLoc) {}
2667 static OMPBarrierDirective *
2668 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc);
2674 static OMPBarrierDirective *
CreateEmpty(
const ASTContext &
C, EmptyShell);
2697 llvm::omp::OMPD_taskwait, StartLoc, EndLoc) {}
2714 static OMPTaskwaitDirective *
Create(
const ASTContext &
C,
2715 SourceLocation StartLoc,
2716 SourceLocation EndLoc,
2717 ArrayRef<OMPClause *> Clauses);
2724 static OMPTaskwaitDirective *
CreateEmpty(
const ASTContext &
C,
2725 unsigned NumClauses, EmptyShell);
2748 llvm::omp::OMPD_taskgroup, StartLoc, EndLoc) {}
2770 static OMPTaskgroupDirective *
2771 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2772 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2773 Expr *ReductionRef);
2780 static OMPTaskgroupDirective *
CreateEmpty(
const ASTContext &
C,
2781 unsigned NumClauses, EmptyShell);
2791 return T->
getStmtClass() == OMPTaskgroupDirectiveClass;
2815 StartLoc, EndLoc) {}
2832 static OMPFlushDirective *
Create(
const ASTContext &
C, SourceLocation StartLoc,
2833 SourceLocation EndLoc,
2834 ArrayRef<OMPClause *> Clauses);
2842 static OMPFlushDirective *
CreateEmpty(
const ASTContext &
C,
2843 unsigned NumClauses, EmptyShell);
2868 StartLoc, EndLoc) {}
2884 static OMPDepobjDirective *
Create(
const ASTContext &
C,
2885 SourceLocation StartLoc,
2886 SourceLocation EndLoc,
2887 ArrayRef<OMPClause *> Clauses);
2895 static OMPDepobjDirective *
CreateEmpty(
const ASTContext &
C,
2896 unsigned NumClauses, EmptyShell);
2919 llvm::omp::OMPD_ordered, StartLoc, EndLoc) {}
2937 static OMPOrderedDirective *
2938 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2939 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
2947 static OMPOrderedDirective *
CreateEmpty(
const ASTContext &
C,
2948 unsigned NumClauses,
2949 bool IsStandalone, EmptyShell);
2977 uint8_t IsXLHSInRHSPart : 1;
2986 uint8_t IsPostfixUpdate : 1;
2989 uint8_t IsFailOnly : 1;
2999 StartLoc, EndLoc) {}
3003 explicit OMPAtomicDirective()
3005 SourceLocation(), SourceLocation()) {}
3007 enum DataPositionTy :
size_t {
3022 void setUpdateExpr(Expr *UE) {
3028 void setR(Expr *R) {
Data->
getChildren()[DataPositionTy::POS_R] = R; }
3030 void setExpr(Expr *E) {
Data->
getChildren()[DataPositionTy::POS_E] = E; }
3032 void setD(Expr *D) {
Data->
getChildren()[DataPositionTy::POS_D] = D; }
3090 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_X]);
3093 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_X]);
3099 return cast_or_null<Expr>(
3103 return cast_or_null<Expr>(
3118 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_V]);
3121 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_V]);
3125 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_R]);
3128 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_R]);
3132 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_E]);
3135 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_E]);
3139 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_D]);
3142 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_D]);
3146 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_Cond]);
3149 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_Cond]);
3175 StartLoc, EndLoc) {}
3192 static OMPTargetDirective *
3193 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3194 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
3202 static OMPTargetDirective *
CreateEmpty(
const ASTContext &
C,
3203 unsigned NumClauses, EmptyShell);
3229 llvm::omp::OMPD_target_data, StartLoc, EndLoc) {}
3247 static OMPTargetDataDirective *
3248 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3249 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
3256 static OMPTargetDataDirective *
CreateEmpty(
const ASTContext &
C,
unsigned N,
3260 return T->
getStmtClass() == OMPTargetDataDirectiveClass;
3283 llvm::omp::OMPD_target_enter_data, StartLoc,
3290 llvm::omp::OMPD_target_enter_data,
3302 static OMPTargetEnterDataDirective *
3303 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3304 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
3311 static OMPTargetEnterDataDirective *
CreateEmpty(
const ASTContext &
C,
3312 unsigned N, EmptyShell);
3315 return T->
getStmtClass() == OMPTargetEnterDataDirectiveClass;
3338 llvm::omp::OMPD_target_exit_data, StartLoc,
3345 llvm::omp::OMPD_target_exit_data,
3357 static OMPTargetExitDataDirective *
3358 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3359 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
3366 static OMPTargetExitDataDirective *
CreateEmpty(
const ASTContext &
C,
3367 unsigned N, EmptyShell);
3370 return T->
getStmtClass() == OMPTargetExitDataDirectiveClass;
3386 bool HasCancel =
false;
3395 llvm::omp::OMPD_target_parallel, StartLoc,
3402 llvm::omp::OMPD_target_parallel,
3408 void setHasCancel(
bool Has) { HasCancel = Has; }
3422 static OMPTargetParallelDirective *
3423 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3424 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
3433 static OMPTargetParallelDirective *
3434 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses, EmptyShell);
3449 return T->
getStmtClass() == OMPTargetParallelDirectiveClass;
3467 bool HasCancel =
false;
3476 unsigned CollapsedNum)
3478 llvm::omp::OMPD_target_parallel_for, StartLoc, EndLoc,
3491 void setTaskReductionRefExpr(Expr *E) {
3497 void setHasCancel(
bool Has) { HasCancel = Has; }
3513 static OMPTargetParallelForDirective *
3514 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3515 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3516 Stmt *AssociatedStmt,
const HelperExprs &Exprs, Expr *TaskRedRef,
3526 static OMPTargetParallelForDirective *
CreateEmpty(
const ASTContext &
C,
3527 unsigned NumClauses,
3528 unsigned CollapsedNum,
3545 return T->
getStmtClass() == OMPTargetParallelForDirectiveClass;
3567 StartLoc, EndLoc) {}
3584 static OMPTeamsDirective *
Create(
const ASTContext &
C, SourceLocation StartLoc,
3585 SourceLocation EndLoc,
3586 ArrayRef<OMPClause *> Clauses,
3587 Stmt *AssociatedStmt);
3595 static OMPTeamsDirective *
CreateEmpty(
const ASTContext &
C,
3596 unsigned NumClauses, EmptyShell);
3622 llvm::omp::OMPD_cancellation_point, StartLoc,
3628 llvm::omp::OMPD_cancellation_point,
3642 static OMPCancellationPointDirective *
3643 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3650 static OMPCancellationPointDirective *
CreateEmpty(
const ASTContext &
C,
3657 return T->
getStmtClass() == OMPCancellationPointDirectiveClass;
3679 StartLoc, EndLoc) {}
3699 static OMPCancelDirective *
3700 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3708 static OMPCancelDirective *
CreateEmpty(
const ASTContext &
C,
3709 unsigned NumClauses, EmptyShell);
3732 bool HasCancel =
false;
3741 unsigned CollapsedNum)
3743 StartLoc, EndLoc, CollapsedNum) {}
3754 void setHasCancel(
bool Has) { HasCancel = Has; }
3768 static OMPTaskLoopDirective *
3769 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3770 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3771 Stmt *AssociatedStmt,
const HelperExprs &Exprs,
bool HasCancel);
3780 static OMPTaskLoopDirective *
CreateEmpty(
const ASTContext &
C,
3781 unsigned NumClauses,
3782 unsigned CollapsedNum, EmptyShell);
3811 unsigned CollapsedNum)
3813 llvm::omp::OMPD_taskloop_simd, StartLoc, EndLoc,
3836 static OMPTaskLoopSimdDirective *
3837 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3838 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3839 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
3848 static OMPTaskLoopSimdDirective *
CreateEmpty(
const ASTContext &
C,
3849 unsigned NumClauses,
3850 unsigned CollapsedNum,
3854 return T->
getStmtClass() == OMPTaskLoopSimdDirectiveClass;
3871 bool HasCancel =
false;
3880 unsigned CollapsedNum)
3882 llvm::omp::OMPD_master_taskloop, StartLoc, EndLoc,
3895 void setHasCancel(
bool Has) { HasCancel = Has; }
3909 static OMPMasterTaskLoopDirective *
3910 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3911 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3912 Stmt *AssociatedStmt,
const HelperExprs &Exprs,
bool HasCancel);
3921 static OMPMasterTaskLoopDirective *
CreateEmpty(
const ASTContext &
C,
3922 unsigned NumClauses,
3923 unsigned CollapsedNum,
3930 return T->
getStmtClass() == OMPMasterTaskLoopDirectiveClass;
3947 bool HasCancel =
false;
3956 unsigned CollapsedNum)
3958 llvm::omp::OMPD_masked_taskloop, StartLoc, EndLoc,
3971 void setHasCancel(
bool Has) { HasCancel = Has; }
3985 static OMPMaskedTaskLoopDirective *
3986 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3987 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3988 Stmt *AssociatedStmt,
const HelperExprs &Exprs,
bool HasCancel);
3997 static OMPMaskedTaskLoopDirective *
CreateEmpty(
const ASTContext &
C,
3998 unsigned NumClauses,
3999 unsigned CollapsedNum,
4006 return T->
getStmtClass() == OMPMaskedTaskLoopDirectiveClass;
4029 unsigned CollapsedNum)
4031 llvm::omp::OMPD_master_taskloop_simd, StartLoc, EndLoc,
4054 static OMPMasterTaskLoopSimdDirective *
4055 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4056 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4057 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4065 static OMPMasterTaskLoopSimdDirective *
CreateEmpty(
const ASTContext &
C,
4066 unsigned NumClauses,
4067 unsigned CollapsedNum,
4071 return T->
getStmtClass() == OMPMasterTaskLoopSimdDirectiveClass;
4094 unsigned CollapsedNum)
4096 llvm::omp::OMPD_masked_taskloop_simd, StartLoc, EndLoc,
4119 static OMPMaskedTaskLoopSimdDirective *
4120 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4121 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4122 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4130 static OMPMaskedTaskLoopSimdDirective *
CreateEmpty(
const ASTContext &
C,
4131 unsigned NumClauses,
4132 unsigned CollapsedNum,
4136 return T->
getStmtClass() == OMPMaskedTaskLoopSimdDirectiveClass;
4154 bool HasCancel =
false;
4164 unsigned CollapsedNum)
4166 llvm::omp::OMPD_parallel_master_taskloop, StartLoc,
4167 EndLoc, CollapsedNum) {}
4175 llvm::omp::OMPD_parallel_master_taskloop,
4179 void setHasCancel(
bool Has) { HasCancel = Has; }
4193 static OMPParallelMasterTaskLoopDirective *
4194 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4195 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4196 Stmt *AssociatedStmt,
const HelperExprs &Exprs,
bool HasCancel);
4205 static OMPParallelMasterTaskLoopDirective *
CreateEmpty(
const ASTContext &
C,
4206 unsigned NumClauses,
4207 unsigned CollapsedNum,
4214 return T->
getStmtClass() == OMPParallelMasterTaskLoopDirectiveClass;
4232 bool HasCancel =
false;
4242 unsigned CollapsedNum)
4244 llvm::omp::OMPD_parallel_masked_taskloop, StartLoc,
4245 EndLoc, CollapsedNum) {}
4253 llvm::omp::OMPD_parallel_masked_taskloop,
4257 void setHasCancel(
bool Has) { HasCancel = Has; }
4271 static OMPParallelMaskedTaskLoopDirective *
4272 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4273 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4274 Stmt *AssociatedStmt,
const HelperExprs &Exprs,
bool HasCancel);
4283 static OMPParallelMaskedTaskLoopDirective *
CreateEmpty(
const ASTContext &
C,
4284 unsigned NumClauses,
4285 unsigned CollapsedNum,
4292 return T->
getStmtClass() == OMPParallelMaskedTaskLoopDirectiveClass;
4317 unsigned CollapsedNum)
4319 llvm::omp::OMPD_parallel_master_taskloop_simd,
4320 StartLoc, EndLoc, CollapsedNum) {}
4328 llvm::omp::OMPD_parallel_master_taskloop_simd,
4342 static OMPParallelMasterTaskLoopSimdDirective *
4343 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4344 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4345 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4354 static OMPParallelMasterTaskLoopSimdDirective *
4355 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
unsigned CollapsedNum,
4359 return T->
getStmtClass() == OMPParallelMasterTaskLoopSimdDirectiveClass;
4384 unsigned CollapsedNum)
4386 llvm::omp::OMPD_parallel_masked_taskloop_simd,
4387 StartLoc, EndLoc, CollapsedNum) {}
4395 llvm::omp::OMPD_parallel_masked_taskloop_simd,
4409 static OMPParallelMaskedTaskLoopSimdDirective *
4410 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4411 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4412 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4421 static OMPParallelMaskedTaskLoopSimdDirective *
4422 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
unsigned CollapsedNum,
4426 return T->
getStmtClass() == OMPParallelMaskedTaskLoopSimdDirectiveClass;
4449 unsigned CollapsedNum)
4451 llvm::omp::OMPD_distribute, StartLoc, EndLoc,
4474 static OMPDistributeDirective *
4475 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4476 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4477 Stmt *AssociatedStmt,
const HelperExprs &Exprs,
4487 static OMPDistributeDirective *
CreateEmpty(
const ASTContext &
C,
4488 unsigned NumClauses,
4489 unsigned CollapsedNum, EmptyShell);
4492 return T->
getStmtClass() == OMPDistributeDirectiveClass;
4515 llvm::omp::OMPD_target_update, StartLoc,
4534 static OMPTargetUpdateDirective *
4535 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4536 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
4544 static OMPTargetUpdateDirective *
CreateEmpty(
const ASTContext &
C,
4545 unsigned NumClauses, EmptyShell);
4548 return T->
getStmtClass() == OMPTargetUpdateDirectiveClass;
4565 bool HasCancel =
false;
4575 unsigned CollapsedNum)
4577 llvm::omp::OMPD_distribute_parallel_for, StartLoc,
4578 EndLoc, CollapsedNum) {}
4586 llvm::omp::OMPD_distribute_parallel_for,
4590 void setTaskReductionRefExpr(Expr *E) {
4596 void setHasCancel(
bool Has) { HasCancel = Has; }
4612 static OMPDistributeParallelForDirective *
4613 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4614 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4615 Stmt *AssociatedStmt,
const HelperExprs &Exprs, Expr *TaskRedRef,
4625 static OMPDistributeParallelForDirective *
CreateEmpty(
const ASTContext &
C,
4626 unsigned NumClauses,
4627 unsigned CollapsedNum,
4644 return T->
getStmtClass() == OMPDistributeParallelForDirectiveClass;
4669 unsigned CollapsedNum)
4671 llvm::omp::OMPD_distribute_parallel_for_simd, StartLoc,
4672 EndLoc, CollapsedNum) {}
4680 llvm::omp::OMPD_distribute_parallel_for_simd,
4694 static OMPDistributeParallelForSimdDirective *
Create(
4695 const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4696 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4697 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4705 static OMPDistributeParallelForSimdDirective *
CreateEmpty(
4706 const ASTContext &
C,
unsigned NumClauses,
unsigned CollapsedNum,
4710 return T->
getStmtClass() == OMPDistributeParallelForSimdDirectiveClass;
4733 unsigned CollapsedNum)
4735 llvm::omp::OMPD_distribute_simd, StartLoc, EndLoc,
4758 static OMPDistributeSimdDirective *
4759 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4760 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4761 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4769 static OMPDistributeSimdDirective *
CreateEmpty(
const ASTContext &
C,
4770 unsigned NumClauses,
4771 unsigned CollapsedNum,
4775 return T->
getStmtClass() == OMPDistributeSimdDirectiveClass;
4800 unsigned CollapsedNum)
4802 llvm::omp::OMPD_target_parallel_for_simd, StartLoc,
4803 EndLoc, CollapsedNum) {}
4811 llvm::omp::OMPD_target_parallel_for_simd,
4825 static OMPTargetParallelForSimdDirective *
4826 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4827 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4828 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4836 static OMPTargetParallelForSimdDirective *
CreateEmpty(
const ASTContext &
C,
4837 unsigned NumClauses,
4838 unsigned CollapsedNum,
4842 return T->
getStmtClass() == OMPTargetParallelForSimdDirectiveClass;
4866 unsigned CollapsedNum)
4868 llvm::omp::OMPD_target_simd, StartLoc, EndLoc,