16 using namespace clang;
17 using namespace llvm::omp;
19 size_t OMPChildren::size(
unsigned NumClauses,
bool HasAssociatedStmt,
20 unsigned NumChildren) {
22 totalSizeToAlloc<OMPClause *, Stmt *>(
23 NumClauses, NumChildren + (HasAssociatedStmt ? 1 : 0)),
28 assert(Clauses.size() == NumClauses &&
29 "Number of clauses is not the same as the preallocated buffer");
30 llvm::copy(Clauses, getTrailingObjects<OMPClause *>());
38 auto *Data = CreateEmpty(Mem, Clauses.size());
39 Data->setClauses(Clauses);
44 Stmt *S,
unsigned NumChildren) {
45 auto *Data = CreateEmpty(Mem, Clauses.size(), S, NumChildren);
46 Data->setClauses(Clauses);
48 Data->setAssociatedStmt(S);
52 OMPChildren *OMPChildren::CreateEmpty(
void *Mem,
unsigned NumClauses,
53 bool HasAssociatedStmt,
54 unsigned NumChildren) {
55 return new (Mem)
OMPChildren(NumClauses, NumChildren, HasAssociatedStmt);
62 if (isa<OMPTargetEnterDataDirective>(
this) ||
63 isa<OMPTargetExitDataDirective>(
this) ||
64 isa<OMPTargetUpdateDirective>(
this))
66 return !hasAssociatedStmt();
70 assert(!isStandaloneDirective() &&
71 "Standalone Executable Directives don't have Structured Blocks.");
72 if (
auto *LD = dyn_cast<OMPLoopDirective>(
this))
79 bool TryImperfectlyNestedLoops) {
80 Stmt *OrigStmt = CurStmt;
83 if (TryImperfectlyNestedLoops) {
84 if (
auto *CS = dyn_cast<CompoundStmt>(CurStmt)) {
88 while (!Statements.empty()) {
89 CS = Statements.pop_back_val();
92 for (
Stmt *S : CS->body()) {
95 if (
auto *CanonLoop = dyn_cast<OMPCanonicalLoop>(S))
96 S = CanonLoop->getLoopStmt();
97 if (isa<ForStmt>(S) || isa<CXXForRangeStmt>(S) ||
98 (isa<OMPLoopBasedDirective>(S) && !isa<OMPLoopDirective>(S))) {
107 S = S->IgnoreContainers();
108 if (
auto *InnerCS = dyn_cast_or_null<CompoundStmt>(S))
109 NextStatements.push_back(InnerCS);
111 if (Statements.empty()) {
115 Statements.swap(NextStatements);
126 Stmt *CurStmt,
bool TryImperfectlyNestedLoops,
unsigned NumLoops,
127 llvm::function_ref<
bool(
unsigned,
Stmt *)> Callback,
129 OnTransformationCallback) {
131 for (
unsigned Cnt = 0; Cnt < NumLoops; ++Cnt) {
133 auto *Dir = dyn_cast<OMPLoopTransformationDirective>(CurStmt);
137 OnTransformationCallback(Dir);
139 Stmt *TransformedStmt = Dir->getTransformedStmt();
140 if (!TransformedStmt) {
141 unsigned NumGeneratedLoops = Dir->getNumGeneratedLoops();
142 if (NumGeneratedLoops == 0) {
147 if (NumGeneratedLoops > 0) {
155 CurStmt = TransformedStmt;
157 if (
auto *CanonLoop = dyn_cast<OMPCanonicalLoop>(CurStmt))
158 CurStmt = CanonLoop->getLoopStmt();
159 if (Callback(Cnt, CurStmt))
166 if (
auto *For = dyn_cast<ForStmt>(CurStmt)) {
167 CurStmt = For->getBody();
169 assert(isa<CXXForRangeStmt>(CurStmt) &&
170 "Expected canonical for or range-based for loops.");
171 CurStmt = cast<CXXForRangeStmt>(CurStmt)->getBody();
174 CurStmt, TryImperfectlyNestedLoops);
180 Stmt *CurStmt,
bool TryImperfectlyNestedLoops,
unsigned NumLoops,
181 llvm::function_ref<
void(
unsigned,
Stmt *,
Stmt *)> Callback) {
183 CurStmt, TryImperfectlyNestedLoops, NumLoops,
184 [Callback](
unsigned Cnt,
Stmt *Loop) {
185 Stmt *Body =
nullptr;
186 if (
auto *For = dyn_cast<ForStmt>(Loop)) {
187 Body = For->getBody();
189 assert(isa<CXXForRangeStmt>(Loop) &&
190 "Expected canonical for or range-based for loops.");
191 Body = cast<CXXForRangeStmt>(Loop)->getBody();
193 if (
auto *CanonLoop = dyn_cast<OMPCanonicalLoop>(Body))
194 Body = CanonLoop->getLoopStmt();
195 Callback(Cnt, Loop, Body);
198 assert(Res &&
"Expected only loops");
204 Stmt *Body =
nullptr;
206 Data->getRawStmt(),
true,
208 [&Body](
unsigned,
Stmt *,
Stmt *BodyStmt) { Body = BodyStmt; });
213 assert(A.size() == getLoopsNumber() &&
214 "Number of loop counters is not the same as the collapsed number");
215 llvm::copy(A, getCounters().begin());
219 assert(A.size() == getLoopsNumber() &&
"Number of loop private counters "
220 "is not the same as the collapsed "
222 llvm::copy(A, getPrivateCounters().begin());
226 assert(A.size() == getLoopsNumber() &&
227 "Number of counter inits is not the same as the collapsed number");
228 llvm::copy(A, getInits().begin());
232 assert(A.size() == getLoopsNumber() &&
233 "Number of counter updates is not the same as the collapsed number");
234 llvm::copy(A, getUpdates().begin());
238 assert(A.size() == getLoopsNumber() &&
239 "Number of counter finals is not the same as the collapsed number");
240 llvm::copy(A, getFinals().begin());
245 A.size() == getLoopsNumber() &&
246 "Number of dependent counters is not the same as the collapsed number");
247 llvm::copy(A, getDependentCounters().begin());
251 assert(A.size() == getLoopsNumber() &&
252 "Number of dependent inits is not the same as the collapsed number");
253 llvm::copy(A, getDependentInits().begin());
257 assert(A.size() == getLoopsNumber() &&
258 "Number of finals conditions is not the same as the collapsed number");
259 llvm::copy(A, getFinalsConditions().begin());
267 auto *Dir = createDirective<OMPMetaDirective>(
268 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);
276 return createEmptyDirective<OMPMetaDirective>(C, NumClauses,
285 auto *Dir = createDirective<OMPParallelDirective>(
286 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);
287 Dir->setTaskReductionRefExpr(TaskRedRef);
288 Dir->setHasCancel(HasCancel);
295 return createEmptyDirective<OMPParallelDirective>(C, NumClauses,
305 auto *Dir = createDirective<OMPSimdDirective>(
306 C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_simd),
307 StartLoc, EndLoc, CollapsedNum);
311 Dir->setPreCond(Exprs.
PreCond);
312 Dir->setCond(Exprs.
Cond);
313 Dir->setInit(Exprs.
Init);
314 Dir->setInc(Exprs.
Inc);
317 Dir->setInits(Exprs.
Inits);
318 Dir->setUpdates(Exprs.
Updates);
319 Dir->setFinals(Exprs.
Finals);
329 unsigned CollapsedNum,
331 return createEmptyDirective<OMPSimdDirective>(
333 numLoopChildren(CollapsedNum, OMPD_simd), CollapsedNum);
340 auto *Dir = createDirective<OMPForDirective>(
341 C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for) + 1,
342 StartLoc, EndLoc, CollapsedNum);
346 Dir->setPreCond(Exprs.
PreCond);
347 Dir->setCond(Exprs.
Cond);
348 Dir->setInit(Exprs.
Init);
349 Dir->setInc(Exprs.
Inc);
350 Dir->setIsLastIterVariable(Exprs.
IL);
351 Dir->setLowerBoundVariable(Exprs.
LB);
352 Dir->setUpperBoundVariable(Exprs.
UB);
353 Dir->setStrideVariable(Exprs.
ST);
354 Dir->setEnsureUpperBound(Exprs.
EUB);
355 Dir->setNextLowerBound(Exprs.
NLB);
356 Dir->setNextUpperBound(Exprs.
NUB);
360 Dir->setInits(Exprs.
Inits);
361 Dir->setUpdates(Exprs.
Updates);
362 Dir->setFinals(Exprs.
Finals);
367 Dir->setTaskReductionRefExpr(TaskRedRef);
368 Dir->setHasCancel(HasCancel);
373 switch (getStmtClass()) {
374 #define STMT(CLASS, PARENT)
375 #define ABSTRACT_STMT(CLASS)
376 #define OMPLOOPTRANSFORMATIONDIRECTIVE(CLASS, PARENT) \
377 case Stmt::CLASS##Class: \
378 return static_cast<const CLASS *>(this)->getTransformedStmt();
379 #include "clang/AST/StmtNodes.inc"
381 llvm_unreachable(
"Not a loop transformation");
386 switch (getStmtClass()) {
387 #define STMT(CLASS, PARENT)
388 #define ABSTRACT_STMT(CLASS)
389 #define OMPLOOPTRANSFORMATIONDIRECTIVE(CLASS, PARENT) \
390 case Stmt::CLASS##Class: \
391 return static_cast<const CLASS *>(this)->getPreInits();
392 #include "clang/AST/StmtNodes.inc"
394 llvm_unreachable(
"Not a loop transformation");
400 unsigned CollapsedNum,
402 return createEmptyDirective<OMPForDirective>(
404 numLoopChildren(CollapsedNum, OMPD_for) + 1, CollapsedNum);
410 unsigned NumLoops,
Stmt *AssociatedStmt,
411 Stmt *TransformedStmt,
Stmt *PreInits) {
413 C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc,
415 Dir->setTransformedStmt(TransformedStmt);
416 Dir->setPreInits(PreInits);
423 return createEmptyDirective<OMPTileDirective>(
424 C, NumClauses,
true, TransformedStmtOffset + 1,
431 Stmt *AssociatedStmt,
unsigned NumGeneratedLoops,
432 Stmt *TransformedStmt,
Stmt *PreInits) {
433 assert(NumGeneratedLoops <= 1 &&
"Unrolling generates at most one loop");
435 auto *Dir = createDirective<OMPUnrollDirective>(
436 C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc);
437 Dir->setNumGeneratedLoops(NumGeneratedLoops);
438 Dir->setTransformedStmt(TransformedStmt);
439 Dir->setPreInits(PreInits);
444 unsigned NumClauses) {
445 return createEmptyDirective<OMPUnrollDirective>(
446 C, NumClauses,
true, TransformedStmtOffset + 1,
455 auto *Dir = createDirective<OMPForSimdDirective>(
456 C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for_simd),
457 StartLoc, EndLoc, CollapsedNum);
461 Dir->setPreCond(Exprs.
PreCond);
462 Dir->setCond(Exprs.
Cond);
463 Dir->setInit(Exprs.
Init);
464 Dir->setInc(Exprs.
Inc);
465 Dir->setIsLastIterVariable(Exprs.
IL);
466 Dir->setLowerBoundVariable(Exprs.
LB);
467 Dir->setUpperBoundVariable(Exprs.
UB);
468 Dir->setStrideVariable(Exprs.
ST);
469 Dir->setEnsureUpperBound(Exprs.
EUB);
470 Dir->setNextLowerBound(Exprs.
NLB);
471 Dir->setNextUpperBound(Exprs.
NUB);
475 Dir->setInits(Exprs.
Inits);
476 Dir->setUpdates(Exprs.
Updates);
477 Dir->setFinals(Exprs.
Finals);
487 unsigned CollapsedNum,
489 return createEmptyDirective<OMPForSimdDirective>(
491 numLoopChildren(CollapsedNum, OMPD_for_simd), CollapsedNum);
498 auto *Dir = createDirective<OMPSectionsDirective>(C, Clauses, AssociatedStmt,
501 Dir->setTaskReductionRefExpr(TaskRedRef);
502 Dir->setHasCancel(HasCancel);
509 return createEmptyDirective<OMPSectionsDirective>(C, NumClauses,
517 Stmt *AssociatedStmt,
520 createDirective<OMPSectionDirective>(C, std::nullopt, AssociatedStmt,
521 0, StartLoc, EndLoc);
522 Dir->setHasCancel(HasCancel);
528 return createEmptyDirective<OMPSectionDirective>(C, 0,
536 Stmt *AssociatedStmt) {
537 return createDirective<OMPSingleDirective>(C, Clauses, AssociatedStmt,
545 return createEmptyDirective<OMPSingleDirective>(C, NumClauses,
552 Stmt *AssociatedStmt) {
553 return createDirective<OMPMasterDirective>(C, std::nullopt, AssociatedStmt,
560 return createEmptyDirective<OMPMasterDirective>(C, 0,
568 return createDirective<OMPCriticalDirective>(C, Clauses, AssociatedStmt,
576 return createEmptyDirective<OMPCriticalDirective>(C, NumClauses,
584 auto *Dir = createDirective<OMPParallelForDirective>(
585 C, Clauses, AssociatedStmt,
586 numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, StartLoc, EndLoc,
591 Dir->setPreCond(Exprs.
PreCond);
592 Dir->setCond(Exprs.
Cond);
593 Dir->setInit(Exprs.
Init);
594 Dir->setInc(Exprs.
Inc);
595 Dir->setIsLastIterVariable(Exprs.
IL);
596 Dir->setLowerBoundVariable(Exprs.
LB);
597 Dir->setUpperBoundVariable(Exprs.
UB);
598 Dir->setStrideVariable(Exprs.
ST);
599 Dir->setEnsureUpperBound(Exprs.
EUB);
600 Dir->setNextLowerBound(Exprs.
NLB);
601 Dir->setNextUpperBound(Exprs.
NUB);
605 Dir->setInits(Exprs.
Inits);
606 Dir->setUpdates(Exprs.
Updates);
607 Dir->setFinals(Exprs.
Finals);
612 Dir->setTaskReductionRefExpr(TaskRedRef);
613 Dir->setHasCancel(HasCancel);
620 return createEmptyDirective<OMPParallelForDirective>(
622 numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, CollapsedNum);
629 auto *Dir = createDirective<OMPParallelForSimdDirective>(
630 C, Clauses, AssociatedStmt,
631 numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), StartLoc, EndLoc,
636 Dir->setPreCond(Exprs.
PreCond);
637 Dir->setCond(Exprs.
Cond);
638 Dir->setInit(Exprs.
Init);
639 Dir->setInc(Exprs.
Inc);
640 Dir->setIsLastIterVariable(Exprs.
IL);
641 Dir->setLowerBoundVariable(Exprs.
LB);
642 Dir->setUpperBoundVariable(Exprs.
UB);
643 Dir->setStrideVariable(Exprs.
ST);
644 Dir->setEnsureUpperBound(Exprs.
EUB);
645 Dir->setNextLowerBound(Exprs.
NLB);
646 Dir->setNextUpperBound(Exprs.
NUB);
650 Dir->setInits(Exprs.
Inits);
651 Dir->setUpdates(Exprs.
Updates);
652 Dir->setFinals(Exprs.
Finals);
664 return createEmptyDirective<OMPParallelForSimdDirective>(
666 numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), CollapsedNum);
672 auto *Dir = createDirective<OMPParallelMasterDirective>(
673 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);
674 Dir->setTaskReductionRefExpr(TaskRedRef);
681 return createEmptyDirective<OMPParallelMasterDirective>(
682 C, NumClauses,
true, 1);
688 auto *Dir = createDirective<OMPParallelMaskedDirective>(
689 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);
690 Dir->setTaskReductionRefExpr(TaskRedRef);
697 return createEmptyDirective<OMPParallelMaskedDirective>(
698 C, NumClauses,
true, 1);
705 auto *Dir = createDirective<OMPParallelSectionsDirective>(
706 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);
707 Dir->setTaskReductionRefExpr(TaskRedRef);
708 Dir->setHasCancel(HasCancel);
715 return createEmptyDirective<OMPParallelSectionsDirective>(
716 C, NumClauses,
true, 1);
722 Stmt *AssociatedStmt,
bool HasCancel) {
723 auto *Dir = createDirective<OMPTaskDirective>(
724 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);
725 Dir->setHasCancel(HasCancel);
732 return createEmptyDirective<OMPTaskDirective>(C, NumClauses,
751 return createDirective<OMPErrorDirective>(
752 C, Clauses,
nullptr, 0, StartLoc,
759 return createEmptyDirective<OMPErrorDirective>(C, NumClauses);
777 return createDirective<OMPTaskwaitDirective>(
778 C, Clauses,
nullptr, 0, StartLoc,
785 return createEmptyDirective<OMPTaskwaitDirective>(C, NumClauses);
791 auto *Dir = createDirective<OMPTaskgroupDirective>(
792 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);
793 Dir->setReductionRef(ReductionRef);
800 return createEmptyDirective<OMPTaskgroupDirective>(
801 C, NumClauses,
true, 1);
808 Dir->setCancelRegion(CancelRegion);
821 auto *Dir = createDirective<OMPCancelDirective>(
822 C, Clauses,
nullptr, 0, StartLoc,
824 Dir->setCancelRegion(CancelRegion);
831 return createEmptyDirective<OMPCancelDirective>(C, NumClauses);
838 return createDirective<OMPFlushDirective>(
839 C, Clauses,
nullptr, 0, StartLoc,
846 return createEmptyDirective<OMPFlushDirective>(C, NumClauses);
853 return createDirective<OMPDepobjDirective>(
855 0, StartLoc, EndLoc);
861 return createEmptyDirective<OMPDepobjDirective>(C, NumClauses);
868 return createDirective<OMPScanDirective>(C, Clauses,
870 0, StartLoc, EndLoc);
876 return createEmptyDirective<OMPScanDirective>(C, NumClauses);
883 Stmt *AssociatedStmt) {
884 return createDirective<OMPOrderedDirective>(
885 C, Clauses, cast_or_null<CapturedStmt>(AssociatedStmt),
886 0, StartLoc, EndLoc);
893 return createEmptyDirective<OMPOrderedDirective>(C, NumClauses,
901 auto *Dir = createDirective<OMPAtomicDirective>(
902 C, Clauses, AssociatedStmt, 7, StartLoc, EndLoc);
906 Dir->setExpr(Exprs.
E);
907 Dir->setUpdateExpr(Exprs.
UE);
909 Dir->setCond(Exprs.
Cond);
912 Dir->Flags.IsFailOnly = Exprs.
IsFailOnly ? 1 : 0;
919 return createEmptyDirective<OMPAtomicDirective>(
920 C, NumClauses,
true, 7);
927 Stmt *AssociatedStmt) {
928 return createDirective<OMPTargetDirective>(
929 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);
935 return createEmptyDirective<OMPTargetDirective>(C, NumClauses,
943 auto *Dir = createDirective<OMPTargetParallelDirective>(
944 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);
945 Dir->setTaskReductionRefExpr(TaskRedRef);
946 Dir->setHasCancel(HasCancel);
953 return createEmptyDirective<OMPTargetParallelDirective>(
954 C, NumClauses,
true, 1);
961 auto *Dir = createDirective<OMPTargetParallelForDirective>(
962 C, Clauses, AssociatedStmt,
963 numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1, StartLoc,
964 EndLoc, CollapsedNum);
968 Dir->setPreCond(Exprs.
PreCond);
969 Dir->setCond(Exprs.
Cond);
970 Dir->setInit(Exprs.
Init);
971 Dir->setInc(Exprs.
Inc);
972 Dir->setIsLastIterVariable(Exprs.
IL);
973 Dir->setLowerBoundVariable(Exprs.
LB);
974 Dir->setUpperBoundVariable(Exprs.
UB);
975 Dir->setStrideVariable(Exprs.
ST);
976 Dir->setEnsureUpperBound(Exprs.
EUB);
977 Dir->setNextLowerBound(Exprs.
NLB);
978 Dir->setNextUpperBound(Exprs.
NUB);
982 Dir->setInits(Exprs.
Inits);
983 Dir->setUpdates(Exprs.
Updates);
984 Dir->setFinals(Exprs.
Finals);
989 Dir->setTaskReductionRefExpr(TaskRedRef);
990 Dir->setHasCancel(HasCancel);
998 return createEmptyDirective<OMPTargetParallelForDirective>(
1000 numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1,
1007 return createDirective<OMPTargetDataDirective>(
1008 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);
1014 return createEmptyDirective<OMPTargetDataDirective>(
1021 return createDirective<OMPTargetEnterDataDirective>(
1022 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);
1028 return createEmptyDirective<OMPTargetEnterDataDirective>(
1035 return createDirective<OMPTargetExitDataDirective>(
1036 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);
1042 return createEmptyDirective<OMPTargetExitDataDirective>(
1050 Stmt *AssociatedStmt) {
1051 return createDirective<OMPTeamsDirective>(
1052 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);
1056 unsigned NumClauses,
1058 return createEmptyDirective<OMPTeamsDirective>(C, NumClauses,
1066 auto *Dir = createDirective<OMPTaskLoopDirective>(
1067 C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_taskloop),
1068 StartLoc, EndLoc, CollapsedNum);
1072 Dir->setPreCond(Exprs.
PreCond);
1073 Dir->setCond(Exprs.
Cond);
1074 Dir->setInit(Exprs.
Init);
1075 Dir->setInc(Exprs.
Inc);
1076 Dir->setIsLastIterVariable(Exprs.
IL);
1077 Dir->setLowerBoundVariable(Exprs.
LB);
1078 Dir->setUpperBoundVariable(Exprs.
UB);
1079 Dir->setStrideVariable(Exprs.
ST);
1080 Dir->setEnsureUpperBound(Exprs.
EUB);
1081 Dir->setNextLowerBound(Exprs.
NLB);
1082 Dir->setNextUpperBound(Exprs.
NUB);
1086 Dir->setInits(Exprs.
Inits);
1087 Dir->setUpdates(Exprs.
Updates);
1088 Dir->setFinals(Exprs.
Finals);
1093 Dir->setHasCancel(HasCancel);
1098 unsigned NumClauses,
1099 unsigned CollapsedNum,
1101 return createEmptyDirective<OMPTaskLoopDirective>(
1102 C, NumClauses,
true,
1103 numLoopChildren(CollapsedNum, OMPD_taskloop), CollapsedNum);
1110 auto *Dir = createDirective<OMPTaskLoopSimdDirective>(
1111 C, Clauses, AssociatedStmt,
1112 numLoopChildren(CollapsedNum, OMPD_taskloop_simd), StartLoc, EndLoc,
1117 Dir->setPreCond(Exprs.
PreCond);
1118 Dir->setCond(Exprs.
Cond);
1119 Dir->setInit(Exprs.
Init);
1120 Dir->setInc(Exprs.
Inc);
1121 Dir->setIsLastIterVariable(Exprs.
IL);
1122 Dir->setLowerBoundVariable(Exprs.
LB);
1123 Dir->setUpperBoundVariable(Exprs.
UB);
1124 Dir->setStrideVariable(Exprs.
ST);
1125 Dir->setEnsureUpperBound(Exprs.
EUB);
1126 Dir->setNextLowerBound(Exprs.
NLB);
1127 Dir->setNextUpperBound(Exprs.
NUB);
1131 Dir->setInits(Exprs.
Inits);
1132 Dir->setUpdates(Exprs.
Updates);
1133 Dir->setFinals(Exprs.
Finals);
1144 return createEmptyDirective<OMPTaskLoopSimdDirective>(
1145 C, NumClauses,
true,
1146 numLoopChildren(CollapsedNum, OMPD_taskloop_simd), CollapsedNum);
1153 auto *Dir = createDirective<OMPMasterTaskLoopDirective>(
1154 C, Clauses, AssociatedStmt,
1155 numLoopChildren(CollapsedNum, OMPD_master_taskloop), StartLoc, EndLoc,
1160 Dir->setPreCond(Exprs.
PreCond);
1161 Dir->setCond(Exprs.
Cond);
1162 Dir->setInit(Exprs.
Init);
1163 Dir->setInc(Exprs.
Inc);
1164 Dir->setIsLastIterVariable(Exprs.
IL);
1165 Dir->setLowerBoundVariable(Exprs.
LB);
1166 Dir->setUpperBoundVariable(Exprs.
UB);
1167 Dir->setStrideVariable(Exprs.
ST);
1168 Dir->setEnsureUpperBound(Exprs.
EUB);
1169 Dir->setNextLowerBound(Exprs.
NLB);
1170 Dir->setNextUpperBound(Exprs.
NUB);
1174 Dir->setInits(Exprs.
Inits);
1175 Dir->setUpdates(Exprs.
Updates);
1176 Dir->setFinals(Exprs.
Finals);
1181 Dir->setHasCancel(HasCancel);
1187 unsigned NumClauses,
1189 return createEmptyDirective<OMPMasterTaskLoopDirective>(
1190 C, NumClauses,
true,
1191 numLoopChildren(CollapsedNum, OMPD_master_taskloop), CollapsedNum);
1198 auto *Dir = createDirective<OMPMaskedTaskLoopDirective>(
1199 C, Clauses, AssociatedStmt,
1200 numLoopChildren(CollapsedNum, OMPD_masked_taskloop), StartLoc, EndLoc,
1205 Dir->setPreCond(Exprs.
PreCond);
1206 Dir->setCond(Exprs.
Cond);
1207 Dir->setInit(Exprs.
Init);
1208 Dir->setInc(Exprs.
Inc);
1209 Dir->setIsLastIterVariable(Exprs.
IL);
1210 Dir->setLowerBoundVariable(Exprs.
LB);
1211 Dir->setUpperBoundVariable(Exprs.
UB);
1212 Dir->setStrideVariable(Exprs.
ST);
1213 Dir->setEnsureUpperBound(Exprs.
EUB);
1214 Dir->setNextLowerBound(Exprs.
NLB);
1215 Dir->setNextUpperBound(Exprs.
NUB);
1219 Dir->setInits(Exprs.
Inits);
1220 Dir->setUpdates(Exprs.
Updates);
1221 Dir->setFinals(Exprs.
Finals);
1226 Dir->setHasCancel(HasCancel);
1232 unsigned NumClauses,
1234 return createEmptyDirective<OMPMaskedTaskLoopDirective>(
1235 C, NumClauses,
true,
1236 numLoopChildren(CollapsedNum, OMPD_masked_taskloop), CollapsedNum);
1243 auto *Dir = createDirective<OMPMasterTaskLoopSimdDirective>(
1244 C, Clauses, AssociatedStmt,
1245 numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), StartLoc,
1246 EndLoc, CollapsedNum);
1250 Dir->setPreCond(Exprs.
PreCond);
1251 Dir->setCond(Exprs.
Cond);
1252 Dir->setInit(Exprs.
Init);
1253 Dir->setInc(Exprs.
Inc);
1254 Dir->setIsLastIterVariable(Exprs.
IL);
1255 Dir->setLowerBoundVariable(Exprs.
LB);
1256 Dir->setUpperBoundVariable(Exprs.
UB);
1257 Dir->setStrideVariable(Exprs.
ST);
1258 Dir->setEnsureUpperBound(Exprs.
EUB);
1259 Dir->setNextLowerBound(Exprs.
NLB);
1260 Dir->setNextUpperBound(Exprs.
NUB);
1264 Dir->setInits(Exprs.
Inits);
1265 Dir->setUpdates(Exprs.
Updates);
1266 Dir->setFinals(Exprs.
Finals);
1276 unsigned NumClauses,
1278 return createEmptyDirective<OMPMasterTaskLoopSimdDirective>(
1279 C, NumClauses,
true,
1280 numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), CollapsedNum);
1287 auto *Dir = createDirective<OMPMaskedTaskLoopSimdDirective>(
1288 C, Clauses, AssociatedStmt,
1289 numLoopChildren(CollapsedNum, OMPD_masked_taskloop_simd), StartLoc,
1290 EndLoc, CollapsedNum);
1294 Dir->setPreCond(Exprs.
PreCond);
1295 Dir->setCond(Exprs.
Cond);
1296 Dir->setInit(Exprs.
Init);
1297 Dir->setInc(Exprs.
Inc);
1298 Dir->setIsLastIterVariable(Exprs.
IL);
1299 Dir->setLowerBoundVariable(Exprs.
LB);
1300 Dir->setUpperBoundVariable(Exprs.
UB);
1301 Dir->setStrideVariable(Exprs.
ST);
1302 Dir->setEnsureUpperBound(Exprs.
EUB);
1303 Dir->setNextLowerBound(Exprs.
NLB);
1304 Dir->setNextUpperBound(Exprs.
NUB);
1308 Dir->setInits(Exprs.
Inits);
1309 Dir->setUpdates(Exprs.
Updates);
1310 Dir->setFinals(Exprs.
Finals);
1320 unsigned NumClauses,
1322 return createEmptyDirective<OMPMaskedTaskLoopSimdDirective>(
1323 C, NumClauses,
true,
1324 numLoopChildren(CollapsedNum, OMPD_masked_taskloop_simd), CollapsedNum);
1331 auto *Dir = createDirective<OMPParallelMasterTaskLoopDirective>(
1332 C, Clauses, AssociatedStmt,
1333 numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop), StartLoc,
1334 EndLoc, CollapsedNum);
1338 Dir->setPreCond(Exprs.
PreCond);
1339 Dir->setCond(Exprs.
Cond);
1340 Dir->setInit(Exprs.
Init);
1341 Dir->setInc(Exprs.
Inc);
1342 Dir->setIsLastIterVariable(Exprs.
IL);
1343 Dir->setLowerBoundVariable(Exprs.
LB);
1344 Dir->setUpperBoundVariable(Exprs.
UB);
1345 Dir->setStrideVariable(Exprs.
ST);
1346 Dir->setEnsureUpperBound(Exprs.
EUB);
1347 Dir->setNextLowerBound(Exprs.
NLB);
1348 Dir->setNextUpperBound(Exprs.
NUB);
1352 Dir->setInits(Exprs.
Inits);
1353 Dir->setUpdates(Exprs.
Updates);
1354 Dir->setFinals(Exprs.
Finals);
1359 Dir->setHasCancel(HasCancel);
1365 unsigned NumClauses,
1366 unsigned CollapsedNum,
1368 return createEmptyDirective<OMPParallelMasterTaskLoopDirective>(
1369 C, NumClauses,
true,
1370 numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop),
1378 auto *Dir = createDirective<OMPParallelMaskedTaskLoopDirective>(
1379 C, Clauses, AssociatedStmt,
1380 numLoopChildren(CollapsedNum, OMPD_parallel_masked_taskloop), StartLoc,
1381 EndLoc, CollapsedNum);
1385 Dir->setPreCond(Exprs.
PreCond);
1386 Dir->setCond(Exprs.
Cond);
1387 Dir->setInit(Exprs.
Init);
1388 Dir->setInc(Exprs.
Inc);
1389 Dir->setIsLastIterVariable(Exprs.
IL);
1390 Dir->setLowerBoundVariable(Exprs.
LB);
1391 Dir->setUpperBoundVariable(Exprs.
UB);
1392 Dir->setStrideVariable(Exprs.
ST);
1393 Dir->setEnsureUpperBound(Exprs.
EUB);
1394 Dir->setNextLowerBound(Exprs.
NLB);
1395 Dir->setNextUpperBound(Exprs.
NUB);
1399 Dir->setInits(Exprs.
Inits);
1400 Dir->setUpdates(Exprs.
Updates);
1401 Dir->setFinals(Exprs.
Finals);
1406 Dir->setHasCancel(HasCancel);
1412 unsigned NumClauses,
1413 unsigned CollapsedNum,
1415 return createEmptyDirective<OMPParallelMaskedTaskLoopDirective>(
1416 C, NumClauses,
true,
1417 numLoopChildren(CollapsedNum, OMPD_parallel_masked_taskloop),
1426 auto *Dir = createDirective<OMPParallelMasterTaskLoopSimdDirective>(
1427 C, Clauses, AssociatedStmt,
1428 numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd),
1429 StartLoc, EndLoc, CollapsedNum);
1433 Dir->setPreCond(Exprs.
PreCond);
1434 Dir->setCond(Exprs.
Cond);
1435 Dir->setInit(Exprs.
Init);
1436 Dir->setInc(Exprs.
Inc);
1437 Dir->setIsLastIterVariable(Exprs.
IL);
1438 Dir->setLowerBoundVariable(Exprs.
LB);
1439 Dir->setUpperBoundVariable(Exprs.
UB);
1440 Dir->setStrideVariable(Exprs.
ST);
1441 Dir->setEnsureUpperBound(Exprs.
EUB);
1442 Dir->setNextLowerBound(Exprs.
NLB);
1443 Dir->setNextUpperBound(Exprs.
NUB);
1447 Dir->setInits(Exprs.
Inits);
1448 Dir->setUpdates(Exprs.
Updates);
1449 Dir->setFinals(Exprs.
Finals);
1459 unsigned NumClauses,
1460 unsigned CollapsedNum,
1462 return createEmptyDirective<OMPParallelMasterTaskLoopSimdDirective>(
1463 C, NumClauses,
true,
1464 numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd),
1473 auto *Dir = createDirective<OMPParallelMaskedTaskLoopSimdDirective>(
1474 C, Clauses, AssociatedStmt,
1475 numLoopChildren(CollapsedNum, OMPD_parallel_masked_taskloop_simd),
1476 StartLoc, EndLoc, CollapsedNum);
1480 Dir->setPreCond(Exprs.
PreCond);
1481 Dir->setCond(Exprs.
Cond);
1482 Dir->setInit(Exprs.
Init);
1483 Dir->setInc(Exprs.
Inc);
1484 Dir->setIsLastIterVariable(Exprs.
IL);
1485 Dir->setLowerBoundVariable(Exprs.
LB);
1486 Dir->setUpperBoundVariable(Exprs.
UB);
1487 Dir->setStrideVariable(Exprs.
ST);
1488 Dir->setEnsureUpperBound(Exprs.
EUB);
1489 Dir->setNextLowerBound(Exprs.
NLB);
1490 Dir->setNextUpperBound(Exprs.
NUB);
1494 Dir->setInits(Exprs.
Inits);
1495 Dir->setUpdates(Exprs.
Updates);
1496 Dir->setFinals(Exprs.
Finals);
1506 unsigned NumClauses,
1507 unsigned CollapsedNum,
1509 return createEmptyDirective<OMPParallelMaskedTaskLoopSimdDirective>(
1510 C, NumClauses,
true,
1511 numLoopChildren(CollapsedNum, OMPD_parallel_masked_taskloop_simd),
1519 auto *Dir = createDirective<OMPDistributeDirective>(
1520 C, Clauses, AssociatedStmt,
1521 numLoopChildren(CollapsedNum, OMPD_distribute), StartLoc, EndLoc,
1526 Dir->setPreCond(Exprs.
PreCond);
1527 Dir->setCond(Exprs.
Cond);
1528 Dir->setInit(Exprs.
Init);
1529 Dir->setInc(Exprs.
Inc);
1530 Dir->setIsLastIterVariable(Exprs.
IL);
1531 Dir->setLowerBoundVariable(Exprs.
LB);
1532 Dir->setUpperBoundVariable(Exprs.
UB);
1533 Dir->setStrideVariable(Exprs.
ST);
1534 Dir->setEnsureUpperBound(Exprs.
EUB);
1535 Dir->setNextLowerBound(Exprs.
NLB);
1536 Dir->setNextUpperBound(Exprs.
NUB);
1540 Dir->setInits(Exprs.
Inits);
1541 Dir->setUpdates(Exprs.
Updates);
1542 Dir->setFinals(Exprs.
Finals);
1553 return createEmptyDirective<OMPDistributeDirective>(
1554 C, NumClauses,
true,
1555 numLoopChildren(CollapsedNum, OMPD_distribute), CollapsedNum);
1561 return createDirective<OMPTargetUpdateDirective>(C, Clauses, AssociatedStmt,
1569 return createEmptyDirective<OMPTargetUpdateDirective>(
1570 C, NumClauses,
true);
1577 auto *Dir = createDirective<OMPDistributeParallelForDirective>(
1578 C, Clauses, AssociatedStmt,
1579 numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1, StartLoc,
1580 EndLoc, CollapsedNum);
1584 Dir->setPreCond(Exprs.
PreCond);
1585 Dir->setCond(Exprs.
Cond);
1586 Dir->setInit(Exprs.
Init);
1587 Dir->setInc(Exprs.
Inc);
1588 Dir->setIsLastIterVariable(Exprs.
IL);
1589 Dir->setLowerBoundVariable(Exprs.
LB);
1590 Dir->setUpperBoundVariable(Exprs.
UB);
1591 Dir->setStrideVariable(Exprs.
ST);
1592 Dir->setEnsureUpperBound(Exprs.
EUB);
1593 Dir->setNextLowerBound(Exprs.
NLB);
1594 Dir->setNextUpperBound(Exprs.
NUB);
1596 Dir->setPrevLowerBoundVariable(Exprs.
PrevLB);
1597 Dir->setPrevUpperBoundVariable(Exprs.
PrevUB);
1598 Dir->setDistInc(Exprs.
DistInc);
1599 Dir->setPrevEnsureUpperBound(Exprs.
PrevEUB);
1602 Dir->setInits(Exprs.
Inits);
1603 Dir->setUpdates(Exprs.
Updates);
1604 Dir->setFinals(Exprs.
Finals);
1618 Dir->setTaskReductionRefExpr(TaskRedRef);
1619 Dir->HasCancel = HasCancel;
1625 unsigned NumClauses,
1626 unsigned CollapsedNum,
1628 return createEmptyDirective<OMPDistributeParallelForDirective>(
1629 C, NumClauses,
true,
1630 numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1,
1639 auto *Dir = createDirective<OMPDistributeParallelForSimdDirective>(
1640 C, Clauses, AssociatedStmt,
1641 numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd),
1642 StartLoc, EndLoc, CollapsedNum);
1646 Dir->setPreCond(Exprs.
PreCond);
1647 Dir->setCond(Exprs.
Cond);
1648 Dir->setInit(Exprs.
Init);
1649 Dir->setInc(Exprs.
Inc);
1650 Dir->setIsLastIterVariable(Exprs.
IL);
1651 Dir->setLowerBoundVariable(Exprs.
LB);
1652 Dir->setUpperBoundVariable(Exprs.
UB);
1653 Dir->setStrideVariable(Exprs.
ST);
1654 Dir->setEnsureUpperBound(Exprs.
EUB);
1655 Dir->setNextLowerBound(Exprs.
NLB);
1656 Dir->setNextUpperBound(Exprs.
NUB);
1658 Dir->setPrevLowerBoundVariable(Exprs.
PrevLB);
1659 Dir->setPrevUpperBoundVariable(Exprs.
PrevUB);
1660 Dir->setDistInc(Exprs.
DistInc);
1661 Dir->setPrevEnsureUpperBound(Exprs.
PrevEUB);
1664 Dir->setInits(Exprs.
Inits);
1665 Dir->setUpdates(Exprs.
Updates);
1666 Dir->setFinals(Exprs.
Finals);
1685 unsigned NumClauses,
1686 unsigned CollapsedNum,
1688 return createEmptyDirective<OMPDistributeParallelForSimdDirective>(
1689 C, NumClauses,
true,
1690 numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd),
1698 auto *Dir = createDirective<OMPDistributeSimdDirective>(
1699 C, Clauses, AssociatedStmt,
1700 numLoopChildren(CollapsedNum, OMPD_distribute_simd), StartLoc, EndLoc,
1705 Dir->setPreCond(Exprs.
PreCond);
1706 Dir->setCond(Exprs.
Cond);
1707 Dir->setInit(Exprs.
Init);
1708 Dir->setInc(Exprs.
Inc);
1709 Dir->setIsLastIterVariable(Exprs.
IL);
1710 Dir->setLowerBoundVariable(Exprs.
LB);
1711 Dir->setUpperBoundVariable(Exprs.
UB);
1712 Dir->setStrideVariable(Exprs.
ST);
1713 Dir->setEnsureUpperBound(Exprs.
EUB);
1714 Dir->setNextLowerBound(Exprs.
NLB);
1715 Dir->setNextUpperBound(Exprs.
NUB);
1719 Dir->setInits(Exprs.
Inits);
1720 Dir->setUpdates(Exprs.
Updates);
1721 Dir->setFinals(Exprs.
Finals);
1731 unsigned NumClauses,
1733 return createEmptyDirective<OMPDistributeSimdDirective>(
1734 C, NumClauses,
true,
1735 numLoopChildren(CollapsedNum, OMPD_distribute_simd), CollapsedNum);
1742 auto *Dir = createDirective<OMPTargetParallelForSimdDirective>(
1743 C, Clauses, AssociatedStmt,
1744 numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd), StartLoc,
1745 EndLoc, CollapsedNum);
1749 Dir->setPreCond(Exprs.
PreCond);
1750 Dir->setCond(Exprs.
Cond);
1751 Dir->setInit(Exprs.
Init);
1752 Dir->setInc(Exprs.
Inc);
1753 Dir->setIsLastIterVariable(Exprs.
IL);
1754 Dir->setLowerBoundVariable(Exprs.
LB);
1755 Dir->setUpperBoundVariable(Exprs.
UB);
1756 Dir->setStrideVariable(Exprs.
ST);
1757 Dir->setEnsureUpperBound(Exprs.
EUB);
1758 Dir->setNextLowerBound(Exprs.
NLB);
1759 Dir->setNextUpperBound(Exprs.
NUB);
1763 Dir->setInits(Exprs.
Inits);
1764 Dir->setUpdates(Exprs.
Updates);
1765 Dir->setFinals(Exprs.
Finals);
1775 unsigned NumClauses,
1776 unsigned CollapsedNum,
1778 return createEmptyDirective<OMPTargetParallelForSimdDirective>(
1779 C, NumClauses,
true,
1780 numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd),
1789 auto *Dir = createDirective<OMPTargetSimdDirective>(
1790 C, Clauses, AssociatedStmt,
1791 numLoopChildren(CollapsedNum, OMPD_target_simd), StartLoc, EndLoc,
1796 Dir->setPreCond(Exprs.
PreCond);
1797 Dir->setCond(Exprs.
Cond);
1798 Dir->setInit(Exprs.
Init);
1799 Dir->setInc(Exprs.
Inc);
1802 Dir->setInits(Exprs.
Inits);
1803 Dir->setUpdates(Exprs.
Updates);
1804 Dir->setFinals(Exprs.
Finals);
1815 return createEmptyDirective<OMPTargetSimdDirective>(
1816 C, NumClauses,
true,
1817 numLoopChildren(CollapsedNum, OMPD_target_simd), CollapsedNum);
1824 auto *Dir = createDirective<OMPTeamsDistributeDirective>(
1825 C, Clauses, AssociatedStmt,
1826 numLoopChildren(CollapsedNum, OMPD_teams_distribute), StartLoc, EndLoc,
1831 Dir->setPreCond(Exprs.
PreCond);
1832 Dir->setCond(Exprs.
Cond);
1833 Dir->setInit(Exprs.
Init);
1834 Dir->setInc(Exprs.
Inc);
1835 Dir->setIsLastIterVariable(Exprs.
IL);
1836 Dir->setLowerBoundVariable(Exprs.
LB);
1837 Dir->setUpperBoundVariable(Exprs.
UB);
1838 Dir->setStrideVariable(Exprs.
ST);
1839 Dir->setEnsureUpperBound(Exprs.
EUB);
1840 Dir->setNextLowerBound(Exprs.
NLB);
1841 Dir->setNextUpperBound(Exprs.
NUB);
1845 Dir->setInits(Exprs.
Inits);
1846 Dir->setUpdates(Exprs.
Updates);
1847 Dir->setFinals(Exprs.
Finals);
1857 unsigned NumClauses,
1859 return createEmptyDirective<OMPTeamsDistributeDirective>(
1860 C, NumClauses,
true,
1861 numLoopChildren(CollapsedNum, OMPD_teams_distribute), CollapsedNum);
1868 auto *Dir = createDirective<OMPTeamsDistributeSimdDirective>(
1869 C, Clauses, AssociatedStmt,
1870 numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), StartLoc,
1871 EndLoc, CollapsedNum);
1875 Dir->setPreCond(Exprs.
PreCond);
1876 Dir->setCond(Exprs.
Cond);
1877 Dir->setInit(Exprs.
Init);
1878 Dir->setInc(Exprs.
Inc);
1879 Dir->setIsLastIterVariable(Exprs.
IL);
1880 Dir->setLowerBoundVariable(Exprs.
LB);
1881 Dir->setUpperBoundVariable(Exprs.
UB);
1882 Dir->setStrideVariable(Exprs.
ST);
1883 Dir->setEnsureUpperBound(Exprs.
EUB);
1884 Dir->setNextLowerBound(Exprs.
NLB);
1885 Dir->setNextUpperBound(Exprs.
NUB);
1889 Dir->setInits(Exprs.
Inits);
1890 Dir->setUpdates(Exprs.
Updates);
1891 Dir->setFinals(Exprs.
Finals);
1900 const ASTContext &C,
unsigned NumClauses,
unsigned CollapsedNum,
1902 return createEmptyDirective<OMPTeamsDistributeSimdDirective>(
1903 C, NumClauses,
true,
1904 numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), CollapsedNum);
1912 auto *Dir = createDirective<OMPTeamsDistributeParallelForSimdDirective>(
1913 C, Clauses, AssociatedStmt,
1914 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd),
1915 StartLoc, EndLoc, CollapsedNum);
1919 Dir->setPreCond(Exprs.
PreCond);
1920 Dir->setCond(Exprs.
Cond);
1921 Dir->setInit(Exprs.
Init);
1922 Dir->setInc(Exprs.
Inc);
1923 Dir->setIsLastIterVariable(Exprs.
IL);
1924 Dir->setLowerBoundVariable(Exprs.
LB);
1925 Dir->setUpperBoundVariable(Exprs.
UB);
1926 Dir->setStrideVariable(Exprs.
ST);
1927 Dir->setEnsureUpperBound(Exprs.
EUB);
1928 Dir->setNextLowerBound(Exprs.
NLB);
1929 Dir->setNextUpperBound(Exprs.
NUB);
1931 Dir->setPrevLowerBoundVariable(Exprs.
PrevLB);
1932 Dir->setPrevUpperBoundVariable(Exprs.
PrevUB);
1933 Dir->setDistInc(Exprs.
DistInc);
1934 Dir->setPrevEnsureUpperBound(Exprs.
PrevEUB);
1937 Dir->setInits(Exprs.
Inits);
1938 Dir->setUpdates(Exprs.
Updates);
1939 Dir->setFinals(Exprs.
Finals);
1958 unsigned NumClauses,
1959 unsigned CollapsedNum,
1961 return createEmptyDirective<OMPTeamsDistributeParallelForSimdDirective>(
1962 C, NumClauses,
true,
1963 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd),
1972 auto *Dir = createDirective<OMPTeamsDistributeParallelForDirective>(
1973 C, Clauses, AssociatedStmt,
1974 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1,
1975 StartLoc, EndLoc, CollapsedNum);
1979 Dir->setPreCond(Exprs.
PreCond);
1980 Dir->setCond(Exprs.
Cond);
1981 Dir->setInit(Exprs.
Init);
1982 Dir->setInc(Exprs.
Inc);
1983 Dir->setIsLastIterVariable(Exprs.
IL);
1984 Dir->setLowerBoundVariable(Exprs.
LB);
1985 Dir->setUpperBoundVariable(Exprs.
UB);
1986 Dir->setStrideVariable(Exprs.
ST);
1987 Dir->setEnsureUpperBound(Exprs.
EUB);
1988 Dir->setNextLowerBound(Exprs.
NLB);
1989 Dir->setNextUpperBound(Exprs.
NUB);
1991 Dir->setPrevLowerBoundVariable(Exprs.
PrevLB);
1992 Dir->setPrevUpperBoundVariable(Exprs.
PrevUB);
1993 Dir->setDistInc(Exprs.
DistInc);
1994 Dir->setPrevEnsureUpperBound(Exprs.
PrevEUB);
1997 Dir->setInits(Exprs.
Inits);
1998 Dir->setUpdates(Exprs.
Updates);
1999 Dir->setFinals(Exprs.
Finals);
2013 Dir->setTaskReductionRefExpr(TaskRedRef);
2014 Dir->HasCancel = HasCancel;
2020 unsigned NumClauses,
2021 unsigned CollapsedNum,
2023 return createEmptyDirective<OMPTeamsDistributeParallelForDirective>(
2024 C, NumClauses,
true,
2025 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1,
2032 return createDirective<OMPTargetTeamsDirective>(C, Clauses, AssociatedStmt,
2040 return createEmptyDirective<OMPTargetTeamsDirective>(
2041 C, NumClauses,
true);
2048 auto *Dir = createDirective<OMPTargetTeamsDistributeDirective>(
2049 C, Clauses, AssociatedStmt,
2050 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute), StartLoc,
2051 EndLoc, CollapsedNum);
2055 Dir->setPreCond(Exprs.
PreCond);
2056 Dir->setCond(Exprs.
Cond);
2057 Dir->setInit(Exprs.
Init);
2058 Dir->setInc(Exprs.
Inc);
2059 Dir->setIsLastIterVariable(Exprs.
IL);
2060 Dir->setLowerBoundVariable(Exprs.
LB);
2061 Dir->setUpperBoundVariable(Exprs.
UB);
2062 Dir->setStrideVariable(Exprs.
ST);
2063 Dir->setEnsureUpperBound(Exprs.
EUB);
2064 Dir->setNextLowerBound(Exprs.
NLB);
2065 Dir->setNextUpperBound(Exprs.
NUB);
2069 Dir->setInits(Exprs.
Inits);
2070 Dir->setUpdates(Exprs.
Updates);
2071 Dir->setFinals(Exprs.
Finals);
2081 unsigned NumClauses,
2082 unsigned CollapsedNum,
2084 return createEmptyDirective<OMPTargetTeamsDistributeDirective>(
2085 C, NumClauses,
true,
2086 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute),
2095 auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForDirective>(
2096 C, Clauses, AssociatedStmt,
2097 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) +
2099 StartLoc, EndLoc, CollapsedNum);
2103 Dir->setPreCond(Exprs.
PreCond);
2104 Dir->setCond(Exprs.
Cond);
2105 Dir->setInit(Exprs.
Init);
2106 Dir->setInc(Exprs.
Inc);
2107 Dir->setIsLastIterVariable(Exprs.
IL);
2108 Dir->setLowerBoundVariable(Exprs.
LB);
2109 Dir->setUpperBoundVariable(Exprs.
UB);
2110 Dir->setStrideVariable(Exprs.
ST);
2111 Dir->setEnsureUpperBound(Exprs.
EUB);
2112 Dir->setNextLowerBound(Exprs.
NLB);
2113 Dir->setNextUpperBound(Exprs.
NUB);
2115 Dir->setPrevLowerBoundVariable(Exprs.
PrevLB);
2116 Dir->setPrevUpperBoundVariable(Exprs.
PrevUB);
2117 Dir->setDistInc(Exprs.
DistInc);
2118 Dir->setPrevEnsureUpperBound(Exprs.
PrevEUB);
2121 Dir->setInits(Exprs.
Inits);
2122 Dir->setUpdates(Exprs.
Updates);
2123 Dir->setFinals(Exprs.
Finals);
2137 Dir->setTaskReductionRefExpr(TaskRedRef);
2138 Dir->HasCancel = HasCancel;
2144 unsigned NumClauses,
2145 unsigned CollapsedNum,
2147 return createEmptyDirective<OMPTargetTeamsDistributeParallelForDirective>(
2148 C, NumClauses,
true,
2149 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) +
2159 auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
2160 C, Clauses, AssociatedStmt,
2161 numLoopChildren(CollapsedNum,
2162 OMPD_target_teams_distribute_parallel_for_simd),
2163 StartLoc, EndLoc, CollapsedNum);
2167 Dir->setPreCond(Exprs.
PreCond);
2168 Dir->setCond(Exprs.
Cond);
2169 Dir->setInit(Exprs.
Init);
2170 Dir->setInc(Exprs.
Inc);
2171 Dir->setIsLastIterVariable(Exprs.
IL);
2172 Dir->setLowerBoundVariable(Exprs.
LB);
2173 Dir->setUpperBoundVariable(Exprs.
UB);
2174 Dir->setStrideVariable(Exprs.
ST);
2175 Dir->setEnsureUpperBound(Exprs.
EUB);
2176 Dir->setNextLowerBound(Exprs.
NLB);
2177 Dir->setNextUpperBound(Exprs.
NUB);
2179 Dir->setPrevLowerBoundVariable(Exprs.
PrevLB);
2180 Dir->setPrevUpperBoundVariable(Exprs.
PrevUB);
2181 Dir->setDistInc(Exprs.
DistInc);
2182 Dir->setPrevEnsureUpperBound(Exprs.
PrevEUB);
2185 Dir->setInits(Exprs.
Inits);
2186 Dir->setUpdates(Exprs.
Updates);
2187 Dir->setFinals(Exprs.
Finals);
2206 const ASTContext &C,
unsigned NumClauses,
unsigned CollapsedNum,
2208 return createEmptyDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
2209 C, NumClauses,
true,
2210 numLoopChildren(CollapsedNum,
2211 OMPD_target_teams_distribute_parallel_for_simd),
2220 auto *Dir = createDirective<OMPTargetTeamsDistributeSimdDirective>(
2221 C, Clauses, AssociatedStmt,
2222 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd),
2223 StartLoc, EndLoc, CollapsedNum);
2227 Dir->setPreCond(Exprs.
PreCond);
2228 Dir->setCond(Exprs.
Cond);
2229 Dir->setInit(Exprs.
Init);
2230 Dir->setInc(Exprs.
Inc);
2231 Dir->setIsLastIterVariable(Exprs.
IL);
2232 Dir->setLowerBoundVariable(Exprs.
LB);
2233 Dir->setUpperBoundVariable(Exprs.
UB);
2234 Dir->setStrideVariable(Exprs.
ST);
2235 Dir->setEnsureUpperBound(Exprs.
EUB);
2236 Dir->setNextLowerBound(Exprs.
NLB);
2237 Dir->setNextUpperBound(Exprs.
NUB);
2241 Dir->setInits(Exprs.
Inits);
2242 Dir->setUpdates(Exprs.
Updates);
2243 Dir->setFinals(Exprs.
Finals);
2253 unsigned NumClauses,
2254 unsigned CollapsedNum,
2256 return createEmptyDirective<OMPTargetTeamsDistributeSimdDirective>(
2257 C, NumClauses,
true,
2258 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd),
2266 return createDirective<OMPInteropDirective>(
2267 C, Clauses,
nullptr, 0, StartLoc,
2272 unsigned NumClauses,
2274 return createEmptyDirective<OMPInteropDirective>(C, NumClauses);
2281 auto *Dir = createDirective<OMPDispatchDirective>(
2282 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);
2283 Dir->setTargetCallLoc(TargetCallLoc);
2288 unsigned NumClauses,
2290 return createEmptyDirective<OMPDispatchDirective>(C, NumClauses,
2299 Stmt *AssociatedStmt) {
2300 return createDirective<OMPMaskedDirective>(C, Clauses, AssociatedStmt,
2306 unsigned NumClauses,
2308 return createEmptyDirective<OMPMaskedDirective>(C, NumClauses,
2316 auto *Dir = createDirective<OMPGenericLoopDirective>(
2317 C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_loop),
2318 StartLoc, EndLoc, CollapsedNum);
2322 Dir->setPreCond(Exprs.
PreCond);
2323 Dir->setCond(Exprs.
Cond);
2324 Dir->setInit(Exprs.
Init);
2325 Dir->setInc(Exprs.
Inc);
2326 Dir->setIsLastIterVariable(Exprs.
IL);
2327 Dir->setLowerBoundVariable(Exprs.
LB);
2328 Dir->setUpperBoundVariable(Exprs.
UB);
2329 Dir->setStrideVariable(Exprs.
ST);
2330 Dir->setEnsureUpperBound(Exprs.
EUB);
2331 Dir->setNextLowerBound(Exprs.
NLB);
2332 Dir->setNextUpperBound(Exprs.
NUB);
2336 Dir->setInits(Exprs.
Inits);
2337 Dir->setUpdates(Exprs.
Updates);
2338 Dir->setFinals(Exprs.
Finals);
2349 return createEmptyDirective<OMPGenericLoopDirective>(
2350 C, NumClauses,
true,
2351 numLoopChildren(CollapsedNum, OMPD_loop), CollapsedNum);
2358 auto *Dir = createDirective<OMPTeamsGenericLoopDirective>(
2359 C, Clauses, AssociatedStmt,
2360 numLoopChildren(CollapsedNum, OMPD_teams_loop), StartLoc, EndLoc,
2365 Dir->setPreCond(Exprs.
PreCond);
2366 Dir->setCond(Exprs.
Cond);
2367 Dir->setInit(Exprs.
Init);
2368 Dir->setInc(Exprs.
Inc);
2369 Dir->setIsLastIterVariable(Exprs.
IL);
2370 Dir->setLowerBoundVariable(Exprs.
LB);
2371 Dir->setUpperBoundVariable(Exprs.
UB);
2372 Dir->setStrideVariable(Exprs.
ST);
2373 Dir->setEnsureUpperBound(Exprs.
EUB);
2374 Dir->setNextLowerBound(Exprs.
NLB);
2375 Dir->setNextUpperBound(Exprs.
NUB);
2379 Dir->setInits(Exprs.
Inits);
2380 Dir->setUpdates(Exprs.
Updates);
2381 Dir->setFinals(Exprs.
Finals);
2391 unsigned NumClauses,
2393 return createEmptyDirective<OMPTeamsGenericLoopDirective>(
2394 C, NumClauses,
true,
2395 numLoopChildren(CollapsedNum, OMPD_teams_loop), CollapsedNum);
2402 auto *Dir = createDirective<OMPTargetTeamsGenericLoopDirective>(
2403 C, Clauses, AssociatedStmt,
2404 numLoopChildren(CollapsedNum, OMPD_target_teams_loop), StartLoc, EndLoc,
2409 Dir->setPreCond(Exprs.
PreCond);
2410 Dir->setCond(Exprs.
Cond);
2411 Dir->setInit(Exprs.
Init);
2412 Dir->setInc(Exprs.
Inc);
2413 Dir->setIsLastIterVariable(Exprs.
IL);
2414 Dir->setLowerBoundVariable(Exprs.
LB);
2415 Dir->setUpperBoundVariable(Exprs.
UB);
2416 Dir->setStrideVariable(Exprs.
ST);
2417 Dir->setEnsureUpperBound(Exprs.
EUB);
2418 Dir->setNextLowerBound(Exprs.
NLB);
2419 Dir->setNextUpperBound(Exprs.
NUB);
2423 Dir->setInits(Exprs.
Inits);
2424 Dir->setUpdates(Exprs.
Updates);
2425 Dir->setFinals(Exprs.
Finals);
2435 unsigned NumClauses,
2436 unsigned CollapsedNum,
2438 return createEmptyDirective<OMPTargetTeamsGenericLoopDirective>(
2439 C, NumClauses,
true,
2440 numLoopChildren(CollapsedNum, OMPD_target_teams_loop), CollapsedNum);
2447 auto *Dir = createDirective<OMPParallelGenericLoopDirective>(
2448 C, Clauses, AssociatedStmt,
2449 numLoopChildren(CollapsedNum, OMPD_parallel_loop), StartLoc, EndLoc,
2454 Dir->setPreCond(Exprs.
PreCond);
2455 Dir->setCond(Exprs.
Cond);
2456 Dir->setInit(Exprs.
Init);
2457 Dir->setInc(Exprs.
Inc);
2458 Dir->setIsLastIterVariable(Exprs.
IL);
2459 Dir->setLowerBoundVariable(Exprs.
LB);
2460 Dir->setUpperBoundVariable(Exprs.
UB);
2461 Dir->setStrideVariable(Exprs.
ST);
2462 Dir->setEnsureUpperBound(Exprs.
EUB);
2463 Dir->setNextLowerBound(Exprs.
NLB);
2464 Dir->setNextUpperBound(Exprs.
NUB);
2468 Dir->setInits(Exprs.
Inits);
2469 Dir->setUpdates(Exprs.
Updates);
2470 Dir->setFinals(Exprs.
Finals);
2479 const ASTContext &C,
unsigned NumClauses,
unsigned CollapsedNum,
2481 return createEmptyDirective<OMPParallelGenericLoopDirective>(
2482 C, NumClauses,
true,
2483 numLoopChildren(CollapsedNum, OMPD_parallel_loop), CollapsedNum);
2491 auto *Dir = createDirective<OMPTargetParallelGenericLoopDirective>(
2492 C, Clauses, AssociatedStmt,
2493 numLoopChildren(CollapsedNum, OMPD_target_parallel_loop), StartLoc,
2494 EndLoc, CollapsedNum);
2498 Dir->setPreCond(Exprs.
PreCond);
2499 Dir->setCond(Exprs.
Cond);
2500 Dir->setInit(Exprs.
Init);
2501 Dir->setInc(Exprs.
Inc);
2502 Dir->setIsLastIterVariable(Exprs.
IL);
2503 Dir->setLowerBoundVariable(Exprs.
LB);
2504 Dir->setUpperBoundVariable(Exprs.
UB);
2505 Dir->setStrideVariable(Exprs.
ST);
2506 Dir->setEnsureUpperBound(Exprs.
EUB);
2507 Dir->setNextLowerBound(Exprs.
NLB);
2508 Dir->setNextUpperBound(Exprs.
NUB);
2512 Dir->setInits(Exprs.
Inits);
2513 Dir->setUpdates(Exprs.
Updates);
2514 Dir->setFinals(Exprs.
Finals);
2524 unsigned NumClauses,
2525 unsigned CollapsedNum,
2527 return createEmptyDirective<OMPTargetParallelGenericLoopDirective>(
2528 C, NumClauses,
true,
2529 numLoopChildren(CollapsedNum, OMPD_target_parallel_loop), CollapsedNum);