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