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>
410 template <
typename SpecificClause>
412 :
public llvm::iterator_adaptor_base<
413 specific_clause_iterator<SpecificClause>,
414 ArrayRef<OMPClause *>::const_iterator, std::forward_iterator_tag,
415 const SpecificClause *, ptrdiff_t, const SpecificClause *,
416 const SpecificClause *> {
419 void SkipToNextClause() {
420 while (this->I != End && !isa<SpecificClause>(*this->I))
432 return cast<SpecificClause>(*this->I);
443 template <
typename SpecificClause>
444 static llvm::iterator_range<specific_clause_iterator<SpecificClause>>
448 llvm::makeArrayRef(Clauses.end(), 0))};
451 template <
typename SpecificClause>
452 llvm::iterator_range<specific_clause_iterator<SpecificClause>>
454 return getClausesOfKind<SpecificClause>(
clauses());
462 template <
typename SpecificClause>
464 auto ClausesOfKind = getClausesOfKind<SpecificClause>(Clauses);
466 if (ClausesOfKind.begin() != ClausesOfKind.end()) {
467 assert(std::next(ClausesOfKind.begin()) == ClausesOfKind.end() &&
468 "There are at least 2 clauses of the specified kind");
469 return *ClausesOfKind.begin();
474 template <
typename SpecificClause>
476 return getSingleClause<SpecificClause>(
clauses());
481 template <
typename SpecificClause>
483 auto Clauses = getClausesOfKind<SpecificClause>();
484 return Clauses.begin() != Clauses.end();
525 "Expected directive with the associated statement.");
535 "Expected directive with the associated statement.");
544 "Expected directive with the associated statement.");
558 return S->getStmtClass() >= firstOMPExecutableDirectiveConstant &&
559 S->getStmtClass() <= lastOMPExecutableDirectiveConstant;
597 "Expected directive with the associated statement.");
615 bool HasCancel =
false;
624 llvm::omp::OMPD_parallel, StartLoc, EndLoc) {}
637 void setHasCancel(
bool Has) { HasCancel = Has; }
651 static OMPParallelDirective *
652 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
653 ArrayRef<OMPClause *> Clauses,
Stmt *AssociatedStmt, Expr *TaskRedRef,
661 static OMPParallelDirective *
CreateEmpty(
const ASTContext &
C,
662 unsigned NumClauses, EmptyShell);
817 Cond !=
nullptr &&
Init !=
nullptr &&
Inc !=
nullptr;
852 for (
unsigned I = 0; I < Size; ++I) {
883 bool TryImperfectlyNestedLoops);
885 bool TryImperfectlyNestedLoops) {
887 TryImperfectlyNestedLoops);
895 llvm::function_ref<
bool(
unsigned,
Stmt *)> Callback,
897 OnTransformationCallback);
901 llvm::function_ref<
bool(
unsigned,
const Stmt *)> Callback,
903 OnTransformationCallback) {
904 auto &&NewCallback = [Callback](
unsigned Cnt,
Stmt *CurStmt) {
905 return Callback(Cnt, CurStmt);
907 auto &&NewTransformCb =
909 OnTransformationCallback(A);
912 NumLoops, NewCallback, NewTransformCb);
920 llvm::function_ref<
bool(
unsigned,
Stmt *)> Callback) {
922 return doForAllLoops(CurStmt, TryImperfectlyNestedLoops, NumLoops, Callback,
928 llvm::function_ref<
bool(
unsigned,
const Stmt *)> Callback) {
929 auto &&NewCallback = [Callback](
unsigned Cnt,
const Stmt *CurStmt) {
930 return Callback(Cnt, CurStmt);
933 NumLoops, NewCallback);
939 Stmt *CurStmt,
bool TryImperfectlyNestedLoops,
unsigned NumLoops,
940 llvm::function_ref<
void(
unsigned,
Stmt *,
Stmt *)> Callback);
942 const Stmt *CurStmt,
bool TryImperfectlyNestedLoops,
unsigned NumLoops,
943 llvm::function_ref<
void(
unsigned,
const Stmt *,
const Stmt *)> Callback) {
944 auto &&NewCallback = [Callback](
unsigned Cnt,
Stmt *Loop,
Stmt *Body) {
945 Callback(Cnt, Loop, Body);
948 NumLoops, NewCallback);
952 if (
auto *D = dyn_cast<OMPExecutableDirective>(T))
963 unsigned NumGeneratedLoops = 0;
1022 IterationVariableOffset = 0,
1023 LastIterationOffset = 1,
1024 CalcLastIterationOffset = 2,
1025 PreConditionOffset = 3,
1036 IsLastIterVariableOffset = 8,
1037 LowerBoundVariableOffset = 9,
1038 UpperBoundVariableOffset = 10,
1039 StrideVariableOffset = 11,
1040 EnsureUpperBoundOffset = 12,
1041 NextLowerBoundOffset = 13,
1042 NextUpperBoundOffset = 14,
1043 NumIterationsOffset = 15,
1045 WorksharingEnd = 16,
1046 PrevLowerBoundVariableOffset = 16,
1047 PrevUpperBoundVariableOffset = 17,
1049 PrevEnsureUpperBoundOffset = 19,
1050 CombinedLowerBoundVariableOffset = 20,
1051 CombinedUpperBoundVariableOffset = 21,
1052 CombinedEnsureUpperBoundOffset = 22,
1053 CombinedInitOffset = 23,
1054 CombinedConditionOffset = 24,
1055 CombinedNextLowerBoundOffset = 25,
1056 CombinedNextUpperBoundOffset = 26,
1057 CombinedDistConditionOffset = 27,
1058 CombinedParForInDistConditionOffset = 28,
1062 CombinedDistributeEnd = 29,
1067 auto **Storage =
reinterpret_cast<Expr **
>(
1073 MutableArrayRef<Expr *> getPrivateCounters() {
1074 auto **Storage =
reinterpret_cast<Expr **
>(
1081 MutableArrayRef<Expr *> getInits() {
1082 auto **Storage =
reinterpret_cast<Expr **
>(
1089 MutableArrayRef<Expr *> getUpdates() {
1090 auto **Storage =
reinterpret_cast<Expr **
>(
1097 MutableArrayRef<Expr *> getFinals() {
1098 auto **Storage =
reinterpret_cast<Expr **
>(
1105 MutableArrayRef<Expr *> getDependentCounters() {
1106 auto **Storage =
reinterpret_cast<Expr **
>(
1113 MutableArrayRef<Expr *> getDependentInits() {
1114 auto **Storage =
reinterpret_cast<Expr **
>(
1121 MutableArrayRef<Expr *> getFinalsConditions() {
1122 auto **Storage =
reinterpret_cast<Expr **
>(
1139 unsigned CollapsedNum)
1145 return CombinedDistributeEnd;
1148 return WorksharingEnd;
1182 "expected worksharing loop directive");
1190 "expected worksharing loop directive");
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");
1243 "expected loop bound sharing directive");
1248 "expected loop bound sharing directive");
1253 "expected loop bound sharing directive");
1258 "expected loop bound sharing directive");
1263 "expected loop bound sharing directive");
1268 "expected loop bound sharing directive");
1273 "expected loop bound sharing directive");
1278 "expected loop bound sharing directive");
1283 "expected loop bound sharing directive");
1288 "expected loop bound sharing directive");
1293 "expected loop bound sharing directive");
1298 "expected loop bound distribute sharing directive");
1303 "expected loop bound distribute sharing directive");
1305 CombParForInDistCond;
1341 "expected worksharing loop directive");
1349 "expected worksharing loop directive");
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");
1402 "expected loop bound sharing directive");
1407 "expected loop bound sharing directive");
1412 "expected loop bound sharing directive");
1417 "expected loop bound sharing directive");
1422 "expected loop bound sharing directive");
1423 return cast<Expr>(
Data->
getChildren()[CombinedLowerBoundVariableOffset]);
1427 "expected loop bound sharing directive");
1428 return cast<Expr>(
Data->
getChildren()[CombinedUpperBoundVariableOffset]);
1432 "expected loop bound sharing directive");
1433 return cast<Expr>(
Data->
getChildren()[CombinedEnsureUpperBoundOffset]);
1437 "expected loop bound sharing directive");
1442 "expected loop bound sharing directive");
1447 "expected loop bound sharing directive");
1452 "expected loop bound sharing directive");
1457 "expected loop bound distribute sharing directive");
1462 "expected loop bound distribute sharing directive");
1463 return cast<Expr>(
Data->
getChildren()[CombinedParForInDistConditionOffset]);
1523 T->
getStmtClass() == OMPParallelForSimdDirectiveClass ||
1526 T->
getStmtClass() == OMPMasterTaskLoopDirectiveClass ||
1527 T->
getStmtClass() == OMPMasterTaskLoopSimdDirectiveClass ||
1529 T->
getStmtClass() == OMPTeamsGenericLoopDirectiveClass ||
1530 T->
getStmtClass() == OMPTargetTeamsGenericLoopDirectiveClass ||
1531 T->
getStmtClass() == OMPParallelGenericLoopDirectiveClass ||
1532 T->
getStmtClass() == OMPTargetParallelGenericLoopDirectiveClass ||
1533 T->
getStmtClass() == OMPParallelMasterTaskLoopDirectiveClass ||
1534 T->
getStmtClass() == OMPParallelMasterTaskLoopSimdDirectiveClass ||
1536 T->
getStmtClass() == OMPTargetParallelForDirectiveClass ||
1537 T->
getStmtClass() == OMPDistributeParallelForDirectiveClass ||
1538 T->
getStmtClass() == OMPDistributeParallelForSimdDirectiveClass ||
1539 T->
getStmtClass() == OMPDistributeSimdDirectiveClass ||
1540 T->
getStmtClass() == OMPTargetParallelForSimdDirectiveClass ||
1542 T->
getStmtClass() == OMPTeamsDistributeDirectiveClass ||
1543 T->
getStmtClass() == OMPTeamsDistributeSimdDirectiveClass ||
1545 OMPTeamsDistributeParallelForSimdDirectiveClass ||
1546 T->
getStmtClass() == OMPTeamsDistributeParallelForDirectiveClass ||
1548 OMPTargetTeamsDistributeParallelForDirectiveClass ||
1550 OMPTargetTeamsDistributeParallelForSimdDirectiveClass ||
1551 T->
getStmtClass() == OMPTargetTeamsDistributeDirectiveClass ||
1552 T->
getStmtClass() == OMPTargetTeamsDistributeSimdDirectiveClass;
1575 unsigned CollapsedNum)
1577 EndLoc, CollapsedNum) {}
1598 static OMPSimdDirective *
Create(
const ASTContext &
C, SourceLocation StartLoc,
1599 SourceLocation EndLoc,
unsigned CollapsedNum,
1600 ArrayRef<OMPClause *> Clauses,
1601 Stmt *AssociatedStmt,
1602 const HelperExprs &Exprs);
1611 static OMPSimdDirective *
CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
1612 unsigned CollapsedNum, EmptyShell);
1632 bool HasCancel =
false;
1641 unsigned CollapsedNum)
1643 EndLoc, CollapsedNum) {}
1654 void setTaskReductionRefExpr(Expr *E) {
1656 llvm::omp::OMPD_for)] = E;
1660 void setHasCancel(
bool Has) { HasCancel = Has; }
1676 static OMPForDirective *
Create(
const ASTContext &
C, SourceLocation StartLoc,
1677 SourceLocation EndLoc,
unsigned CollapsedNum,
1678 ArrayRef<OMPClause *> Clauses,
1679 Stmt *AssociatedStmt,
const HelperExprs &Exprs,
1680 Expr *TaskRedRef,
bool HasCancel);
1689 static OMPForDirective *
CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
1690 unsigned CollapsedNum, EmptyShell);
1728 unsigned CollapsedNum)
1730 StartLoc, EndLoc, CollapsedNum) {}
1751 static OMPForSimdDirective *
1752 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
1753 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
1754 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
1763 static OMPForSimdDirective *
CreateEmpty(
const ASTContext &
C,
1764 unsigned NumClauses,
1765 unsigned CollapsedNum, EmptyShell);
1786 bool HasCancel =
false;
1795 llvm::omp::OMPD_sections, StartLoc, EndLoc) {}
1808 void setHasCancel(
bool Has) { HasCancel = Has; }
1822 static OMPSectionsDirective *
1823 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
1824 ArrayRef<OMPClause *> Clauses,
Stmt *AssociatedStmt, Expr *TaskRedRef,
1833 static OMPSectionsDirective *
CreateEmpty(
const ASTContext &
C,
1834 unsigned NumClauses, EmptyShell);
1863 bool HasCancel =
false;
1872 llvm::omp::OMPD_section, StartLoc, EndLoc) {}
1890 static OMPSectionDirective *
Create(
const ASTContext &
C,
1891 SourceLocation StartLoc,
1892 SourceLocation EndLoc,
1893 Stmt *AssociatedStmt,
bool HasCancel);
1899 static OMPSectionDirective *
CreateEmpty(
const ASTContext &
C, EmptyShell);
1930 StartLoc, EndLoc) {}
1947 static OMPSingleDirective *
1948 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
1949 ArrayRef<OMPClause *> Clauses,
Stmt *AssociatedStmt);
1957 static OMPSingleDirective *
CreateEmpty(
const ASTContext &
C,
1958 unsigned NumClauses, EmptyShell);
1981 StartLoc, EndLoc) {}
1997 static OMPMasterDirective *
Create(
const ASTContext &
C,
1998 SourceLocation StartLoc,
1999 SourceLocation EndLoc,
2000 Stmt *AssociatedStmt);
2006 static OMPMasterDirective *
CreateEmpty(
const ASTContext &
C, EmptyShell);
2033 llvm::omp::OMPD_critical, StartLoc, EndLoc),
2047 void setDirectiveName(
const DeclarationNameInfo &Name) { DirName = Name; }
2059 static OMPCriticalDirective *
2060 Create(
const ASTContext &
C,
const DeclarationNameInfo &Name,
2061 SourceLocation StartLoc, SourceLocation EndLoc,
2062 ArrayRef<OMPClause *> Clauses,
Stmt *AssociatedStmt);
2069 static OMPCriticalDirective *
CreateEmpty(
const ASTContext &
C,
2070 unsigned NumClauses, EmptyShell);
2095 bool HasCancel =
false;
2104 unsigned CollapsedNum)
2106 llvm::omp::OMPD_parallel_for, StartLoc, EndLoc,
2119 void setTaskReductionRefExpr(Expr *E) {
2121 llvm::omp::OMPD_parallel_for)] = E;
2125 void setHasCancel(
bool Has) { HasCancel = Has; }
2141 static OMPParallelForDirective *
2142 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2143 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
2144 Stmt *AssociatedStmt,
const HelperExprs &Exprs, Expr *TaskRedRef,
2154 static OMPParallelForDirective *
CreateEmpty(
const ASTContext &
C,
2155 unsigned NumClauses,
2156 unsigned CollapsedNum,
2173 return T->
getStmtClass() == OMPParallelForDirectiveClass;
2197 unsigned CollapsedNum)
2199 llvm::omp::OMPD_parallel_for_simd, StartLoc, EndLoc,
2222 static OMPParallelForSimdDirective *
2223 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2224 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
2225 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
2234 static OMPParallelForSimdDirective *
CreateEmpty(
const ASTContext &
C,
2235 unsigned NumClauses,
2236 unsigned CollapsedNum,
2240 return T->
getStmtClass() == OMPParallelForSimdDirectiveClass;
2258 llvm::omp::OMPD_parallel_master, StartLoc,
2263 llvm::omp::OMPD_parallel_master,
2280 static OMPParallelMasterDirective *
2281 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2282 ArrayRef<OMPClause *> Clauses,
Stmt *AssociatedStmt, Expr *TaskRedRef);
2290 static OMPParallelMasterDirective *
2291 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses, EmptyShell);
2303 return T->
getStmtClass() == OMPParallelMasterDirectiveClass;
2321 bool HasCancel =
false;
2330 llvm::omp::OMPD_parallel_sections, StartLoc,
2337 llvm::omp::OMPD_parallel_sections,
2344 void setHasCancel(
bool Has) { HasCancel = Has; }
2358 static OMPParallelSectionsDirective *
2359 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2360 ArrayRef<OMPClause *> Clauses,
Stmt *AssociatedStmt, Expr *TaskRedRef,
2369 static OMPParallelSectionsDirective *
2370 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses, EmptyShell);
2385 return T->
getStmtClass() == OMPParallelSectionsDirectiveClass;
2401 bool HasCancel =
false;
2410 StartLoc, EndLoc) {}
2419 void setHasCancel(
bool Has) { HasCancel = Has; }
2431 static OMPTaskDirective *
Create(
const ASTContext &
C, SourceLocation StartLoc,
2432 SourceLocation EndLoc,
2433 ArrayRef<OMPClause *> Clauses,
2434 Stmt *AssociatedStmt,
bool HasCancel);
2442 static OMPTaskDirective *
CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
2469 llvm::omp::OMPD_taskyield, StartLoc, EndLoc) {}
2485 static OMPTaskyieldDirective *
2486 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc);
2492 static OMPTaskyieldDirective *
CreateEmpty(
const ASTContext &
C, EmptyShell);
2495 return T->
getStmtClass() == OMPTaskyieldDirectiveClass;
2515 llvm::omp::OMPD_barrier, StartLoc, EndLoc) {}
2531 static OMPBarrierDirective *
2532 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc);
2538 static OMPBarrierDirective *
CreateEmpty(
const ASTContext &
C, EmptyShell);
2561 llvm::omp::OMPD_taskwait, StartLoc, EndLoc) {}
2578 static OMPTaskwaitDirective *
Create(
const ASTContext &
C,
2579 SourceLocation StartLoc,
2580 SourceLocation EndLoc,
2581 ArrayRef<OMPClause *> Clauses);
2588 static OMPTaskwaitDirective *
CreateEmpty(
const ASTContext &
C,
2589 unsigned NumClauses, EmptyShell);
2612 llvm::omp::OMPD_taskgroup, StartLoc, EndLoc) {}
2634 static OMPTaskgroupDirective *
2635 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2636 ArrayRef<OMPClause *> Clauses,
Stmt *AssociatedStmt,
2637 Expr *ReductionRef);
2644 static OMPTaskgroupDirective *
CreateEmpty(
const ASTContext &
C,
2645 unsigned NumClauses, EmptyShell);
2655 return T->
getStmtClass() == OMPTaskgroupDirectiveClass;
2679 StartLoc, EndLoc) {}
2696 static OMPFlushDirective *
Create(
const ASTContext &
C, SourceLocation StartLoc,
2697 SourceLocation EndLoc,
2698 ArrayRef<OMPClause *> Clauses);
2706 static OMPFlushDirective *
CreateEmpty(
const ASTContext &
C,
2707 unsigned NumClauses, EmptyShell);
2732 StartLoc, EndLoc) {}
2748 static OMPDepobjDirective *
Create(
const ASTContext &
C,
2749 SourceLocation StartLoc,
2750 SourceLocation EndLoc,
2751 ArrayRef<OMPClause *> Clauses);
2759 static OMPDepobjDirective *
CreateEmpty(
const ASTContext &
C,
2760 unsigned NumClauses, EmptyShell);
2783 llvm::omp::OMPD_ordered, StartLoc, EndLoc) {}
2801 static OMPOrderedDirective *
2802 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
2803 ArrayRef<OMPClause *> Clauses,
Stmt *AssociatedStmt);
2811 static OMPOrderedDirective *
CreateEmpty(
const ASTContext &
C,
2812 unsigned NumClauses,
2813 bool IsStandalone, EmptyShell);
2841 uint8_t IsXLHSInRHSPart : 1;
2850 uint8_t IsPostfixUpdate : 1;
2860 StartLoc, EndLoc) {}
2864 explicit OMPAtomicDirective()
2866 SourceLocation(), SourceLocation()) {}
2868 enum DataPositionTy :
size_t {
2882 void setUpdateExpr(Expr *UE) {
2888 void setExpr(Expr *E) {
Data->
getChildren()[DataPositionTy::POS_E] = E; }
2890 void setD(Expr *D) {
Data->
getChildren()[DataPositionTy::POS_D] = D; }
2892 void setCond(Expr *C) {
Data->
getChildren()[DataPositionTy::POS_Cond] =
C; }
2943 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_X]);
2946 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_X]);
2952 return cast_or_null<Expr>(
2956 return cast_or_null<Expr>(
2968 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_V]);
2971 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_V]);
2975 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_E]);
2978 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_E]);
2982 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_D]);
2985 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_D]);
2989 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_Cond]);
2992 return cast_or_null<Expr>(
Data->
getChildren()[DataPositionTy::POS_Cond]);
3018 StartLoc, EndLoc) {}
3035 static OMPTargetDirective *
3036 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3037 ArrayRef<OMPClause *> Clauses,
Stmt *AssociatedStmt);
3045 static OMPTargetDirective *
CreateEmpty(
const ASTContext &
C,
3046 unsigned NumClauses, EmptyShell);
3072 llvm::omp::OMPD_target_data, StartLoc, EndLoc) {}
3090 static OMPTargetDataDirective *
3091 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3092 ArrayRef<OMPClause *> Clauses,
Stmt *AssociatedStmt);
3099 static OMPTargetDataDirective *
CreateEmpty(
const ASTContext &
C,
unsigned N,
3103 return T->
getStmtClass() == OMPTargetDataDirectiveClass;
3126 llvm::omp::OMPD_target_enter_data, StartLoc,
3133 llvm::omp::OMPD_target_enter_data,
3145 static OMPTargetEnterDataDirective *
3146 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3147 ArrayRef<OMPClause *> Clauses,
Stmt *AssociatedStmt);
3154 static OMPTargetEnterDataDirective *
CreateEmpty(
const ASTContext &
C,
3155 unsigned N, EmptyShell);
3158 return T->
getStmtClass() == OMPTargetEnterDataDirectiveClass;
3181 llvm::omp::OMPD_target_exit_data, StartLoc,
3188 llvm::omp::OMPD_target_exit_data,
3200 static OMPTargetExitDataDirective *
3201 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3202 ArrayRef<OMPClause *> Clauses,
Stmt *AssociatedStmt);
3209 static OMPTargetExitDataDirective *
CreateEmpty(
const ASTContext &
C,
3210 unsigned N, EmptyShell);
3213 return T->
getStmtClass() == OMPTargetExitDataDirectiveClass;
3229 bool HasCancel =
false;
3238 llvm::omp::OMPD_target_parallel, StartLoc,
3245 llvm::omp::OMPD_target_parallel,
3251 void setHasCancel(
bool Has) { HasCancel = Has; }
3265 static OMPTargetParallelDirective *
3266 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3267 ArrayRef<OMPClause *> Clauses,
Stmt *AssociatedStmt, Expr *TaskRedRef,
3276 static OMPTargetParallelDirective *
3277 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses, EmptyShell);
3292 return T->
getStmtClass() == OMPTargetParallelDirectiveClass;
3310 bool HasCancel =
false;
3319 unsigned CollapsedNum)
3321 llvm::omp::OMPD_target_parallel_for, StartLoc, EndLoc,
3334 void setTaskReductionRefExpr(Expr *E) {
3340 void setHasCancel(
bool Has) { HasCancel = Has; }
3356 static OMPTargetParallelForDirective *
3357 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3358 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3359 Stmt *AssociatedStmt,
const HelperExprs &Exprs, Expr *TaskRedRef,
3369 static OMPTargetParallelForDirective *
CreateEmpty(
const ASTContext &
C,
3370 unsigned NumClauses,
3371 unsigned CollapsedNum,
3388 return T->
getStmtClass() == OMPTargetParallelForDirectiveClass;
3410 StartLoc, EndLoc) {}
3427 static OMPTeamsDirective *
Create(
const ASTContext &
C, SourceLocation StartLoc,
3428 SourceLocation EndLoc,
3429 ArrayRef<OMPClause *> Clauses,
3430 Stmt *AssociatedStmt);
3438 static OMPTeamsDirective *
CreateEmpty(
const ASTContext &
C,
3439 unsigned NumClauses, EmptyShell);
3465 llvm::omp::OMPD_cancellation_point, StartLoc,
3471 llvm::omp::OMPD_cancellation_point,
3485 static OMPCancellationPointDirective *
3486 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3493 static OMPCancellationPointDirective *
CreateEmpty(
const ASTContext &
C,
3500 return T->
getStmtClass() == OMPCancellationPointDirectiveClass;
3522 StartLoc, EndLoc) {}
3542 static OMPCancelDirective *
3543 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3551 static OMPCancelDirective *
CreateEmpty(
const ASTContext &
C,
3552 unsigned NumClauses, EmptyShell);
3575 bool HasCancel =
false;
3584 unsigned CollapsedNum)
3586 StartLoc, EndLoc, CollapsedNum) {}
3597 void setHasCancel(
bool Has) { HasCancel = Has; }
3611 static OMPTaskLoopDirective *
3612 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3613 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3614 Stmt *AssociatedStmt,
const HelperExprs &Exprs,
bool HasCancel);
3623 static OMPTaskLoopDirective *
CreateEmpty(
const ASTContext &
C,
3624 unsigned NumClauses,
3625 unsigned CollapsedNum, EmptyShell);
3654 unsigned CollapsedNum)
3656 llvm::omp::OMPD_taskloop_simd, StartLoc, EndLoc,
3679 static OMPTaskLoopSimdDirective *
3680 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3681 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3682 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
3691 static OMPTaskLoopSimdDirective *
CreateEmpty(
const ASTContext &
C,
3692 unsigned NumClauses,
3693 unsigned CollapsedNum,
3697 return T->
getStmtClass() == OMPTaskLoopSimdDirectiveClass;
3714 bool HasCancel =
false;
3723 unsigned CollapsedNum)
3725 llvm::omp::OMPD_master_taskloop, StartLoc, EndLoc,
3738 void setHasCancel(
bool Has) { HasCancel = Has; }
3752 static OMPMasterTaskLoopDirective *
3753 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3754 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3755 Stmt *AssociatedStmt,
const HelperExprs &Exprs,
bool HasCancel);
3764 static OMPMasterTaskLoopDirective *
CreateEmpty(
const ASTContext &
C,
3765 unsigned NumClauses,
3766 unsigned CollapsedNum,
3773 return T->
getStmtClass() == OMPMasterTaskLoopDirectiveClass;
3796 unsigned CollapsedNum)
3798 llvm::omp::OMPD_master_taskloop_simd, StartLoc, EndLoc,
3821 static OMPMasterTaskLoopSimdDirective *
3822 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3823 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3824 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
3832 static OMPMasterTaskLoopSimdDirective *
CreateEmpty(
const ASTContext &
C,
3833 unsigned NumClauses,
3834 unsigned CollapsedNum,
3838 return T->
getStmtClass() == OMPMasterTaskLoopSimdDirectiveClass;
3856 bool HasCancel =
false;
3866 unsigned CollapsedNum)
3868 llvm::omp::OMPD_parallel_master_taskloop, StartLoc,
3869 EndLoc, CollapsedNum) {}
3877 llvm::omp::OMPD_parallel_master_taskloop,
3881 void setHasCancel(
bool Has) { HasCancel = Has; }
3895 static OMPParallelMasterTaskLoopDirective *
3896 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3897 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3898 Stmt *AssociatedStmt,
const HelperExprs &Exprs,
bool HasCancel);
3907 static OMPParallelMasterTaskLoopDirective *
CreateEmpty(
const ASTContext &
C,
3908 unsigned NumClauses,
3909 unsigned CollapsedNum,
3916 return T->
getStmtClass() == OMPParallelMasterTaskLoopDirectiveClass;
3941 unsigned CollapsedNum)
3943 llvm::omp::OMPD_parallel_master_taskloop_simd,
3944 StartLoc, EndLoc, CollapsedNum) {}
3952 llvm::omp::OMPD_parallel_master_taskloop_simd,
3966 static OMPParallelMasterTaskLoopSimdDirective *
3967 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
3968 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3969 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
3978 static OMPParallelMasterTaskLoopSimdDirective *
3979 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
unsigned CollapsedNum,
3983 return T->
getStmtClass() == OMPParallelMasterTaskLoopSimdDirectiveClass;
4006 unsigned CollapsedNum)
4008 llvm::omp::OMPD_distribute, StartLoc, EndLoc,
4031 static OMPDistributeDirective *
4032 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4033 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4034 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4043 static OMPDistributeDirective *
CreateEmpty(
const ASTContext &
C,
4044 unsigned NumClauses,
4045 unsigned CollapsedNum, EmptyShell);
4048 return T->
getStmtClass() == OMPDistributeDirectiveClass;
4071 llvm::omp::OMPD_target_update, StartLoc,
4090 static OMPTargetUpdateDirective *
4091 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4092 ArrayRef<OMPClause *> Clauses,
Stmt *AssociatedStmt);
4100 static OMPTargetUpdateDirective *
CreateEmpty(
const ASTContext &
C,
4101 unsigned NumClauses, EmptyShell);
4104 return T->
getStmtClass() == OMPTargetUpdateDirectiveClass;
4121 bool HasCancel =
false;
4131 unsigned CollapsedNum)
4133 llvm::omp::OMPD_distribute_parallel_for, StartLoc,
4134 EndLoc, CollapsedNum) {}
4142 llvm::omp::OMPD_distribute_parallel_for,
4146 void setTaskReductionRefExpr(Expr *E) {
4152 void setHasCancel(
bool Has) { HasCancel = Has; }
4168 static OMPDistributeParallelForDirective *
4169 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4170 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4171 Stmt *AssociatedStmt,
const HelperExprs &Exprs, Expr *TaskRedRef,
4181 static OMPDistributeParallelForDirective *
CreateEmpty(
const ASTContext &
C,
4182 unsigned NumClauses,
4183 unsigned CollapsedNum,
4200 return T->
getStmtClass() == OMPDistributeParallelForDirectiveClass;
4225 unsigned CollapsedNum)
4227 llvm::omp::OMPD_distribute_parallel_for_simd, StartLoc,
4228 EndLoc, CollapsedNum) {}
4236 llvm::omp::OMPD_distribute_parallel_for_simd,
4250 static OMPDistributeParallelForSimdDirective *
Create(
4251 const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4252 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4253 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4261 static OMPDistributeParallelForSimdDirective *
CreateEmpty(
4262 const ASTContext &
C,
unsigned NumClauses,
unsigned CollapsedNum,
4266 return T->
getStmtClass() == OMPDistributeParallelForSimdDirectiveClass;
4289 unsigned CollapsedNum)
4291 llvm::omp::OMPD_distribute_simd, StartLoc, EndLoc,
4314 static OMPDistributeSimdDirective *
4315 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4316 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4317 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4325 static OMPDistributeSimdDirective *
CreateEmpty(
const ASTContext &
C,
4326 unsigned NumClauses,
4327 unsigned CollapsedNum,
4331 return T->
getStmtClass() == OMPDistributeSimdDirectiveClass;
4356 unsigned CollapsedNum)
4358 llvm::omp::OMPD_target_parallel_for_simd, StartLoc,
4359 EndLoc, CollapsedNum) {}
4367 llvm::omp::OMPD_target_parallel_for_simd,
4381 static OMPTargetParallelForSimdDirective *
4382 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4383 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4384 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4392 static OMPTargetParallelForSimdDirective *
CreateEmpty(
const ASTContext &
C,
4393 unsigned NumClauses,
4394 unsigned CollapsedNum,
4398 return T->
getStmtClass() == OMPTargetParallelForSimdDirectiveClass;
4422 unsigned CollapsedNum)
4424 llvm::omp::OMPD_target_simd, StartLoc, EndLoc,
4447 static OMPTargetSimdDirective *
4448 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4449 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4450 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4458 static OMPTargetSimdDirective *
CreateEmpty(
const ASTContext &
C,
4459 unsigned NumClauses,
4460 unsigned CollapsedNum,
4464 return T->
getStmtClass() == OMPTargetSimdDirectiveClass;
4487 unsigned CollapsedNum)
4489 llvm::omp::OMPD_teams_distribute, StartLoc, EndLoc,
4512 static OMPTeamsDistributeDirective *
4513 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4514 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4515 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4523 static OMPTeamsDistributeDirective *
CreateEmpty(
const ASTContext &
C,
4524 unsigned NumClauses,
4525 unsigned CollapsedNum,
4529 return T->
getStmtClass() == OMPTeamsDistributeDirectiveClass;
4555 llvm::omp::OMPD_teams_distribute_simd, StartLoc,
4556 EndLoc, CollapsedNum) {}
4564 llvm::omp::OMPD_teams_distribute_simd,
4578 static OMPTeamsDistributeSimdDirective *
4579 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4580 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4581 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4590 static OMPTeamsDistributeSimdDirective *
CreateEmpty(
const ASTContext &
C,
4591 unsigned NumClauses,
4592 unsigned CollapsedNum,
4596 return T->
getStmtClass() == OMPTeamsDistributeSimdDirectiveClass;
4622 unsigned CollapsedNum)
4624 llvm::omp::OMPD_teams_distribute_parallel_for_simd,
4625 StartLoc, EndLoc, CollapsedNum) {}
4633 llvm::omp::OMPD_teams_distribute_parallel_for_simd,
4647 static OMPTeamsDistributeParallelForSimdDirective *
4648 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4649 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4650 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4658 static OMPTeamsDistributeParallelForSimdDirective *
4659 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
unsigned CollapsedNum,
4663 return T->
getStmtClass() == OMPTeamsDistributeParallelForSimdDirectiveClass;
4680 bool HasCancel =
false;
4690 unsigned CollapsedNum)
4692 llvm::omp::OMPD_teams_distribute_parallel_for,
4693 StartLoc, EndLoc, CollapsedNum) {}
4701 llvm::omp::OMPD_teams_distribute_parallel_for,
4705 void setTaskReductionRefExpr(Expr *E) {
4707 getLoopsNumber(), llvm::omp::OMPD_teams_distribute_parallel_for)] = E;
4711 void setHasCancel(
bool Has) { HasCancel = Has; }
4727 static OMPTeamsDistributeParallelForDirective *
4728 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4729 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4730 Stmt *AssociatedStmt,
const HelperExprs &Exprs, Expr *TaskRedRef,
4739 static OMPTeamsDistributeParallelForDirective *
4740 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
unsigned CollapsedNum,
4746 getLoopsNumber(), llvm::omp::OMPD_teams_distribute_parallel_for)]);
4757 return T->
getStmtClass() == OMPTeamsDistributeParallelForDirectiveClass;
4779 llvm::omp::OMPD_target_teams, StartLoc, EndLoc) {
4798 static OMPTargetTeamsDirective *
Create(
const ASTContext &
C,
4799 SourceLocation StartLoc,
4800 SourceLocation EndLoc,
4801 ArrayRef<OMPClause *> Clauses,
4802 Stmt *AssociatedStmt);
4809 static OMPTargetTeamsDirective *
CreateEmpty(
const ASTContext &
C,
4810 unsigned NumClauses, EmptyShell);
4813 return T->
getStmtClass() == OMPTargetTeamsDirectiveClass;
4837 unsigned CollapsedNum)
4839 llvm::omp::OMPD_target_teams_distribute, StartLoc,
4840 EndLoc, CollapsedNum) {}
4848 llvm::omp::OMPD_target_teams_distribute,
4862 static OMPTargetTeamsDistributeDirective *
4863 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4864 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4865 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
4873 static OMPTargetTeamsDistributeDirective *
4874 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
unsigned CollapsedNum,
4878 return T->
getStmtClass() == OMPTargetTeamsDistributeDirectiveClass;
4896 bool HasCancel =
false;
4906 unsigned CollapsedNum)
4908 llvm::omp::OMPD_target_teams_distribute_parallel_for,
4909 StartLoc, EndLoc, CollapsedNum) {}
4917 llvm::omp::OMPD_target_teams_distribute_parallel_for,
4921 void setTaskReductionRefExpr(Expr *E) {
4924 llvm::omp::OMPD_target_teams_distribute_parallel_for)] = E;
4928 void setHasCancel(
bool Has) { HasCancel = Has; }
4944 static OMPTargetTeamsDistributeParallelForDirective *
4945 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
4946 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4947 Stmt *AssociatedStmt,
const HelperExprs &Exprs, Expr *TaskRedRef,
4956 static OMPTargetTeamsDistributeParallelForDirective *
4957 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
unsigned CollapsedNum,
4964 llvm::omp::OMPD_target_teams_distribute_parallel_for)]);
4976 OMPTargetTeamsDistributeParallelForDirectiveClass;
5002 unsigned CollapsedNum)
5004 OMPTargetTeamsDistributeParallelForSimdDirectiveClass,
5005 llvm::omp::OMPD_target_teams_distribute_parallel_for_simd, StartLoc,
5006 EndLoc, CollapsedNum) {}
5013 unsigned CollapsedNum)
5015 OMPTargetTeamsDistributeParallelForSimdDirectiveClass,
5016 llvm::omp::OMPD_target_teams_distribute_parallel_for_simd,
5030 static OMPTargetTeamsDistributeParallelForSimdDirective *
5031 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
5032 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
5033 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
5041 static OMPTargetTeamsDistributeParallelForSimdDirective *
5042 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
unsigned CollapsedNum,
5047 OMPTargetTeamsDistributeParallelForSimdDirectiveClass;
5072 unsigned CollapsedNum)
5074 llvm::omp::OMPD_target_teams_distribute_simd, StartLoc,
5075 EndLoc, CollapsedNum) {}
5083 llvm::omp::OMPD_target_teams_distribute_simd,
5097 static OMPTargetTeamsDistributeSimdDirective *
5098 Create(
const ASTContext &
C, SourceLocation StartLoc, SourceLocation EndLoc,
5099 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
5100 Stmt *AssociatedStmt,
const HelperExprs &Exprs);
5108 static OMPTargetTeamsDistributeSimdDirective *
5109 CreateEmpty(
const ASTContext &
C,
unsigned NumClauses,
unsigned CollapsedNum,
5113 return T->
getStmtClass() == OMPTargetTeamsDistributeSimdDirectiveClass;
5125 TransformedStmtOffset,
5131 llvm::omp::OMPD_tile, StartLoc, EndLoc,
5136 void setPreInits(
Stmt *PreInits) {
5140 void setTransformedStmt(