1//===--- StmtOpenMP.cpp - Classes for OpenMP directives -------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the subclasses of Stmt class declared in StmtOpenMP.h
10//
11//===----------------------------------------------------------------------===//
12
13#include "clang/AST/StmtOpenMP.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/Attr.h"
16#include "clang/AST/Stmt.h"
17
18using namespace clang;
19using namespace llvm::omp;
20
21/// Returns the intra-tile hint attribute for the given statement.
22const OMPInvariantPredicateBoundAttr *
23OMPLoopBasedDirective::getIntraTileHint(const Stmt *S) {
24 if (const auto *AS = dyn_cast_or_null<AttributedStmt>(Val: S))
25 return getSpecificAttr<OMPInvariantPredicateBoundAttr>(container: AS->getAttrs());
26 return nullptr;
27}
28
29/// Peek through an intra-tile hint wrapper to return the underlying loop.
30Stmt *OMPLoopBasedDirective::ignoreIntraTileHint(Stmt *S) {
31 if (auto *AS = dyn_cast_or_null<AttributedStmt>(Val: S))
32 if (hasSpecificAttr<OMPInvariantPredicateBoundAttr>(container: AS->getAttrs()))
33 return AS->getSubStmt();
34 return S;
35}
36
37ArrayRef<Stmt *> OMPLoopBasedDirective::getStmtsBeforeNestedLoop(Stmt *Body) {
38 auto *CS = dyn_cast_or_null<CompoundStmt>(Val: Body);
39 if (!CS || CS->size() < 2)
40 return {};
41 return ArrayRef(CS->body_begin(), CS->size() - 1);
42}
43
44/// Like `Stmt::IgnoreContainers`, but stops at (and preserves) an intra-tile
45/// hint wrapper so that the enclosing loop walker can deliver the hint to
46/// loop-associated analysis (e.g. `collapse`). Non-hint attributed statements
47/// and single-statement compounds are still skipped.
48static Stmt *ignoreContainersKeepingIntraTileHint(Stmt *S) {
49 while (true) {
50 if (auto *AS = dyn_cast_or_null<AttributedStmt>(Val: S)) {
51 if (hasSpecificAttr<OMPInvariantPredicateBoundAttr>(container: AS->getAttrs()))
52 break;
53 S = AS->getSubStmt();
54 continue;
55 }
56 if (auto *CS = dyn_cast_or_null<CompoundStmt>(Val: S)) {
57 if (CS->size() != 1)
58 break;
59 S = CS->body_back();
60 continue;
61 }
62 break;
63 }
64 return S;
65}
66
67size_t OMPChildren::size(unsigned NumClauses, bool HasAssociatedStmt,
68 unsigned NumChildren) {
69 return llvm::alignTo(
70 Value: totalSizeToAlloc<OMPClause *, Stmt *>(
71 Counts: NumClauses, Counts: NumChildren + (HasAssociatedStmt ? 1 : 0)),
72 Align: alignof(OMPChildren));
73}
74
75void OMPChildren::setClauses(ArrayRef<OMPClause *> Clauses) {
76 assert(Clauses.size() == NumClauses &&
77 "Number of clauses is not the same as the preallocated buffer");
78 llvm::copy(Range&: Clauses, Out: getTrailingObjects<OMPClause *>());
79}
80
81MutableArrayRef<Stmt *> OMPChildren::getChildren() {
82 return getTrailingObjects<Stmt *>(N: NumChildren);
83}
84
85OMPChildren *OMPChildren::Create(void *Mem, ArrayRef<OMPClause *> Clauses) {
86 auto *Data = CreateEmpty(Mem, NumClauses: Clauses.size());
87 Data->setClauses(Clauses);
88 return Data;
89}
90
91OMPChildren *OMPChildren::Create(void *Mem, ArrayRef<OMPClause *> Clauses,
92 Stmt *S, unsigned NumChildren) {
93 auto *Data = CreateEmpty(Mem, NumClauses: Clauses.size(), HasAssociatedStmt: S, NumChildren);
94 Data->setClauses(Clauses);
95 if (S)
96 Data->setAssociatedStmt(S);
97 return Data;
98}
99
100OMPChildren *OMPChildren::CreateEmpty(void *Mem, unsigned NumClauses,
101 bool HasAssociatedStmt,
102 unsigned NumChildren) {
103 return new (Mem) OMPChildren(NumClauses, NumChildren, HasAssociatedStmt);
104}
105
106bool OMPExecutableDirective::isStandaloneDirective() const {
107 // Special case: 'omp target enter data', 'omp target exit data',
108 // 'omp target update' are stand-alone directives, but for implementation
109 // reasons they have empty synthetic structured block, to simplify codegen.
110 if (isa<OMPTargetEnterDataDirective>(Val: this) ||
111 isa<OMPTargetExitDataDirective>(Val: this) ||
112 isa<OMPTargetUpdateDirective>(Val: this))
113 return true;
114 return !hasAssociatedStmt();
115}
116
117Stmt *OMPExecutableDirective::getStructuredBlock() {
118 assert(!isStandaloneDirective() &&
119 "Standalone Executable Directives don't have Structured Blocks.");
120 if (auto *LD = dyn_cast<OMPLoopDirective>(Val: this))
121 return LD->getBody();
122 return getRawStmt();
123}
124
125Stmt *
126OMPLoopBasedDirective::tryToFindNextInnerLoop(Stmt *CurStmt,
127 bool TryImperfectlyNestedLoops) {
128 Stmt *OrigStmt = CurStmt;
129 CurStmt = ignoreContainersKeepingIntraTileHint(S: CurStmt);
130 // Additional work for imperfectly nested loops, introduced in OpenMP 5.0.
131 if (TryImperfectlyNestedLoops) {
132 if (auto *CS = dyn_cast<CompoundStmt>(Val: CurStmt)) {
133 CurStmt = nullptr;
134 SmallVector<CompoundStmt *, 4> Statements(1, CS);
135 SmallVector<CompoundStmt *, 4> NextStatements;
136 while (!Statements.empty()) {
137 CS = Statements.pop_back_val();
138 if (!CS)
139 continue;
140 for (Stmt *S : CS->body()) {
141 if (!S)
142 continue;
143 // Peek past a single-child container so a nested loop or
144 // loop-transformation directive (e.g. `#pragma omp reverse` inside
145 // the body of an outer loop) is recognized here. Preserve any
146 // intra-tile hint wrapper so it still reaches the loop-analysis
147 // callback.
148 S = ignoreContainersKeepingIntraTileHint(S);
149 Stmt *Inner = S;
150 if (auto *CanonLoop = dyn_cast<OMPCanonicalLoop>(Val: Inner))
151 Inner = CanonLoop->getLoopStmt();
152 Inner = OMPLoopBasedDirective::ignoreIntraTileHint(S: Inner);
153 if (isa<ForStmt>(Val: Inner) || isa<CXXForRangeStmt>(Val: Inner) ||
154 (isa<OMPLoopBasedDirective>(Val: Inner) &&
155 !isa<OMPLoopDirective>(Val: Inner))) {
156 // Only single loop construct is allowed.
157 if (CurStmt) {
158 CurStmt = OrigStmt;
159 break;
160 }
161 CurStmt = S;
162 continue;
163 }
164 S = OMPLoopBasedDirective::ignoreIntraTileHint(S);
165 if (auto *InnerCS = dyn_cast_or_null<CompoundStmt>(Val: S))
166 NextStatements.push_back(Elt: InnerCS);
167 }
168 if (Statements.empty()) {
169 // Found single inner loop or multiple loops - exit.
170 if (CurStmt)
171 break;
172 Statements.swap(RHS&: NextStatements);
173 }
174 }
175 if (!CurStmt)
176 CurStmt = OrigStmt;
177 }
178 }
179 return CurStmt;
180}
181
182bool OMPLoopBasedDirective::doForAllLoops(
183 Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops,
184 llvm::function_ref<bool(unsigned, Stmt *, Stmt *)> Callback,
185 llvm::function_ref<void(OMPLoopTransformationDirective *)>
186 OnTransformationCallback,
187 bool RelaxNestForPeeledTransformation) {
188 CurStmt = ignoreContainersKeepingIntraTileHint(S: CurStmt);
189 for (unsigned Cnt = 0; Cnt < NumLoops; ++Cnt) {
190 // A loop generated by a peeled transformation may hold statements before
191 // the next loop (e.g. `reverse` recomputes the user counter there). They
192 // are not intervening user code, so callers that re-emit them may look
193 // through them; the rest of the nest is still checked as usual.
194 bool PeeledTransformation = false;
195 while (true) {
196 auto *Dir = dyn_cast<OMPLoopTransformationDirective>(Val: CurStmt);
197 if (!Dir)
198 break;
199
200 OnTransformationCallback(Dir);
201
202 Stmt *TransformedStmt = Dir->getTransformedStmt();
203 if (!TransformedStmt) {
204 unsigned NumGeneratedTopLevelLoops =
205 Dir->getNumGeneratedTopLevelLoops();
206 if (NumGeneratedTopLevelLoops == 0) {
207 // May happen if the loop transformation does not result in a
208 // generated loop (such as full unrolling).
209 break;
210 }
211 if (NumGeneratedTopLevelLoops > 0) {
212 // The loop transformation construct has generated loops, but these
213 // may not have been generated yet due to being in a dependent
214 // context.
215 return true;
216 }
217 }
218
219 CurStmt = TransformedStmt;
220 PeeledTransformation = true;
221 }
222 if (auto *CanonLoop = dyn_cast<OMPCanonicalLoop>(Val: CurStmt))
223 CurStmt = CanonLoop->getLoopStmt();
224 // Always hand the real loop to the callback and pass the hint wrapper
225 // separately so the callee can read it.
226 Stmt *LoopStmt = ignoreIntraTileHint(S: CurStmt);
227 Stmt *HintWrapper = LoopStmt != CurStmt ? CurStmt : nullptr;
228 if (Callback(Cnt, LoopStmt, HintWrapper))
229 return false;
230 // Move on to the next nested for loop, or to the loop body.
231 // OpenMP [2.8.1, simd construct, Restrictions]
232 // All loops associated with the construct must be perfectly nested; that
233 // is, there must be no intervening code nor any OpenMP directive between
234 // any two loops.
235 if (auto *For = dyn_cast<ForStmt>(Val: LoopStmt)) {
236 CurStmt = For->getBody();
237 } else {
238 assert(isa<CXXForRangeStmt>(LoopStmt) &&
239 "Expected canonical for or range-based for loops.");
240 CurStmt = cast<CXXForRangeStmt>(Val: LoopStmt)->getBody();
241 }
242 if (RelaxNestForPeeledTransformation && PeeledTransformation &&
243 !getStmtsBeforeNestedLoop(Body: CurStmt).empty())
244 CurStmt = cast<CompoundStmt>(Val: CurStmt)->body_back();
245 CurStmt = OMPLoopBasedDirective::tryToFindNextInnerLoop(
246 CurStmt, TryImperfectlyNestedLoops);
247 }
248 return true;
249}
250
251void OMPLoopBasedDirective::doForAllLoopsBodies(
252 Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops,
253 llvm::function_ref<void(unsigned, Stmt *, Stmt *)> Callback) {
254 bool Res = OMPLoopBasedDirective::doForAllLoops(
255 CurStmt, TryImperfectlyNestedLoops, NumLoops,
256 Callback: [Callback](unsigned Cnt, Stmt *Loop) {
257 Stmt *Body = nullptr;
258 if (auto *For = dyn_cast<ForStmt>(Val: Loop)) {
259 Body = For->getBody();
260 } else {
261 assert(isa<CXXForRangeStmt>(Loop) &&
262 "Expected canonical for or range-based for loops.");
263 Body = cast<CXXForRangeStmt>(Val: Loop)->getBody();
264 }
265 if (auto *CanonLoop = dyn_cast<OMPCanonicalLoop>(Val: Body))
266 Body = CanonLoop->getLoopStmt();
267 Callback(Cnt, Loop, Body);
268 return false;
269 });
270 assert(Res && "Expected only loops");
271 (void)Res;
272}
273
274Stmt *OMPLoopDirective::getBody() {
275 // This relies on the loop form is already checked by Sema.
276 Stmt *Body = nullptr;
277 OMPLoopBasedDirective::doForAllLoopsBodies(
278 CurStmt: Data->getRawStmt(), /*TryImperfectlyNestedLoops=*/true,
279 NumLoops: NumAssociatedLoops,
280 Callback: [&Body](unsigned, Stmt *, Stmt *BodyStmt) { Body = BodyStmt; });
281 return Body;
282}
283
284void OMPLoopDirective::setCounters(ArrayRef<Expr *> A) {
285 assert(A.size() == getLoopsNumber() &&
286 "Number of loop counters is not the same as the collapsed number");
287 llvm::copy(Range&: A, Out: getCounters().begin());
288}
289
290void OMPLoopDirective::setPrivateCounters(ArrayRef<Expr *> A) {
291 assert(A.size() == getLoopsNumber() && "Number of loop private counters "
292 "is not the same as the collapsed "
293 "number");
294 llvm::copy(Range&: A, Out: getPrivateCounters().begin());
295}
296
297void OMPLoopDirective::setInits(ArrayRef<Expr *> A) {
298 assert(A.size() == getLoopsNumber() &&
299 "Number of counter inits is not the same as the collapsed number");
300 llvm::copy(Range&: A, Out: getInits().begin());
301}
302
303void OMPLoopDirective::setUpdates(ArrayRef<Expr *> A) {
304 assert(A.size() == getLoopsNumber() &&
305 "Number of counter updates is not the same as the collapsed number");
306 llvm::copy(Range&: A, Out: getUpdates().begin());
307}
308
309void OMPLoopDirective::setFinals(ArrayRef<Expr *> A) {
310 assert(A.size() == getLoopsNumber() &&
311 "Number of counter finals is not the same as the collapsed number");
312 llvm::copy(Range&: A, Out: getFinals().begin());
313}
314
315void OMPLoopDirective::setDependentCounters(ArrayRef<Expr *> A) {
316 assert(
317 A.size() == getLoopsNumber() &&
318 "Number of dependent counters is not the same as the collapsed number");
319 llvm::copy(Range&: A, Out: getDependentCounters().begin());
320}
321
322void OMPLoopDirective::setDependentInits(ArrayRef<Expr *> A) {
323 assert(A.size() == getLoopsNumber() &&
324 "Number of dependent inits is not the same as the collapsed number");
325 llvm::copy(Range&: A, Out: getDependentInits().begin());
326}
327
328void OMPLoopDirective::setFinalsConditions(ArrayRef<Expr *> A) {
329 assert(A.size() == getLoopsNumber() &&
330 "Number of finals conditions is not the same as the collapsed number");
331 llvm::copy(Range&: A, Out: getFinalsConditions().begin());
332}
333
334OMPMetaDirective *OMPMetaDirective::Create(const ASTContext &C,
335 SourceLocation StartLoc,
336 SourceLocation EndLoc,
337 ArrayRef<OMPClause *> Clauses,
338 Stmt *AssociatedStmt, Stmt *IfStmt) {
339 auto *Dir = createDirective<OMPMetaDirective>(
340 C, Clauses, AssociatedStmt, /*NumChildren=*/1, P&: StartLoc, P&: EndLoc);
341 Dir->setIfStmt(IfStmt);
342 return Dir;
343}
344
345OMPMetaDirective *OMPMetaDirective::CreateEmpty(const ASTContext &C,
346 unsigned NumClauses,
347 EmptyShell) {
348 return createEmptyDirective<OMPMetaDirective>(C, NumClauses,
349 /*HasAssociatedStmt=*/true,
350 /*NumChildren=*/1);
351}
352
353OMPParallelDirective *OMPParallelDirective::Create(
354 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
355 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
356 bool HasCancel) {
357 auto *Dir = createDirective<OMPParallelDirective>(
358 C, Clauses, AssociatedStmt, /*NumChildren=*/1, P&: StartLoc, P&: EndLoc);
359 Dir->setTaskReductionRefExpr(TaskRedRef);
360 Dir->setHasCancel(HasCancel);
361 return Dir;
362}
363
364OMPParallelDirective *OMPParallelDirective::CreateEmpty(const ASTContext &C,
365 unsigned NumClauses,
366 EmptyShell) {
367 return createEmptyDirective<OMPParallelDirective>(C, NumClauses,
368 /*HasAssociatedStmt=*/true,
369 /*NumChildren=*/1);
370}
371
372OMPSimdDirective *
373OMPSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
374 SourceLocation EndLoc, unsigned CollapsedNum,
375 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
376 const HelperExprs &Exprs) {
377 auto *Dir = createDirective<OMPSimdDirective>(
378 C, Clauses, AssociatedStmt, NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_simd),
379 P&: StartLoc, P&: EndLoc, P&: CollapsedNum);
380 Dir->setIterationVariable(Exprs.IterationVarRef);
381 Dir->setLastIteration(Exprs.LastIteration);
382 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
383 Dir->setPreCond(Exprs.PreCond);
384 Dir->setCond(Exprs.Cond);
385 Dir->setInit(Exprs.Init);
386 Dir->setInc(Exprs.Inc);
387 Dir->setCounters(Exprs.Counters);
388 Dir->setPrivateCounters(Exprs.PrivateCounters);
389 Dir->setInits(Exprs.Inits);
390 Dir->setUpdates(Exprs.Updates);
391 Dir->setFinals(Exprs.Finals);
392 Dir->setDependentCounters(Exprs.DependentCounters);
393 Dir->setDependentInits(Exprs.DependentInits);
394 Dir->setFinalsConditions(Exprs.FinalsConditions);
395 Dir->setPreInits(Exprs.PreInits);
396 return Dir;
397}
398
399OMPSimdDirective *OMPSimdDirective::CreateEmpty(const ASTContext &C,
400 unsigned NumClauses,
401 unsigned CollapsedNum,
402 EmptyShell) {
403 return createEmptyDirective<OMPSimdDirective>(
404 C, NumClauses, /*HasAssociatedStmt=*/true,
405 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_simd), P&: CollapsedNum);
406}
407
408OMPForDirective *OMPForDirective::Create(
409 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
410 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
411 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
412 auto *Dir = createDirective<OMPForDirective>(
413 C, Clauses, AssociatedStmt, NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_for) + 1,
414 P&: StartLoc, P&: EndLoc, P&: CollapsedNum);
415 Dir->setIterationVariable(Exprs.IterationVarRef);
416 Dir->setLastIteration(Exprs.LastIteration);
417 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
418 Dir->setPreCond(Exprs.PreCond);
419 Dir->setCond(Exprs.Cond);
420 Dir->setInit(Exprs.Init);
421 Dir->setInc(Exprs.Inc);
422 Dir->setIsLastIterVariable(Exprs.IL);
423 Dir->setLowerBoundVariable(Exprs.LB);
424 Dir->setUpperBoundVariable(Exprs.UB);
425 Dir->setStrideVariable(Exprs.ST);
426 Dir->setEnsureUpperBound(Exprs.EUB);
427 Dir->setNextLowerBound(Exprs.NLB);
428 Dir->setNextUpperBound(Exprs.NUB);
429 Dir->setNumIterations(Exprs.NumIterations);
430 Dir->setCounters(Exprs.Counters);
431 Dir->setPrivateCounters(Exprs.PrivateCounters);
432 Dir->setInits(Exprs.Inits);
433 Dir->setUpdates(Exprs.Updates);
434 Dir->setFinals(Exprs.Finals);
435 Dir->setDependentCounters(Exprs.DependentCounters);
436 Dir->setDependentInits(Exprs.DependentInits);
437 Dir->setFinalsConditions(Exprs.FinalsConditions);
438 Dir->setPreInits(Exprs.PreInits);
439 Dir->setTaskReductionRefExpr(TaskRedRef);
440 Dir->setHasCancel(HasCancel);
441 return Dir;
442}
443
444Stmt *OMPLoopTransformationDirective::getTransformedStmt() const {
445 if (auto *D = dyn_cast<OMPCanonicalLoopNestTransformationDirective>(Val: S))
446 return D->getTransformedStmt();
447 if (auto *D = dyn_cast<OMPCanonicalLoopSequenceTransformationDirective>(Val: S))
448 return D->getTransformedStmt();
449 llvm_unreachable("unexpected object type");
450}
451
452Stmt *OMPLoopTransformationDirective::getPreInits() const {
453 if (auto *D = dyn_cast<OMPCanonicalLoopNestTransformationDirective>(Val: S))
454 return D->getPreInits();
455 if (auto *D = dyn_cast<OMPCanonicalLoopSequenceTransformationDirective>(Val: S))
456 return D->getPreInits();
457 llvm_unreachable("unexpected object type");
458}
459
460Stmt *OMPCanonicalLoopNestTransformationDirective::getTransformedStmt() const {
461 switch (getStmtClass()) {
462#define STMT(CLASS, PARENT)
463#define ABSTRACT_STMT(CLASS)
464#define OMPCANONICALLOOPNESTTRANSFORMATIONDIRECTIVE(CLASS, PARENT) \
465 case Stmt::CLASS##Class: \
466 return static_cast<const CLASS *>(this)->getTransformedStmt();
467#include "clang/AST/StmtNodes.inc"
468 default:
469 llvm_unreachable("Not a loop transformation for canonical loop nests");
470 }
471}
472
473Stmt *OMPCanonicalLoopNestTransformationDirective::getPreInits() const {
474 switch (getStmtClass()) {
475#define STMT(CLASS, PARENT)
476#define ABSTRACT_STMT(CLASS)
477#define OMPCANONICALLOOPNESTTRANSFORMATIONDIRECTIVE(CLASS, PARENT) \
478 case Stmt::CLASS##Class: \
479 return static_cast<const CLASS *>(this)->getPreInits();
480#include "clang/AST/StmtNodes.inc"
481 default:
482 llvm_unreachable("Not a loop transformation for canonical loop nests");
483 }
484}
485
486Stmt *
487OMPCanonicalLoopSequenceTransformationDirective::getTransformedStmt() const {
488 switch (getStmtClass()) {
489#define STMT(CLASS, PARENT)
490#define ABSTRACT_STMT(CLASS)
491#define OMPCANONICALLOOPSEQUENCETRANSFORMATIONDIRECTIVE(CLASS, PARENT) \
492 case Stmt::CLASS##Class: \
493 return static_cast<const CLASS *>(this)->getTransformedStmt();
494#include "clang/AST/StmtNodes.inc"
495 default:
496 llvm_unreachable("Not a loop transformation for canonical loop sequences");
497 }
498}
499
500Stmt *OMPCanonicalLoopSequenceTransformationDirective::getPreInits() const {
501 switch (getStmtClass()) {
502#define STMT(CLASS, PARENT)
503#define ABSTRACT_STMT(CLASS)
504#define OMPCANONICALLOOPSEQUENCETRANSFORMATIONDIRECTIVE(CLASS, PARENT) \
505 case Stmt::CLASS##Class: \
506 return static_cast<const CLASS *>(this)->getPreInits();
507#include "clang/AST/StmtNodes.inc"
508 default:
509 llvm_unreachable("Not a loop transformation for canonical loop sequences");
510 }
511}
512
513OMPForDirective *OMPForDirective::CreateEmpty(const ASTContext &C,
514 unsigned NumClauses,
515 unsigned CollapsedNum,
516 EmptyShell) {
517 return createEmptyDirective<OMPForDirective>(
518 C, NumClauses, /*HasAssociatedStmt=*/true,
519 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_for) + 1, P&: CollapsedNum);
520}
521
522OMPTileDirective *
523OMPTileDirective::Create(const ASTContext &C, SourceLocation StartLoc,
524 SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
525 unsigned NumLoops, Stmt *AssociatedStmt,
526 Stmt *TransformedStmt, Stmt *PreInits) {
527 OMPTileDirective *Dir = createDirective<OMPTileDirective>(
528 C, Clauses, AssociatedStmt, NumChildren: TransformedStmtOffset + 1, P&: StartLoc, P&: EndLoc,
529 P&: NumLoops);
530 Dir->setTransformedStmt(TransformedStmt);
531 Dir->setPreInits(PreInits);
532 return Dir;
533}
534
535OMPTileDirective *OMPTileDirective::CreateEmpty(const ASTContext &C,
536 unsigned NumClauses,
537 unsigned NumLoops) {
538 return createEmptyDirective<OMPTileDirective>(
539 C, NumClauses, /*HasAssociatedStmt=*/true, NumChildren: TransformedStmtOffset + 1,
540 P: SourceLocation(), P: SourceLocation(), P&: NumLoops);
541}
542
543OMPStripeDirective *
544OMPStripeDirective::Create(const ASTContext &C, SourceLocation StartLoc,
545 SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
546 unsigned NumLoops, Stmt *AssociatedStmt,
547 Stmt *TransformedStmt, Stmt *PreInits) {
548 OMPStripeDirective *Dir = createDirective<OMPStripeDirective>(
549 C, Clauses, AssociatedStmt, NumChildren: TransformedStmtOffset + 1, P&: StartLoc, P&: EndLoc,
550 P&: NumLoops);
551 Dir->setTransformedStmt(TransformedStmt);
552 Dir->setPreInits(PreInits);
553 return Dir;
554}
555
556OMPStripeDirective *OMPStripeDirective::CreateEmpty(const ASTContext &C,
557 unsigned NumClauses,
558 unsigned NumLoops) {
559 return createEmptyDirective<OMPStripeDirective>(
560 C, NumClauses, /*HasAssociatedStmt=*/true, NumChildren: TransformedStmtOffset + 1,
561 P: SourceLocation(), P: SourceLocation(), P&: NumLoops);
562}
563
564OMPUnrollDirective *OMPUnrollDirective::Create(
565 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
566 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
567 unsigned NumGeneratedTopLevelLoops, Stmt *TransformedStmt, Stmt *PreInits) {
568 assert(NumGeneratedTopLevelLoops <= 1 &&
569 "Unrolling generates at most one loop");
570
571 auto *Dir = createDirective<OMPUnrollDirective>(
572 C, Clauses, AssociatedStmt, NumChildren: TransformedStmtOffset + 1, P&: StartLoc, P&: EndLoc);
573 Dir->setNumGeneratedTopLevelLoops(NumGeneratedTopLevelLoops);
574 Dir->setTransformedStmt(TransformedStmt);
575 Dir->setPreInits(PreInits);
576 return Dir;
577}
578
579OMPUnrollDirective *OMPUnrollDirective::CreateEmpty(const ASTContext &C,
580 unsigned NumClauses) {
581 return createEmptyDirective<OMPUnrollDirective>(
582 C, NumClauses, /*HasAssociatedStmt=*/true, NumChildren: TransformedStmtOffset + 1,
583 P: SourceLocation(), P: SourceLocation());
584}
585
586OMPReverseDirective *
587OMPReverseDirective::Create(const ASTContext &C, SourceLocation StartLoc,
588 SourceLocation EndLoc, Stmt *AssociatedStmt,
589 unsigned NumLoops, Stmt *TransformedStmt,
590 Stmt *PreInits) {
591 OMPReverseDirective *Dir = createDirective<OMPReverseDirective>(
592 C, Clauses: {}, AssociatedStmt, NumChildren: TransformedStmtOffset + 1, P&: StartLoc, P&: EndLoc,
593 P&: NumLoops);
594 Dir->setTransformedStmt(TransformedStmt);
595 Dir->setPreInits(PreInits);
596 return Dir;
597}
598
599OMPReverseDirective *OMPReverseDirective::CreateEmpty(const ASTContext &C,
600 unsigned NumLoops) {
601 return createEmptyDirective<OMPReverseDirective>(
602 C, /*NumClauses=*/0, /*HasAssociatedStmt=*/true,
603 NumChildren: TransformedStmtOffset + 1, P: SourceLocation(), P: SourceLocation(), P&: NumLoops);
604}
605
606OMPInterchangeDirective *OMPInterchangeDirective::Create(
607 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
608 ArrayRef<OMPClause *> Clauses, unsigned NumLoops, Stmt *AssociatedStmt,
609 Stmt *TransformedStmt, Stmt *PreInits) {
610 OMPInterchangeDirective *Dir = createDirective<OMPInterchangeDirective>(
611 C, Clauses, AssociatedStmt, NumChildren: TransformedStmtOffset + 1, P&: StartLoc, P&: EndLoc,
612 P&: NumLoops);
613 Dir->setTransformedStmt(TransformedStmt);
614 Dir->setPreInits(PreInits);
615 return Dir;
616}
617
618OMPInterchangeDirective *
619OMPInterchangeDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
620 unsigned NumLoops) {
621 return createEmptyDirective<OMPInterchangeDirective>(
622 C, NumClauses, /*HasAssociatedStmt=*/true, NumChildren: TransformedStmtOffset + 1,
623 P: SourceLocation(), P: SourceLocation(), P&: NumLoops);
624}
625
626OMPFlattenDirective *OMPFlattenDirective::Create(
627 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
628 ArrayRef<OMPClause *> Clauses, unsigned NumLoops, Stmt *AssociatedStmt,
629 Stmt *TransformedStmt, Stmt *PreInits, Stmt *Finals) {
630 OMPFlattenDirective *Dir = createDirective<OMPFlattenDirective>(
631 C, Clauses, AssociatedStmt, NumChildren: FinalsOffset + 1, P&: StartLoc, P&: EndLoc, P&: NumLoops);
632 Dir->setTransformedStmt(TransformedStmt);
633 Dir->setPreInits(PreInits);
634 Dir->setFinals(Finals);
635 return Dir;
636}
637
638OMPFlattenDirective *OMPFlattenDirective::CreateEmpty(const ASTContext &C,
639 unsigned NumClauses,
640 unsigned NumLoops) {
641 return createEmptyDirective<OMPFlattenDirective>(
642 C, NumClauses, /*HasAssociatedStmt=*/true, NumChildren: FinalsOffset + 1,
643 P: SourceLocation(), P: SourceLocation(), P&: NumLoops);
644}
645
646OMPSplitDirective *
647OMPSplitDirective::Create(const ASTContext &C, SourceLocation StartLoc,
648 SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
649 unsigned NumLoops, Stmt *AssociatedStmt,
650 Stmt *TransformedStmt, Stmt *PreInits) {
651 OMPSplitDirective *Dir = createDirective<OMPSplitDirective>(
652 C, Clauses, AssociatedStmt, NumChildren: TransformedStmtOffset + 1, P&: StartLoc, P&: EndLoc,
653 P&: NumLoops);
654 Dir->setTransformedStmt(TransformedStmt);
655 Dir->setPreInits(PreInits);
656 return Dir;
657}
658
659OMPSplitDirective *OMPSplitDirective::CreateEmpty(const ASTContext &C,
660 unsigned NumClauses,
661 unsigned NumLoops) {
662 return createEmptyDirective<OMPSplitDirective>(
663 C, NumClauses, /*HasAssociatedStmt=*/true, NumChildren: TransformedStmtOffset + 1,
664 P: SourceLocation(), P: SourceLocation(), P&: NumLoops);
665}
666
667OMPFuseDirective *OMPFuseDirective::Create(
668 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
669 ArrayRef<OMPClause *> Clauses, unsigned NumGeneratedTopLevelLoops,
670 Stmt *AssociatedStmt, Stmt *TransformedStmt, Stmt *PreInits) {
671
672 OMPFuseDirective *Dir = createDirective<OMPFuseDirective>(
673 C, Clauses, AssociatedStmt, NumChildren: TransformedStmtOffset + 1, P&: StartLoc, P&: EndLoc);
674 Dir->setTransformedStmt(TransformedStmt);
675 Dir->setPreInits(PreInits);
676 Dir->setNumGeneratedTopLevelLoops(NumGeneratedTopLevelLoops);
677 return Dir;
678}
679
680OMPFuseDirective *OMPFuseDirective::CreateEmpty(const ASTContext &C,
681 unsigned NumClauses) {
682 OMPFuseDirective *Dir = createEmptyDirective<OMPFuseDirective>(
683 C, NumClauses, /*HasAssociatedStmt=*/true, NumChildren: TransformedStmtOffset + 1,
684 P: SourceLocation(), P: SourceLocation());
685 return Dir;
686}
687
688OMPForSimdDirective *
689OMPForSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
690 SourceLocation EndLoc, unsigned CollapsedNum,
691 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
692 const HelperExprs &Exprs) {
693 auto *Dir = createDirective<OMPForSimdDirective>(
694 C, Clauses, AssociatedStmt, NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_for_simd),
695 P&: StartLoc, P&: EndLoc, P&: CollapsedNum);
696 Dir->setIterationVariable(Exprs.IterationVarRef);
697 Dir->setLastIteration(Exprs.LastIteration);
698 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
699 Dir->setPreCond(Exprs.PreCond);
700 Dir->setCond(Exprs.Cond);
701 Dir->setInit(Exprs.Init);
702 Dir->setInc(Exprs.Inc);
703 Dir->setIsLastIterVariable(Exprs.IL);
704 Dir->setLowerBoundVariable(Exprs.LB);
705 Dir->setUpperBoundVariable(Exprs.UB);
706 Dir->setStrideVariable(Exprs.ST);
707 Dir->setEnsureUpperBound(Exprs.EUB);
708 Dir->setNextLowerBound(Exprs.NLB);
709 Dir->setNextUpperBound(Exprs.NUB);
710 Dir->setNumIterations(Exprs.NumIterations);
711 Dir->setCounters(Exprs.Counters);
712 Dir->setPrivateCounters(Exprs.PrivateCounters);
713 Dir->setInits(Exprs.Inits);
714 Dir->setUpdates(Exprs.Updates);
715 Dir->setFinals(Exprs.Finals);
716 Dir->setDependentCounters(Exprs.DependentCounters);
717 Dir->setDependentInits(Exprs.DependentInits);
718 Dir->setFinalsConditions(Exprs.FinalsConditions);
719 Dir->setPreInits(Exprs.PreInits);
720 return Dir;
721}
722
723OMPForSimdDirective *OMPForSimdDirective::CreateEmpty(const ASTContext &C,
724 unsigned NumClauses,
725 unsigned CollapsedNum,
726 EmptyShell) {
727 return createEmptyDirective<OMPForSimdDirective>(
728 C, NumClauses, /*HasAssociatedStmt=*/true,
729 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_for_simd), P&: CollapsedNum);
730}
731
732OMPSectionsDirective *OMPSectionsDirective::Create(
733 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
734 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
735 bool HasCancel) {
736 auto *Dir = createDirective<OMPSectionsDirective>(C, Clauses, AssociatedStmt,
737 /*NumChildren=*/1, P&: StartLoc,
738 P&: EndLoc);
739 Dir->setTaskReductionRefExpr(TaskRedRef);
740 Dir->setHasCancel(HasCancel);
741 return Dir;
742}
743
744OMPSectionsDirective *OMPSectionsDirective::CreateEmpty(const ASTContext &C,
745 unsigned NumClauses,
746 EmptyShell) {
747 return createEmptyDirective<OMPSectionsDirective>(C, NumClauses,
748 /*HasAssociatedStmt=*/true,
749 /*NumChildren=*/1);
750}
751
752OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C,
753 SourceLocation StartLoc,
754 SourceLocation EndLoc,
755 Stmt *AssociatedStmt,
756 bool HasCancel) {
757 auto *Dir =
758 createDirective<OMPSectionDirective>(C, Clauses: {}, AssociatedStmt,
759 /*NumChildren=*/0, P&: StartLoc, P&: EndLoc);
760 Dir->setHasCancel(HasCancel);
761 return Dir;
762}
763
764OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C,
765 EmptyShell) {
766 return createEmptyDirective<OMPSectionDirective>(C, /*NumClauses=*/0,
767 /*HasAssociatedStmt=*/true);
768}
769
770OMPScopeDirective *OMPScopeDirective::Create(const ASTContext &C,
771 SourceLocation StartLoc,
772 SourceLocation EndLoc,
773 ArrayRef<OMPClause *> Clauses,
774 Stmt *AssociatedStmt) {
775 return createDirective<OMPScopeDirective>(C, Clauses, AssociatedStmt,
776 /*NumChildren=*/0, P&: StartLoc,
777 P&: EndLoc);
778}
779
780OMPScopeDirective *OMPScopeDirective::CreateEmpty(const ASTContext &C,
781 unsigned NumClauses,
782 EmptyShell) {
783 return createEmptyDirective<OMPScopeDirective>(C, NumClauses,
784 /*HasAssociatedStmt=*/true);
785}
786
787OMPSingleDirective *OMPSingleDirective::Create(const ASTContext &C,
788 SourceLocation StartLoc,
789 SourceLocation EndLoc,
790 ArrayRef<OMPClause *> Clauses,
791 Stmt *AssociatedStmt) {
792 return createDirective<OMPSingleDirective>(C, Clauses, AssociatedStmt,
793 /*NumChildren=*/0, P&: StartLoc,
794 P&: EndLoc);
795}
796
797OMPSingleDirective *OMPSingleDirective::CreateEmpty(const ASTContext &C,
798 unsigned NumClauses,
799 EmptyShell) {
800 return createEmptyDirective<OMPSingleDirective>(C, NumClauses,
801 /*HasAssociatedStmt=*/true);
802}
803
804OMPMasterDirective *OMPMasterDirective::Create(const ASTContext &C,
805 SourceLocation StartLoc,
806 SourceLocation EndLoc,
807 Stmt *AssociatedStmt) {
808 return createDirective<OMPMasterDirective>(C, Clauses: {}, AssociatedStmt,
809 /*NumChildren=*/0, P&: StartLoc,
810 P&: EndLoc);
811}
812
813OMPMasterDirective *OMPMasterDirective::CreateEmpty(const ASTContext &C,
814 EmptyShell) {
815 return createEmptyDirective<OMPMasterDirective>(C, /*NumClauses=*/0,
816 /*HasAssociatedStmt=*/true);
817}
818
819OMPCriticalDirective *OMPCriticalDirective::Create(
820 const ASTContext &C, const DeclarationNameInfo &Name,
821 SourceLocation StartLoc, SourceLocation EndLoc,
822 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
823 return createDirective<OMPCriticalDirective>(C, Clauses, AssociatedStmt,
824 /*NumChildren=*/0, P: Name,
825 P&: StartLoc, P&: EndLoc);
826}
827
828OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C,
829 unsigned NumClauses,
830 EmptyShell) {
831 return createEmptyDirective<OMPCriticalDirective>(C, NumClauses,
832 /*HasAssociatedStmt=*/true);
833}
834
835OMPParallelForDirective *OMPParallelForDirective::Create(
836 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
837 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
838 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
839 auto *Dir = createDirective<OMPParallelForDirective>(
840 C, Clauses, AssociatedStmt,
841 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_parallel_for) + 1, P&: StartLoc, P&: EndLoc,
842 P&: CollapsedNum);
843 Dir->setIterationVariable(Exprs.IterationVarRef);
844 Dir->setLastIteration(Exprs.LastIteration);
845 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
846 Dir->setPreCond(Exprs.PreCond);
847 Dir->setCond(Exprs.Cond);
848 Dir->setInit(Exprs.Init);
849 Dir->setInc(Exprs.Inc);
850 Dir->setIsLastIterVariable(Exprs.IL);
851 Dir->setLowerBoundVariable(Exprs.LB);
852 Dir->setUpperBoundVariable(Exprs.UB);
853 Dir->setStrideVariable(Exprs.ST);
854 Dir->setEnsureUpperBound(Exprs.EUB);
855 Dir->setNextLowerBound(Exprs.NLB);
856 Dir->setNextUpperBound(Exprs.NUB);
857 Dir->setNumIterations(Exprs.NumIterations);
858 Dir->setCounters(Exprs.Counters);
859 Dir->setPrivateCounters(Exprs.PrivateCounters);
860 Dir->setInits(Exprs.Inits);
861 Dir->setUpdates(Exprs.Updates);
862 Dir->setFinals(Exprs.Finals);
863 Dir->setDependentCounters(Exprs.DependentCounters);
864 Dir->setDependentInits(Exprs.DependentInits);
865 Dir->setFinalsConditions(Exprs.FinalsConditions);
866 Dir->setPreInits(Exprs.PreInits);
867 Dir->setTaskReductionRefExpr(TaskRedRef);
868 Dir->setHasCancel(HasCancel);
869 return Dir;
870}
871
872OMPParallelForDirective *
873OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
874 unsigned CollapsedNum, EmptyShell) {
875 return createEmptyDirective<OMPParallelForDirective>(
876 C, NumClauses, /*HasAssociatedStmt=*/true,
877 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_parallel_for) + 1, P&: CollapsedNum);
878}
879
880OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create(
881 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
882 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
883 const HelperExprs &Exprs) {
884 auto *Dir = createDirective<OMPParallelForSimdDirective>(
885 C, Clauses, AssociatedStmt,
886 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_parallel_for_simd), P&: StartLoc, P&: EndLoc,
887 P&: CollapsedNum);
888 Dir->setIterationVariable(Exprs.IterationVarRef);
889 Dir->setLastIteration(Exprs.LastIteration);
890 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
891 Dir->setPreCond(Exprs.PreCond);
892 Dir->setCond(Exprs.Cond);
893 Dir->setInit(Exprs.Init);
894 Dir->setInc(Exprs.Inc);
895 Dir->setIsLastIterVariable(Exprs.IL);
896 Dir->setLowerBoundVariable(Exprs.LB);
897 Dir->setUpperBoundVariable(Exprs.UB);
898 Dir->setStrideVariable(Exprs.ST);
899 Dir->setEnsureUpperBound(Exprs.EUB);
900 Dir->setNextLowerBound(Exprs.NLB);
901 Dir->setNextUpperBound(Exprs.NUB);
902 Dir->setNumIterations(Exprs.NumIterations);
903 Dir->setCounters(Exprs.Counters);
904 Dir->setPrivateCounters(Exprs.PrivateCounters);
905 Dir->setInits(Exprs.Inits);
906 Dir->setUpdates(Exprs.Updates);
907 Dir->setFinals(Exprs.Finals);
908 Dir->setDependentCounters(Exprs.DependentCounters);
909 Dir->setDependentInits(Exprs.DependentInits);
910 Dir->setFinalsConditions(Exprs.FinalsConditions);
911 Dir->setPreInits(Exprs.PreInits);
912 return Dir;
913}
914
915OMPParallelForSimdDirective *
916OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C,
917 unsigned NumClauses,
918 unsigned CollapsedNum, EmptyShell) {
919 return createEmptyDirective<OMPParallelForSimdDirective>(
920 C, NumClauses, /*HasAssociatedStmt=*/true,
921 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_parallel_for_simd), P&: CollapsedNum);
922}
923
924OMPParallelMasterDirective *OMPParallelMasterDirective::Create(
925 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
926 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef) {
927 auto *Dir = createDirective<OMPParallelMasterDirective>(
928 C, Clauses, AssociatedStmt, /*NumChildren=*/1, P&: StartLoc, P&: EndLoc);
929 Dir->setTaskReductionRefExpr(TaskRedRef);
930 return Dir;
931}
932
933OMPParallelMasterDirective *
934OMPParallelMasterDirective::CreateEmpty(const ASTContext &C,
935 unsigned NumClauses, EmptyShell) {
936 return createEmptyDirective<OMPParallelMasterDirective>(
937 C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
938}
939
940OMPParallelMaskedDirective *OMPParallelMaskedDirective::Create(
941 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
942 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef) {
943 auto *Dir = createDirective<OMPParallelMaskedDirective>(
944 C, Clauses, AssociatedStmt, /*NumChildren=*/1, P&: StartLoc, P&: EndLoc);
945 Dir->setTaskReductionRefExpr(TaskRedRef);
946 return Dir;
947}
948
949OMPParallelMaskedDirective *
950OMPParallelMaskedDirective::CreateEmpty(const ASTContext &C,
951 unsigned NumClauses, EmptyShell) {
952 return createEmptyDirective<OMPParallelMaskedDirective>(
953 C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
954}
955
956OMPParallelSectionsDirective *OMPParallelSectionsDirective::Create(
957 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
958 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
959 bool HasCancel) {
960 auto *Dir = createDirective<OMPParallelSectionsDirective>(
961 C, Clauses, AssociatedStmt, /*NumChildren=*/1, P&: StartLoc, P&: EndLoc);
962 Dir->setTaskReductionRefExpr(TaskRedRef);
963 Dir->setHasCancel(HasCancel);
964 return Dir;
965}
966
967OMPParallelSectionsDirective *
968OMPParallelSectionsDirective::CreateEmpty(const ASTContext &C,
969 unsigned NumClauses, EmptyShell) {
970 return createEmptyDirective<OMPParallelSectionsDirective>(
971 C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
972}
973
974OMPTaskDirective *
975OMPTaskDirective::Create(const ASTContext &C, SourceLocation StartLoc,
976 SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
977 Stmt *AssociatedStmt, bool HasCancel) {
978 auto *Dir = createDirective<OMPTaskDirective>(
979 C, Clauses, AssociatedStmt, /*NumChildren=*/0, P&: StartLoc, P&: EndLoc);
980 Dir->setHasCancel(HasCancel);
981 return Dir;
982}
983
984OMPTaskDirective *OMPTaskDirective::CreateEmpty(const ASTContext &C,
985 unsigned NumClauses,
986 EmptyShell) {
987 return createEmptyDirective<OMPTaskDirective>(C, NumClauses,
988 /*HasAssociatedStmt=*/true);
989}
990
991OMPTaskyieldDirective *OMPTaskyieldDirective::Create(const ASTContext &C,
992 SourceLocation StartLoc,
993 SourceLocation EndLoc) {
994 return new (C) OMPTaskyieldDirective(StartLoc, EndLoc);
995}
996
997OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C,
998 EmptyShell) {
999 return new (C) OMPTaskyieldDirective();
1000}
1001
1002OMPAssumeDirective *OMPAssumeDirective::Create(const ASTContext &C,
1003 SourceLocation StartLoc,
1004 SourceLocation EndLoc,
1005 ArrayRef<OMPClause *> Clauses,
1006 Stmt *AStmt) {
1007 return createDirective<OMPAssumeDirective>(C, Clauses, AssociatedStmt: AStmt,
1008 /*NumChildren=*/0, P&: StartLoc,
1009 P&: EndLoc);
1010}
1011
1012OMPAssumeDirective *OMPAssumeDirective::CreateEmpty(const ASTContext &C,
1013 unsigned NumClauses,
1014 EmptyShell) {
1015 return createEmptyDirective<OMPAssumeDirective>(C, NumClauses,
1016 /*HasAssociatedStmt=*/true);
1017}
1018
1019OMPErrorDirective *OMPErrorDirective::Create(const ASTContext &C,
1020 SourceLocation StartLoc,
1021 SourceLocation EndLoc,
1022 ArrayRef<OMPClause *> Clauses) {
1023 return createDirective<OMPErrorDirective>(
1024 C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, P&: StartLoc,
1025 P&: EndLoc);
1026}
1027
1028OMPErrorDirective *OMPErrorDirective::CreateEmpty(const ASTContext &C,
1029 unsigned NumClauses,
1030 EmptyShell) {
1031 return createEmptyDirective<OMPErrorDirective>(C, NumClauses);
1032}
1033
1034OMPBarrierDirective *OMPBarrierDirective::Create(const ASTContext &C,
1035 SourceLocation StartLoc,
1036 SourceLocation EndLoc) {
1037 return new (C) OMPBarrierDirective(StartLoc, EndLoc);
1038}
1039
1040OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C,
1041 EmptyShell) {
1042 return new (C) OMPBarrierDirective();
1043}
1044
1045OMPTaskwaitDirective *
1046OMPTaskwaitDirective::Create(const ASTContext &C, SourceLocation StartLoc,
1047 SourceLocation EndLoc,
1048 ArrayRef<OMPClause *> Clauses) {
1049 return createDirective<OMPTaskwaitDirective>(
1050 C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, P&: StartLoc,
1051 P&: EndLoc);
1052}
1053
1054OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C,
1055 unsigned NumClauses,
1056 EmptyShell) {
1057 return createEmptyDirective<OMPTaskwaitDirective>(C, NumClauses);
1058}
1059
1060OMPTaskgroupDirective *OMPTaskgroupDirective::Create(
1061 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1062 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *ReductionRef) {
1063 auto *Dir = createDirective<OMPTaskgroupDirective>(
1064 C, Clauses, AssociatedStmt, /*NumChildren=*/1, P&: StartLoc, P&: EndLoc);
1065 Dir->setReductionRef(ReductionRef);
1066 return Dir;
1067}
1068
1069OMPTaskgroupDirective *OMPTaskgroupDirective::CreateEmpty(const ASTContext &C,
1070 unsigned NumClauses,
1071 EmptyShell) {
1072 return createEmptyDirective<OMPTaskgroupDirective>(
1073 C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
1074}
1075
1076OMPCancellationPointDirective *OMPCancellationPointDirective::Create(
1077 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1078 OpenMPDirectiveKind CancelRegion) {
1079 auto *Dir = new (C) OMPCancellationPointDirective(StartLoc, EndLoc);
1080 Dir->setCancelRegion(CancelRegion);
1081 return Dir;
1082}
1083
1084OMPCancellationPointDirective *
1085OMPCancellationPointDirective::CreateEmpty(const ASTContext &C, EmptyShell) {
1086 return new (C) OMPCancellationPointDirective();
1087}
1088
1089OMPCancelDirective *
1090OMPCancelDirective::Create(const ASTContext &C, SourceLocation StartLoc,
1091 SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
1092 OpenMPDirectiveKind CancelRegion) {
1093 auto *Dir = createDirective<OMPCancelDirective>(
1094 C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, P&: StartLoc,
1095 P&: EndLoc);
1096 Dir->setCancelRegion(CancelRegion);
1097 return Dir;
1098}
1099
1100OMPCancelDirective *OMPCancelDirective::CreateEmpty(const ASTContext &C,
1101 unsigned NumClauses,
1102 EmptyShell) {
1103 return createEmptyDirective<OMPCancelDirective>(C, NumClauses);
1104}
1105
1106OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C,
1107 SourceLocation StartLoc,
1108 SourceLocation EndLoc,
1109 ArrayRef<OMPClause *> Clauses) {
1110 return createDirective<OMPFlushDirective>(
1111 C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, P&: StartLoc,
1112 P&: EndLoc);
1113}
1114
1115OMPFlushDirective *OMPFlushDirective::CreateEmpty(const ASTContext &C,
1116 unsigned NumClauses,
1117 EmptyShell) {
1118 return createEmptyDirective<OMPFlushDirective>(C, NumClauses);
1119}
1120
1121OMPDepobjDirective *OMPDepobjDirective::Create(const ASTContext &C,
1122 SourceLocation StartLoc,
1123 SourceLocation EndLoc,
1124 ArrayRef<OMPClause *> Clauses) {
1125 return createDirective<OMPDepobjDirective>(
1126 C, Clauses, /*AssociatedStmt=*/nullptr,
1127 /*NumChildren=*/0, P&: StartLoc, P&: EndLoc);
1128}
1129
1130OMPDepobjDirective *OMPDepobjDirective::CreateEmpty(const ASTContext &C,
1131 unsigned NumClauses,
1132 EmptyShell) {
1133 return createEmptyDirective<OMPDepobjDirective>(C, NumClauses);
1134}
1135
1136OMPScanDirective *OMPScanDirective::Create(const ASTContext &C,
1137 SourceLocation StartLoc,
1138 SourceLocation EndLoc,
1139 ArrayRef<OMPClause *> Clauses) {
1140 return createDirective<OMPScanDirective>(C, Clauses,
1141 /*AssociatedStmt=*/nullptr,
1142 /*NumChildren=*/0, P&: StartLoc, P&: EndLoc);
1143}
1144
1145OMPScanDirective *OMPScanDirective::CreateEmpty(const ASTContext &C,
1146 unsigned NumClauses,
1147 EmptyShell) {
1148 return createEmptyDirective<OMPScanDirective>(C, NumClauses);
1149}
1150
1151OMPOrderedStandaloneDirective *OMPOrderedStandaloneDirective::Create(
1152 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1153 ArrayRef<OMPClause *> Clauses) {
1154 return createDirective<OMPOrderedStandaloneDirective>(
1155 C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, P&: StartLoc,
1156 P&: EndLoc);
1157}
1158
1159OMPOrderedStandaloneDirective *
1160OMPOrderedStandaloneDirective::CreateEmpty(const ASTContext &C,
1161 unsigned NumClauses, EmptyShell) {
1162 return createEmptyDirective<OMPOrderedStandaloneDirective>(C, NumClauses);
1163}
1164
1165OMPOrderedBlockAssocDirective *OMPOrderedBlockAssocDirective::Create(
1166 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1167 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1168 return createDirective<OMPOrderedBlockAssocDirective>(
1169 C, Clauses, AssociatedStmt: cast<CapturedStmt>(Val: AssociatedStmt), /*NumChildren=*/0,
1170 P&: StartLoc, P&: EndLoc);
1171}
1172
1173OMPOrderedBlockAssocDirective *
1174OMPOrderedBlockAssocDirective::CreateEmpty(const ASTContext &C,
1175 unsigned NumClauses, EmptyShell) {
1176 return createEmptyDirective<OMPOrderedBlockAssocDirective>(
1177 C, NumClauses, /*HasAssociatedStmt=*/true);
1178}
1179
1180OMPAtomicDirective *
1181OMPAtomicDirective::Create(const ASTContext &C, SourceLocation StartLoc,
1182 SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
1183 Stmt *AssociatedStmt, Expressions Exprs) {
1184 auto *Dir = createDirective<OMPAtomicDirective>(
1185 C, Clauses, AssociatedStmt, /*NumChildren=*/7, P&: StartLoc, P&: EndLoc);
1186 Dir->setX(Exprs.X);
1187 Dir->setV(Exprs.V);
1188 Dir->setR(Exprs.R);
1189 Dir->setExpr(Exprs.E);
1190 Dir->setUpdateExpr(Exprs.UE);
1191 Dir->setD(Exprs.D);
1192 Dir->setCond(Exprs.Cond);
1193 Dir->Flags.IsXLHSInRHSPart = Exprs.IsXLHSInRHSPart ? 1 : 0;
1194 Dir->Flags.IsPostfixUpdate = Exprs.IsPostfixUpdate ? 1 : 0;
1195 Dir->Flags.IsFailOnly = Exprs.IsFailOnly ? 1 : 0;
1196 return Dir;
1197}
1198
1199OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C,
1200 unsigned NumClauses,
1201 EmptyShell) {
1202 return createEmptyDirective<OMPAtomicDirective>(
1203 C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/7);
1204}
1205
1206OMPTargetDirective *OMPTargetDirective::Create(const ASTContext &C,
1207 SourceLocation StartLoc,
1208 SourceLocation EndLoc,
1209 ArrayRef<OMPClause *> Clauses,
1210 Stmt *AssociatedStmt) {
1211 return createDirective<OMPTargetDirective>(
1212 C, Clauses, AssociatedStmt, /*NumChildren=*/0, P&: StartLoc, P&: EndLoc);
1213}
1214
1215OMPTargetDirective *OMPTargetDirective::CreateEmpty(const ASTContext &C,
1216 unsigned NumClauses,
1217 EmptyShell) {
1218 return createEmptyDirective<OMPTargetDirective>(C, NumClauses,
1219 /*HasAssociatedStmt=*/true);
1220}
1221
1222OMPTargetParallelDirective *OMPTargetParallelDirective::Create(
1223 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1224 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
1225 bool HasCancel) {
1226 auto *Dir = createDirective<OMPTargetParallelDirective>(
1227 C, Clauses, AssociatedStmt, /*NumChildren=*/1, P&: StartLoc, P&: EndLoc);
1228 Dir->setTaskReductionRefExpr(TaskRedRef);
1229 Dir->setHasCancel(HasCancel);
1230 return Dir;
1231}
1232
1233OMPTargetParallelDirective *
1234OMPTargetParallelDirective::CreateEmpty(const ASTContext &C,
1235 unsigned NumClauses, EmptyShell) {
1236 return createEmptyDirective<OMPTargetParallelDirective>(
1237 C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
1238}
1239
1240OMPTargetParallelForDirective *OMPTargetParallelForDirective::Create(
1241 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1242 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1243 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
1244 auto *Dir = createDirective<OMPTargetParallelForDirective>(
1245 C, Clauses, AssociatedStmt,
1246 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_target_parallel_for) + 1, P&: StartLoc,
1247 P&: EndLoc, P&: CollapsedNum);
1248 Dir->setIterationVariable(Exprs.IterationVarRef);
1249 Dir->setLastIteration(Exprs.LastIteration);
1250 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1251 Dir->setPreCond(Exprs.PreCond);
1252 Dir->setCond(Exprs.Cond);
1253 Dir->setInit(Exprs.Init);
1254 Dir->setInc(Exprs.Inc);
1255 Dir->setIsLastIterVariable(Exprs.IL);
1256 Dir->setLowerBoundVariable(Exprs.LB);
1257 Dir->setUpperBoundVariable(Exprs.UB);
1258 Dir->setStrideVariable(Exprs.ST);
1259 Dir->setEnsureUpperBound(Exprs.EUB);
1260 Dir->setNextLowerBound(Exprs.NLB);
1261 Dir->setNextUpperBound(Exprs.NUB);
1262 Dir->setNumIterations(Exprs.NumIterations);
1263 Dir->setCounters(Exprs.Counters);
1264 Dir->setPrivateCounters(Exprs.PrivateCounters);
1265 Dir->setInits(Exprs.Inits);
1266 Dir->setUpdates(Exprs.Updates);
1267 Dir->setFinals(Exprs.Finals);
1268 Dir->setDependentCounters(Exprs.DependentCounters);
1269 Dir->setDependentInits(Exprs.DependentInits);
1270 Dir->setFinalsConditions(Exprs.FinalsConditions);
1271 Dir->setPreInits(Exprs.PreInits);
1272 Dir->setTaskReductionRefExpr(TaskRedRef);
1273 Dir->setHasCancel(HasCancel);
1274 return Dir;
1275}
1276
1277OMPTargetParallelForDirective *
1278OMPTargetParallelForDirective::CreateEmpty(const ASTContext &C,
1279 unsigned NumClauses,
1280 unsigned CollapsedNum, EmptyShell) {
1281 return createEmptyDirective<OMPTargetParallelForDirective>(
1282 C, NumClauses, /*HasAssociatedStmt=*/true,
1283 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_target_parallel_for) + 1,
1284 P&: CollapsedNum);
1285}
1286
1287OMPTargetDataDirective *OMPTargetDataDirective::Create(
1288 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1289 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1290 return createDirective<OMPTargetDataDirective>(
1291 C, Clauses, AssociatedStmt, /*NumChildren=*/0, P&: StartLoc, P&: EndLoc);
1292}
1293
1294OMPTargetDataDirective *OMPTargetDataDirective::CreateEmpty(const ASTContext &C,
1295 unsigned N,
1296 EmptyShell) {
1297 return createEmptyDirective<OMPTargetDataDirective>(
1298 C, NumClauses: N, /*HasAssociatedStmt=*/true);
1299}
1300
1301OMPTargetEnterDataDirective *OMPTargetEnterDataDirective::Create(
1302 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1303 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1304 return createDirective<OMPTargetEnterDataDirective>(
1305 C, Clauses, AssociatedStmt, /*NumChildren=*/0, P&: StartLoc, P&: EndLoc);
1306}
1307
1308OMPTargetEnterDataDirective *
1309OMPTargetEnterDataDirective::CreateEmpty(const ASTContext &C, unsigned N,
1310 EmptyShell) {
1311 return createEmptyDirective<OMPTargetEnterDataDirective>(
1312 C, NumClauses: N, /*HasAssociatedStmt=*/true);
1313}
1314
1315OMPTargetExitDataDirective *OMPTargetExitDataDirective::Create(
1316 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1317 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1318 return createDirective<OMPTargetExitDataDirective>(
1319 C, Clauses, AssociatedStmt, /*NumChildren=*/0, P&: StartLoc, P&: EndLoc);
1320}
1321
1322OMPTargetExitDataDirective *
1323OMPTargetExitDataDirective::CreateEmpty(const ASTContext &C, unsigned N,
1324 EmptyShell) {
1325 return createEmptyDirective<OMPTargetExitDataDirective>(
1326 C, NumClauses: N, /*HasAssociatedStmt=*/true);
1327}
1328
1329OMPTeamsDirective *OMPTeamsDirective::Create(const ASTContext &C,
1330 SourceLocation StartLoc,
1331 SourceLocation EndLoc,
1332 ArrayRef<OMPClause *> Clauses,
1333 Stmt *AssociatedStmt) {
1334 return createDirective<OMPTeamsDirective>(
1335 C, Clauses, AssociatedStmt, /*NumChildren=*/0, P&: StartLoc, P&: EndLoc);
1336}
1337
1338OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C,
1339 unsigned NumClauses,
1340 EmptyShell) {
1341 return createEmptyDirective<OMPTeamsDirective>(C, NumClauses,
1342 /*HasAssociatedStmt=*/true);
1343}
1344
1345OMPTaskLoopDirective *OMPTaskLoopDirective::Create(
1346 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1347 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1348 const HelperExprs &Exprs, bool HasCancel) {
1349 auto *Dir = createDirective<OMPTaskLoopDirective>(
1350 C, Clauses, AssociatedStmt, NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_taskloop),
1351 P&: StartLoc, P&: EndLoc, P&: CollapsedNum);
1352 Dir->setIterationVariable(Exprs.IterationVarRef);
1353 Dir->setLastIteration(Exprs.LastIteration);
1354 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1355 Dir->setPreCond(Exprs.PreCond);
1356 Dir->setCond(Exprs.Cond);
1357 Dir->setInit(Exprs.Init);
1358 Dir->setInc(Exprs.Inc);
1359 Dir->setIsLastIterVariable(Exprs.IL);
1360 Dir->setLowerBoundVariable(Exprs.LB);
1361 Dir->setUpperBoundVariable(Exprs.UB);
1362 Dir->setStrideVariable(Exprs.ST);
1363 Dir->setEnsureUpperBound(Exprs.EUB);
1364 Dir->setNextLowerBound(Exprs.NLB);
1365 Dir->setNextUpperBound(Exprs.NUB);
1366 Dir->setNumIterations(Exprs.NumIterations);
1367 Dir->setCounters(Exprs.Counters);
1368 Dir->setPrivateCounters(Exprs.PrivateCounters);
1369 Dir->setInits(Exprs.Inits);
1370 Dir->setUpdates(Exprs.Updates);
1371 Dir->setFinals(Exprs.Finals);
1372 Dir->setDependentCounters(Exprs.DependentCounters);
1373 Dir->setDependentInits(Exprs.DependentInits);
1374 Dir->setFinalsConditions(Exprs.FinalsConditions);
1375 Dir->setPreInits(Exprs.PreInits);
1376 Dir->setHasCancel(HasCancel);
1377 return Dir;
1378}
1379
1380OMPTaskLoopDirective *OMPTaskLoopDirective::CreateEmpty(const ASTContext &C,
1381 unsigned NumClauses,
1382 unsigned CollapsedNum,
1383 EmptyShell) {
1384 return createEmptyDirective<OMPTaskLoopDirective>(
1385 C, NumClauses, /*HasAssociatedStmt=*/true,
1386 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_taskloop), P&: CollapsedNum);
1387}
1388
1389OMPTaskLoopSimdDirective *OMPTaskLoopSimdDirective::Create(
1390 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1391 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1392 const HelperExprs &Exprs) {
1393 auto *Dir = createDirective<OMPTaskLoopSimdDirective>(
1394 C, Clauses, AssociatedStmt,
1395 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_taskloop_simd), P&: StartLoc, P&: EndLoc,
1396 P&: CollapsedNum);
1397 Dir->setIterationVariable(Exprs.IterationVarRef);
1398 Dir->setLastIteration(Exprs.LastIteration);
1399 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1400 Dir->setPreCond(Exprs.PreCond);
1401 Dir->setCond(Exprs.Cond);
1402 Dir->setInit(Exprs.Init);
1403 Dir->setInc(Exprs.Inc);
1404 Dir->setIsLastIterVariable(Exprs.IL);
1405 Dir->setLowerBoundVariable(Exprs.LB);
1406 Dir->setUpperBoundVariable(Exprs.UB);
1407 Dir->setStrideVariable(Exprs.ST);
1408 Dir->setEnsureUpperBound(Exprs.EUB);
1409 Dir->setNextLowerBound(Exprs.NLB);
1410 Dir->setNextUpperBound(Exprs.NUB);
1411 Dir->setNumIterations(Exprs.NumIterations);
1412 Dir->setCounters(Exprs.Counters);
1413 Dir->setPrivateCounters(Exprs.PrivateCounters);
1414 Dir->setInits(Exprs.Inits);
1415 Dir->setUpdates(Exprs.Updates);
1416 Dir->setFinals(Exprs.Finals);
1417 Dir->setDependentCounters(Exprs.DependentCounters);
1418 Dir->setDependentInits(Exprs.DependentInits);
1419 Dir->setFinalsConditions(Exprs.FinalsConditions);
1420 Dir->setPreInits(Exprs.PreInits);
1421 return Dir;
1422}
1423
1424OMPTaskLoopSimdDirective *
1425OMPTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1426 unsigned CollapsedNum, EmptyShell) {
1427 return createEmptyDirective<OMPTaskLoopSimdDirective>(
1428 C, NumClauses, /*HasAssociatedStmt=*/true,
1429 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_taskloop_simd), P&: CollapsedNum);
1430}
1431
1432OMPMasterTaskLoopDirective *OMPMasterTaskLoopDirective::Create(
1433 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1434 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1435 const HelperExprs &Exprs, bool HasCancel) {
1436 auto *Dir = createDirective<OMPMasterTaskLoopDirective>(
1437 C, Clauses, AssociatedStmt,
1438 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_master_taskloop), P&: StartLoc, P&: EndLoc,
1439 P&: CollapsedNum);
1440 Dir->setIterationVariable(Exprs.IterationVarRef);
1441 Dir->setLastIteration(Exprs.LastIteration);
1442 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1443 Dir->setPreCond(Exprs.PreCond);
1444 Dir->setCond(Exprs.Cond);
1445 Dir->setInit(Exprs.Init);
1446 Dir->setInc(Exprs.Inc);
1447 Dir->setIsLastIterVariable(Exprs.IL);
1448 Dir->setLowerBoundVariable(Exprs.LB);
1449 Dir->setUpperBoundVariable(Exprs.UB);
1450 Dir->setStrideVariable(Exprs.ST);
1451 Dir->setEnsureUpperBound(Exprs.EUB);
1452 Dir->setNextLowerBound(Exprs.NLB);
1453 Dir->setNextUpperBound(Exprs.NUB);
1454 Dir->setNumIterations(Exprs.NumIterations);
1455 Dir->setCounters(Exprs.Counters);
1456 Dir->setPrivateCounters(Exprs.PrivateCounters);
1457 Dir->setInits(Exprs.Inits);
1458 Dir->setUpdates(Exprs.Updates);
1459 Dir->setFinals(Exprs.Finals);
1460 Dir->setDependentCounters(Exprs.DependentCounters);
1461 Dir->setDependentInits(Exprs.DependentInits);
1462 Dir->setFinalsConditions(Exprs.FinalsConditions);
1463 Dir->setPreInits(Exprs.PreInits);
1464 Dir->setHasCancel(HasCancel);
1465 return Dir;
1466}
1467
1468OMPMasterTaskLoopDirective *
1469OMPMasterTaskLoopDirective::CreateEmpty(const ASTContext &C,
1470 unsigned NumClauses,
1471 unsigned CollapsedNum, EmptyShell) {
1472 return createEmptyDirective<OMPMasterTaskLoopDirective>(
1473 C, NumClauses, /*HasAssociatedStmt=*/true,
1474 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_master_taskloop), P&: CollapsedNum);
1475}
1476
1477OMPMaskedTaskLoopDirective *OMPMaskedTaskLoopDirective::Create(
1478 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1479 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1480 const HelperExprs &Exprs, bool HasCancel) {
1481 auto *Dir = createDirective<OMPMaskedTaskLoopDirective>(
1482 C, Clauses, AssociatedStmt,
1483 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_masked_taskloop), P&: StartLoc, P&: EndLoc,
1484 P&: CollapsedNum);
1485 Dir->setIterationVariable(Exprs.IterationVarRef);
1486 Dir->setLastIteration(Exprs.LastIteration);
1487 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1488 Dir->setPreCond(Exprs.PreCond);
1489 Dir->setCond(Exprs.Cond);
1490 Dir->setInit(Exprs.Init);
1491 Dir->setInc(Exprs.Inc);
1492 Dir->setIsLastIterVariable(Exprs.IL);
1493 Dir->setLowerBoundVariable(Exprs.LB);
1494 Dir->setUpperBoundVariable(Exprs.UB);
1495 Dir->setStrideVariable(Exprs.ST);
1496 Dir->setEnsureUpperBound(Exprs.EUB);
1497 Dir->setNextLowerBound(Exprs.NLB);
1498 Dir->setNextUpperBound(Exprs.NUB);
1499 Dir->setNumIterations(Exprs.NumIterations);
1500 Dir->setCounters(Exprs.Counters);
1501 Dir->setPrivateCounters(Exprs.PrivateCounters);
1502 Dir->setInits(Exprs.Inits);
1503 Dir->setUpdates(Exprs.Updates);
1504 Dir->setFinals(Exprs.Finals);
1505 Dir->setDependentCounters(Exprs.DependentCounters);
1506 Dir->setDependentInits(Exprs.DependentInits);
1507 Dir->setFinalsConditions(Exprs.FinalsConditions);
1508 Dir->setPreInits(Exprs.PreInits);
1509 Dir->setHasCancel(HasCancel);
1510 return Dir;
1511}
1512
1513OMPMaskedTaskLoopDirective *
1514OMPMaskedTaskLoopDirective::CreateEmpty(const ASTContext &C,
1515 unsigned NumClauses,
1516 unsigned CollapsedNum, EmptyShell) {
1517 return createEmptyDirective<OMPMaskedTaskLoopDirective>(
1518 C, NumClauses, /*HasAssociatedStmt=*/true,
1519 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_masked_taskloop), P&: CollapsedNum);
1520}
1521
1522OMPMasterTaskLoopSimdDirective *OMPMasterTaskLoopSimdDirective::Create(
1523 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1524 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1525 const HelperExprs &Exprs) {
1526 auto *Dir = createDirective<OMPMasterTaskLoopSimdDirective>(
1527 C, Clauses, AssociatedStmt,
1528 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_master_taskloop_simd), P&: StartLoc,
1529 P&: EndLoc, P&: CollapsedNum);
1530 Dir->setIterationVariable(Exprs.IterationVarRef);
1531 Dir->setLastIteration(Exprs.LastIteration);
1532 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1533 Dir->setPreCond(Exprs.PreCond);
1534 Dir->setCond(Exprs.Cond);
1535 Dir->setInit(Exprs.Init);
1536 Dir->setInc(Exprs.Inc);
1537 Dir->setIsLastIterVariable(Exprs.IL);
1538 Dir->setLowerBoundVariable(Exprs.LB);
1539 Dir->setUpperBoundVariable(Exprs.UB);
1540 Dir->setStrideVariable(Exprs.ST);
1541 Dir->setEnsureUpperBound(Exprs.EUB);
1542 Dir->setNextLowerBound(Exprs.NLB);
1543 Dir->setNextUpperBound(Exprs.NUB);
1544 Dir->setNumIterations(Exprs.NumIterations);
1545 Dir->setCounters(Exprs.Counters);
1546 Dir->setPrivateCounters(Exprs.PrivateCounters);
1547 Dir->setInits(Exprs.Inits);
1548 Dir->setUpdates(Exprs.Updates);
1549 Dir->setFinals(Exprs.Finals);
1550 Dir->setDependentCounters(Exprs.DependentCounters);
1551 Dir->setDependentInits(Exprs.DependentInits);
1552 Dir->setFinalsConditions(Exprs.FinalsConditions);
1553 Dir->setPreInits(Exprs.PreInits);
1554 return Dir;
1555}
1556
1557OMPMasterTaskLoopSimdDirective *
1558OMPMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C,
1559 unsigned NumClauses,
1560 unsigned CollapsedNum, EmptyShell) {
1561 return createEmptyDirective<OMPMasterTaskLoopSimdDirective>(
1562 C, NumClauses, /*HasAssociatedStmt=*/true,
1563 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_master_taskloop_simd), P&: CollapsedNum);
1564}
1565
1566OMPMaskedTaskLoopSimdDirective *OMPMaskedTaskLoopSimdDirective::Create(
1567 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1568 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1569 const HelperExprs &Exprs) {
1570 auto *Dir = createDirective<OMPMaskedTaskLoopSimdDirective>(
1571 C, Clauses, AssociatedStmt,
1572 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_masked_taskloop_simd), P&: StartLoc,
1573 P&: EndLoc, P&: CollapsedNum);
1574 Dir->setIterationVariable(Exprs.IterationVarRef);
1575 Dir->setLastIteration(Exprs.LastIteration);
1576 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1577 Dir->setPreCond(Exprs.PreCond);
1578 Dir->setCond(Exprs.Cond);
1579 Dir->setInit(Exprs.Init);
1580 Dir->setInc(Exprs.Inc);
1581 Dir->setIsLastIterVariable(Exprs.IL);
1582 Dir->setLowerBoundVariable(Exprs.LB);
1583 Dir->setUpperBoundVariable(Exprs.UB);
1584 Dir->setStrideVariable(Exprs.ST);
1585 Dir->setEnsureUpperBound(Exprs.EUB);
1586 Dir->setNextLowerBound(Exprs.NLB);
1587 Dir->setNextUpperBound(Exprs.NUB);
1588 Dir->setNumIterations(Exprs.NumIterations);
1589 Dir->setCounters(Exprs.Counters);
1590 Dir->setPrivateCounters(Exprs.PrivateCounters);
1591 Dir->setInits(Exprs.Inits);
1592 Dir->setUpdates(Exprs.Updates);
1593 Dir->setFinals(Exprs.Finals);
1594 Dir->setDependentCounters(Exprs.DependentCounters);
1595 Dir->setDependentInits(Exprs.DependentInits);
1596 Dir->setFinalsConditions(Exprs.FinalsConditions);
1597 Dir->setPreInits(Exprs.PreInits);
1598 return Dir;
1599}
1600
1601OMPMaskedTaskLoopSimdDirective *
1602OMPMaskedTaskLoopSimdDirective::CreateEmpty(const ASTContext &C,
1603 unsigned NumClauses,
1604 unsigned CollapsedNum, EmptyShell) {
1605 return createEmptyDirective<OMPMaskedTaskLoopSimdDirective>(
1606 C, NumClauses, /*HasAssociatedStmt=*/true,
1607 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_masked_taskloop_simd), P&: CollapsedNum);
1608}
1609
1610OMPParallelMasterTaskLoopDirective *OMPParallelMasterTaskLoopDirective::Create(
1611 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1612 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1613 const HelperExprs &Exprs, bool HasCancel) {
1614 auto *Dir = createDirective<OMPParallelMasterTaskLoopDirective>(
1615 C, Clauses, AssociatedStmt,
1616 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_parallel_master_taskloop), P&: StartLoc,
1617 P&: EndLoc, P&: CollapsedNum);
1618 Dir->setIterationVariable(Exprs.IterationVarRef);
1619 Dir->setLastIteration(Exprs.LastIteration);
1620 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1621 Dir->setPreCond(Exprs.PreCond);
1622 Dir->setCond(Exprs.Cond);
1623 Dir->setInit(Exprs.Init);
1624 Dir->setInc(Exprs.Inc);
1625 Dir->setIsLastIterVariable(Exprs.IL);
1626 Dir->setLowerBoundVariable(Exprs.LB);
1627 Dir->setUpperBoundVariable(Exprs.UB);
1628 Dir->setStrideVariable(Exprs.ST);
1629 Dir->setEnsureUpperBound(Exprs.EUB);
1630 Dir->setNextLowerBound(Exprs.NLB);
1631 Dir->setNextUpperBound(Exprs.NUB);
1632 Dir->setNumIterations(Exprs.NumIterations);
1633 Dir->setCounters(Exprs.Counters);
1634 Dir->setPrivateCounters(Exprs.PrivateCounters);
1635 Dir->setInits(Exprs.Inits);
1636 Dir->setUpdates(Exprs.Updates);
1637 Dir->setFinals(Exprs.Finals);
1638 Dir->setDependentCounters(Exprs.DependentCounters);
1639 Dir->setDependentInits(Exprs.DependentInits);
1640 Dir->setFinalsConditions(Exprs.FinalsConditions);
1641 Dir->setPreInits(Exprs.PreInits);
1642 Dir->setHasCancel(HasCancel);
1643 return Dir;
1644}
1645
1646OMPParallelMasterTaskLoopDirective *
1647OMPParallelMasterTaskLoopDirective::CreateEmpty(const ASTContext &C,
1648 unsigned NumClauses,
1649 unsigned CollapsedNum,
1650 EmptyShell) {
1651 return createEmptyDirective<OMPParallelMasterTaskLoopDirective>(
1652 C, NumClauses, /*HasAssociatedStmt=*/true,
1653 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_parallel_master_taskloop),
1654 P&: CollapsedNum);
1655}
1656
1657OMPParallelMaskedTaskLoopDirective *OMPParallelMaskedTaskLoopDirective::Create(
1658 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1659 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1660 const HelperExprs &Exprs, bool HasCancel) {
1661 auto *Dir = createDirective<OMPParallelMaskedTaskLoopDirective>(
1662 C, Clauses, AssociatedStmt,
1663 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_parallel_masked_taskloop), P&: StartLoc,
1664 P&: EndLoc, P&: CollapsedNum);
1665 Dir->setIterationVariable(Exprs.IterationVarRef);
1666 Dir->setLastIteration(Exprs.LastIteration);
1667 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1668 Dir->setPreCond(Exprs.PreCond);
1669 Dir->setCond(Exprs.Cond);
1670 Dir->setInit(Exprs.Init);
1671 Dir->setInc(Exprs.Inc);
1672 Dir->setIsLastIterVariable(Exprs.IL);
1673 Dir->setLowerBoundVariable(Exprs.LB);
1674 Dir->setUpperBoundVariable(Exprs.UB);
1675 Dir->setStrideVariable(Exprs.ST);
1676 Dir->setEnsureUpperBound(Exprs.EUB);
1677 Dir->setNextLowerBound(Exprs.NLB);
1678 Dir->setNextUpperBound(Exprs.NUB);
1679 Dir->setNumIterations(Exprs.NumIterations);
1680 Dir->setCounters(Exprs.Counters);
1681 Dir->setPrivateCounters(Exprs.PrivateCounters);
1682 Dir->setInits(Exprs.Inits);
1683 Dir->setUpdates(Exprs.Updates);
1684 Dir->setFinals(Exprs.Finals);
1685 Dir->setDependentCounters(Exprs.DependentCounters);
1686 Dir->setDependentInits(Exprs.DependentInits);
1687 Dir->setFinalsConditions(Exprs.FinalsConditions);
1688 Dir->setPreInits(Exprs.PreInits);
1689 Dir->setHasCancel(HasCancel);
1690 return Dir;
1691}
1692
1693OMPParallelMaskedTaskLoopDirective *
1694OMPParallelMaskedTaskLoopDirective::CreateEmpty(const ASTContext &C,
1695 unsigned NumClauses,
1696 unsigned CollapsedNum,
1697 EmptyShell) {
1698 return createEmptyDirective<OMPParallelMaskedTaskLoopDirective>(
1699 C, NumClauses, /*HasAssociatedStmt=*/true,
1700 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_parallel_masked_taskloop),
1701 P&: CollapsedNum);
1702}
1703
1704OMPParallelMasterTaskLoopSimdDirective *
1705OMPParallelMasterTaskLoopSimdDirective::Create(
1706 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1707 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1708 const HelperExprs &Exprs) {
1709 auto *Dir = createDirective<OMPParallelMasterTaskLoopSimdDirective>(
1710 C, Clauses, AssociatedStmt,
1711 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_parallel_master_taskloop_simd),
1712 P&: StartLoc, P&: EndLoc, P&: CollapsedNum);
1713 Dir->setIterationVariable(Exprs.IterationVarRef);
1714 Dir->setLastIteration(Exprs.LastIteration);
1715 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1716 Dir->setPreCond(Exprs.PreCond);
1717 Dir->setCond(Exprs.Cond);
1718 Dir->setInit(Exprs.Init);
1719 Dir->setInc(Exprs.Inc);
1720 Dir->setIsLastIterVariable(Exprs.IL);
1721 Dir->setLowerBoundVariable(Exprs.LB);
1722 Dir->setUpperBoundVariable(Exprs.UB);
1723 Dir->setStrideVariable(Exprs.ST);
1724 Dir->setEnsureUpperBound(Exprs.EUB);
1725 Dir->setNextLowerBound(Exprs.NLB);
1726 Dir->setNextUpperBound(Exprs.NUB);
1727 Dir->setNumIterations(Exprs.NumIterations);
1728 Dir->setCounters(Exprs.Counters);
1729 Dir->setPrivateCounters(Exprs.PrivateCounters);
1730 Dir->setInits(Exprs.Inits);
1731 Dir->setUpdates(Exprs.Updates);
1732 Dir->setFinals(Exprs.Finals);
1733 Dir->setDependentCounters(Exprs.DependentCounters);
1734 Dir->setDependentInits(Exprs.DependentInits);
1735 Dir->setFinalsConditions(Exprs.FinalsConditions);
1736 Dir->setPreInits(Exprs.PreInits);
1737 return Dir;
1738}
1739
1740OMPParallelMasterTaskLoopSimdDirective *
1741OMPParallelMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C,
1742 unsigned NumClauses,
1743 unsigned CollapsedNum,
1744 EmptyShell) {
1745 return createEmptyDirective<OMPParallelMasterTaskLoopSimdDirective>(
1746 C, NumClauses, /*HasAssociatedStmt=*/true,
1747 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_parallel_master_taskloop_simd),
1748 P&: CollapsedNum);
1749}
1750
1751OMPParallelMaskedTaskLoopSimdDirective *
1752OMPParallelMaskedTaskLoopSimdDirective::Create(
1753 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1754 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1755 const HelperExprs &Exprs) {
1756 auto *Dir = createDirective<OMPParallelMaskedTaskLoopSimdDirective>(
1757 C, Clauses, AssociatedStmt,
1758 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_parallel_masked_taskloop_simd),
1759 P&: StartLoc, P&: EndLoc, P&: CollapsedNum);
1760 Dir->setIterationVariable(Exprs.IterationVarRef);
1761 Dir->setLastIteration(Exprs.LastIteration);
1762 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1763 Dir->setPreCond(Exprs.PreCond);
1764 Dir->setCond(Exprs.Cond);
1765 Dir->setInit(Exprs.Init);
1766 Dir->setInc(Exprs.Inc);
1767 Dir->setIsLastIterVariable(Exprs.IL);
1768 Dir->setLowerBoundVariable(Exprs.LB);
1769 Dir->setUpperBoundVariable(Exprs.UB);
1770 Dir->setStrideVariable(Exprs.ST);
1771 Dir->setEnsureUpperBound(Exprs.EUB);
1772 Dir->setNextLowerBound(Exprs.NLB);
1773 Dir->setNextUpperBound(Exprs.NUB);
1774 Dir->setNumIterations(Exprs.NumIterations);
1775 Dir->setCounters(Exprs.Counters);
1776 Dir->setPrivateCounters(Exprs.PrivateCounters);
1777 Dir->setInits(Exprs.Inits);
1778 Dir->setUpdates(Exprs.Updates);
1779 Dir->setFinals(Exprs.Finals);
1780 Dir->setDependentCounters(Exprs.DependentCounters);
1781 Dir->setDependentInits(Exprs.DependentInits);
1782 Dir->setFinalsConditions(Exprs.FinalsConditions);
1783 Dir->setPreInits(Exprs.PreInits);
1784 return Dir;
1785}
1786
1787OMPParallelMaskedTaskLoopSimdDirective *
1788OMPParallelMaskedTaskLoopSimdDirective::CreateEmpty(const ASTContext &C,
1789 unsigned NumClauses,
1790 unsigned CollapsedNum,
1791 EmptyShell) {
1792 return createEmptyDirective<OMPParallelMaskedTaskLoopSimdDirective>(
1793 C, NumClauses, /*HasAssociatedStmt=*/true,
1794 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_parallel_masked_taskloop_simd),
1795 P&: CollapsedNum);
1796}
1797
1798OMPDistributeDirective *
1799OMPDistributeDirective::Create(const ASTContext &C, SourceLocation StartLoc,
1800 SourceLocation EndLoc, unsigned CollapsedNum,
1801 ArrayRef<OMPClause *> Clauses,
1802 Stmt *AssociatedStmt, const HelperExprs &Exprs) {
1803 auto *Dir = createDirective<OMPDistributeDirective>(
1804 C, Clauses, AssociatedStmt,
1805 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_distribute), P&: StartLoc, P&: EndLoc,
1806 P&: CollapsedNum);
1807 Dir->setIterationVariable(Exprs.IterationVarRef);
1808 Dir->setLastIteration(Exprs.LastIteration);
1809 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1810 Dir->setPreCond(Exprs.PreCond);
1811 Dir->setCond(Exprs.Cond);
1812 Dir->setInit(Exprs.Init);
1813 Dir->setInc(Exprs.Inc);
1814 Dir->setIsLastIterVariable(Exprs.IL);
1815 Dir->setLowerBoundVariable(Exprs.LB);
1816 Dir->setUpperBoundVariable(Exprs.UB);
1817 Dir->setStrideVariable(Exprs.ST);
1818 Dir->setEnsureUpperBound(Exprs.EUB);
1819 Dir->setNextLowerBound(Exprs.NLB);
1820 Dir->setNextUpperBound(Exprs.NUB);
1821 Dir->setNumIterations(Exprs.NumIterations);
1822 Dir->setCounters(Exprs.Counters);
1823 Dir->setPrivateCounters(Exprs.PrivateCounters);
1824 Dir->setInits(Exprs.Inits);
1825 Dir->setUpdates(Exprs.Updates);
1826 Dir->setFinals(Exprs.Finals);
1827 Dir->setDependentCounters(Exprs.DependentCounters);
1828 Dir->setDependentInits(Exprs.DependentInits);
1829 Dir->setFinalsConditions(Exprs.FinalsConditions);
1830 Dir->setPreInits(Exprs.PreInits);
1831 return Dir;
1832}
1833
1834OMPDistributeDirective *
1835OMPDistributeDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1836 unsigned CollapsedNum, EmptyShell) {
1837 return createEmptyDirective<OMPDistributeDirective>(
1838 C, NumClauses, /*HasAssociatedStmt=*/true,
1839 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_distribute), P&: CollapsedNum);
1840}
1841
1842OMPTargetUpdateDirective *OMPTargetUpdateDirective::Create(
1843 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1844 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1845 return createDirective<OMPTargetUpdateDirective>(C, Clauses, AssociatedStmt,
1846 /*NumChildren=*/0, P&: StartLoc,
1847 P&: EndLoc);
1848}
1849
1850OMPTargetUpdateDirective *
1851OMPTargetUpdateDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1852 EmptyShell) {
1853 return createEmptyDirective<OMPTargetUpdateDirective>(
1854 C, NumClauses, /*HasAssociatedStmt=*/true);
1855}
1856
1857OMPDistributeParallelForDirective *OMPDistributeParallelForDirective::Create(
1858 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1859 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1860 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
1861 auto *Dir = createDirective<OMPDistributeParallelForDirective>(
1862 C, Clauses, AssociatedStmt,
1863 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_distribute_parallel_for) + 1, P&: StartLoc,
1864 P&: EndLoc, P&: CollapsedNum);
1865 Dir->setIterationVariable(Exprs.IterationVarRef);
1866 Dir->setLastIteration(Exprs.LastIteration);
1867 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1868 Dir->setPreCond(Exprs.PreCond);
1869 Dir->setCond(Exprs.Cond);
1870 Dir->setInit(Exprs.Init);
1871 Dir->setInc(Exprs.Inc);
1872 Dir->setIsLastIterVariable(Exprs.IL);
1873 Dir->setLowerBoundVariable(Exprs.LB);
1874 Dir->setUpperBoundVariable(Exprs.UB);
1875 Dir->setStrideVariable(Exprs.ST);
1876 Dir->setEnsureUpperBound(Exprs.EUB);
1877 Dir->setNextLowerBound(Exprs.NLB);
1878 Dir->setNextUpperBound(Exprs.NUB);
1879 Dir->setNumIterations(Exprs.NumIterations);
1880 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1881 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1882 Dir->setDistInc(Exprs.DistInc);
1883 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1884 Dir->setCounters(Exprs.Counters);
1885 Dir->setPrivateCounters(Exprs.PrivateCounters);
1886 Dir->setInits(Exprs.Inits);
1887 Dir->setUpdates(Exprs.Updates);
1888 Dir->setFinals(Exprs.Finals);
1889 Dir->setDependentCounters(Exprs.DependentCounters);
1890 Dir->setDependentInits(Exprs.DependentInits);
1891 Dir->setFinalsConditions(Exprs.FinalsConditions);
1892 Dir->setPreInits(Exprs.PreInits);
1893 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1894 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1895 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1896 Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1897 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1898 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1899 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1900 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1901 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1902 Dir->setTaskReductionRefExpr(TaskRedRef);
1903 Dir->HasCancel = HasCancel;
1904 return Dir;
1905}
1906
1907OMPDistributeParallelForDirective *
1908OMPDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
1909 unsigned NumClauses,
1910 unsigned CollapsedNum,
1911 EmptyShell) {
1912 return createEmptyDirective<OMPDistributeParallelForDirective>(
1913 C, NumClauses, /*HasAssociatedStmt=*/true,
1914 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_distribute_parallel_for) + 1,
1915 P&: CollapsedNum);
1916}
1917
1918OMPDistributeParallelForSimdDirective *
1919OMPDistributeParallelForSimdDirective::Create(
1920 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1921 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1922 const HelperExprs &Exprs) {
1923 auto *Dir = createDirective<OMPDistributeParallelForSimdDirective>(
1924 C, Clauses, AssociatedStmt,
1925 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_distribute_parallel_for_simd),
1926 P&: StartLoc, P&: EndLoc, P&: CollapsedNum);
1927 Dir->setIterationVariable(Exprs.IterationVarRef);
1928 Dir->setLastIteration(Exprs.LastIteration);
1929 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1930 Dir->setPreCond(Exprs.PreCond);
1931 Dir->setCond(Exprs.Cond);
1932 Dir->setInit(Exprs.Init);
1933 Dir->setInc(Exprs.Inc);
1934 Dir->setIsLastIterVariable(Exprs.IL);
1935 Dir->setLowerBoundVariable(Exprs.LB);
1936 Dir->setUpperBoundVariable(Exprs.UB);
1937 Dir->setStrideVariable(Exprs.ST);
1938 Dir->setEnsureUpperBound(Exprs.EUB);
1939 Dir->setNextLowerBound(Exprs.NLB);
1940 Dir->setNextUpperBound(Exprs.NUB);
1941 Dir->setNumIterations(Exprs.NumIterations);
1942 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1943 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1944 Dir->setDistInc(Exprs.DistInc);
1945 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1946 Dir->setCounters(Exprs.Counters);
1947 Dir->setPrivateCounters(Exprs.PrivateCounters);
1948 Dir->setInits(Exprs.Inits);
1949 Dir->setUpdates(Exprs.Updates);
1950 Dir->setFinals(Exprs.Finals);
1951 Dir->setDependentCounters(Exprs.DependentCounters);
1952 Dir->setDependentInits(Exprs.DependentInits);
1953 Dir->setFinalsConditions(Exprs.FinalsConditions);
1954 Dir->setPreInits(Exprs.PreInits);
1955 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1956 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1957 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1958 Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1959 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1960 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1961 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1962 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1963 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1964 return Dir;
1965}
1966
1967OMPDistributeParallelForSimdDirective *
1968OMPDistributeParallelForSimdDirective::CreateEmpty(const ASTContext &C,
1969 unsigned NumClauses,
1970 unsigned CollapsedNum,
1971 EmptyShell) {
1972 return createEmptyDirective<OMPDistributeParallelForSimdDirective>(
1973 C, NumClauses, /*HasAssociatedStmt=*/true,
1974 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_distribute_parallel_for_simd),
1975 P&: CollapsedNum);
1976}
1977
1978OMPDistributeSimdDirective *OMPDistributeSimdDirective::Create(
1979 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1980 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1981 const HelperExprs &Exprs) {
1982 auto *Dir = createDirective<OMPDistributeSimdDirective>(
1983 C, Clauses, AssociatedStmt,
1984 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_distribute_simd), P&: StartLoc, P&: EndLoc,
1985 P&: CollapsedNum);
1986 Dir->setIterationVariable(Exprs.IterationVarRef);
1987 Dir->setLastIteration(Exprs.LastIteration);
1988 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1989 Dir->setPreCond(Exprs.PreCond);
1990 Dir->setCond(Exprs.Cond);
1991 Dir->setInit(Exprs.Init);
1992 Dir->setInc(Exprs.Inc);
1993 Dir->setIsLastIterVariable(Exprs.IL);
1994 Dir->setLowerBoundVariable(Exprs.LB);
1995 Dir->setUpperBoundVariable(Exprs.UB);
1996 Dir->setStrideVariable(Exprs.ST);
1997 Dir->setEnsureUpperBound(Exprs.EUB);
1998 Dir->setNextLowerBound(Exprs.NLB);
1999 Dir->setNextUpperBound(Exprs.NUB);
2000 Dir->setNumIterations(Exprs.NumIterations);
2001 Dir->setCounters(Exprs.Counters);
2002 Dir->setPrivateCounters(Exprs.PrivateCounters);
2003 Dir->setInits(Exprs.Inits);
2004 Dir->setUpdates(Exprs.Updates);
2005 Dir->setFinals(Exprs.Finals);
2006 Dir->setDependentCounters(Exprs.DependentCounters);
2007 Dir->setDependentInits(Exprs.DependentInits);
2008 Dir->setFinalsConditions(Exprs.FinalsConditions);
2009 Dir->setPreInits(Exprs.PreInits);
2010 return Dir;
2011}
2012
2013OMPDistributeSimdDirective *
2014OMPDistributeSimdDirective::CreateEmpty(const ASTContext &C,
2015 unsigned NumClauses,
2016 unsigned CollapsedNum, EmptyShell) {
2017 return createEmptyDirective<OMPDistributeSimdDirective>(
2018 C, NumClauses, /*HasAssociatedStmt=*/true,
2019 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_distribute_simd), P&: CollapsedNum);
2020}
2021
2022OMPTargetParallelForSimdDirective *OMPTargetParallelForSimdDirective::Create(
2023 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2024 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2025 const HelperExprs &Exprs) {
2026 auto *Dir = createDirective<OMPTargetParallelForSimdDirective>(
2027 C, Clauses, AssociatedStmt,
2028 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_target_parallel_for_simd), P&: StartLoc,
2029 P&: EndLoc, P&: CollapsedNum);
2030 Dir->setIterationVariable(Exprs.IterationVarRef);
2031 Dir->setLastIteration(Exprs.LastIteration);
2032 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2033 Dir->setPreCond(Exprs.PreCond);
2034 Dir->setCond(Exprs.Cond);
2035 Dir->setInit(Exprs.Init);
2036 Dir->setInc(Exprs.Inc);
2037 Dir->setIsLastIterVariable(Exprs.IL);
2038 Dir->setLowerBoundVariable(Exprs.LB);
2039 Dir->setUpperBoundVariable(Exprs.UB);
2040 Dir->setStrideVariable(Exprs.ST);
2041 Dir->setEnsureUpperBound(Exprs.EUB);
2042 Dir->setNextLowerBound(Exprs.NLB);
2043 Dir->setNextUpperBound(Exprs.NUB);
2044 Dir->setNumIterations(Exprs.NumIterations);
2045 Dir->setCounters(Exprs.Counters);
2046 Dir->setPrivateCounters(Exprs.PrivateCounters);
2047 Dir->setInits(Exprs.Inits);
2048 Dir->setUpdates(Exprs.Updates);
2049 Dir->setFinals(Exprs.Finals);
2050 Dir->setDependentCounters(Exprs.DependentCounters);
2051 Dir->setDependentInits(Exprs.DependentInits);
2052 Dir->setFinalsConditions(Exprs.FinalsConditions);
2053 Dir->setPreInits(Exprs.PreInits);
2054 return Dir;
2055}
2056
2057OMPTargetParallelForSimdDirective *
2058OMPTargetParallelForSimdDirective::CreateEmpty(const ASTContext &C,
2059 unsigned NumClauses,
2060 unsigned CollapsedNum,
2061 EmptyShell) {
2062 return createEmptyDirective<OMPTargetParallelForSimdDirective>(
2063 C, NumClauses, /*HasAssociatedStmt=*/true,
2064 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_target_parallel_for_simd),
2065 P&: CollapsedNum);
2066}
2067
2068OMPTargetSimdDirective *
2069OMPTargetSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
2070 SourceLocation EndLoc, unsigned CollapsedNum,
2071 ArrayRef<OMPClause *> Clauses,
2072 Stmt *AssociatedStmt, const HelperExprs &Exprs) {
2073 auto *Dir = createDirective<OMPTargetSimdDirective>(
2074 C, Clauses, AssociatedStmt,
2075 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_target_simd), P&: StartLoc, P&: EndLoc,
2076 P&: CollapsedNum);
2077 Dir->setIterationVariable(Exprs.IterationVarRef);
2078 Dir->setLastIteration(Exprs.LastIteration);
2079 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2080 Dir->setPreCond(Exprs.PreCond);
2081 Dir->setCond(Exprs.Cond);
2082 Dir->setInit(Exprs.Init);
2083 Dir->setInc(Exprs.Inc);
2084 Dir->setCounters(Exprs.Counters);
2085 Dir->setPrivateCounters(Exprs.PrivateCounters);
2086 Dir->setInits(Exprs.Inits);
2087 Dir->setUpdates(Exprs.Updates);
2088 Dir->setFinals(Exprs.Finals);
2089 Dir->setDependentCounters(Exprs.DependentCounters);
2090 Dir->setDependentInits(Exprs.DependentInits);
2091 Dir->setFinalsConditions(Exprs.FinalsConditions);
2092 Dir->setPreInits(Exprs.PreInits);
2093 return Dir;
2094}
2095
2096OMPTargetSimdDirective *
2097OMPTargetSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
2098 unsigned CollapsedNum, EmptyShell) {
2099 return createEmptyDirective<OMPTargetSimdDirective>(
2100 C, NumClauses, /*HasAssociatedStmt=*/true,
2101 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_target_simd), P&: CollapsedNum);
2102}
2103
2104OMPTeamsDistributeDirective *OMPTeamsDistributeDirective::Create(
2105 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2106 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2107 const HelperExprs &Exprs) {
2108 auto *Dir = createDirective<OMPTeamsDistributeDirective>(
2109 C, Clauses, AssociatedStmt,
2110 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_teams_distribute), P&: StartLoc, P&: EndLoc,
2111 P&: CollapsedNum);
2112 Dir->setIterationVariable(Exprs.IterationVarRef);
2113 Dir->setLastIteration(Exprs.LastIteration);
2114 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2115 Dir->setPreCond(Exprs.PreCond);
2116 Dir->setCond(Exprs.Cond);
2117 Dir->setInit(Exprs.Init);
2118 Dir->setInc(Exprs.Inc);
2119 Dir->setIsLastIterVariable(Exprs.IL);
2120 Dir->setLowerBoundVariable(Exprs.LB);
2121 Dir->setUpperBoundVariable(Exprs.UB);
2122 Dir->setStrideVariable(Exprs.ST);
2123 Dir->setEnsureUpperBound(Exprs.EUB);
2124 Dir->setNextLowerBound(Exprs.NLB);
2125 Dir->setNextUpperBound(Exprs.NUB);
2126 Dir->setNumIterations(Exprs.NumIterations);
2127 Dir->setCounters(Exprs.Counters);
2128 Dir->setPrivateCounters(Exprs.PrivateCounters);
2129 Dir->setInits(Exprs.Inits);
2130 Dir->setUpdates(Exprs.Updates);
2131 Dir->setFinals(Exprs.Finals);
2132 Dir->setDependentCounters(Exprs.DependentCounters);
2133 Dir->setDependentInits(Exprs.DependentInits);
2134 Dir->setFinalsConditions(Exprs.FinalsConditions);
2135 Dir->setPreInits(Exprs.PreInits);
2136 return Dir;
2137}
2138
2139OMPTeamsDistributeDirective *
2140OMPTeamsDistributeDirective::CreateEmpty(const ASTContext &C,
2141 unsigned NumClauses,
2142 unsigned CollapsedNum, EmptyShell) {
2143 return createEmptyDirective<OMPTeamsDistributeDirective>(
2144 C, NumClauses, /*HasAssociatedStmt=*/true,
2145 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_teams_distribute), P&: CollapsedNum);
2146}
2147
2148OMPTeamsDistributeSimdDirective *OMPTeamsDistributeSimdDirective::Create(
2149 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2150 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2151 const HelperExprs &Exprs) {
2152 auto *Dir = createDirective<OMPTeamsDistributeSimdDirective>(
2153 C, Clauses, AssociatedStmt,
2154 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_teams_distribute_simd), P&: StartLoc,
2155 P&: EndLoc, P&: CollapsedNum);
2156 Dir->setIterationVariable(Exprs.IterationVarRef);
2157 Dir->setLastIteration(Exprs.LastIteration);
2158 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2159 Dir->setPreCond(Exprs.PreCond);
2160 Dir->setCond(Exprs.Cond);
2161 Dir->setInit(Exprs.Init);
2162 Dir->setInc(Exprs.Inc);
2163 Dir->setIsLastIterVariable(Exprs.IL);
2164 Dir->setLowerBoundVariable(Exprs.LB);
2165 Dir->setUpperBoundVariable(Exprs.UB);
2166 Dir->setStrideVariable(Exprs.ST);
2167 Dir->setEnsureUpperBound(Exprs.EUB);
2168 Dir->setNextLowerBound(Exprs.NLB);
2169 Dir->setNextUpperBound(Exprs.NUB);
2170 Dir->setNumIterations(Exprs.NumIterations);
2171 Dir->setCounters(Exprs.Counters);
2172 Dir->setPrivateCounters(Exprs.PrivateCounters);
2173 Dir->setInits(Exprs.Inits);
2174 Dir->setUpdates(Exprs.Updates);
2175 Dir->setFinals(Exprs.Finals);
2176 Dir->setDependentCounters(Exprs.DependentCounters);
2177 Dir->setDependentInits(Exprs.DependentInits);
2178 Dir->setFinalsConditions(Exprs.FinalsConditions);
2179 Dir->setPreInits(Exprs.PreInits);
2180 return Dir;
2181}
2182
2183OMPTeamsDistributeSimdDirective *OMPTeamsDistributeSimdDirective::CreateEmpty(
2184 const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
2185 EmptyShell) {
2186 return createEmptyDirective<OMPTeamsDistributeSimdDirective>(
2187 C, NumClauses, /*HasAssociatedStmt=*/true,
2188 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_teams_distribute_simd), P&: CollapsedNum);
2189}
2190
2191OMPTeamsDistributeParallelForSimdDirective *
2192OMPTeamsDistributeParallelForSimdDirective::Create(
2193 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2194 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2195 const HelperExprs &Exprs) {
2196 auto *Dir = createDirective<OMPTeamsDistributeParallelForSimdDirective>(
2197 C, Clauses, AssociatedStmt,
2198 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_teams_distribute_parallel_for_simd),
2199 P&: StartLoc, P&: EndLoc, P&: CollapsedNum);
2200 Dir->setIterationVariable(Exprs.IterationVarRef);
2201 Dir->setLastIteration(Exprs.LastIteration);
2202 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2203 Dir->setPreCond(Exprs.PreCond);
2204 Dir->setCond(Exprs.Cond);
2205 Dir->setInit(Exprs.Init);
2206 Dir->setInc(Exprs.Inc);
2207 Dir->setIsLastIterVariable(Exprs.IL);
2208 Dir->setLowerBoundVariable(Exprs.LB);
2209 Dir->setUpperBoundVariable(Exprs.UB);
2210 Dir->setStrideVariable(Exprs.ST);
2211 Dir->setEnsureUpperBound(Exprs.EUB);
2212 Dir->setNextLowerBound(Exprs.NLB);
2213 Dir->setNextUpperBound(Exprs.NUB);
2214 Dir->setNumIterations(Exprs.NumIterations);
2215 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
2216 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
2217 Dir->setDistInc(Exprs.DistInc);
2218 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
2219 Dir->setCounters(Exprs.Counters);
2220 Dir->setPrivateCounters(Exprs.PrivateCounters);
2221 Dir->setInits(Exprs.Inits);
2222 Dir->setUpdates(Exprs.Updates);
2223 Dir->setFinals(Exprs.Finals);
2224 Dir->setDependentCounters(Exprs.DependentCounters);
2225 Dir->setDependentInits(Exprs.DependentInits);
2226 Dir->setFinalsConditions(Exprs.FinalsConditions);
2227 Dir->setPreInits(Exprs.PreInits);
2228 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
2229 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
2230 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
2231 Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
2232 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
2233 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
2234 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
2235 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
2236 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
2237 return Dir;
2238}
2239
2240OMPTeamsDistributeParallelForSimdDirective *
2241OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(const ASTContext &C,
2242 unsigned NumClauses,
2243 unsigned CollapsedNum,
2244 EmptyShell) {
2245 return createEmptyDirective<OMPTeamsDistributeParallelForSimdDirective>(
2246 C, NumClauses, /*HasAssociatedStmt=*/true,
2247 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_teams_distribute_parallel_for_simd),
2248 P&: CollapsedNum);
2249}
2250
2251OMPTeamsDistributeParallelForDirective *
2252OMPTeamsDistributeParallelForDirective::Create(
2253 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2254 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2255 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
2256 auto *Dir = createDirective<OMPTeamsDistributeParallelForDirective>(
2257 C, Clauses, AssociatedStmt,
2258 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_teams_distribute_parallel_for) + 1,
2259 P&: StartLoc, P&: EndLoc, P&: CollapsedNum);
2260 Dir->setIterationVariable(Exprs.IterationVarRef);
2261 Dir->setLastIteration(Exprs.LastIteration);
2262 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2263 Dir->setPreCond(Exprs.PreCond);
2264 Dir->setCond(Exprs.Cond);
2265 Dir->setInit(Exprs.Init);
2266 Dir->setInc(Exprs.Inc);
2267 Dir->setIsLastIterVariable(Exprs.IL);
2268 Dir->setLowerBoundVariable(Exprs.LB);
2269 Dir->setUpperBoundVariable(Exprs.UB);
2270 Dir->setStrideVariable(Exprs.ST);
2271 Dir->setEnsureUpperBound(Exprs.EUB);
2272 Dir->setNextLowerBound(Exprs.NLB);
2273 Dir->setNextUpperBound(Exprs.NUB);
2274 Dir->setNumIterations(Exprs.NumIterations);
2275 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
2276 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
2277 Dir->setDistInc(Exprs.DistInc);
2278 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
2279 Dir->setCounters(Exprs.Counters);
2280 Dir->setPrivateCounters(Exprs.PrivateCounters);
2281 Dir->setInits(Exprs.Inits);
2282 Dir->setUpdates(Exprs.Updates);
2283 Dir->setFinals(Exprs.Finals);
2284 Dir->setDependentCounters(Exprs.DependentCounters);
2285 Dir->setDependentInits(Exprs.DependentInits);
2286 Dir->setFinalsConditions(Exprs.FinalsConditions);
2287 Dir->setPreInits(Exprs.PreInits);
2288 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
2289 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
2290 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
2291 Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
2292 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
2293 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
2294 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
2295 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
2296 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
2297 Dir->setTaskReductionRefExpr(TaskRedRef);
2298 Dir->HasCancel = HasCancel;
2299 return Dir;
2300}
2301
2302OMPTeamsDistributeParallelForDirective *
2303OMPTeamsDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
2304 unsigned NumClauses,
2305 unsigned CollapsedNum,
2306 EmptyShell) {
2307 return createEmptyDirective<OMPTeamsDistributeParallelForDirective>(
2308 C, NumClauses, /*HasAssociatedStmt=*/true,
2309 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_teams_distribute_parallel_for) + 1,
2310 P&: CollapsedNum);
2311}
2312
2313OMPTargetTeamsDirective *OMPTargetTeamsDirective::Create(
2314 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2315 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
2316 return createDirective<OMPTargetTeamsDirective>(C, Clauses, AssociatedStmt,
2317 /*NumChildren=*/0, P&: StartLoc,
2318 P&: EndLoc);
2319}
2320
2321OMPTargetTeamsDirective *
2322OMPTargetTeamsDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
2323 EmptyShell) {
2324 return createEmptyDirective<OMPTargetTeamsDirective>(
2325 C, NumClauses, /*HasAssociatedStmt=*/true);
2326}
2327
2328OMPTargetTeamsDistributeDirective *OMPTargetTeamsDistributeDirective::Create(
2329 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2330 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2331 const HelperExprs &Exprs) {
2332 auto *Dir = createDirective<OMPTargetTeamsDistributeDirective>(
2333 C, Clauses, AssociatedStmt,
2334 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_target_teams_distribute), P&: StartLoc,
2335 P&: EndLoc, P&: CollapsedNum);
2336 Dir->setIterationVariable(Exprs.IterationVarRef);
2337 Dir->setLastIteration(Exprs.LastIteration);
2338 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2339 Dir->setPreCond(Exprs.PreCond);
2340 Dir->setCond(Exprs.Cond);
2341 Dir->setInit(Exprs.Init);
2342 Dir->setInc(Exprs.Inc);
2343 Dir->setIsLastIterVariable(Exprs.IL);
2344 Dir->setLowerBoundVariable(Exprs.LB);
2345 Dir->setUpperBoundVariable(Exprs.UB);
2346 Dir->setStrideVariable(Exprs.ST);
2347 Dir->setEnsureUpperBound(Exprs.EUB);
2348 Dir->setNextLowerBound(Exprs.NLB);
2349 Dir->setNextUpperBound(Exprs.NUB);
2350 Dir->setNumIterations(Exprs.NumIterations);
2351 Dir->setCounters(Exprs.Counters);
2352 Dir->setPrivateCounters(Exprs.PrivateCounters);
2353 Dir->setInits(Exprs.Inits);
2354 Dir->setUpdates(Exprs.Updates);
2355 Dir->setFinals(Exprs.Finals);
2356 Dir->setDependentCounters(Exprs.DependentCounters);
2357 Dir->setDependentInits(Exprs.DependentInits);
2358 Dir->setFinalsConditions(Exprs.FinalsConditions);
2359 Dir->setPreInits(Exprs.PreInits);
2360 return Dir;
2361}
2362
2363OMPTargetTeamsDistributeDirective *
2364OMPTargetTeamsDistributeDirective::CreateEmpty(const ASTContext &C,
2365 unsigned NumClauses,
2366 unsigned CollapsedNum,
2367 EmptyShell) {
2368 return createEmptyDirective<OMPTargetTeamsDistributeDirective>(
2369 C, NumClauses, /*HasAssociatedStmt=*/true,
2370 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_target_teams_distribute),
2371 P&: CollapsedNum);
2372}
2373
2374OMPTargetTeamsDistributeParallelForDirective *
2375OMPTargetTeamsDistributeParallelForDirective::Create(
2376 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2377 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2378 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
2379 auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForDirective>(
2380 C, Clauses, AssociatedStmt,
2381 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_target_teams_distribute_parallel_for) +
2382 1,
2383 P&: StartLoc, P&: EndLoc, P&: CollapsedNum);
2384 Dir->setIterationVariable(Exprs.IterationVarRef);
2385 Dir->setLastIteration(Exprs.LastIteration);
2386 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2387 Dir->setPreCond(Exprs.PreCond);
2388 Dir->setCond(Exprs.Cond);
2389 Dir->setInit(Exprs.Init);
2390 Dir->setInc(Exprs.Inc);
2391 Dir->setIsLastIterVariable(Exprs.IL);
2392 Dir->setLowerBoundVariable(Exprs.LB);
2393 Dir->setUpperBoundVariable(Exprs.UB);
2394 Dir->setStrideVariable(Exprs.ST);
2395 Dir->setEnsureUpperBound(Exprs.EUB);
2396 Dir->setNextLowerBound(Exprs.NLB);
2397 Dir->setNextUpperBound(Exprs.NUB);
2398 Dir->setNumIterations(Exprs.NumIterations);
2399 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
2400 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
2401 Dir->setDistInc(Exprs.DistInc);
2402 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
2403 Dir->setCounters(Exprs.Counters);
2404 Dir->setPrivateCounters(Exprs.PrivateCounters);
2405 Dir->setInits(Exprs.Inits);
2406 Dir->setUpdates(Exprs.Updates);
2407 Dir->setFinals(Exprs.Finals);
2408 Dir->setDependentCounters(Exprs.DependentCounters);
2409 Dir->setDependentInits(Exprs.DependentInits);
2410 Dir->setFinalsConditions(Exprs.FinalsConditions);
2411 Dir->setPreInits(Exprs.PreInits);
2412 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
2413 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
2414 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
2415 Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
2416 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
2417 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
2418 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
2419 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
2420 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
2421 Dir->setTaskReductionRefExpr(TaskRedRef);
2422 Dir->HasCancel = HasCancel;
2423 return Dir;
2424}
2425
2426OMPTargetTeamsDistributeParallelForDirective *
2427OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
2428 unsigned NumClauses,
2429 unsigned CollapsedNum,
2430 EmptyShell) {
2431 return createEmptyDirective<OMPTargetTeamsDistributeParallelForDirective>(
2432 C, NumClauses, /*HasAssociatedStmt=*/true,
2433 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_target_teams_distribute_parallel_for) +
2434 1,
2435 P&: CollapsedNum);
2436}
2437
2438OMPTargetTeamsDistributeParallelForSimdDirective *
2439OMPTargetTeamsDistributeParallelForSimdDirective::Create(
2440 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2441 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2442 const HelperExprs &Exprs) {
2443 auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
2444 C, Clauses, AssociatedStmt,
2445 NumChildren: numLoopChildren(CollapsedNum,
2446 Kind: OMPD_target_teams_distribute_parallel_for_simd),
2447 P&: StartLoc, P&: EndLoc, P&: CollapsedNum);
2448 Dir->setIterationVariable(Exprs.IterationVarRef);
2449 Dir->setLastIteration(Exprs.LastIteration);
2450 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2451 Dir->setPreCond(Exprs.PreCond);
2452 Dir->setCond(Exprs.Cond);
2453 Dir->setInit(Exprs.Init);
2454 Dir->setInc(Exprs.Inc);
2455 Dir->setIsLastIterVariable(Exprs.IL);
2456 Dir->setLowerBoundVariable(Exprs.LB);
2457 Dir->setUpperBoundVariable(Exprs.UB);
2458 Dir->setStrideVariable(Exprs.ST);
2459 Dir->setEnsureUpperBound(Exprs.EUB);
2460 Dir->setNextLowerBound(Exprs.NLB);
2461 Dir->setNextUpperBound(Exprs.NUB);
2462 Dir->setNumIterations(Exprs.NumIterations);
2463 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
2464 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
2465 Dir->setDistInc(Exprs.DistInc);
2466 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
2467 Dir->setCounters(Exprs.Counters);
2468 Dir->setPrivateCounters(Exprs.PrivateCounters);
2469 Dir->setInits(Exprs.Inits);
2470 Dir->setUpdates(Exprs.Updates);
2471 Dir->setFinals(Exprs.Finals);
2472 Dir->setDependentCounters(Exprs.DependentCounters);
2473 Dir->setDependentInits(Exprs.DependentInits);
2474 Dir->setFinalsConditions(Exprs.FinalsConditions);
2475 Dir->setPreInits(Exprs.PreInits);
2476 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
2477 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
2478 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
2479 Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
2480 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
2481 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
2482 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
2483 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
2484 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
2485 return Dir;
2486}
2487
2488OMPTargetTeamsDistributeParallelForSimdDirective *
2489OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty(
2490 const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
2491 EmptyShell) {
2492 return createEmptyDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
2493 C, NumClauses, /*HasAssociatedStmt=*/true,
2494 NumChildren: numLoopChildren(CollapsedNum,
2495 Kind: OMPD_target_teams_distribute_parallel_for_simd),
2496 P&: CollapsedNum);
2497}
2498
2499OMPTargetTeamsDistributeSimdDirective *
2500OMPTargetTeamsDistributeSimdDirective::Create(
2501 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2502 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2503 const HelperExprs &Exprs) {
2504 auto *Dir = createDirective<OMPTargetTeamsDistributeSimdDirective>(
2505 C, Clauses, AssociatedStmt,
2506 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_target_teams_distribute_simd),
2507 P&: StartLoc, P&: EndLoc, P&: CollapsedNum);
2508 Dir->setIterationVariable(Exprs.IterationVarRef);
2509 Dir->setLastIteration(Exprs.LastIteration);
2510 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2511 Dir->setPreCond(Exprs.PreCond);
2512 Dir->setCond(Exprs.Cond);
2513 Dir->setInit(Exprs.Init);
2514 Dir->setInc(Exprs.Inc);
2515 Dir->setIsLastIterVariable(Exprs.IL);
2516 Dir->setLowerBoundVariable(Exprs.LB);
2517 Dir->setUpperBoundVariable(Exprs.UB);
2518 Dir->setStrideVariable(Exprs.ST);
2519 Dir->setEnsureUpperBound(Exprs.EUB);
2520 Dir->setNextLowerBound(Exprs.NLB);
2521 Dir->setNextUpperBound(Exprs.NUB);
2522 Dir->setNumIterations(Exprs.NumIterations);
2523 Dir->setCounters(Exprs.Counters);
2524 Dir->setPrivateCounters(Exprs.PrivateCounters);
2525 Dir->setInits(Exprs.Inits);
2526 Dir->setUpdates(Exprs.Updates);
2527 Dir->setFinals(Exprs.Finals);
2528 Dir->setDependentCounters(Exprs.DependentCounters);
2529 Dir->setDependentInits(Exprs.DependentInits);
2530 Dir->setFinalsConditions(Exprs.FinalsConditions);
2531 Dir->setPreInits(Exprs.PreInits);
2532 return Dir;
2533}
2534
2535OMPTargetTeamsDistributeSimdDirective *
2536OMPTargetTeamsDistributeSimdDirective::CreateEmpty(const ASTContext &C,
2537 unsigned NumClauses,
2538 unsigned CollapsedNum,
2539 EmptyShell) {
2540 return createEmptyDirective<OMPTargetTeamsDistributeSimdDirective>(
2541 C, NumClauses, /*HasAssociatedStmt=*/true,
2542 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_target_teams_distribute_simd),
2543 P&: CollapsedNum);
2544}
2545
2546OMPInteropDirective *
2547OMPInteropDirective::Create(const ASTContext &C, SourceLocation StartLoc,
2548 SourceLocation EndLoc,
2549 ArrayRef<OMPClause *> Clauses) {
2550 return createDirective<OMPInteropDirective>(
2551 C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, P&: StartLoc,
2552 P&: EndLoc);
2553}
2554
2555OMPInteropDirective *OMPInteropDirective::CreateEmpty(const ASTContext &C,
2556 unsigned NumClauses,
2557 EmptyShell) {
2558 return createEmptyDirective<OMPInteropDirective>(C, NumClauses);
2559}
2560
2561OMPDispatchDirective *OMPDispatchDirective::Create(
2562 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2563 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2564 SourceLocation TargetCallLoc) {
2565 auto *Dir = createDirective<OMPDispatchDirective>(
2566 C, Clauses, AssociatedStmt, /*NumChildren=*/0, P&: StartLoc, P&: EndLoc);
2567 Dir->setTargetCallLoc(TargetCallLoc);
2568 return Dir;
2569}
2570
2571OMPDispatchDirective *OMPDispatchDirective::CreateEmpty(const ASTContext &C,
2572 unsigned NumClauses,
2573 EmptyShell) {
2574 return createEmptyDirective<OMPDispatchDirective>(C, NumClauses,
2575 /*HasAssociatedStmt=*/true,
2576 /*NumChildren=*/0);
2577}
2578
2579OMPMaskedDirective *OMPMaskedDirective::Create(const ASTContext &C,
2580 SourceLocation StartLoc,
2581 SourceLocation EndLoc,
2582 ArrayRef<OMPClause *> Clauses,
2583 Stmt *AssociatedStmt) {
2584 return createDirective<OMPMaskedDirective>(C, Clauses, AssociatedStmt,
2585 /*NumChildren=*/0, P&: StartLoc,
2586 P&: EndLoc);
2587}
2588
2589OMPMaskedDirective *OMPMaskedDirective::CreateEmpty(const ASTContext &C,
2590 unsigned NumClauses,
2591 EmptyShell) {
2592 return createEmptyDirective<OMPMaskedDirective>(C, NumClauses,
2593 /*HasAssociatedStmt=*/true);
2594}
2595
2596OMPGenericLoopDirective *OMPGenericLoopDirective::Create(
2597 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2598 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2599 const HelperExprs &Exprs) {
2600 auto *Dir = createDirective<OMPGenericLoopDirective>(
2601 C, Clauses, AssociatedStmt, NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_loop),
2602 P&: StartLoc, P&: EndLoc, P&: CollapsedNum);
2603 Dir->setIterationVariable(Exprs.IterationVarRef);
2604 Dir->setLastIteration(Exprs.LastIteration);
2605 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2606 Dir->setPreCond(Exprs.PreCond);
2607 Dir->setCond(Exprs.Cond);
2608 Dir->setInit(Exprs.Init);
2609 Dir->setInc(Exprs.Inc);
2610 Dir->setIsLastIterVariable(Exprs.IL);
2611 Dir->setLowerBoundVariable(Exprs.LB);
2612 Dir->setUpperBoundVariable(Exprs.UB);
2613 Dir->setStrideVariable(Exprs.ST);
2614 Dir->setEnsureUpperBound(Exprs.EUB);
2615 Dir->setNextLowerBound(Exprs.NLB);
2616 Dir->setNextUpperBound(Exprs.NUB);
2617 Dir->setNumIterations(Exprs.NumIterations);
2618 Dir->setCounters(Exprs.Counters);
2619 Dir->setPrivateCounters(Exprs.PrivateCounters);
2620 Dir->setInits(Exprs.Inits);
2621 Dir->setUpdates(Exprs.Updates);
2622 Dir->setFinals(Exprs.Finals);
2623 Dir->setDependentCounters(Exprs.DependentCounters);
2624 Dir->setDependentInits(Exprs.DependentInits);
2625 Dir->setFinalsConditions(Exprs.FinalsConditions);
2626 Dir->setPreInits(Exprs.PreInits);
2627 return Dir;
2628}
2629
2630OMPGenericLoopDirective *
2631OMPGenericLoopDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
2632 unsigned CollapsedNum, EmptyShell) {
2633 return createEmptyDirective<OMPGenericLoopDirective>(
2634 C, NumClauses, /*HasAssociatedStmt=*/true,
2635 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_loop), P&: CollapsedNum);
2636}
2637
2638OMPTeamsGenericLoopDirective *OMPTeamsGenericLoopDirective::Create(
2639 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2640 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2641 const HelperExprs &Exprs) {
2642 auto *Dir = createDirective<OMPTeamsGenericLoopDirective>(
2643 C, Clauses, AssociatedStmt,
2644 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_teams_loop), P&: StartLoc, P&: EndLoc,
2645 P&: CollapsedNum);
2646 Dir->setIterationVariable(Exprs.IterationVarRef);
2647 Dir->setLastIteration(Exprs.LastIteration);
2648 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2649 Dir->setPreCond(Exprs.PreCond);
2650 Dir->setCond(Exprs.Cond);
2651 Dir->setInit(Exprs.Init);
2652 Dir->setInc(Exprs.Inc);
2653 Dir->setIsLastIterVariable(Exprs.IL);
2654 Dir->setLowerBoundVariable(Exprs.LB);
2655 Dir->setUpperBoundVariable(Exprs.UB);
2656 Dir->setStrideVariable(Exprs.ST);
2657 Dir->setEnsureUpperBound(Exprs.EUB);
2658 Dir->setNextLowerBound(Exprs.NLB);
2659 Dir->setNextUpperBound(Exprs.NUB);
2660 Dir->setNumIterations(Exprs.NumIterations);
2661 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
2662 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
2663 Dir->setDistInc(Exprs.DistInc);
2664 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
2665 Dir->setCounters(Exprs.Counters);
2666 Dir->setPrivateCounters(Exprs.PrivateCounters);
2667 Dir->setInits(Exprs.Inits);
2668 Dir->setUpdates(Exprs.Updates);
2669 Dir->setFinals(Exprs.Finals);
2670 Dir->setDependentCounters(Exprs.DependentCounters);
2671 Dir->setDependentInits(Exprs.DependentInits);
2672 Dir->setFinalsConditions(Exprs.FinalsConditions);
2673 Dir->setPreInits(Exprs.PreInits);
2674 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
2675 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
2676 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
2677 Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
2678 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
2679 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
2680 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
2681 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
2682 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
2683 return Dir;
2684}
2685
2686OMPTeamsGenericLoopDirective *
2687OMPTeamsGenericLoopDirective::CreateEmpty(const ASTContext &C,
2688 unsigned NumClauses,
2689 unsigned CollapsedNum, EmptyShell) {
2690 return createEmptyDirective<OMPTeamsGenericLoopDirective>(
2691 C, NumClauses, /*HasAssociatedStmt=*/true,
2692 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_teams_loop), P&: CollapsedNum);
2693}
2694
2695OMPTargetTeamsGenericLoopDirective *OMPTargetTeamsGenericLoopDirective::Create(
2696 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2697 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2698 const HelperExprs &Exprs, bool CanBeParallelFor) {
2699 auto *Dir = createDirective<OMPTargetTeamsGenericLoopDirective>(
2700 C, Clauses, AssociatedStmt,
2701 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_target_teams_loop), P&: StartLoc, P&: EndLoc,
2702 P&: CollapsedNum);
2703 Dir->setIterationVariable(Exprs.IterationVarRef);
2704 Dir->setLastIteration(Exprs.LastIteration);
2705 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2706 Dir->setPreCond(Exprs.PreCond);
2707 Dir->setCond(Exprs.Cond);
2708 Dir->setInit(Exprs.Init);
2709 Dir->setInc(Exprs.Inc);
2710 Dir->setIsLastIterVariable(Exprs.IL);
2711 Dir->setLowerBoundVariable(Exprs.LB);
2712 Dir->setUpperBoundVariable(Exprs.UB);
2713 Dir->setStrideVariable(Exprs.ST);
2714 Dir->setEnsureUpperBound(Exprs.EUB);
2715 Dir->setNextLowerBound(Exprs.NLB);
2716 Dir->setNextUpperBound(Exprs.NUB);
2717 Dir->setNumIterations(Exprs.NumIterations);
2718 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
2719 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
2720 Dir->setDistInc(Exprs.DistInc);
2721 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
2722 Dir->setCounters(Exprs.Counters);
2723 Dir->setPrivateCounters(Exprs.PrivateCounters);
2724 Dir->setInits(Exprs.Inits);
2725 Dir->setUpdates(Exprs.Updates);
2726 Dir->setFinals(Exprs.Finals);
2727 Dir->setDependentCounters(Exprs.DependentCounters);
2728 Dir->setDependentInits(Exprs.DependentInits);
2729 Dir->setFinalsConditions(Exprs.FinalsConditions);
2730 Dir->setPreInits(Exprs.PreInits);
2731 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
2732 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
2733 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
2734 Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
2735 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
2736 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
2737 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
2738 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
2739 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
2740 Dir->setCanBeParallelFor(CanBeParallelFor);
2741 return Dir;
2742}
2743
2744OMPTargetTeamsGenericLoopDirective *
2745OMPTargetTeamsGenericLoopDirective::CreateEmpty(const ASTContext &C,
2746 unsigned NumClauses,
2747 unsigned CollapsedNum,
2748 EmptyShell) {
2749 return createEmptyDirective<OMPTargetTeamsGenericLoopDirective>(
2750 C, NumClauses, /*HasAssociatedStmt=*/true,
2751 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_target_teams_loop), P&: CollapsedNum);
2752}
2753
2754OMPParallelGenericLoopDirective *OMPParallelGenericLoopDirective::Create(
2755 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2756 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2757 const HelperExprs &Exprs) {
2758 auto *Dir = createDirective<OMPParallelGenericLoopDirective>(
2759 C, Clauses, AssociatedStmt,
2760 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_parallel_loop), P&: StartLoc, P&: EndLoc,
2761 P&: CollapsedNum);
2762 Dir->setIterationVariable(Exprs.IterationVarRef);
2763 Dir->setLastIteration(Exprs.LastIteration);
2764 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2765 Dir->setPreCond(Exprs.PreCond);
2766 Dir->setCond(Exprs.Cond);
2767 Dir->setInit(Exprs.Init);
2768 Dir->setInc(Exprs.Inc);
2769 Dir->setIsLastIterVariable(Exprs.IL);
2770 Dir->setLowerBoundVariable(Exprs.LB);
2771 Dir->setUpperBoundVariable(Exprs.UB);
2772 Dir->setStrideVariable(Exprs.ST);
2773 Dir->setEnsureUpperBound(Exprs.EUB);
2774 Dir->setNextLowerBound(Exprs.NLB);
2775 Dir->setNextUpperBound(Exprs.NUB);
2776 Dir->setNumIterations(Exprs.NumIterations);
2777 Dir->setCounters(Exprs.Counters);
2778 Dir->setPrivateCounters(Exprs.PrivateCounters);
2779 Dir->setInits(Exprs.Inits);
2780 Dir->setUpdates(Exprs.Updates);
2781 Dir->setFinals(Exprs.Finals);
2782 Dir->setDependentCounters(Exprs.DependentCounters);
2783 Dir->setDependentInits(Exprs.DependentInits);
2784 Dir->setFinalsConditions(Exprs.FinalsConditions);
2785 Dir->setPreInits(Exprs.PreInits);
2786 return Dir;
2787}
2788
2789OMPParallelGenericLoopDirective *OMPParallelGenericLoopDirective::CreateEmpty(
2790 const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
2791 EmptyShell) {
2792 return createEmptyDirective<OMPParallelGenericLoopDirective>(
2793 C, NumClauses, /*HasAssociatedStmt=*/true,
2794 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_parallel_loop), P&: CollapsedNum);
2795}
2796
2797OMPTargetParallelGenericLoopDirective *
2798OMPTargetParallelGenericLoopDirective::Create(
2799 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2800 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2801 const HelperExprs &Exprs) {
2802 auto *Dir = createDirective<OMPTargetParallelGenericLoopDirective>(
2803 C, Clauses, AssociatedStmt,
2804 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_target_parallel_loop), P&: StartLoc,
2805 P&: EndLoc, P&: CollapsedNum);
2806 Dir->setIterationVariable(Exprs.IterationVarRef);
2807 Dir->setLastIteration(Exprs.LastIteration);
2808 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2809 Dir->setPreCond(Exprs.PreCond);
2810 Dir->setCond(Exprs.Cond);
2811 Dir->setInit(Exprs.Init);
2812 Dir->setInc(Exprs.Inc);
2813 Dir->setIsLastIterVariable(Exprs.IL);
2814 Dir->setLowerBoundVariable(Exprs.LB);
2815 Dir->setUpperBoundVariable(Exprs.UB);
2816 Dir->setStrideVariable(Exprs.ST);
2817 Dir->setEnsureUpperBound(Exprs.EUB);
2818 Dir->setNextLowerBound(Exprs.NLB);
2819 Dir->setNextUpperBound(Exprs.NUB);
2820 Dir->setNumIterations(Exprs.NumIterations);
2821 Dir->setCounters(Exprs.Counters);
2822 Dir->setPrivateCounters(Exprs.PrivateCounters);
2823 Dir->setInits(Exprs.Inits);
2824 Dir->setUpdates(Exprs.Updates);
2825 Dir->setFinals(Exprs.Finals);
2826 Dir->setDependentCounters(Exprs.DependentCounters);
2827 Dir->setDependentInits(Exprs.DependentInits);
2828 Dir->setFinalsConditions(Exprs.FinalsConditions);
2829 Dir->setPreInits(Exprs.PreInits);
2830 return Dir;
2831}
2832
2833OMPTargetParallelGenericLoopDirective *
2834OMPTargetParallelGenericLoopDirective::CreateEmpty(const ASTContext &C,
2835 unsigned NumClauses,
2836 unsigned CollapsedNum,
2837 EmptyShell) {
2838 return createEmptyDirective<OMPTargetParallelGenericLoopDirective>(
2839 C, NumClauses, /*HasAssociatedStmt=*/true,
2840 NumChildren: numLoopChildren(CollapsedNum, Kind: OMPD_target_parallel_loop), P&: CollapsedNum);
2841}
2842