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,
305 auto *Dir = createDirective<OMPSimdDirective>(
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>(
340 auto *Dir = createDirective<OMPForDirective>(
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);
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");
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>(
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>(
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>(
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>(
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>(
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,
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>(
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>(
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,
1110 auto *Dir = createDirective<OMPTaskLoopSimdDirective>(
1111 C, Clauses, AssociatedStmt,
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,
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,
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,
1243 auto *Dir = createDirective<OMPMasterTaskLoopSimdDirective>(
1244 C, Clauses, AssociatedStmt,
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,
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,
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,
1426 auto *Dir = createDirective<OMPParallelMasterTaskLoopSimdDirective>(
1427 C, Clauses, AssociatedStmt,
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,
1473 auto *Dir = createDirective<OMPParallelMaskedTaskLoopSimdDirective>(
1474 C, Clauses, AssociatedStmt,
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,
1519 auto *Dir = createDirective<OMPDistributeDirective>(
1520 C, Clauses, AssociatedStmt,
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,
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,
1639 auto *Dir = createDirective<OMPDistributeParallelForSimdDirective>(
1640 C, Clauses, AssociatedStmt,
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,
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,
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,
1789 auto *Dir = createDirective<OMPTargetSimdDirective>(
1790 C, Clauses, AssociatedStmt,
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,
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,
1868 auto *Dir = createDirective<OMPTeamsDistributeSimdDirective>(
1869 C, Clauses, AssociatedStmt,
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,
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,
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,
2211 OMPD_target_teams_distribute_parallel_for_simd),
2220 auto *Dir = createDirective<OMPTargetTeamsDistributeSimdDirective>(
2221 C, Clauses, AssociatedStmt,
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,
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>(
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,
2358 auto *Dir = createDirective<OMPTeamsGenericLoopDirective>(
2359 C, Clauses, AssociatedStmt,
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,
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,
2447 auto *Dir = createDirective<OMPParallelGenericLoopDirective>(
2448 C, Clauses, AssociatedStmt,
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,
2491 auto *Dir = createDirective<OMPTargetParallelGenericLoopDirective>(
2492 C, Clauses, AssociatedStmt,
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);
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)
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)
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 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)
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,...
llvm::omp::Directive OpenMPDirectiveKind
OpenMP directives.
@ C
Languages that the frontend can parse and compile.
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....