17using namespace llvm::omp;
19size_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);
52OMPChildren *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))
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;
208 [&Body](
unsigned,
Stmt *,
Stmt *BodyStmt) { Body = BodyStmt; });
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());
227 "Number of counter inits is not the same as the collapsed number");
228 llvm::copy(A, getInits().begin());
233 "Number of counter updates is not the same as the collapsed number");
234 llvm::copy(A, getUpdates().begin());
239 "Number of counter finals is not the same as the collapsed number");
240 llvm::copy(A, getFinals().begin());
246 "Number of dependent counters is not the same as the collapsed number");
247 llvm::copy(A, getDependentCounters().begin());
252 "Number of dependent inits is not the same as the collapsed number");
253 llvm::copy(A, getDependentInits().begin());
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,
304 auto *Dir = createDirective<OMPSimdDirective>(
306 StartLoc, EndLoc, CollapsedNum);
310 Dir->setPreCond(Exprs.
PreCond);
311 Dir->setCond(Exprs.
Cond);
312 Dir->setInit(Exprs.
Init);
313 Dir->setInc(Exprs.
Inc);
316 Dir->setInits(Exprs.
Inits);
317 Dir->setUpdates(Exprs.
Updates);
318 Dir->setFinals(Exprs.
Finals);
323 Dir->setMappedDirective(ParamPrevMappedDirective);
329 unsigned CollapsedNum,
331 return createEmptyDirective<OMPSimdDirective>(
341 auto *Dir = createDirective<OMPForDirective>(
343 StartLoc, EndLoc, CollapsedNum);
347 Dir->setPreCond(Exprs.
PreCond);
348 Dir->setCond(Exprs.
Cond);
349 Dir->setInit(Exprs.
Init);
350 Dir->setInc(Exprs.
Inc);
351 Dir->setIsLastIterVariable(Exprs.
IL);
352 Dir->setLowerBoundVariable(Exprs.
LB);
353 Dir->setUpperBoundVariable(Exprs.
UB);
354 Dir->setStrideVariable(Exprs.
ST);
355 Dir->setEnsureUpperBound(Exprs.
EUB);
356 Dir->setNextLowerBound(Exprs.
NLB);
357 Dir->setNextUpperBound(Exprs.
NUB);
361 Dir->setInits(Exprs.
Inits);
362 Dir->setUpdates(Exprs.
Updates);
363 Dir->setFinals(Exprs.
Finals);
368 Dir->setTaskReductionRefExpr(TaskRedRef);
369 Dir->setHasCancel(HasCancel);
370 Dir->setMappedDirective(ParamPrevMappedDirective);
376#define STMT(CLASS, PARENT)
377#define ABSTRACT_STMT(CLASS)
378#define OMPLOOPTRANSFORMATIONDIRECTIVE(CLASS, PARENT) \
379 case Stmt::CLASS##Class: \
380 return static_cast<const CLASS *>(this)->getTransformedStmt();
381#include "clang/AST/StmtNodes.inc"
383 llvm_unreachable(
"Not a loop transformation");
389#define STMT(CLASS, PARENT)
390#define ABSTRACT_STMT(CLASS)
391#define OMPLOOPTRANSFORMATIONDIRECTIVE(CLASS, PARENT) \
392 case Stmt::CLASS##Class: \
393 return static_cast<const CLASS *>(this)->getPreInits();
394#include "clang/AST/StmtNodes.inc"
396 llvm_unreachable(
"Not a loop transformation");
402 unsigned CollapsedNum,
404 return createEmptyDirective<OMPForDirective>(
412 unsigned NumLoops,
Stmt *AssociatedStmt,
413 Stmt *TransformedStmt,
Stmt *PreInits) {
415 C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc,
417 Dir->setTransformedStmt(TransformedStmt);
418 Dir->setPreInits(PreInits);
425 return createEmptyDirective<OMPTileDirective>(
426 C, NumClauses,
true, TransformedStmtOffset + 1,
433 Stmt *AssociatedStmt,
unsigned NumGeneratedLoops,
434 Stmt *TransformedStmt,
Stmt *PreInits) {
435 assert(NumGeneratedLoops <= 1 &&
"Unrolling generates at most one loop");
437 auto *Dir = createDirective<OMPUnrollDirective>(
438 C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc);
439 Dir->setNumGeneratedLoops(NumGeneratedLoops);
440 Dir->setTransformedStmt(TransformedStmt);
441 Dir->setPreInits(PreInits);
446 unsigned NumClauses) {
447 return createEmptyDirective<OMPUnrollDirective>(
448 C, NumClauses,
true, TransformedStmtOffset + 1,
457 auto *Dir = createDirective<OMPForSimdDirective>(
459 StartLoc, EndLoc, CollapsedNum);
463 Dir->setPreCond(Exprs.
PreCond);
464 Dir->setCond(Exprs.
Cond);
465 Dir->setInit(Exprs.
Init);
466 Dir->setInc(Exprs.
Inc);
467 Dir->setIsLastIterVariable(Exprs.
IL);
468 Dir->setLowerBoundVariable(Exprs.
LB);
469 Dir->setUpperBoundVariable(Exprs.
UB);
470 Dir->setStrideVariable(Exprs.
ST);
471 Dir->setEnsureUpperBound(Exprs.
EUB);
472 Dir->setNextLowerBound(Exprs.
NLB);
473 Dir->setNextUpperBound(Exprs.
NUB);
477 Dir->setInits(Exprs.
Inits);
478 Dir->setUpdates(Exprs.
Updates);
479 Dir->setFinals(Exprs.
Finals);
489 unsigned CollapsedNum,
491 return createEmptyDirective<OMPForSimdDirective>(
500 auto *Dir = createDirective<OMPSectionsDirective>(
C, Clauses, AssociatedStmt,
503 Dir->setTaskReductionRefExpr(TaskRedRef);
504 Dir->setHasCancel(HasCancel);
511 return createEmptyDirective<OMPSectionsDirective>(
C, NumClauses,
519 Stmt *AssociatedStmt,
522 createDirective<OMPSectionDirective>(
C, std::nullopt, AssociatedStmt,
523 0, StartLoc, EndLoc);
524 Dir->setHasCancel(HasCancel);
530 return createEmptyDirective<OMPSectionDirective>(
C, 0,
538 Stmt *AssociatedStmt) {
539 return createDirective<OMPScopeDirective>(
C, Clauses, AssociatedStmt,
547 return createEmptyDirective<OMPScopeDirective>(
C, NumClauses,
555 Stmt *AssociatedStmt) {
556 return createDirective<OMPSingleDirective>(
C, Clauses, AssociatedStmt,
564 return createEmptyDirective<OMPSingleDirective>(
C, NumClauses,
571 Stmt *AssociatedStmt) {
572 return createDirective<OMPMasterDirective>(
C, std::nullopt, AssociatedStmt,
579 return createEmptyDirective<OMPMasterDirective>(
C, 0,
587 return createDirective<OMPCriticalDirective>(
C, Clauses, AssociatedStmt,
595 return createEmptyDirective<OMPCriticalDirective>(
C, NumClauses,
603 auto *Dir = createDirective<OMPParallelForDirective>(
604 C, Clauses, AssociatedStmt,
605 numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, StartLoc, EndLoc,
610 Dir->setPreCond(Exprs.
PreCond);
611 Dir->setCond(Exprs.
Cond);
612 Dir->setInit(Exprs.
Init);
613 Dir->setInc(Exprs.
Inc);
614 Dir->setIsLastIterVariable(Exprs.
IL);
615 Dir->setLowerBoundVariable(Exprs.
LB);
616 Dir->setUpperBoundVariable(Exprs.
UB);
617 Dir->setStrideVariable(Exprs.
ST);
618 Dir->setEnsureUpperBound(Exprs.
EUB);
619 Dir->setNextLowerBound(Exprs.
NLB);
620 Dir->setNextUpperBound(Exprs.
NUB);
624 Dir->setInits(Exprs.
Inits);
625 Dir->setUpdates(Exprs.
Updates);
626 Dir->setFinals(Exprs.
Finals);
631 Dir->setTaskReductionRefExpr(TaskRedRef);
632 Dir->setHasCancel(HasCancel);
639 return createEmptyDirective<OMPParallelForDirective>(
648 auto *Dir = createDirective<OMPParallelForSimdDirective>(
649 C, Clauses, AssociatedStmt,
650 numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), StartLoc, EndLoc,
655 Dir->setPreCond(Exprs.
PreCond);
656 Dir->setCond(Exprs.
Cond);
657 Dir->setInit(Exprs.
Init);
658 Dir->setInc(Exprs.
Inc);
659 Dir->setIsLastIterVariable(Exprs.
IL);
660 Dir->setLowerBoundVariable(Exprs.
LB);
661 Dir->setUpperBoundVariable(Exprs.
UB);
662 Dir->setStrideVariable(Exprs.
ST);
663 Dir->setEnsureUpperBound(Exprs.
EUB);
664 Dir->setNextLowerBound(Exprs.
NLB);
665 Dir->setNextUpperBound(Exprs.
NUB);
669 Dir->setInits(Exprs.
Inits);
670 Dir->setUpdates(Exprs.
Updates);
671 Dir->setFinals(Exprs.
Finals);
683 return createEmptyDirective<OMPParallelForSimdDirective>(
691 auto *Dir = createDirective<OMPParallelMasterDirective>(
692 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);
693 Dir->setTaskReductionRefExpr(TaskRedRef);
700 return createEmptyDirective<OMPParallelMasterDirective>(
701 C, NumClauses,
true, 1);
707 auto *Dir = createDirective<OMPParallelMaskedDirective>(
708 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);
709 Dir->setTaskReductionRefExpr(TaskRedRef);
716 return createEmptyDirective<OMPParallelMaskedDirective>(
717 C, NumClauses,
true, 1);
724 auto *Dir = createDirective<OMPParallelSectionsDirective>(
725 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);
726 Dir->setTaskReductionRefExpr(TaskRedRef);
727 Dir->setHasCancel(HasCancel);
734 return createEmptyDirective<OMPParallelSectionsDirective>(
735 C, NumClauses,
true, 1);
741 Stmt *AssociatedStmt,
bool HasCancel) {
742 auto *Dir = createDirective<OMPTaskDirective>(
743 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);
744 Dir->setHasCancel(HasCancel);
751 return createEmptyDirective<OMPTaskDirective>(
C, NumClauses,
770 return createDirective<OMPErrorDirective>(
771 C, Clauses,
nullptr, 0, StartLoc,
778 return createEmptyDirective<OMPErrorDirective>(
C, NumClauses);
796 return createDirective<OMPTaskwaitDirective>(
797 C, Clauses,
nullptr, 0, StartLoc,
804 return createEmptyDirective<OMPTaskwaitDirective>(
C, NumClauses);
810 auto *Dir = createDirective<OMPTaskgroupDirective>(
811 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);
812 Dir->setReductionRef(ReductionRef);
819 return createEmptyDirective<OMPTaskgroupDirective>(
820 C, NumClauses,
true, 1);
827 Dir->setCancelRegion(CancelRegion);
840 auto *Dir = createDirective<OMPCancelDirective>(
841 C, Clauses,
nullptr, 0, StartLoc,
843 Dir->setCancelRegion(CancelRegion);
850 return createEmptyDirective<OMPCancelDirective>(
C, NumClauses);
857 return createDirective<OMPFlushDirective>(
858 C, Clauses,
nullptr, 0, StartLoc,
865 return createEmptyDirective<OMPFlushDirective>(
C, NumClauses);
872 return createDirective<OMPDepobjDirective>(
874 0, StartLoc, EndLoc);
880 return createEmptyDirective<OMPDepobjDirective>(
C, NumClauses);
887 return createDirective<OMPScanDirective>(
C, Clauses,
889 0, StartLoc, EndLoc);
895 return createEmptyDirective<OMPScanDirective>(
C, NumClauses);
902 Stmt *AssociatedStmt) {
903 return createDirective<OMPOrderedDirective>(
904 C, Clauses, cast_or_null<CapturedStmt>(AssociatedStmt),
905 0, StartLoc, EndLoc);
912 return createEmptyDirective<OMPOrderedDirective>(
C, NumClauses,
920 auto *Dir = createDirective<OMPAtomicDirective>(
921 C, Clauses, AssociatedStmt, 7, StartLoc, EndLoc);
925 Dir->setExpr(Exprs.
E);
926 Dir->setUpdateExpr(Exprs.
UE);
928 Dir->setCond(Exprs.
Cond);
931 Dir->Flags.IsFailOnly = Exprs.
IsFailOnly ? 1 : 0;
938 return createEmptyDirective<OMPAtomicDirective>(
939 C, NumClauses,
true, 7);
946 Stmt *AssociatedStmt) {
947 return createDirective<OMPTargetDirective>(
948 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);
954 return createEmptyDirective<OMPTargetDirective>(
C, NumClauses,
962 auto *Dir = createDirective<OMPTargetParallelDirective>(
963 C, Clauses, AssociatedStmt, 1, StartLoc, EndLoc);
964 Dir->setTaskReductionRefExpr(TaskRedRef);
965 Dir->setHasCancel(HasCancel);
972 return createEmptyDirective<OMPTargetParallelDirective>(
973 C, NumClauses,
true, 1);
980 auto *Dir = createDirective<OMPTargetParallelForDirective>(
981 C, Clauses, AssociatedStmt,
983 EndLoc, CollapsedNum);
987 Dir->setPreCond(Exprs.
PreCond);
988 Dir->setCond(Exprs.
Cond);
989 Dir->setInit(Exprs.
Init);
990 Dir->setInc(Exprs.
Inc);
991 Dir->setIsLastIterVariable(Exprs.
IL);
992 Dir->setLowerBoundVariable(Exprs.
LB);
993 Dir->setUpperBoundVariable(Exprs.
UB);
994 Dir->setStrideVariable(Exprs.
ST);
995 Dir->setEnsureUpperBound(Exprs.
EUB);
996 Dir->setNextLowerBound(Exprs.
NLB);
997 Dir->setNextUpperBound(Exprs.
NUB);
1001 Dir->setInits(Exprs.
Inits);
1002 Dir->setUpdates(Exprs.
Updates);
1003 Dir->setFinals(Exprs.
Finals);
1008 Dir->setTaskReductionRefExpr(TaskRedRef);
1009 Dir->setHasCancel(HasCancel);
1015 unsigned NumClauses,
1017 return createEmptyDirective<OMPTargetParallelForDirective>(
1018 C, NumClauses,
true,
1026 return createDirective<OMPTargetDataDirective>(
1027 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);
1033 return createEmptyDirective<OMPTargetDataDirective>(
1040 return createDirective<OMPTargetEnterDataDirective>(
1041 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);
1047 return createEmptyDirective<OMPTargetEnterDataDirective>(
1054 return createDirective<OMPTargetExitDataDirective>(
1055 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);
1061 return createEmptyDirective<OMPTargetExitDataDirective>(
1069 Stmt *AssociatedStmt) {
1070 return createDirective<OMPTeamsDirective>(
1071 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);
1075 unsigned NumClauses,
1077 return createEmptyDirective<OMPTeamsDirective>(
C, NumClauses,
1085 auto *Dir = createDirective<OMPTaskLoopDirective>(
1087 StartLoc, EndLoc, CollapsedNum);
1091 Dir->setPreCond(Exprs.
PreCond);
1092 Dir->setCond(Exprs.
Cond);
1093 Dir->setInit(Exprs.
Init);
1094 Dir->setInc(Exprs.
Inc);
1095 Dir->setIsLastIterVariable(Exprs.
IL);
1096 Dir->setLowerBoundVariable(Exprs.
LB);
1097 Dir->setUpperBoundVariable(Exprs.
UB);
1098 Dir->setStrideVariable(Exprs.
ST);
1099 Dir->setEnsureUpperBound(Exprs.
EUB);
1100 Dir->setNextLowerBound(Exprs.
NLB);
1101 Dir->setNextUpperBound(Exprs.
NUB);
1105 Dir->setInits(Exprs.
Inits);
1106 Dir->setUpdates(Exprs.
Updates);
1107 Dir->setFinals(Exprs.
Finals);
1112 Dir->setHasCancel(HasCancel);
1117 unsigned NumClauses,
1118 unsigned CollapsedNum,
1120 return createEmptyDirective<OMPTaskLoopDirective>(
1121 C, NumClauses,
true,
1129 auto *Dir = createDirective<OMPTaskLoopSimdDirective>(
1130 C, Clauses, AssociatedStmt,
1136 Dir->setPreCond(Exprs.
PreCond);
1137 Dir->setCond(Exprs.
Cond);
1138 Dir->setInit(Exprs.
Init);
1139 Dir->setInc(Exprs.
Inc);
1140 Dir->setIsLastIterVariable(Exprs.
IL);
1141 Dir->setLowerBoundVariable(Exprs.
LB);
1142 Dir->setUpperBoundVariable(Exprs.
UB);
1143 Dir->setStrideVariable(Exprs.
ST);
1144 Dir->setEnsureUpperBound(Exprs.
EUB);
1145 Dir->setNextLowerBound(Exprs.
NLB);
1146 Dir->setNextUpperBound(Exprs.
NUB);
1150 Dir->setInits(Exprs.
Inits);
1151 Dir->setUpdates(Exprs.
Updates);
1152 Dir->setFinals(Exprs.
Finals);
1163 return createEmptyDirective<OMPTaskLoopSimdDirective>(
1164 C, NumClauses,
true,
1172 auto *Dir = createDirective<OMPMasterTaskLoopDirective>(
1173 C, Clauses, AssociatedStmt,
1174 numLoopChildren(CollapsedNum, OMPD_master_taskloop), StartLoc, EndLoc,
1179 Dir->setPreCond(Exprs.
PreCond);
1180 Dir->setCond(Exprs.
Cond);
1181 Dir->setInit(Exprs.
Init);
1182 Dir->setInc(Exprs.
Inc);
1183 Dir->setIsLastIterVariable(Exprs.
IL);
1184 Dir->setLowerBoundVariable(Exprs.
LB);
1185 Dir->setUpperBoundVariable(Exprs.
UB);
1186 Dir->setStrideVariable(Exprs.
ST);
1187 Dir->setEnsureUpperBound(Exprs.
EUB);
1188 Dir->setNextLowerBound(Exprs.
NLB);
1189 Dir->setNextUpperBound(Exprs.
NUB);
1193 Dir->setInits(Exprs.
Inits);
1194 Dir->setUpdates(Exprs.
Updates);
1195 Dir->setFinals(Exprs.
Finals);
1200 Dir->setHasCancel(HasCancel);
1206 unsigned NumClauses,
1208 return createEmptyDirective<OMPMasterTaskLoopDirective>(
1209 C, NumClauses,
true,
1217 auto *Dir = createDirective<OMPMaskedTaskLoopDirective>(
1218 C, Clauses, AssociatedStmt,
1219 numLoopChildren(CollapsedNum, OMPD_masked_taskloop), StartLoc, EndLoc,
1224 Dir->setPreCond(Exprs.
PreCond);
1225 Dir->setCond(Exprs.
Cond);
1226 Dir->setInit(Exprs.
Init);
1227 Dir->setInc(Exprs.
Inc);
1228 Dir->setIsLastIterVariable(Exprs.
IL);
1229 Dir->setLowerBoundVariable(Exprs.
LB);
1230 Dir->setUpperBoundVariable(Exprs.
UB);
1231 Dir->setStrideVariable(Exprs.
ST);
1232 Dir->setEnsureUpperBound(Exprs.
EUB);
1233 Dir->setNextLowerBound(Exprs.
NLB);
1234 Dir->setNextUpperBound(Exprs.
NUB);
1238 Dir->setInits(Exprs.
Inits);
1239 Dir->setUpdates(Exprs.
Updates);
1240 Dir->setFinals(Exprs.
Finals);
1245 Dir->setHasCancel(HasCancel);
1251 unsigned NumClauses,
1253 return createEmptyDirective<OMPMaskedTaskLoopDirective>(
1254 C, NumClauses,
true,
1262 auto *Dir = createDirective<OMPMasterTaskLoopSimdDirective>(
1263 C, Clauses, AssociatedStmt,
1265 EndLoc, CollapsedNum);
1269 Dir->setPreCond(Exprs.
PreCond);
1270 Dir->setCond(Exprs.
Cond);
1271 Dir->setInit(Exprs.
Init);
1272 Dir->setInc(Exprs.
Inc);
1273 Dir->setIsLastIterVariable(Exprs.
IL);
1274 Dir->setLowerBoundVariable(Exprs.
LB);
1275 Dir->setUpperBoundVariable(Exprs.
UB);
1276 Dir->setStrideVariable(Exprs.
ST);
1277 Dir->setEnsureUpperBound(Exprs.
EUB);
1278 Dir->setNextLowerBound(Exprs.
NLB);
1279 Dir->setNextUpperBound(Exprs.
NUB);
1283 Dir->setInits(Exprs.
Inits);
1284 Dir->setUpdates(Exprs.
Updates);
1285 Dir->setFinals(Exprs.
Finals);
1295 unsigned NumClauses,
1297 return createEmptyDirective<OMPMasterTaskLoopSimdDirective>(
1298 C, NumClauses,
true,
1299 numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), CollapsedNum);
1306 auto *Dir = createDirective<OMPMaskedTaskLoopSimdDirective>(
1307 C, Clauses, AssociatedStmt,
1309 EndLoc, CollapsedNum);
1313 Dir->setPreCond(Exprs.
PreCond);
1314 Dir->setCond(Exprs.
Cond);
1315 Dir->setInit(Exprs.
Init);
1316 Dir->setInc(Exprs.
Inc);
1317 Dir->setIsLastIterVariable(Exprs.
IL);
1318 Dir->setLowerBoundVariable(Exprs.
LB);
1319 Dir->setUpperBoundVariable(Exprs.
UB);
1320 Dir->setStrideVariable(Exprs.
ST);
1321 Dir->setEnsureUpperBound(Exprs.
EUB);
1322 Dir->setNextLowerBound(Exprs.
NLB);
1323 Dir->setNextUpperBound(Exprs.
NUB);
1327 Dir->setInits(Exprs.
Inits);
1328 Dir->setUpdates(Exprs.
Updates);
1329 Dir->setFinals(Exprs.
Finals);
1339 unsigned NumClauses,
1341 return createEmptyDirective<OMPMaskedTaskLoopSimdDirective>(
1342 C, NumClauses,
true,
1343 numLoopChildren(CollapsedNum, OMPD_masked_taskloop_simd), CollapsedNum);
1350 auto *Dir = createDirective<OMPParallelMasterTaskLoopDirective>(
1351 C, Clauses, AssociatedStmt,
1352 numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop), StartLoc,
1353 EndLoc, CollapsedNum);
1357 Dir->setPreCond(Exprs.
PreCond);
1358 Dir->setCond(Exprs.
Cond);
1359 Dir->setInit(Exprs.
Init);
1360 Dir->setInc(Exprs.
Inc);
1361 Dir->setIsLastIterVariable(Exprs.
IL);
1362 Dir->setLowerBoundVariable(Exprs.
LB);
1363 Dir->setUpperBoundVariable(Exprs.
UB);
1364 Dir->setStrideVariable(Exprs.
ST);
1365 Dir->setEnsureUpperBound(Exprs.
EUB);
1366 Dir->setNextLowerBound(Exprs.
NLB);
1367 Dir->setNextUpperBound(Exprs.
NUB);
1371 Dir->setInits(Exprs.
Inits);
1372 Dir->setUpdates(Exprs.
Updates);
1373 Dir->setFinals(Exprs.
Finals);
1378 Dir->setHasCancel(HasCancel);
1384 unsigned NumClauses,
1385 unsigned CollapsedNum,
1387 return createEmptyDirective<OMPParallelMasterTaskLoopDirective>(
1388 C, NumClauses,
true,
1397 auto *Dir = createDirective<OMPParallelMaskedTaskLoopDirective>(
1398 C, Clauses, AssociatedStmt,
1399 numLoopChildren(CollapsedNum, OMPD_parallel_masked_taskloop), StartLoc,
1400 EndLoc, CollapsedNum);
1404 Dir->setPreCond(Exprs.
PreCond);
1405 Dir->setCond(Exprs.
Cond);
1406 Dir->setInit(Exprs.
Init);
1407 Dir->setInc(Exprs.
Inc);
1408 Dir->setIsLastIterVariable(Exprs.
IL);
1409 Dir->setLowerBoundVariable(Exprs.
LB);
1410 Dir->setUpperBoundVariable(Exprs.
UB);
1411 Dir->setStrideVariable(Exprs.
ST);
1412 Dir->setEnsureUpperBound(Exprs.
EUB);
1413 Dir->setNextLowerBound(Exprs.
NLB);
1414 Dir->setNextUpperBound(Exprs.
NUB);
1418 Dir->setInits(Exprs.
Inits);
1419 Dir->setUpdates(Exprs.
Updates);
1420 Dir->setFinals(Exprs.
Finals);
1425 Dir->setHasCancel(HasCancel);
1431 unsigned NumClauses,
1432 unsigned CollapsedNum,
1434 return createEmptyDirective<OMPParallelMaskedTaskLoopDirective>(
1435 C, NumClauses,
true,
1445 auto *Dir = createDirective<OMPParallelMasterTaskLoopSimdDirective>(
1446 C, Clauses, AssociatedStmt,
1448 StartLoc, EndLoc, CollapsedNum);
1452 Dir->setPreCond(Exprs.
PreCond);
1453 Dir->setCond(Exprs.
Cond);
1454 Dir->setInit(Exprs.
Init);
1455 Dir->setInc(Exprs.
Inc);
1456 Dir->setIsLastIterVariable(Exprs.
IL);
1457 Dir->setLowerBoundVariable(Exprs.
LB);
1458 Dir->setUpperBoundVariable(Exprs.
UB);
1459 Dir->setStrideVariable(Exprs.
ST);
1460 Dir->setEnsureUpperBound(Exprs.
EUB);
1461 Dir->setNextLowerBound(Exprs.
NLB);
1462 Dir->setNextUpperBound(Exprs.
NUB);
1466 Dir->setInits(Exprs.
Inits);
1467 Dir->setUpdates(Exprs.
Updates);
1468 Dir->setFinals(Exprs.
Finals);
1478 unsigned NumClauses,
1479 unsigned CollapsedNum,
1481 return createEmptyDirective<OMPParallelMasterTaskLoopSimdDirective>(
1482 C, NumClauses,
true,
1492 auto *Dir = createDirective<OMPParallelMaskedTaskLoopSimdDirective>(
1493 C, Clauses, AssociatedStmt,
1495 StartLoc, EndLoc, CollapsedNum);
1499 Dir->setPreCond(Exprs.
PreCond);
1500 Dir->setCond(Exprs.
Cond);
1501 Dir->setInit(Exprs.
Init);
1502 Dir->setInc(Exprs.
Inc);
1503 Dir->setIsLastIterVariable(Exprs.
IL);
1504 Dir->setLowerBoundVariable(Exprs.
LB);
1505 Dir->setUpperBoundVariable(Exprs.
UB);
1506 Dir->setStrideVariable(Exprs.
ST);
1507 Dir->setEnsureUpperBound(Exprs.
EUB);
1508 Dir->setNextLowerBound(Exprs.
NLB);
1509 Dir->setNextUpperBound(Exprs.
NUB);
1513 Dir->setInits(Exprs.
Inits);
1514 Dir->setUpdates(Exprs.
Updates);
1515 Dir->setFinals(Exprs.
Finals);
1525 unsigned NumClauses,
1526 unsigned CollapsedNum,
1528 return createEmptyDirective<OMPParallelMaskedTaskLoopSimdDirective>(
1529 C, NumClauses,
true,
1538 auto *Dir = createDirective<OMPDistributeDirective>(
1539 C, Clauses, AssociatedStmt,
1545 Dir->setPreCond(Exprs.
PreCond);
1546 Dir->setCond(Exprs.
Cond);
1547 Dir->setInit(Exprs.
Init);
1548 Dir->setInc(Exprs.
Inc);
1549 Dir->setIsLastIterVariable(Exprs.
IL);
1550 Dir->setLowerBoundVariable(Exprs.
LB);
1551 Dir->setUpperBoundVariable(Exprs.
UB);
1552 Dir->setStrideVariable(Exprs.
ST);
1553 Dir->setEnsureUpperBound(Exprs.
EUB);
1554 Dir->setNextLowerBound(Exprs.
NLB);
1555 Dir->setNextUpperBound(Exprs.
NUB);
1559 Dir->setInits(Exprs.
Inits);
1560 Dir->setUpdates(Exprs.
Updates);
1561 Dir->setFinals(Exprs.
Finals);
1566 Dir->setMappedDirective(ParamPrevMappedDirective);
1573 return createEmptyDirective<OMPDistributeDirective>(
1574 C, NumClauses,
true,
1581 return createDirective<OMPTargetUpdateDirective>(
C, Clauses, AssociatedStmt,
1589 return createEmptyDirective<OMPTargetUpdateDirective>(
1590 C, NumClauses,
true);
1597 auto *Dir = createDirective<OMPDistributeParallelForDirective>(
1598 C, Clauses, AssociatedStmt,
1599 numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1, StartLoc,
1600 EndLoc, CollapsedNum);
1604 Dir->setPreCond(Exprs.
PreCond);
1605 Dir->setCond(Exprs.
Cond);
1606 Dir->setInit(Exprs.
Init);
1607 Dir->setInc(Exprs.
Inc);
1608 Dir->setIsLastIterVariable(Exprs.
IL);
1609 Dir->setLowerBoundVariable(Exprs.
LB);
1610 Dir->setUpperBoundVariable(Exprs.
UB);
1611 Dir->setStrideVariable(Exprs.
ST);
1612 Dir->setEnsureUpperBound(Exprs.
EUB);
1613 Dir->setNextLowerBound(Exprs.
NLB);
1614 Dir->setNextUpperBound(Exprs.
NUB);
1616 Dir->setPrevLowerBoundVariable(Exprs.
PrevLB);
1617 Dir->setPrevUpperBoundVariable(Exprs.
PrevUB);
1618 Dir->setDistInc(Exprs.
DistInc);
1619 Dir->setPrevEnsureUpperBound(Exprs.
PrevEUB);
1622 Dir->setInits(Exprs.
Inits);
1623 Dir->setUpdates(Exprs.
Updates);
1624 Dir->setFinals(Exprs.
Finals);
1638 Dir->setTaskReductionRefExpr(TaskRedRef);
1639 Dir->HasCancel = HasCancel;
1645 unsigned NumClauses,
1646 unsigned CollapsedNum,
1648 return createEmptyDirective<OMPDistributeParallelForDirective>(
1649 C, NumClauses,
true,
1659 auto *Dir = createDirective<OMPDistributeParallelForSimdDirective>(
1660 C, Clauses, AssociatedStmt,
1662 StartLoc, EndLoc, CollapsedNum);
1666 Dir->setPreCond(Exprs.
PreCond);
1667 Dir->setCond(Exprs.
Cond);
1668 Dir->setInit(Exprs.
Init);
1669 Dir->setInc(Exprs.
Inc);
1670 Dir->setIsLastIterVariable(Exprs.
IL);
1671 Dir->setLowerBoundVariable(Exprs.
LB);
1672 Dir->setUpperBoundVariable(Exprs.
UB);
1673 Dir->setStrideVariable(Exprs.
ST);
1674 Dir->setEnsureUpperBound(Exprs.
EUB);
1675 Dir->setNextLowerBound(Exprs.
NLB);
1676 Dir->setNextUpperBound(Exprs.
NUB);
1678 Dir->setPrevLowerBoundVariable(Exprs.
PrevLB);
1679 Dir->setPrevUpperBoundVariable(Exprs.
PrevUB);
1680 Dir->setDistInc(Exprs.
DistInc);
1681 Dir->setPrevEnsureUpperBound(Exprs.
PrevEUB);
1684 Dir->setInits(Exprs.
Inits);
1685 Dir->setUpdates(Exprs.
Updates);
1686 Dir->setFinals(Exprs.
Finals);
1705 unsigned NumClauses,
1706 unsigned CollapsedNum,
1708 return createEmptyDirective<OMPDistributeParallelForSimdDirective>(
1709 C, NumClauses,
true,
1718 auto *Dir = createDirective<OMPDistributeSimdDirective>(
1719 C, Clauses, AssociatedStmt,
1720 numLoopChildren(CollapsedNum, OMPD_distribute_simd), StartLoc, EndLoc,
1725 Dir->setPreCond(Exprs.
PreCond);
1726 Dir->setCond(Exprs.
Cond);
1727 Dir->setInit(Exprs.
Init);
1728 Dir->setInc(Exprs.
Inc);
1729 Dir->setIsLastIterVariable(Exprs.
IL);
1730 Dir->setLowerBoundVariable(Exprs.
LB);
1731 Dir->setUpperBoundVariable(Exprs.
UB);
1732 Dir->setStrideVariable(Exprs.
ST);
1733 Dir->setEnsureUpperBound(Exprs.
EUB);
1734 Dir->setNextLowerBound(Exprs.
NLB);
1735 Dir->setNextUpperBound(Exprs.
NUB);
1739 Dir->setInits(Exprs.
Inits);
1740 Dir->setUpdates(Exprs.
Updates);
1741 Dir->setFinals(Exprs.
Finals);
1751 unsigned NumClauses,
1753 return createEmptyDirective<OMPDistributeSimdDirective>(
1754 C, NumClauses,
true,
1762 auto *Dir = createDirective<OMPTargetParallelForSimdDirective>(
1763 C, Clauses, AssociatedStmt,
1764 numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd), StartLoc,
1765 EndLoc, CollapsedNum);
1769 Dir->setPreCond(Exprs.
PreCond);
1770 Dir->setCond(Exprs.
Cond);
1771 Dir->setInit(Exprs.
Init);
1772 Dir->setInc(Exprs.
Inc);
1773 Dir->setIsLastIterVariable(Exprs.
IL);
1774 Dir->setLowerBoundVariable(Exprs.
LB);
1775 Dir->setUpperBoundVariable(Exprs.
UB);
1776 Dir->setStrideVariable(Exprs.
ST);
1777 Dir->setEnsureUpperBound(Exprs.
EUB);
1778 Dir->setNextLowerBound(Exprs.
NLB);
1779 Dir->setNextUpperBound(Exprs.
NUB);
1783 Dir->setInits(Exprs.
Inits);
1784 Dir->setUpdates(Exprs.
Updates);
1785 Dir->setFinals(Exprs.
Finals);
1795 unsigned NumClauses,
1796 unsigned CollapsedNum,
1798 return createEmptyDirective<OMPTargetParallelForSimdDirective>(
1799 C, NumClauses,
true,
1809 auto *Dir = createDirective<OMPTargetSimdDirective>(
1810 C, Clauses, AssociatedStmt,
1816 Dir->setPreCond(Exprs.
PreCond);
1817 Dir->setCond(Exprs.
Cond);
1818 Dir->setInit(Exprs.
Init);
1819 Dir->setInc(Exprs.
Inc);
1822 Dir->setInits(Exprs.
Inits);
1823 Dir->setUpdates(Exprs.
Updates);
1824 Dir->setFinals(Exprs.
Finals);
1835 return createEmptyDirective<OMPTargetSimdDirective>(
1836 C, NumClauses,
true,
1844 auto *Dir = createDirective<OMPTeamsDistributeDirective>(
1845 C, Clauses, AssociatedStmt,
1846 numLoopChildren(CollapsedNum, OMPD_teams_distribute), StartLoc, EndLoc,
1851 Dir->setPreCond(Exprs.
PreCond);
1852 Dir->setCond(Exprs.
Cond);
1853 Dir->setInit(Exprs.
Init);
1854 Dir->setInc(Exprs.
Inc);
1855 Dir->setIsLastIterVariable(Exprs.
IL);
1856 Dir->setLowerBoundVariable(Exprs.
LB);
1857 Dir->setUpperBoundVariable(Exprs.
UB);
1858 Dir->setStrideVariable(Exprs.
ST);
1859 Dir->setEnsureUpperBound(Exprs.
EUB);
1860 Dir->setNextLowerBound(Exprs.
NLB);
1861 Dir->setNextUpperBound(Exprs.
NUB);
1865 Dir->setInits(Exprs.
Inits);
1866 Dir->setUpdates(Exprs.
Updates);
1867 Dir->setFinals(Exprs.
Finals);
1877 unsigned NumClauses,
1879 return createEmptyDirective<OMPTeamsDistributeDirective>(
1880 C, NumClauses,
true,
1888 auto *Dir = createDirective<OMPTeamsDistributeSimdDirective>(
1889 C, Clauses, AssociatedStmt,
1891 EndLoc, CollapsedNum);
1895 Dir->setPreCond(Exprs.
PreCond);
1896 Dir->setCond(Exprs.
Cond);
1897 Dir->setInit(Exprs.
Init);
1898 Dir->setInc(Exprs.
Inc);
1899 Dir->setIsLastIterVariable(Exprs.
IL);
1900 Dir->setLowerBoundVariable(Exprs.
LB);
1901 Dir->setUpperBoundVariable(Exprs.
UB);
1902 Dir->setStrideVariable(Exprs.
ST);
1903 Dir->setEnsureUpperBound(Exprs.
EUB);
1904 Dir->setNextLowerBound(Exprs.
NLB);
1905 Dir->setNextUpperBound(Exprs.
NUB);
1909 Dir->setInits(Exprs.
Inits);
1910 Dir->setUpdates(Exprs.
Updates);
1911 Dir->setFinals(Exprs.
Finals);
1920 const ASTContext &
C,
unsigned NumClauses,
unsigned CollapsedNum,
1922 return createEmptyDirective<OMPTeamsDistributeSimdDirective>(
1923 C, NumClauses,
true,
1924 numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), CollapsedNum);
1932 auto *Dir = createDirective<OMPTeamsDistributeParallelForSimdDirective>(
1933 C, Clauses, AssociatedStmt,
1934 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd),
1935 StartLoc, EndLoc, CollapsedNum);
1939 Dir->setPreCond(Exprs.
PreCond);
1940 Dir->setCond(Exprs.
Cond);
1941 Dir->setInit(Exprs.
Init);
1942 Dir->setInc(Exprs.
Inc);
1943 Dir->setIsLastIterVariable(Exprs.
IL);
1944 Dir->setLowerBoundVariable(Exprs.
LB);
1945 Dir->setUpperBoundVariable(Exprs.
UB);
1946 Dir->setStrideVariable(Exprs.
ST);
1947 Dir->setEnsureUpperBound(Exprs.
EUB);
1948 Dir->setNextLowerBound(Exprs.
NLB);
1949 Dir->setNextUpperBound(Exprs.
NUB);
1951 Dir->setPrevLowerBoundVariable(Exprs.
PrevLB);
1952 Dir->setPrevUpperBoundVariable(Exprs.
PrevUB);
1953 Dir->setDistInc(Exprs.
DistInc);
1954 Dir->setPrevEnsureUpperBound(Exprs.
PrevEUB);
1957 Dir->setInits(Exprs.
Inits);
1958 Dir->setUpdates(Exprs.
Updates);
1959 Dir->setFinals(Exprs.
Finals);
1978 unsigned NumClauses,
1979 unsigned CollapsedNum,
1981 return createEmptyDirective<OMPTeamsDistributeParallelForSimdDirective>(
1982 C, NumClauses,
true,
1983 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd),
1992 auto *Dir = createDirective<OMPTeamsDistributeParallelForDirective>(
1993 C, Clauses, AssociatedStmt,
1994 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1,
1995 StartLoc, EndLoc, CollapsedNum);
1999 Dir->setPreCond(Exprs.
PreCond);
2000 Dir->setCond(Exprs.
Cond);
2001 Dir->setInit(Exprs.
Init);
2002 Dir->setInc(Exprs.
Inc);
2003 Dir->setIsLastIterVariable(Exprs.
IL);
2004 Dir->setLowerBoundVariable(Exprs.
LB);
2005 Dir->setUpperBoundVariable(Exprs.
UB);
2006 Dir->setStrideVariable(Exprs.
ST);
2007 Dir->setEnsureUpperBound(Exprs.
EUB);
2008 Dir->setNextLowerBound(Exprs.
NLB);
2009 Dir->setNextUpperBound(Exprs.
NUB);
2011 Dir->setPrevLowerBoundVariable(Exprs.
PrevLB);
2012 Dir->setPrevUpperBoundVariable(Exprs.
PrevUB);
2013 Dir->setDistInc(Exprs.
DistInc);
2014 Dir->setPrevEnsureUpperBound(Exprs.
PrevEUB);
2017 Dir->setInits(Exprs.
Inits);
2018 Dir->setUpdates(Exprs.
Updates);
2019 Dir->setFinals(Exprs.
Finals);
2033 Dir->setTaskReductionRefExpr(TaskRedRef);
2034 Dir->HasCancel = HasCancel;
2040 unsigned NumClauses,
2041 unsigned CollapsedNum,
2043 return createEmptyDirective<OMPTeamsDistributeParallelForDirective>(
2044 C, NumClauses,
true,
2045 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1,
2052 return createDirective<OMPTargetTeamsDirective>(
C, Clauses, AssociatedStmt,
2060 return createEmptyDirective<OMPTargetTeamsDirective>(
2061 C, NumClauses,
true);
2068 auto *Dir = createDirective<OMPTargetTeamsDistributeDirective>(
2069 C, Clauses, AssociatedStmt,
2070 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute), StartLoc,
2071 EndLoc, CollapsedNum);
2075 Dir->setPreCond(Exprs.
PreCond);
2076 Dir->setCond(Exprs.
Cond);
2077 Dir->setInit(Exprs.
Init);
2078 Dir->setInc(Exprs.
Inc);
2079 Dir->setIsLastIterVariable(Exprs.
IL);
2080 Dir->setLowerBoundVariable(Exprs.
LB);
2081 Dir->setUpperBoundVariable(Exprs.
UB);
2082 Dir->setStrideVariable(Exprs.
ST);
2083 Dir->setEnsureUpperBound(Exprs.
EUB);
2084 Dir->setNextLowerBound(Exprs.
NLB);
2085 Dir->setNextUpperBound(Exprs.
NUB);
2089 Dir->setInits(Exprs.
Inits);
2090 Dir->setUpdates(Exprs.
Updates);
2091 Dir->setFinals(Exprs.
Finals);
2101 unsigned NumClauses,
2102 unsigned CollapsedNum,
2104 return createEmptyDirective<OMPTargetTeamsDistributeDirective>(
2105 C, NumClauses,
true,
2115 auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForDirective>(
2116 C, Clauses, AssociatedStmt,
2117 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) +
2119 StartLoc, EndLoc, CollapsedNum);
2123 Dir->setPreCond(Exprs.
PreCond);
2124 Dir->setCond(Exprs.
Cond);
2125 Dir->setInit(Exprs.
Init);
2126 Dir->setInc(Exprs.
Inc);
2127 Dir->setIsLastIterVariable(Exprs.
IL);
2128 Dir->setLowerBoundVariable(Exprs.
LB);
2129 Dir->setUpperBoundVariable(Exprs.
UB);
2130 Dir->setStrideVariable(Exprs.
ST);
2131 Dir->setEnsureUpperBound(Exprs.
EUB);
2132 Dir->setNextLowerBound(Exprs.
NLB);
2133 Dir->setNextUpperBound(Exprs.
NUB);
2135 Dir->setPrevLowerBoundVariable(Exprs.
PrevLB);
2136 Dir->setPrevUpperBoundVariable(Exprs.
PrevUB);
2137 Dir->setDistInc(Exprs.
DistInc);
2138 Dir->setPrevEnsureUpperBound(Exprs.
PrevEUB);
2141 Dir->setInits(Exprs.
Inits);
2142 Dir->setUpdates(Exprs.
Updates);
2143 Dir->setFinals(Exprs.
Finals);
2157 Dir->setTaskReductionRefExpr(TaskRedRef);
2158 Dir->HasCancel = HasCancel;
2164 unsigned NumClauses,
2165 unsigned CollapsedNum,
2167 return createEmptyDirective<OMPTargetTeamsDistributeParallelForDirective>(
2168 C, NumClauses,
true,
2169 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) +
2179 auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
2180 C, Clauses, AssociatedStmt,
2182 OMPD_target_teams_distribute_parallel_for_simd),
2183 StartLoc, EndLoc, CollapsedNum);
2187 Dir->setPreCond(Exprs.
PreCond);
2188 Dir->setCond(Exprs.
Cond);
2189 Dir->setInit(Exprs.
Init);
2190 Dir->setInc(Exprs.
Inc);
2191 Dir->setIsLastIterVariable(Exprs.
IL);
2192 Dir->setLowerBoundVariable(Exprs.
LB);
2193 Dir->setUpperBoundVariable(Exprs.
UB);
2194 Dir->setStrideVariable(Exprs.
ST);
2195 Dir->setEnsureUpperBound(Exprs.
EUB);
2196 Dir->setNextLowerBound(Exprs.
NLB);
2197 Dir->setNextUpperBound(Exprs.
NUB);
2199 Dir->setPrevLowerBoundVariable(Exprs.
PrevLB);
2200 Dir->setPrevUpperBoundVariable(Exprs.
PrevUB);
2201 Dir->setDistInc(Exprs.
DistInc);
2202 Dir->setPrevEnsureUpperBound(Exprs.
PrevEUB);
2205 Dir->setInits(Exprs.
Inits);
2206 Dir->setUpdates(Exprs.
Updates);
2207 Dir->setFinals(Exprs.
Finals);
2226 const ASTContext &
C,
unsigned NumClauses,
unsigned CollapsedNum,
2228 return createEmptyDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
2229 C, NumClauses,
true,
2231 OMPD_target_teams_distribute_parallel_for_simd),
2240 auto *Dir = createDirective<OMPTargetTeamsDistributeSimdDirective>(
2241 C, Clauses, AssociatedStmt,
2243 StartLoc, EndLoc, CollapsedNum);
2247 Dir->setPreCond(Exprs.
PreCond);
2248 Dir->setCond(Exprs.
Cond);
2249 Dir->setInit(Exprs.
Init);
2250 Dir->setInc(Exprs.
Inc);
2251 Dir->setIsLastIterVariable(Exprs.
IL);
2252 Dir->setLowerBoundVariable(Exprs.
LB);
2253 Dir->setUpperBoundVariable(Exprs.
UB);
2254 Dir->setStrideVariable(Exprs.
ST);
2255 Dir->setEnsureUpperBound(Exprs.
EUB);
2256 Dir->setNextLowerBound(Exprs.
NLB);
2257 Dir->setNextUpperBound(Exprs.
NUB);
2261 Dir->setInits(Exprs.
Inits);
2262 Dir->setUpdates(Exprs.
Updates);
2263 Dir->setFinals(Exprs.
Finals);
2273 unsigned NumClauses,
2274 unsigned CollapsedNum,
2276 return createEmptyDirective<OMPTargetTeamsDistributeSimdDirective>(
2277 C, NumClauses,
true,
2286 return createDirective<OMPInteropDirective>(
2287 C, Clauses,
nullptr, 0, StartLoc,
2292 unsigned NumClauses,
2294 return createEmptyDirective<OMPInteropDirective>(
C, NumClauses);
2301 auto *Dir = createDirective<OMPDispatchDirective>(
2302 C, Clauses, AssociatedStmt, 0, StartLoc, EndLoc);
2303 Dir->setTargetCallLoc(TargetCallLoc);
2308 unsigned NumClauses,
2310 return createEmptyDirective<OMPDispatchDirective>(
C, NumClauses,
2319 Stmt *AssociatedStmt) {
2320 return createDirective<OMPMaskedDirective>(
C, Clauses, AssociatedStmt,
2326 unsigned NumClauses,
2328 return createEmptyDirective<OMPMaskedDirective>(
C, NumClauses,
2336 auto *Dir = createDirective<OMPGenericLoopDirective>(
2338 StartLoc, EndLoc, CollapsedNum);
2342 Dir->setPreCond(Exprs.
PreCond);
2343 Dir->setCond(Exprs.
Cond);
2344 Dir->setInit(Exprs.
Init);
2345 Dir->setInc(Exprs.
Inc);
2346 Dir->setIsLastIterVariable(Exprs.
IL);
2347 Dir->setLowerBoundVariable(Exprs.
LB);
2348 Dir->setUpperBoundVariable(Exprs.
UB);
2349 Dir->setStrideVariable(Exprs.
ST);
2350 Dir->setEnsureUpperBound(Exprs.
EUB);
2351 Dir->setNextLowerBound(Exprs.
NLB);
2352 Dir->setNextUpperBound(Exprs.
NUB);
2356 Dir->setInits(Exprs.
Inits);
2357 Dir->setUpdates(Exprs.
Updates);
2358 Dir->setFinals(Exprs.
Finals);
2369 return createEmptyDirective<OMPGenericLoopDirective>(
2370 C, NumClauses,
true,
2378 auto *Dir = createDirective<OMPTeamsGenericLoopDirective>(
2379 C, Clauses, AssociatedStmt,
2385 Dir->setPreCond(Exprs.
PreCond);
2386 Dir->setCond(Exprs.
Cond);
2387 Dir->setInit(Exprs.
Init);
2388 Dir->setInc(Exprs.
Inc);
2389 Dir->setIsLastIterVariable(Exprs.
IL);
2390 Dir->setLowerBoundVariable(Exprs.
LB);
2391 Dir->setUpperBoundVariable(Exprs.
UB);
2392 Dir->setStrideVariable(Exprs.
ST);
2393 Dir->setEnsureUpperBound(Exprs.
EUB);
2394 Dir->setNextLowerBound(Exprs.
NLB);
2395 Dir->setNextUpperBound(Exprs.
NUB);
2397 Dir->setPrevLowerBoundVariable(Exprs.
PrevLB);
2398 Dir->setPrevUpperBoundVariable(Exprs.
PrevUB);
2399 Dir->setDistInc(Exprs.
DistInc);
2400 Dir->setPrevEnsureUpperBound(Exprs.
PrevEUB);
2403 Dir->setInits(Exprs.
Inits);
2404 Dir->setUpdates(Exprs.
Updates);
2405 Dir->setFinals(Exprs.
Finals);
2424 unsigned NumClauses,
2426 return createEmptyDirective<OMPTeamsGenericLoopDirective>(
2427 C, NumClauses,
true,
2435 auto *Dir = createDirective<OMPTargetTeamsGenericLoopDirective>(
2436 C, Clauses, AssociatedStmt,
2437 numLoopChildren(CollapsedNum, OMPD_target_teams_loop), StartLoc, EndLoc,
2442 Dir->setPreCond(Exprs.
PreCond);
2443 Dir->setCond(Exprs.
Cond);
2444 Dir->setInit(Exprs.
Init);
2445 Dir->setInc(Exprs.
Inc);
2446 Dir->setIsLastIterVariable(Exprs.
IL);
2447 Dir->setLowerBoundVariable(Exprs.
LB);
2448 Dir->setUpperBoundVariable(Exprs.
UB);
2449 Dir->setStrideVariable(Exprs.
ST);
2450 Dir->setEnsureUpperBound(Exprs.
EUB);
2451 Dir->setNextLowerBound(Exprs.
NLB);
2452 Dir->setNextUpperBound(Exprs.
NUB);
2454 Dir->setPrevLowerBoundVariable(Exprs.
PrevLB);
2455 Dir->setPrevUpperBoundVariable(Exprs.
PrevUB);
2456 Dir->setDistInc(Exprs.
DistInc);
2457 Dir->setPrevEnsureUpperBound(Exprs.
PrevEUB);
2460 Dir->setInits(Exprs.
Inits);
2461 Dir->setUpdates(Exprs.
Updates);
2462 Dir->setFinals(Exprs.
Finals);
2481 unsigned NumClauses,
2482 unsigned CollapsedNum,
2484 return createEmptyDirective<OMPTargetTeamsGenericLoopDirective>(
2485 C, NumClauses,
true,
2493 auto *Dir = createDirective<OMPParallelGenericLoopDirective>(
2494 C, Clauses, AssociatedStmt,
2500 Dir->setPreCond(Exprs.
PreCond);
2501 Dir->setCond(Exprs.
Cond);
2502 Dir->setInit(Exprs.
Init);
2503 Dir->setInc(Exprs.
Inc);
2504 Dir->setIsLastIterVariable(Exprs.
IL);
2505 Dir->setLowerBoundVariable(Exprs.
LB);
2506 Dir->setUpperBoundVariable(Exprs.
UB);
2507 Dir->setStrideVariable(Exprs.
ST);
2508 Dir->setEnsureUpperBound(Exprs.
EUB);
2509 Dir->setNextLowerBound(Exprs.
NLB);
2510 Dir->setNextUpperBound(Exprs.
NUB);
2514 Dir->setInits(Exprs.
Inits);
2515 Dir->setUpdates(Exprs.
Updates);
2516 Dir->setFinals(Exprs.
Finals);
2525 const ASTContext &
C,
unsigned NumClauses,
unsigned CollapsedNum,
2527 return createEmptyDirective<OMPParallelGenericLoopDirective>(
2528 C, NumClauses,
true,
2537 auto *Dir = createDirective<OMPTargetParallelGenericLoopDirective>(
2538 C, Clauses, AssociatedStmt,
2540 EndLoc, CollapsedNum);
2544 Dir->setPreCond(Exprs.
PreCond);
2545 Dir->setCond(Exprs.
Cond);
2546 Dir->setInit(Exprs.
Init);
2547 Dir->setInc(Exprs.
Inc);
2548 Dir->setIsLastIterVariable(Exprs.
IL);
2549 Dir->setLowerBoundVariable(Exprs.
LB);
2550 Dir->setUpperBoundVariable(Exprs.
UB);
2551 Dir->setStrideVariable(Exprs.
ST);
2552 Dir->setEnsureUpperBound(Exprs.
EUB);
2553 Dir->setNextLowerBound(Exprs.
NLB);
2554 Dir->setNextUpperBound(Exprs.
NUB);
2558 Dir->setInits(Exprs.
Inits);
2559 Dir->setUpdates(Exprs.
Updates);
2560 Dir->setFinals(Exprs.
Finals);
2570 unsigned NumClauses,
2571 unsigned CollapsedNum,
2573 return createEmptyDirective<OMPTargetParallelGenericLoopDirective>(
2574 C, NumClauses,
true,
2575 numLoopChildren(CollapsedNum, OMPD_target_parallel_loop), CollapsedNum);
Defines the clang::ASTContext interface.
This file defines OpenMP AST classes for executable directives and clauses.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
This represents one expression.
IfStmt - This represents an if/then/else.
This represents '#pragma omp atomic' directive.
static OMPAtomicDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPAtomicDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expressions Exprs)
Creates directive with a list of Clauses and 'x', 'v' and 'expr' parts of the atomic construct (see S...
This represents '#pragma omp barrier' directive.
static OMPBarrierDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Creates directive.
static OMPBarrierDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
This represents '#pragma omp cancel' directive.
static OMPCancelDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, OpenMPDirectiveKind CancelRegion)
Creates directive.
static OMPCancelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
This represents '#pragma omp cancellation point' directive.
static OMPCancellationPointDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
static OMPCancellationPointDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, OpenMPDirectiveKind CancelRegion)
Creates directive.
Contains data for OpenMP directives: clauses, children expressions/statements (helpers for codegen) a...
void setClauses(ArrayRef< OMPClause * > Clauses)
Sets the list of variables for this clause.
MutableArrayRef< Stmt * > getChildren()
This represents '#pragma omp critical' directive.
static OMPCriticalDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
static OMPCriticalDirective * Create(const ASTContext &C, const DeclarationNameInfo &Name, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive.
This represents '#pragma omp depobj' directive.
static OMPDepobjDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPDepobjDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive with a list of Clauses.
This represents '#pragma omp dispatch' directive.
static OMPDispatchDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, SourceLocation TargetCallLoc)
Creates directive with a list of Clauses.
static OMPDispatchDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp distribute' directive.
static OMPDistributeDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, OpenMPDirectiveKind ParamPrevMappedDirective)
Creates directive with a list of Clauses.
static OMPDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp distribute parallel for' composite directive.
static OMPDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPDistributeParallelForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
This represents '#pragma omp distribute parallel for simd' composite directive.
static OMPDistributeParallelForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp distribute simd' composite directive.
static OMPDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPDistributeSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents '#pragma omp error' directive.
static OMPErrorDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
static OMPErrorDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
bool hasAssociatedStmt() const
Returns true if directive has associated statement.
const Stmt * getRawStmt() const
OMPChildren * Data
Data, associated with the directive.
const Stmt * getStructuredBlock() const
Returns the AST node representing OpenMP structured-block of this OpenMP executable directive,...
bool isStandaloneDirective() const
Returns whether or not this is a Standalone directive.
This represents '#pragma omp flush' directive.
static OMPFlushDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPFlushDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive with a list of Clauses.
This represents '#pragma omp for' directive.
static OMPForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel, OpenMPDirectiveKind ParamPrevMappedDirective)
Creates directive with a list of Clauses.
static OMPForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp for simd' directive.
static OMPForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents '#pragma omp loop' directive.
static OMPGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with a place for NumClauses clauses.
static OMPGenericLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents '#pragma omp interop' directive.
static OMPInteropDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
static OMPInteropDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive.
static void doForAllLoopsBodies(Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops, llvm::function_ref< void(unsigned, Stmt *, Stmt *)> Callback)
Calls the specified callback function for all the loop bodies in CurStmt, from the outermost loop to ...
unsigned NumAssociatedLoops
Number of collapsed loops as specified by 'collapse' clause.
static Stmt * tryToFindNextInnerLoop(Stmt *CurStmt, bool TryImperfectlyNestedLoops)
Try to find the next loop sub-statement in the specified statement CurStmt.
static bool doForAllLoops(Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops, llvm::function_ref< bool(unsigned, Stmt *)> Callback, llvm::function_ref< void(OMPLoopTransformationDirective *)> OnTransformationCallback)
Calls the specified callback function for all the loops in CurStmt, from the outermost to the innermo...
unsigned getLoopsNumber() const
Get number of collapsed loops.
void setFinals(ArrayRef< Expr * > A)
void setDependentCounters(ArrayRef< Expr * > A)
void setFinalsConditions(ArrayRef< Expr * > A)
void setInits(ArrayRef< Expr * > A)
static unsigned numLoopChildren(unsigned CollapsedNum, OpenMPDirectiveKind Kind)
Children number.
void setCounters(ArrayRef< Expr * > A)
void setDependentInits(ArrayRef< Expr * > A)
void setUpdates(ArrayRef< Expr * > A)
void setPrivateCounters(ArrayRef< Expr * > A)
This represents '#pragma omp masked' directive.
static OMPMaskedDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
static OMPMaskedDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive.
This represents '#pragma omp masked taskloop' directive.
static OMPMaskedTaskLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel)
Creates directive with a list of Clauses.
static OMPMaskedTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp masked taskloop simd' directive.
static OMPMaskedTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPMaskedTaskLoopSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents '#pragma omp master' directive.
static OMPMasterDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt)
Creates directive.
static OMPMasterDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
This represents '#pragma omp master taskloop' directive.
static OMPMasterTaskLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel)
Creates directive with a list of Clauses.
static OMPMasterTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp master taskloop simd' directive.
static OMPMasterTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPMasterTaskLoopSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents '#pragma omp ordered' directive.
static OMPOrderedDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive.
static OMPOrderedDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, bool IsStandalone, EmptyShell)
Creates an empty directive.
This represents '#pragma omp parallel' directive.
static OMPParallelDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
static OMPParallelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for N clauses.
This represents '#pragma omp parallel for' directive.
static OMPParallelForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
static OMPParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp parallel for simd' directive.
static OMPParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPParallelForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents '#pragma omp parallel loop' directive.
static OMPParallelGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPParallelGenericLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents '#pragma omp parallel masked' directive.
static OMPParallelMaskedDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPParallelMaskedDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef)
Creates directive with a list of Clauses.
This represents '#pragma omp parallel masked taskloop' directive.
static OMPParallelMaskedTaskLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel)
Creates directive with a list of Clauses.
static OMPParallelMaskedTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp parallel masked taskloop simd' directive.
static OMPParallelMaskedTaskLoopSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPParallelMaskedTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp parallel master' directive.
static OMPParallelMasterDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef)
Creates directive with a list of Clauses.
static OMPParallelMasterDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp parallel master taskloop' directive.
static OMPParallelMasterTaskLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel)
Creates directive with a list of Clauses.
static OMPParallelMasterTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp parallel master taskloop simd' directive.
static OMPParallelMasterTaskLoopSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPParallelMasterTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp parallel sections' directive.
static OMPParallelSectionsDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
static OMPParallelSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp scan' directive.
static OMPScanDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPScanDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive with a list of Clauses.
This represents '#pragma omp scope' directive.
static OMPScopeDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive.
static OMPScopeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
This represents '#pragma omp section' directive.
static OMPSectionDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
static OMPSectionDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt, bool HasCancel)
Creates directive.
This represents '#pragma omp sections' directive.
static OMPSectionsDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
static OMPSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp simd' directive.
static OMPSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, OpenMPDirectiveKind ParamPrevMappedDirective)
Creates directive with a list of Clauses.
static OMPSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp single' directive.
static OMPSingleDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
static OMPSingleDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp target data' directive.
static OMPTargetDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
static OMPTargetDataDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
This represents '#pragma omp target' directive.
static OMPTargetDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
static OMPTargetDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp target enter data' directive.
static OMPTargetEnterDataDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
static OMPTargetEnterDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
This represents '#pragma omp target exit data' directive.
static OMPTargetExitDataDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
static OMPTargetExitDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
This represents '#pragma omp target parallel' directive.
static OMPTargetParallelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTargetParallelDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
This represents '#pragma omp target parallel for' directive.
static OMPTargetParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTargetParallelForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
This represents '#pragma omp target parallel for simd' directive.
static OMPTargetParallelForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPTargetParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp target parallel loop' directive.
static OMPTargetParallelGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTargetParallelGenericLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents '#pragma omp target simd' directive.
static OMPTargetSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPTargetSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp target teams' directive.
static OMPTargetTeamsDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
static OMPTargetTeamsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp target teams distribute' combined directive.
static OMPTargetTeamsDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTargetTeamsDistributeDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents '#pragma omp target teams distribute parallel for' combined directive.
static OMPTargetTeamsDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTargetTeamsDistributeParallelForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
This represents '#pragma omp target teams distribute parallel for simd' combined directive.
static OMPTargetTeamsDistributeParallelForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPTargetTeamsDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp target teams distribute simd' combined directive.
static OMPTargetTeamsDistributeSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPTargetTeamsDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp target teams loop' directive.
static OMPTargetTeamsGenericLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPTargetTeamsGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp target update' directive.
static OMPTargetUpdateDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTargetUpdateDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
This represents '#pragma omp task' directive.
static OMPTaskDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTaskDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, bool HasCancel)
Creates directive with a list of Clauses.
This represents '#pragma omp taskloop' directive.
static OMPTaskLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel)
Creates directive with a list of Clauses.
static OMPTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp taskloop simd' directive.
static OMPTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTaskLoopSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents '#pragma omp taskgroup' directive.
static OMPTaskgroupDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *ReductionRef)
Creates directive.
static OMPTaskgroupDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
This represents '#pragma omp taskwait' directive.
static OMPTaskwaitDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
static OMPTaskwaitDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive.
This represents '#pragma omp taskyield' directive.
static OMPTaskyieldDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
static OMPTaskyieldDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Creates directive.
This represents '#pragma omp teams' directive.
static OMPTeamsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTeamsDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
This represents '#pragma omp teams distribute' directive.
static OMPTeamsDistributeDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPTeamsDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp teams distribute parallel for' composite directive.
static OMPTeamsDistributeParallelForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
static OMPTeamsDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp teams distribute parallel for simd' composite directive.
static OMPTeamsDistributeParallelForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPTeamsDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp teams distribute simd' combined directive.
static OMPTeamsDistributeSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPTeamsDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp teams loop' directive.
static OMPTeamsGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTeamsGenericLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents the '#pragma omp tile' loop transformation directive.
static OMPTileDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned NumLoops)
Build an empty '#pragma omp tile' AST node for deserialization.
static OMPTileDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, unsigned NumLoops, Stmt *AssociatedStmt, Stmt *TransformedStmt, Stmt *PreInits)
Create a new AST node representation for '#pragma omp tile'.
This represents the '#pragma omp unroll' loop transformation directive.
static OMPUnrollDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, unsigned NumGeneratedLoops, Stmt *TransformedStmt, Stmt *PreInits)
Create a new AST node representation for '#pragma omp unroll'.
static OMPUnrollDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses)
Build an empty '#pragma omp unroll' AST node for deserialization.
Encodes a location in the source.
Stmt - This represents one statement.
StmtClass getStmtClass() const
Stmt * IgnoreContainers(bool IgnoreCaptured=false)
Skip no-op (attributed, compound) container stmts and skip captured stmt at the top,...
The JSON file list parser is used to communicate input to InstallAPI.
llvm::omp::Directive OpenMPDirectiveKind
OpenMP directives.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
Expr * E
'expr' part of the associated expression/statement.
Expr * D
'd' part of the associated expression/statement.
Expr * UE
UE Helper expression of the form: 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or 'OpaqueValueExp...
bool IsFailOnly
True if 'v' is updated only when the condition is false (compare capture only).
Expr * X
'x' part of the associated expression/statement.
Expr * Cond
Conditional expression in atomic compare construct.
Expr * V
'v' part of the associated expression/statement.
bool IsPostfixUpdate
True if original value of 'x' must be stored in 'v', not an updated one.
bool IsXLHSInRHSPart
True if UE has the first form and false if the second.
Expr * ParForInDistCond
'omp parallel for' loop condition used when composed with 'omp distribute' in the same construct and ...
Expr * LB
DistributeLowerBound - used when composing 'omp distribute' with 'omp for' in a same construct.
Expr * Init
Distribute loop iteration variable init used when composing 'omp distribute' with 'omp for' in a same...
Expr * NUB
Update of UpperBound for statically scheduled omp loops for outer loop in combined constructs (e....
Expr * EUB
DistributeEnsureUpperBound - used when composing 'omp distribute' with 'omp for' in a same construct,...
Expr * UB
DistributeUpperBound - used when composing 'omp distribute' with 'omp for' in a same construct.
Expr * NLB
Update of LowerBound for statically scheduled omp loops for outer loop in combined constructs (e....
Expr * DistCond
Distribute Loop condition used when composing 'omp distribute' with 'omp for' in a same construct whe...
Expr * Cond
Distribute Loop condition used when composing 'omp distribute' with 'omp for' in a same construct.
The expressions built for the OpenMP loop CodeGen for the whole collapsed loop nest.
Expr * LastIteration
Loop last iteration number.
Expr * Cond
Loop condition.
SmallVector< Expr *, 4 > DependentInits
List of initializers required for the generation of the non-rectangular loops.
SmallVector< Expr *, 4 > Inits
Expressions for loop counters inits for CodeGen.
Expr * PrevEUB
PrevEUB - expression similar to EUB but to be used when loop scheduling uses PrevLB and PrevUB (e....
Expr * DistInc
DistInc - increment expression for distribute loop when found combined with a further loop level (e....
Expr * IL
IsLastIteration - local flag variable passed to runtime.
SmallVector< Expr *, 4 > PrivateCounters
PrivateCounters Loop counters.
Expr * CalcLastIteration
Calculation of last iteration.
SmallVector< Expr *, 4 > Updates
Expressions for loop counters update for CodeGen.
Expr * ST
Stride - local variable passed to runtime.
SmallVector< Expr *, 4 > Finals
Final loop counter values for GodeGen.
SmallVector< Expr *, 4 > FinalsConditions
List of final conditions required for the generation of the non-rectangular loops.
Expr * PreCond
Loop pre-condition.
Stmt * PreInits
Init statement for all captured expressions.
Expr * IterationVarRef
Loop iteration variable.
Expr * NumIterations
Loop number of iterations.
SmallVector< Expr *, 4 > Counters
Counters Loop counters.
Expr * NLB
Update of LowerBound for statically scheduled 'omp for' loops.
Expr * PrevUB
PreviousUpperBound - local variable passed to runtime in the enclosing schedule or null if that does ...
DistCombinedHelperExprs DistCombinedFields
Expressions used when combining OpenMP loop pragmas.
Expr * Inc
Loop increment.
Expr * EUB
EnsureUpperBound – expression UB = min(UB, NumIterations).
Expr * UB
UpperBound - local variable passed to runtime.
Expr * NUB
Update of UpperBound for statically scheduled 'omp for' loops.
Expr * LB
LowerBound - local variable passed to runtime.
Expr * PrevLB
PreviousLowerBound - local variable passed to runtime in the enclosing schedule or null if that does ...
SmallVector< Expr *, 4 > DependentCounters
List of counters required for the generation of the non-rectangular loops.
Expr * Init
Loop iteration variable init.
A placeholder type used to construct an empty shell of a type, that will be filled in later (e....