clang 22.0.0git
StmtOpenMP.cpp
Go to the documentation of this file.
1//===--- StmtOpenMP.cpp - Classes for OpenMP directives -------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the subclasses of Stmt class declared in StmtOpenMP.h
10//
11//===----------------------------------------------------------------------===//
12
15
16using namespace clang;
17using namespace llvm::omp;
18
19size_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
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
34 return getTrailingObjects<Stmt *>(NumChildren);
35}
36
37OMPChildren *OMPChildren::Create(void *Mem, ArrayRef<OMPClause *> Clauses) {
38 auto *Data = CreateEmpty(Mem, Clauses.size());
39 Data->setClauses(Clauses);
40 return Data;
41}
42
43OMPChildren *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
52OMPChildren *OMPChildren::CreateEmpty(void *Mem, unsigned NumClauses,
53 bool HasAssociatedStmt,
54 unsigned NumChildren) {
55 return new (Mem) OMPChildren(NumClauses, NumChildren, HasAssociatedStmt);
56}
57
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
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
77Stmt *
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
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 }
174 CurStmt, TryImperfectlyNestedLoops);
175 }
176 return true;
177}
178
180 Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops,
181 llvm::function_ref<void(unsigned, Stmt *, Stmt *)> Callback) {
183 CurStmt, TryImperfectlyNestedLoops, NumLoops,
184 [Callback](unsigned Cnt, Stmt *Loop) {
185 Stmt *Body = nullptr;
186 if (auto *For = dyn_cast<ForStmt>(Loop)) {
187 Body = For->getBody();
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
203 // This relies on the loop form is already checked by Sema.
204 Stmt *Body = nullptr;
206 Data->getRawStmt(), /*TryImperfectlyNestedLoops=*/true,
208 [&Body](unsigned, Stmt *, Stmt *BodyStmt) { Body = BodyStmt; });
209 return Body;
210}
211
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
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
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
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
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
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
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
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
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
274 unsigned NumClauses,
275 EmptyShell) {
276 return createEmptyDirective<OMPMetaDirective>(C, NumClauses,
277 /*HasAssociatedStmt=*/true,
278 /*NumChildren=*/1);
279}
280
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
293 unsigned NumClauses,
294 EmptyShell) {
295 return createEmptyDirective<OMPParallelDirective>(C, NumClauses,
296 /*HasAssociatedStmt=*/true,
297 /*NumChildren=*/1);
298}
299
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
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
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
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
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
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
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
421 unsigned NumClauses,
422 unsigned NumLoops) {
423 return createEmptyDirective<OMPTileDirective>(
424 C, NumClauses, /*HasAssociatedStmt=*/true, TransformedStmtOffset + 1,
425 SourceLocation(), SourceLocation(), NumLoops);
426}
427
431 unsigned NumLoops, Stmt *AssociatedStmt,
432 Stmt *TransformedStmt, Stmt *PreInits) {
433 OMPStripeDirective *Dir = createDirective<OMPStripeDirective>(
434 C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc,
435 NumLoops);
436 Dir->setTransformedStmt(TransformedStmt);
437 Dir->setPreInits(PreInits);
438 return Dir;
439}
440
442 unsigned NumClauses,
443 unsigned NumLoops) {
444 return createEmptyDirective<OMPStripeDirective>(
445 C, NumClauses, /*HasAssociatedStmt=*/true, TransformedStmtOffset + 1,
446 SourceLocation(), SourceLocation(), NumLoops);
447}
448
452 Stmt *AssociatedStmt, unsigned NumGeneratedLoops,
453 Stmt *TransformedStmt, Stmt *PreInits) {
454 assert(NumGeneratedLoops <= 1 && "Unrolling generates at most one loop");
455
456 auto *Dir = createDirective<OMPUnrollDirective>(
457 C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc);
458 Dir->setNumGeneratedLoops(NumGeneratedLoops);
459 Dir->setTransformedStmt(TransformedStmt);
460 Dir->setPreInits(PreInits);
461 return Dir;
462}
463
465 unsigned NumClauses) {
466 return createEmptyDirective<OMPUnrollDirective>(
467 C, NumClauses, /*HasAssociatedStmt=*/true, TransformedStmtOffset + 1,
469}
470
473 SourceLocation EndLoc, Stmt *AssociatedStmt,
474 unsigned NumLoops, Stmt *TransformedStmt,
475 Stmt *PreInits) {
476 OMPReverseDirective *Dir = createDirective<OMPReverseDirective>(
477 C, {}, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc,
478 NumLoops);
479 Dir->setTransformedStmt(TransformedStmt);
480 Dir->setPreInits(PreInits);
481 return Dir;
482}
483
485 unsigned NumLoops) {
486 return createEmptyDirective<OMPReverseDirective>(
487 C, /*NumClauses=*/0, /*HasAssociatedStmt=*/true,
488 TransformedStmtOffset + 1, SourceLocation(), SourceLocation(), NumLoops);
489}
490
492 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
493 ArrayRef<OMPClause *> Clauses, unsigned NumLoops, Stmt *AssociatedStmt,
494 Stmt *TransformedStmt, Stmt *PreInits) {
495 OMPInterchangeDirective *Dir = createDirective<OMPInterchangeDirective>(
496 C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc,
497 NumLoops);
498 Dir->setTransformedStmt(TransformedStmt);
499 Dir->setPreInits(PreInits);
500 return Dir;
501}
502
505 unsigned NumLoops) {
506 return createEmptyDirective<OMPInterchangeDirective>(
507 C, NumClauses, /*HasAssociatedStmt=*/true, TransformedStmtOffset + 1,
508 SourceLocation(), SourceLocation(), NumLoops);
509}
510
513 SourceLocation EndLoc, unsigned CollapsedNum,
514 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
515 const HelperExprs &Exprs) {
516 auto *Dir = createDirective<OMPForSimdDirective>(
517 C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for_simd),
518 StartLoc, EndLoc, CollapsedNum);
519 Dir->setIterationVariable(Exprs.IterationVarRef);
520 Dir->setLastIteration(Exprs.LastIteration);
521 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
522 Dir->setPreCond(Exprs.PreCond);
523 Dir->setCond(Exprs.Cond);
524 Dir->setInit(Exprs.Init);
525 Dir->setInc(Exprs.Inc);
526 Dir->setIsLastIterVariable(Exprs.IL);
527 Dir->setLowerBoundVariable(Exprs.LB);
528 Dir->setUpperBoundVariable(Exprs.UB);
529 Dir->setStrideVariable(Exprs.ST);
530 Dir->setEnsureUpperBound(Exprs.EUB);
531 Dir->setNextLowerBound(Exprs.NLB);
532 Dir->setNextUpperBound(Exprs.NUB);
533 Dir->setNumIterations(Exprs.NumIterations);
534 Dir->setCounters(Exprs.Counters);
535 Dir->setPrivateCounters(Exprs.PrivateCounters);
536 Dir->setInits(Exprs.Inits);
537 Dir->setUpdates(Exprs.Updates);
538 Dir->setFinals(Exprs.Finals);
539 Dir->setDependentCounters(Exprs.DependentCounters);
540 Dir->setDependentInits(Exprs.DependentInits);
541 Dir->setFinalsConditions(Exprs.FinalsConditions);
542 Dir->setPreInits(Exprs.PreInits);
543 return Dir;
544}
545
547 unsigned NumClauses,
548 unsigned CollapsedNum,
549 EmptyShell) {
550 return createEmptyDirective<OMPForSimdDirective>(
551 C, NumClauses, /*HasAssociatedStmt=*/true,
552 numLoopChildren(CollapsedNum, OMPD_for_simd), CollapsedNum);
553}
554
556 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
557 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
558 bool HasCancel) {
559 auto *Dir = createDirective<OMPSectionsDirective>(C, Clauses, AssociatedStmt,
560 /*NumChildren=*/1, StartLoc,
561 EndLoc);
562 Dir->setTaskReductionRefExpr(TaskRedRef);
563 Dir->setHasCancel(HasCancel);
564 return Dir;
565}
566
568 unsigned NumClauses,
569 EmptyShell) {
570 return createEmptyDirective<OMPSectionsDirective>(C, NumClauses,
571 /*HasAssociatedStmt=*/true,
572 /*NumChildren=*/1);
573}
574
576 SourceLocation StartLoc,
577 SourceLocation EndLoc,
578 Stmt *AssociatedStmt,
579 bool HasCancel) {
580 auto *Dir =
581 createDirective<OMPSectionDirective>(C, {}, AssociatedStmt,
582 /*NumChildren=*/0, StartLoc, EndLoc);
583 Dir->setHasCancel(HasCancel);
584 return Dir;
585}
586
588 EmptyShell) {
589 return createEmptyDirective<OMPSectionDirective>(C, /*NumClauses=*/0,
590 /*HasAssociatedStmt=*/true);
591}
592
594 SourceLocation StartLoc,
595 SourceLocation EndLoc,
596 ArrayRef<OMPClause *> Clauses,
597 Stmt *AssociatedStmt) {
598 return createDirective<OMPScopeDirective>(C, Clauses, AssociatedStmt,
599 /*NumChildren=*/0, StartLoc,
600 EndLoc);
601}
602
604 unsigned NumClauses,
605 EmptyShell) {
606 return createEmptyDirective<OMPScopeDirective>(C, NumClauses,
607 /*HasAssociatedStmt=*/true);
608}
609
611 SourceLocation StartLoc,
612 SourceLocation EndLoc,
613 ArrayRef<OMPClause *> Clauses,
614 Stmt *AssociatedStmt) {
615 return createDirective<OMPSingleDirective>(C, Clauses, AssociatedStmt,
616 /*NumChildren=*/0, StartLoc,
617 EndLoc);
618}
619
621 unsigned NumClauses,
622 EmptyShell) {
623 return createEmptyDirective<OMPSingleDirective>(C, NumClauses,
624 /*HasAssociatedStmt=*/true);
625}
626
628 SourceLocation StartLoc,
629 SourceLocation EndLoc,
630 Stmt *AssociatedStmt) {
631 return createDirective<OMPMasterDirective>(C, {}, AssociatedStmt,
632 /*NumChildren=*/0, StartLoc,
633 EndLoc);
634}
635
637 EmptyShell) {
638 return createEmptyDirective<OMPMasterDirective>(C, /*NumClauses=*/0,
639 /*HasAssociatedStmt=*/true);
640}
641
643 const ASTContext &C, const DeclarationNameInfo &Name,
644 SourceLocation StartLoc, SourceLocation EndLoc,
645 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
646 return createDirective<OMPCriticalDirective>(C, Clauses, AssociatedStmt,
647 /*NumChildren=*/0, Name,
648 StartLoc, EndLoc);
649}
650
652 unsigned NumClauses,
653 EmptyShell) {
654 return createEmptyDirective<OMPCriticalDirective>(C, NumClauses,
655 /*HasAssociatedStmt=*/true);
656}
657
659 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
660 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
661 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
662 auto *Dir = createDirective<OMPParallelForDirective>(
663 C, Clauses, AssociatedStmt,
664 numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, StartLoc, EndLoc,
665 CollapsedNum);
666 Dir->setIterationVariable(Exprs.IterationVarRef);
667 Dir->setLastIteration(Exprs.LastIteration);
668 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
669 Dir->setPreCond(Exprs.PreCond);
670 Dir->setCond(Exprs.Cond);
671 Dir->setInit(Exprs.Init);
672 Dir->setInc(Exprs.Inc);
673 Dir->setIsLastIterVariable(Exprs.IL);
674 Dir->setLowerBoundVariable(Exprs.LB);
675 Dir->setUpperBoundVariable(Exprs.UB);
676 Dir->setStrideVariable(Exprs.ST);
677 Dir->setEnsureUpperBound(Exprs.EUB);
678 Dir->setNextLowerBound(Exprs.NLB);
679 Dir->setNextUpperBound(Exprs.NUB);
680 Dir->setNumIterations(Exprs.NumIterations);
681 Dir->setCounters(Exprs.Counters);
682 Dir->setPrivateCounters(Exprs.PrivateCounters);
683 Dir->setInits(Exprs.Inits);
684 Dir->setUpdates(Exprs.Updates);
685 Dir->setFinals(Exprs.Finals);
686 Dir->setDependentCounters(Exprs.DependentCounters);
687 Dir->setDependentInits(Exprs.DependentInits);
688 Dir->setFinalsConditions(Exprs.FinalsConditions);
689 Dir->setPreInits(Exprs.PreInits);
690 Dir->setTaskReductionRefExpr(TaskRedRef);
691 Dir->setHasCancel(HasCancel);
692 return Dir;
693}
694
697 unsigned CollapsedNum, EmptyShell) {
698 return createEmptyDirective<OMPParallelForDirective>(
699 C, NumClauses, /*HasAssociatedStmt=*/true,
700 numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, CollapsedNum);
701}
702
704 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
705 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
706 const HelperExprs &Exprs) {
707 auto *Dir = createDirective<OMPParallelForSimdDirective>(
708 C, Clauses, AssociatedStmt,
709 numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), StartLoc, EndLoc,
710 CollapsedNum);
711 Dir->setIterationVariable(Exprs.IterationVarRef);
712 Dir->setLastIteration(Exprs.LastIteration);
713 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
714 Dir->setPreCond(Exprs.PreCond);
715 Dir->setCond(Exprs.Cond);
716 Dir->setInit(Exprs.Init);
717 Dir->setInc(Exprs.Inc);
718 Dir->setIsLastIterVariable(Exprs.IL);
719 Dir->setLowerBoundVariable(Exprs.LB);
720 Dir->setUpperBoundVariable(Exprs.UB);
721 Dir->setStrideVariable(Exprs.ST);
722 Dir->setEnsureUpperBound(Exprs.EUB);
723 Dir->setNextLowerBound(Exprs.NLB);
724 Dir->setNextUpperBound(Exprs.NUB);
725 Dir->setNumIterations(Exprs.NumIterations);
726 Dir->setCounters(Exprs.Counters);
727 Dir->setPrivateCounters(Exprs.PrivateCounters);
728 Dir->setInits(Exprs.Inits);
729 Dir->setUpdates(Exprs.Updates);
730 Dir->setFinals(Exprs.Finals);
731 Dir->setDependentCounters(Exprs.DependentCounters);
732 Dir->setDependentInits(Exprs.DependentInits);
733 Dir->setFinalsConditions(Exprs.FinalsConditions);
734 Dir->setPreInits(Exprs.PreInits);
735 return Dir;
736}
737
740 unsigned NumClauses,
741 unsigned CollapsedNum, EmptyShell) {
742 return createEmptyDirective<OMPParallelForSimdDirective>(
743 C, NumClauses, /*HasAssociatedStmt=*/true,
744 numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), CollapsedNum);
745}
746
748 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
749 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef) {
750 auto *Dir = createDirective<OMPParallelMasterDirective>(
751 C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
752 Dir->setTaskReductionRefExpr(TaskRedRef);
753 return Dir;
754}
755
758 unsigned NumClauses, EmptyShell) {
759 return createEmptyDirective<OMPParallelMasterDirective>(
760 C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
761}
762
764 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
765 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef) {
766 auto *Dir = createDirective<OMPParallelMaskedDirective>(
767 C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
768 Dir->setTaskReductionRefExpr(TaskRedRef);
769 return Dir;
770}
771
774 unsigned NumClauses, EmptyShell) {
775 return createEmptyDirective<OMPParallelMaskedDirective>(
776 C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
777}
778
780 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
781 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
782 bool HasCancel) {
783 auto *Dir = createDirective<OMPParallelSectionsDirective>(
784 C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
785 Dir->setTaskReductionRefExpr(TaskRedRef);
786 Dir->setHasCancel(HasCancel);
787 return Dir;
788}
789
792 unsigned NumClauses, EmptyShell) {
793 return createEmptyDirective<OMPParallelSectionsDirective>(
794 C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
795}
796
800 Stmt *AssociatedStmt, bool HasCancel) {
801 auto *Dir = createDirective<OMPTaskDirective>(
802 C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
803 Dir->setHasCancel(HasCancel);
804 return Dir;
805}
806
808 unsigned NumClauses,
809 EmptyShell) {
810 return createEmptyDirective<OMPTaskDirective>(C, NumClauses,
811 /*HasAssociatedStmt=*/true);
812}
813
815 SourceLocation StartLoc,
816 SourceLocation EndLoc) {
817 return new (C) OMPTaskyieldDirective(StartLoc, EndLoc);
818}
819
821 EmptyShell) {
822 return new (C) OMPTaskyieldDirective();
823}
824
826 SourceLocation StartLoc,
827 SourceLocation EndLoc,
828 ArrayRef<OMPClause *> Clauses,
829 Stmt *AStmt) {
830 return createDirective<OMPAssumeDirective>(C, Clauses, AStmt,
831 /*NumChildren=*/0, StartLoc,
832 EndLoc);
833}
834
836 unsigned NumClauses,
837 EmptyShell) {
838 return createEmptyDirective<OMPAssumeDirective>(C, NumClauses,
839 /*HasAssociatedStmt=*/true);
840}
841
843 SourceLocation StartLoc,
844 SourceLocation EndLoc,
845 ArrayRef<OMPClause *> Clauses) {
846 return createDirective<OMPErrorDirective>(
847 C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc,
848 EndLoc);
849}
850
852 unsigned NumClauses,
853 EmptyShell) {
854 return createEmptyDirective<OMPErrorDirective>(C, NumClauses);
855}
856
858 SourceLocation StartLoc,
859 SourceLocation EndLoc) {
860 return new (C) OMPBarrierDirective(StartLoc, EndLoc);
861}
862
864 EmptyShell) {
865 return new (C) OMPBarrierDirective();
866}
867
870 SourceLocation EndLoc,
871 ArrayRef<OMPClause *> Clauses) {
872 return createDirective<OMPTaskwaitDirective>(
873 C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc,
874 EndLoc);
875}
876
878 unsigned NumClauses,
879 EmptyShell) {
880 return createEmptyDirective<OMPTaskwaitDirective>(C, NumClauses);
881}
882
884 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
885 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *ReductionRef) {
886 auto *Dir = createDirective<OMPTaskgroupDirective>(
887 C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
888 Dir->setReductionRef(ReductionRef);
889 return Dir;
890}
891
893 unsigned NumClauses,
894 EmptyShell) {
895 return createEmptyDirective<OMPTaskgroupDirective>(
896 C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
897}
898
900 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
901 OpenMPDirectiveKind CancelRegion) {
902 auto *Dir = new (C) OMPCancellationPointDirective(StartLoc, EndLoc);
903 Dir->setCancelRegion(CancelRegion);
904 return Dir;
905}
906
909 return new (C) OMPCancellationPointDirective();
910}
911
915 OpenMPDirectiveKind CancelRegion) {
916 auto *Dir = createDirective<OMPCancelDirective>(
917 C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc,
918 EndLoc);
919 Dir->setCancelRegion(CancelRegion);
920 return Dir;
921}
922
924 unsigned NumClauses,
925 EmptyShell) {
926 return createEmptyDirective<OMPCancelDirective>(C, NumClauses);
927}
928
930 SourceLocation StartLoc,
931 SourceLocation EndLoc,
932 ArrayRef<OMPClause *> Clauses) {
933 return createDirective<OMPFlushDirective>(
934 C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc,
935 EndLoc);
936}
937
939 unsigned NumClauses,
940 EmptyShell) {
941 return createEmptyDirective<OMPFlushDirective>(C, NumClauses);
942}
943
945 SourceLocation StartLoc,
946 SourceLocation EndLoc,
947 ArrayRef<OMPClause *> Clauses) {
948 return createDirective<OMPDepobjDirective>(
949 C, Clauses, /*AssociatedStmt=*/nullptr,
950 /*NumChildren=*/0, StartLoc, EndLoc);
951}
952
954 unsigned NumClauses,
955 EmptyShell) {
956 return createEmptyDirective<OMPDepobjDirective>(C, NumClauses);
957}
958
960 SourceLocation StartLoc,
961 SourceLocation EndLoc,
962 ArrayRef<OMPClause *> Clauses) {
963 return createDirective<OMPScanDirective>(C, Clauses,
964 /*AssociatedStmt=*/nullptr,
965 /*NumChildren=*/0, StartLoc, EndLoc);
966}
967
969 unsigned NumClauses,
970 EmptyShell) {
971 return createEmptyDirective<OMPScanDirective>(C, NumClauses);
972}
973
975 SourceLocation StartLoc,
976 SourceLocation EndLoc,
977 ArrayRef<OMPClause *> Clauses,
978 Stmt *AssociatedStmt) {
979 return createDirective<OMPOrderedDirective>(
980 C, Clauses, cast_or_null<CapturedStmt>(AssociatedStmt),
981 /*NumChildren=*/0, StartLoc, EndLoc);
982}
983
985 unsigned NumClauses,
986 bool IsStandalone,
987 EmptyShell) {
988 return createEmptyDirective<OMPOrderedDirective>(C, NumClauses,
989 !IsStandalone);
990}
991
995 Stmt *AssociatedStmt, Expressions Exprs) {
996 auto *Dir = createDirective<OMPAtomicDirective>(
997 C, Clauses, AssociatedStmt, /*NumChildren=*/7, StartLoc, EndLoc);
998 Dir->setX(Exprs.X);
999 Dir->setV(Exprs.V);
1000 Dir->setR(Exprs.R);
1001 Dir->setExpr(Exprs.E);
1002 Dir->setUpdateExpr(Exprs.UE);
1003 Dir->setD(Exprs.D);
1004 Dir->setCond(Exprs.Cond);
1005 Dir->Flags.IsXLHSInRHSPart = Exprs.IsXLHSInRHSPart ? 1 : 0;
1006 Dir->Flags.IsPostfixUpdate = Exprs.IsPostfixUpdate ? 1 : 0;
1007 Dir->Flags.IsFailOnly = Exprs.IsFailOnly ? 1 : 0;
1008 return Dir;
1009}
1010
1012 unsigned NumClauses,
1013 EmptyShell) {
1014 return createEmptyDirective<OMPAtomicDirective>(
1015 C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/7);
1016}
1017
1019 SourceLocation StartLoc,
1020 SourceLocation EndLoc,
1021 ArrayRef<OMPClause *> Clauses,
1022 Stmt *AssociatedStmt) {
1023 return createDirective<OMPTargetDirective>(
1024 C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
1025}
1026
1028 unsigned NumClauses,
1029 EmptyShell) {
1030 return createEmptyDirective<OMPTargetDirective>(C, NumClauses,
1031 /*HasAssociatedStmt=*/true);
1032}
1033
1035 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1036 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
1037 bool HasCancel) {
1038 auto *Dir = createDirective<OMPTargetParallelDirective>(
1039 C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
1040 Dir->setTaskReductionRefExpr(TaskRedRef);
1041 Dir->setHasCancel(HasCancel);
1042 return Dir;
1043}
1044
1047 unsigned NumClauses, EmptyShell) {
1048 return createEmptyDirective<OMPTargetParallelDirective>(
1049 C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
1050}
1051
1053 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1054 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1055 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
1056 auto *Dir = createDirective<OMPTargetParallelForDirective>(
1057 C, Clauses, AssociatedStmt,
1058 numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1, StartLoc,
1059 EndLoc, CollapsedNum);
1060 Dir->setIterationVariable(Exprs.IterationVarRef);
1061 Dir->setLastIteration(Exprs.LastIteration);
1062 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1063 Dir->setPreCond(Exprs.PreCond);
1064 Dir->setCond(Exprs.Cond);
1065 Dir->setInit(Exprs.Init);
1066 Dir->setInc(Exprs.Inc);
1067 Dir->setIsLastIterVariable(Exprs.IL);
1068 Dir->setLowerBoundVariable(Exprs.LB);
1069 Dir->setUpperBoundVariable(Exprs.UB);
1070 Dir->setStrideVariable(Exprs.ST);
1071 Dir->setEnsureUpperBound(Exprs.EUB);
1072 Dir->setNextLowerBound(Exprs.NLB);
1073 Dir->setNextUpperBound(Exprs.NUB);
1074 Dir->setNumIterations(Exprs.NumIterations);
1075 Dir->setCounters(Exprs.Counters);
1076 Dir->setPrivateCounters(Exprs.PrivateCounters);
1077 Dir->setInits(Exprs.Inits);
1078 Dir->setUpdates(Exprs.Updates);
1079 Dir->setFinals(Exprs.Finals);
1080 Dir->setDependentCounters(Exprs.DependentCounters);
1081 Dir->setDependentInits(Exprs.DependentInits);
1082 Dir->setFinalsConditions(Exprs.FinalsConditions);
1083 Dir->setPreInits(Exprs.PreInits);
1084 Dir->setTaskReductionRefExpr(TaskRedRef);
1085 Dir->setHasCancel(HasCancel);
1086 return Dir;
1087}
1088
1091 unsigned NumClauses,
1092 unsigned CollapsedNum, EmptyShell) {
1093 return createEmptyDirective<OMPTargetParallelForDirective>(
1094 C, NumClauses, /*HasAssociatedStmt=*/true,
1095 numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1,
1096 CollapsedNum);
1097}
1098
1100 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1101 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1102 return createDirective<OMPTargetDataDirective>(
1103 C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
1104}
1105
1107 unsigned N,
1108 EmptyShell) {
1109 return createEmptyDirective<OMPTargetDataDirective>(
1110 C, N, /*HasAssociatedStmt=*/true);
1111}
1112
1114 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1115 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1116 return createDirective<OMPTargetEnterDataDirective>(
1117 C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
1118}
1119
1122 EmptyShell) {
1123 return createEmptyDirective<OMPTargetEnterDataDirective>(
1124 C, N, /*HasAssociatedStmt=*/true);
1125}
1126
1128 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1129 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1130 return createDirective<OMPTargetExitDataDirective>(
1131 C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
1132}
1133
1136 EmptyShell) {
1137 return createEmptyDirective<OMPTargetExitDataDirective>(
1138 C, N, /*HasAssociatedStmt=*/true);
1139}
1140
1142 SourceLocation StartLoc,
1143 SourceLocation EndLoc,
1144 ArrayRef<OMPClause *> Clauses,
1145 Stmt *AssociatedStmt) {
1146 return createDirective<OMPTeamsDirective>(
1147 C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
1148}
1149
1151 unsigned NumClauses,
1152 EmptyShell) {
1153 return createEmptyDirective<OMPTeamsDirective>(C, NumClauses,
1154 /*HasAssociatedStmt=*/true);
1155}
1156
1158 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1159 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1160 const HelperExprs &Exprs, bool HasCancel) {
1161 auto *Dir = createDirective<OMPTaskLoopDirective>(
1162 C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_taskloop),
1163 StartLoc, EndLoc, CollapsedNum);
1164 Dir->setIterationVariable(Exprs.IterationVarRef);
1165 Dir->setLastIteration(Exprs.LastIteration);
1166 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1167 Dir->setPreCond(Exprs.PreCond);
1168 Dir->setCond(Exprs.Cond);
1169 Dir->setInit(Exprs.Init);
1170 Dir->setInc(Exprs.Inc);
1171 Dir->setIsLastIterVariable(Exprs.IL);
1172 Dir->setLowerBoundVariable(Exprs.LB);
1173 Dir->setUpperBoundVariable(Exprs.UB);
1174 Dir->setStrideVariable(Exprs.ST);
1175 Dir->setEnsureUpperBound(Exprs.EUB);
1176 Dir->setNextLowerBound(Exprs.NLB);
1177 Dir->setNextUpperBound(Exprs.NUB);
1178 Dir->setNumIterations(Exprs.NumIterations);
1179 Dir->setCounters(Exprs.Counters);
1180 Dir->setPrivateCounters(Exprs.PrivateCounters);
1181 Dir->setInits(Exprs.Inits);
1182 Dir->setUpdates(Exprs.Updates);
1183 Dir->setFinals(Exprs.Finals);
1184 Dir->setDependentCounters(Exprs.DependentCounters);
1185 Dir->setDependentInits(Exprs.DependentInits);
1186 Dir->setFinalsConditions(Exprs.FinalsConditions);
1187 Dir->setPreInits(Exprs.PreInits);
1188 Dir->setHasCancel(HasCancel);
1189 return Dir;
1190}
1191
1193 unsigned NumClauses,
1194 unsigned CollapsedNum,
1195 EmptyShell) {
1196 return createEmptyDirective<OMPTaskLoopDirective>(
1197 C, NumClauses, /*HasAssociatedStmt=*/true,
1198 numLoopChildren(CollapsedNum, OMPD_taskloop), CollapsedNum);
1199}
1200
1202 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1203 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1204 const HelperExprs &Exprs) {
1205 auto *Dir = createDirective<OMPTaskLoopSimdDirective>(
1206 C, Clauses, AssociatedStmt,
1207 numLoopChildren(CollapsedNum, OMPD_taskloop_simd), StartLoc, EndLoc,
1208 CollapsedNum);
1209 Dir->setIterationVariable(Exprs.IterationVarRef);
1210 Dir->setLastIteration(Exprs.LastIteration);
1211 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1212 Dir->setPreCond(Exprs.PreCond);
1213 Dir->setCond(Exprs.Cond);
1214 Dir->setInit(Exprs.Init);
1215 Dir->setInc(Exprs.Inc);
1216 Dir->setIsLastIterVariable(Exprs.IL);
1217 Dir->setLowerBoundVariable(Exprs.LB);
1218 Dir->setUpperBoundVariable(Exprs.UB);
1219 Dir->setStrideVariable(Exprs.ST);
1220 Dir->setEnsureUpperBound(Exprs.EUB);
1221 Dir->setNextLowerBound(Exprs.NLB);
1222 Dir->setNextUpperBound(Exprs.NUB);
1223 Dir->setNumIterations(Exprs.NumIterations);
1224 Dir->setCounters(Exprs.Counters);
1225 Dir->setPrivateCounters(Exprs.PrivateCounters);
1226 Dir->setInits(Exprs.Inits);
1227 Dir->setUpdates(Exprs.Updates);
1228 Dir->setFinals(Exprs.Finals);
1229 Dir->setDependentCounters(Exprs.DependentCounters);
1230 Dir->setDependentInits(Exprs.DependentInits);
1231 Dir->setFinalsConditions(Exprs.FinalsConditions);
1232 Dir->setPreInits(Exprs.PreInits);
1233 return Dir;
1234}
1235
1238 unsigned CollapsedNum, EmptyShell) {
1239 return createEmptyDirective<OMPTaskLoopSimdDirective>(
1240 C, NumClauses, /*HasAssociatedStmt=*/true,
1241 numLoopChildren(CollapsedNum, OMPD_taskloop_simd), CollapsedNum);
1242}
1243
1245 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1246 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1247 const HelperExprs &Exprs, bool HasCancel) {
1248 auto *Dir = createDirective<OMPMasterTaskLoopDirective>(
1249 C, Clauses, AssociatedStmt,
1250 numLoopChildren(CollapsedNum, OMPD_master_taskloop), StartLoc, EndLoc,
1251 CollapsedNum);
1252 Dir->setIterationVariable(Exprs.IterationVarRef);
1253 Dir->setLastIteration(Exprs.LastIteration);
1254 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1255 Dir->setPreCond(Exprs.PreCond);
1256 Dir->setCond(Exprs.Cond);
1257 Dir->setInit(Exprs.Init);
1258 Dir->setInc(Exprs.Inc);
1259 Dir->setIsLastIterVariable(Exprs.IL);
1260 Dir->setLowerBoundVariable(Exprs.LB);
1261 Dir->setUpperBoundVariable(Exprs.UB);
1262 Dir->setStrideVariable(Exprs.ST);
1263 Dir->setEnsureUpperBound(Exprs.EUB);
1264 Dir->setNextLowerBound(Exprs.NLB);
1265 Dir->setNextUpperBound(Exprs.NUB);
1266 Dir->setNumIterations(Exprs.NumIterations);
1267 Dir->setCounters(Exprs.Counters);
1268 Dir->setPrivateCounters(Exprs.PrivateCounters);
1269 Dir->setInits(Exprs.Inits);
1270 Dir->setUpdates(Exprs.Updates);
1271 Dir->setFinals(Exprs.Finals);
1272 Dir->setDependentCounters(Exprs.DependentCounters);
1273 Dir->setDependentInits(Exprs.DependentInits);
1274 Dir->setFinalsConditions(Exprs.FinalsConditions);
1275 Dir->setPreInits(Exprs.PreInits);
1276 Dir->setHasCancel(HasCancel);
1277 return Dir;
1278}
1279
1282 unsigned NumClauses,
1283 unsigned CollapsedNum, EmptyShell) {
1284 return createEmptyDirective<OMPMasterTaskLoopDirective>(
1285 C, NumClauses, /*HasAssociatedStmt=*/true,
1286 numLoopChildren(CollapsedNum, OMPD_master_taskloop), CollapsedNum);
1287}
1288
1290 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1291 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1292 const HelperExprs &Exprs, bool HasCancel) {
1293 auto *Dir = createDirective<OMPMaskedTaskLoopDirective>(
1294 C, Clauses, AssociatedStmt,
1295 numLoopChildren(CollapsedNum, OMPD_masked_taskloop), StartLoc, EndLoc,
1296 CollapsedNum);
1297 Dir->setIterationVariable(Exprs.IterationVarRef);
1298 Dir->setLastIteration(Exprs.LastIteration);
1299 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1300 Dir->setPreCond(Exprs.PreCond);
1301 Dir->setCond(Exprs.Cond);
1302 Dir->setInit(Exprs.Init);
1303 Dir->setInc(Exprs.Inc);
1304 Dir->setIsLastIterVariable(Exprs.IL);
1305 Dir->setLowerBoundVariable(Exprs.LB);
1306 Dir->setUpperBoundVariable(Exprs.UB);
1307 Dir->setStrideVariable(Exprs.ST);
1308 Dir->setEnsureUpperBound(Exprs.EUB);
1309 Dir->setNextLowerBound(Exprs.NLB);
1310 Dir->setNextUpperBound(Exprs.NUB);
1311 Dir->setNumIterations(Exprs.NumIterations);
1312 Dir->setCounters(Exprs.Counters);
1313 Dir->setPrivateCounters(Exprs.PrivateCounters);
1314 Dir->setInits(Exprs.Inits);
1315 Dir->setUpdates(Exprs.Updates);
1316 Dir->setFinals(Exprs.Finals);
1317 Dir->setDependentCounters(Exprs.DependentCounters);
1318 Dir->setDependentInits(Exprs.DependentInits);
1319 Dir->setFinalsConditions(Exprs.FinalsConditions);
1320 Dir->setPreInits(Exprs.PreInits);
1321 Dir->setHasCancel(HasCancel);
1322 return Dir;
1323}
1324
1327 unsigned NumClauses,
1328 unsigned CollapsedNum, EmptyShell) {
1329 return createEmptyDirective<OMPMaskedTaskLoopDirective>(
1330 C, NumClauses, /*HasAssociatedStmt=*/true,
1331 numLoopChildren(CollapsedNum, OMPD_masked_taskloop), CollapsedNum);
1332}
1333
1335 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1336 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1337 const HelperExprs &Exprs) {
1338 auto *Dir = createDirective<OMPMasterTaskLoopSimdDirective>(
1339 C, Clauses, AssociatedStmt,
1340 numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), StartLoc,
1341 EndLoc, CollapsedNum);
1342 Dir->setIterationVariable(Exprs.IterationVarRef);
1343 Dir->setLastIteration(Exprs.LastIteration);
1344 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1345 Dir->setPreCond(Exprs.PreCond);
1346 Dir->setCond(Exprs.Cond);
1347 Dir->setInit(Exprs.Init);
1348 Dir->setInc(Exprs.Inc);
1349 Dir->setIsLastIterVariable(Exprs.IL);
1350 Dir->setLowerBoundVariable(Exprs.LB);
1351 Dir->setUpperBoundVariable(Exprs.UB);
1352 Dir->setStrideVariable(Exprs.ST);
1353 Dir->setEnsureUpperBound(Exprs.EUB);
1354 Dir->setNextLowerBound(Exprs.NLB);
1355 Dir->setNextUpperBound(Exprs.NUB);
1356 Dir->setNumIterations(Exprs.NumIterations);
1357 Dir->setCounters(Exprs.Counters);
1358 Dir->setPrivateCounters(Exprs.PrivateCounters);
1359 Dir->setInits(Exprs.Inits);
1360 Dir->setUpdates(Exprs.Updates);
1361 Dir->setFinals(Exprs.Finals);
1362 Dir->setDependentCounters(Exprs.DependentCounters);
1363 Dir->setDependentInits(Exprs.DependentInits);
1364 Dir->setFinalsConditions(Exprs.FinalsConditions);
1365 Dir->setPreInits(Exprs.PreInits);
1366 return Dir;
1367}
1368
1371 unsigned NumClauses,
1372 unsigned CollapsedNum, EmptyShell) {
1373 return createEmptyDirective<OMPMasterTaskLoopSimdDirective>(
1374 C, NumClauses, /*HasAssociatedStmt=*/true,
1375 numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), CollapsedNum);
1376}
1377
1379 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1380 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1381 const HelperExprs &Exprs) {
1382 auto *Dir = createDirective<OMPMaskedTaskLoopSimdDirective>(
1383 C, Clauses, AssociatedStmt,
1384 numLoopChildren(CollapsedNum, OMPD_masked_taskloop_simd), StartLoc,
1385 EndLoc, CollapsedNum);
1386 Dir->setIterationVariable(Exprs.IterationVarRef);
1387 Dir->setLastIteration(Exprs.LastIteration);
1388 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1389 Dir->setPreCond(Exprs.PreCond);
1390 Dir->setCond(Exprs.Cond);
1391 Dir->setInit(Exprs.Init);
1392 Dir->setInc(Exprs.Inc);
1393 Dir->setIsLastIterVariable(Exprs.IL);
1394 Dir->setLowerBoundVariable(Exprs.LB);
1395 Dir->setUpperBoundVariable(Exprs.UB);
1396 Dir->setStrideVariable(Exprs.ST);
1397 Dir->setEnsureUpperBound(Exprs.EUB);
1398 Dir->setNextLowerBound(Exprs.NLB);
1399 Dir->setNextUpperBound(Exprs.NUB);
1400 Dir->setNumIterations(Exprs.NumIterations);
1401 Dir->setCounters(Exprs.Counters);
1402 Dir->setPrivateCounters(Exprs.PrivateCounters);
1403 Dir->setInits(Exprs.Inits);
1404 Dir->setUpdates(Exprs.Updates);
1405 Dir->setFinals(Exprs.Finals);
1406 Dir->setDependentCounters(Exprs.DependentCounters);
1407 Dir->setDependentInits(Exprs.DependentInits);
1408 Dir->setFinalsConditions(Exprs.FinalsConditions);
1409 Dir->setPreInits(Exprs.PreInits);
1410 return Dir;
1411}
1412
1415 unsigned NumClauses,
1416 unsigned CollapsedNum, EmptyShell) {
1417 return createEmptyDirective<OMPMaskedTaskLoopSimdDirective>(
1418 C, NumClauses, /*HasAssociatedStmt=*/true,
1419 numLoopChildren(CollapsedNum, OMPD_masked_taskloop_simd), CollapsedNum);
1420}
1421
1423 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1424 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1425 const HelperExprs &Exprs, bool HasCancel) {
1426 auto *Dir = createDirective<OMPParallelMasterTaskLoopDirective>(
1427 C, Clauses, AssociatedStmt,
1428 numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop), StartLoc,
1429 EndLoc, CollapsedNum);
1430 Dir->setIterationVariable(Exprs.IterationVarRef);
1431 Dir->setLastIteration(Exprs.LastIteration);
1432 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1433 Dir->setPreCond(Exprs.PreCond);
1434 Dir->setCond(Exprs.Cond);
1435 Dir->setInit(Exprs.Init);
1436 Dir->setInc(Exprs.Inc);
1437 Dir->setIsLastIterVariable(Exprs.IL);
1438 Dir->setLowerBoundVariable(Exprs.LB);
1439 Dir->setUpperBoundVariable(Exprs.UB);
1440 Dir->setStrideVariable(Exprs.ST);
1441 Dir->setEnsureUpperBound(Exprs.EUB);
1442 Dir->setNextLowerBound(Exprs.NLB);
1443 Dir->setNextUpperBound(Exprs.NUB);
1444 Dir->setNumIterations(Exprs.NumIterations);
1445 Dir->setCounters(Exprs.Counters);
1446 Dir->setPrivateCounters(Exprs.PrivateCounters);
1447 Dir->setInits(Exprs.Inits);
1448 Dir->setUpdates(Exprs.Updates);
1449 Dir->setFinals(Exprs.Finals);
1450 Dir->setDependentCounters(Exprs.DependentCounters);
1451 Dir->setDependentInits(Exprs.DependentInits);
1452 Dir->setFinalsConditions(Exprs.FinalsConditions);
1453 Dir->setPreInits(Exprs.PreInits);
1454 Dir->setHasCancel(HasCancel);
1455 return Dir;
1456}
1457
1460 unsigned NumClauses,
1461 unsigned CollapsedNum,
1462 EmptyShell) {
1463 return createEmptyDirective<OMPParallelMasterTaskLoopDirective>(
1464 C, NumClauses, /*HasAssociatedStmt=*/true,
1465 numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop),
1466 CollapsedNum);
1467}
1468
1470 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1471 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1472 const HelperExprs &Exprs, bool HasCancel) {
1473 auto *Dir = createDirective<OMPParallelMaskedTaskLoopDirective>(
1474 C, Clauses, AssociatedStmt,
1475 numLoopChildren(CollapsedNum, OMPD_parallel_masked_taskloop), StartLoc,
1476 EndLoc, CollapsedNum);
1477 Dir->setIterationVariable(Exprs.IterationVarRef);
1478 Dir->setLastIteration(Exprs.LastIteration);
1479 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1480 Dir->setPreCond(Exprs.PreCond);
1481 Dir->setCond(Exprs.Cond);
1482 Dir->setInit(Exprs.Init);
1483 Dir->setInc(Exprs.Inc);
1484 Dir->setIsLastIterVariable(Exprs.IL);
1485 Dir->setLowerBoundVariable(Exprs.LB);
1486 Dir->setUpperBoundVariable(Exprs.UB);
1487 Dir->setStrideVariable(Exprs.ST);
1488 Dir->setEnsureUpperBound(Exprs.EUB);
1489 Dir->setNextLowerBound(Exprs.NLB);
1490 Dir->setNextUpperBound(Exprs.NUB);
1491 Dir->setNumIterations(Exprs.NumIterations);
1492 Dir->setCounters(Exprs.Counters);
1493 Dir->setPrivateCounters(Exprs.PrivateCounters);
1494 Dir->setInits(Exprs.Inits);
1495 Dir->setUpdates(Exprs.Updates);
1496 Dir->setFinals(Exprs.Finals);
1497 Dir->setDependentCounters(Exprs.DependentCounters);
1498 Dir->setDependentInits(Exprs.DependentInits);
1499 Dir->setFinalsConditions(Exprs.FinalsConditions);
1500 Dir->setPreInits(Exprs.PreInits);
1501 Dir->setHasCancel(HasCancel);
1502 return Dir;
1503}
1504
1507 unsigned NumClauses,
1508 unsigned CollapsedNum,
1509 EmptyShell) {
1510 return createEmptyDirective<OMPParallelMaskedTaskLoopDirective>(
1511 C, NumClauses, /*HasAssociatedStmt=*/true,
1512 numLoopChildren(CollapsedNum, OMPD_parallel_masked_taskloop),
1513 CollapsedNum);
1514}
1515
1518 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1519 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1520 const HelperExprs &Exprs) {
1521 auto *Dir = createDirective<OMPParallelMasterTaskLoopSimdDirective>(
1522 C, Clauses, AssociatedStmt,
1523 numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd),
1524 StartLoc, EndLoc, CollapsedNum);
1525 Dir->setIterationVariable(Exprs.IterationVarRef);
1526 Dir->setLastIteration(Exprs.LastIteration);
1527 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1528 Dir->setPreCond(Exprs.PreCond);
1529 Dir->setCond(Exprs.Cond);
1530 Dir->setInit(Exprs.Init);
1531 Dir->setInc(Exprs.Inc);
1532 Dir->setIsLastIterVariable(Exprs.IL);
1533 Dir->setLowerBoundVariable(Exprs.LB);
1534 Dir->setUpperBoundVariable(Exprs.UB);
1535 Dir->setStrideVariable(Exprs.ST);
1536 Dir->setEnsureUpperBound(Exprs.EUB);
1537 Dir->setNextLowerBound(Exprs.NLB);
1538 Dir->setNextUpperBound(Exprs.NUB);
1539 Dir->setNumIterations(Exprs.NumIterations);
1540 Dir->setCounters(Exprs.Counters);
1541 Dir->setPrivateCounters(Exprs.PrivateCounters);
1542 Dir->setInits(Exprs.Inits);
1543 Dir->setUpdates(Exprs.Updates);
1544 Dir->setFinals(Exprs.Finals);
1545 Dir->setDependentCounters(Exprs.DependentCounters);
1546 Dir->setDependentInits(Exprs.DependentInits);
1547 Dir->setFinalsConditions(Exprs.FinalsConditions);
1548 Dir->setPreInits(Exprs.PreInits);
1549 return Dir;
1550}
1551
1554 unsigned NumClauses,
1555 unsigned CollapsedNum,
1556 EmptyShell) {
1557 return createEmptyDirective<OMPParallelMasterTaskLoopSimdDirective>(
1558 C, NumClauses, /*HasAssociatedStmt=*/true,
1559 numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd),
1560 CollapsedNum);
1561}
1562
1565 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1566 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1567 const HelperExprs &Exprs) {
1568 auto *Dir = createDirective<OMPParallelMaskedTaskLoopSimdDirective>(
1569 C, Clauses, AssociatedStmt,
1570 numLoopChildren(CollapsedNum, OMPD_parallel_masked_taskloop_simd),
1571 StartLoc, EndLoc, CollapsedNum);
1572 Dir->setIterationVariable(Exprs.IterationVarRef);
1573 Dir->setLastIteration(Exprs.LastIteration);
1574 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1575 Dir->setPreCond(Exprs.PreCond);
1576 Dir->setCond(Exprs.Cond);
1577 Dir->setInit(Exprs.Init);
1578 Dir->setInc(Exprs.Inc);
1579 Dir->setIsLastIterVariable(Exprs.IL);
1580 Dir->setLowerBoundVariable(Exprs.LB);
1581 Dir->setUpperBoundVariable(Exprs.UB);
1582 Dir->setStrideVariable(Exprs.ST);
1583 Dir->setEnsureUpperBound(Exprs.EUB);
1584 Dir->setNextLowerBound(Exprs.NLB);
1585 Dir->setNextUpperBound(Exprs.NUB);
1586 Dir->setNumIterations(Exprs.NumIterations);
1587 Dir->setCounters(Exprs.Counters);
1588 Dir->setPrivateCounters(Exprs.PrivateCounters);
1589 Dir->setInits(Exprs.Inits);
1590 Dir->setUpdates(Exprs.Updates);
1591 Dir->setFinals(Exprs.Finals);
1592 Dir->setDependentCounters(Exprs.DependentCounters);
1593 Dir->setDependentInits(Exprs.DependentInits);
1594 Dir->setFinalsConditions(Exprs.FinalsConditions);
1595 Dir->setPreInits(Exprs.PreInits);
1596 return Dir;
1597}
1598
1601 unsigned NumClauses,
1602 unsigned CollapsedNum,
1603 EmptyShell) {
1604 return createEmptyDirective<OMPParallelMaskedTaskLoopSimdDirective>(
1605 C, NumClauses, /*HasAssociatedStmt=*/true,
1606 numLoopChildren(CollapsedNum, OMPD_parallel_masked_taskloop_simd),
1607 CollapsedNum);
1608}
1609
1612 SourceLocation EndLoc, unsigned CollapsedNum,
1613 ArrayRef<OMPClause *> Clauses,
1614 Stmt *AssociatedStmt, const HelperExprs &Exprs) {
1615 auto *Dir = createDirective<OMPDistributeDirective>(
1616 C, Clauses, AssociatedStmt,
1617 numLoopChildren(CollapsedNum, OMPD_distribute), StartLoc, EndLoc,
1618 CollapsedNum);
1619 Dir->setIterationVariable(Exprs.IterationVarRef);
1620 Dir->setLastIteration(Exprs.LastIteration);
1621 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1622 Dir->setPreCond(Exprs.PreCond);
1623 Dir->setCond(Exprs.Cond);
1624 Dir->setInit(Exprs.Init);
1625 Dir->setInc(Exprs.Inc);
1626 Dir->setIsLastIterVariable(Exprs.IL);
1627 Dir->setLowerBoundVariable(Exprs.LB);
1628 Dir->setUpperBoundVariable(Exprs.UB);
1629 Dir->setStrideVariable(Exprs.ST);
1630 Dir->setEnsureUpperBound(Exprs.EUB);
1631 Dir->setNextLowerBound(Exprs.NLB);
1632 Dir->setNextUpperBound(Exprs.NUB);
1633 Dir->setNumIterations(Exprs.NumIterations);
1634 Dir->setCounters(Exprs.Counters);
1635 Dir->setPrivateCounters(Exprs.PrivateCounters);
1636 Dir->setInits(Exprs.Inits);
1637 Dir->setUpdates(Exprs.Updates);
1638 Dir->setFinals(Exprs.Finals);
1639 Dir->setDependentCounters(Exprs.DependentCounters);
1640 Dir->setDependentInits(Exprs.DependentInits);
1641 Dir->setFinalsConditions(Exprs.FinalsConditions);
1642 Dir->setPreInits(Exprs.PreInits);
1643 return Dir;
1644}
1645
1648 unsigned CollapsedNum, EmptyShell) {
1649 return createEmptyDirective<OMPDistributeDirective>(
1650 C, NumClauses, /*HasAssociatedStmt=*/true,
1651 numLoopChildren(CollapsedNum, OMPD_distribute), CollapsedNum);
1652}
1653
1655 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1656 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1657 return createDirective<OMPTargetUpdateDirective>(C, Clauses, AssociatedStmt,
1658 /*NumChildren=*/0, StartLoc,
1659 EndLoc);
1660}
1661
1664 EmptyShell) {
1665 return createEmptyDirective<OMPTargetUpdateDirective>(
1666 C, NumClauses, /*HasAssociatedStmt=*/true);
1667}
1668
1670 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1671 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1672 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
1673 auto *Dir = createDirective<OMPDistributeParallelForDirective>(
1674 C, Clauses, AssociatedStmt,
1675 numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1, StartLoc,
1676 EndLoc, CollapsedNum);
1677 Dir->setIterationVariable(Exprs.IterationVarRef);
1678 Dir->setLastIteration(Exprs.LastIteration);
1679 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1680 Dir->setPreCond(Exprs.PreCond);
1681 Dir->setCond(Exprs.Cond);
1682 Dir->setInit(Exprs.Init);
1683 Dir->setInc(Exprs.Inc);
1684 Dir->setIsLastIterVariable(Exprs.IL);
1685 Dir->setLowerBoundVariable(Exprs.LB);
1686 Dir->setUpperBoundVariable(Exprs.UB);
1687 Dir->setStrideVariable(Exprs.ST);
1688 Dir->setEnsureUpperBound(Exprs.EUB);
1689 Dir->setNextLowerBound(Exprs.NLB);
1690 Dir->setNextUpperBound(Exprs.NUB);
1691 Dir->setNumIterations(Exprs.NumIterations);
1692 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1693 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1694 Dir->setDistInc(Exprs.DistInc);
1695 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1696 Dir->setCounters(Exprs.Counters);
1697 Dir->setPrivateCounters(Exprs.PrivateCounters);
1698 Dir->setInits(Exprs.Inits);
1699 Dir->setUpdates(Exprs.Updates);
1700 Dir->setFinals(Exprs.Finals);
1701 Dir->setDependentCounters(Exprs.DependentCounters);
1702 Dir->setDependentInits(Exprs.DependentInits);
1703 Dir->setFinalsConditions(Exprs.FinalsConditions);
1704 Dir->setPreInits(Exprs.PreInits);
1705 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1706 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1707 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1708 Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1709 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1710 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1711 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1712 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1713 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1714 Dir->setTaskReductionRefExpr(TaskRedRef);
1715 Dir->HasCancel = HasCancel;
1716 return Dir;
1717}
1718
1721 unsigned NumClauses,
1722 unsigned CollapsedNum,
1723 EmptyShell) {
1724 return createEmptyDirective<OMPDistributeParallelForDirective>(
1725 C, NumClauses, /*HasAssociatedStmt=*/true,
1726 numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1,
1727 CollapsedNum);
1728}
1729
1732 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1733 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1734 const HelperExprs &Exprs) {
1735 auto *Dir = createDirective<OMPDistributeParallelForSimdDirective>(
1736 C, Clauses, AssociatedStmt,
1737 numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd),
1738 StartLoc, EndLoc, CollapsedNum);
1739 Dir->setIterationVariable(Exprs.IterationVarRef);
1740 Dir->setLastIteration(Exprs.LastIteration);
1741 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1742 Dir->setPreCond(Exprs.PreCond);
1743 Dir->setCond(Exprs.Cond);
1744 Dir->setInit(Exprs.Init);
1745 Dir->setInc(Exprs.Inc);
1746 Dir->setIsLastIterVariable(Exprs.IL);
1747 Dir->setLowerBoundVariable(Exprs.LB);
1748 Dir->setUpperBoundVariable(Exprs.UB);
1749 Dir->setStrideVariable(Exprs.ST);
1750 Dir->setEnsureUpperBound(Exprs.EUB);
1751 Dir->setNextLowerBound(Exprs.NLB);
1752 Dir->setNextUpperBound(Exprs.NUB);
1753 Dir->setNumIterations(Exprs.NumIterations);
1754 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1755 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1756 Dir->setDistInc(Exprs.DistInc);
1757 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1758 Dir->setCounters(Exprs.Counters);
1759 Dir->setPrivateCounters(Exprs.PrivateCounters);
1760 Dir->setInits(Exprs.Inits);
1761 Dir->setUpdates(Exprs.Updates);
1762 Dir->setFinals(Exprs.Finals);
1763 Dir->setDependentCounters(Exprs.DependentCounters);
1764 Dir->setDependentInits(Exprs.DependentInits);
1765 Dir->setFinalsConditions(Exprs.FinalsConditions);
1766 Dir->setPreInits(Exprs.PreInits);
1767 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1768 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1769 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1770 Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1771 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1772 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1773 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1774 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1775 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1776 return Dir;
1777}
1778
1781 unsigned NumClauses,
1782 unsigned CollapsedNum,
1783 EmptyShell) {
1784 return createEmptyDirective<OMPDistributeParallelForSimdDirective>(
1785 C, NumClauses, /*HasAssociatedStmt=*/true,
1786 numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd),
1787 CollapsedNum);
1788}
1789
1791 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1792 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1793 const HelperExprs &Exprs) {
1794 auto *Dir = createDirective<OMPDistributeSimdDirective>(
1795 C, Clauses, AssociatedStmt,
1796 numLoopChildren(CollapsedNum, OMPD_distribute_simd), StartLoc, EndLoc,
1797 CollapsedNum);
1798 Dir->setIterationVariable(Exprs.IterationVarRef);
1799 Dir->setLastIteration(Exprs.LastIteration);
1800 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1801 Dir->setPreCond(Exprs.PreCond);
1802 Dir->setCond(Exprs.Cond);
1803 Dir->setInit(Exprs.Init);
1804 Dir->setInc(Exprs.Inc);
1805 Dir->setIsLastIterVariable(Exprs.IL);
1806 Dir->setLowerBoundVariable(Exprs.LB);
1807 Dir->setUpperBoundVariable(Exprs.UB);
1808 Dir->setStrideVariable(Exprs.ST);
1809 Dir->setEnsureUpperBound(Exprs.EUB);
1810 Dir->setNextLowerBound(Exprs.NLB);
1811 Dir->setNextUpperBound(Exprs.NUB);
1812 Dir->setNumIterations(Exprs.NumIterations);
1813 Dir->setCounters(Exprs.Counters);
1814 Dir->setPrivateCounters(Exprs.PrivateCounters);
1815 Dir->setInits(Exprs.Inits);
1816 Dir->setUpdates(Exprs.Updates);
1817 Dir->setFinals(Exprs.Finals);
1818 Dir->setDependentCounters(Exprs.DependentCounters);
1819 Dir->setDependentInits(Exprs.DependentInits);
1820 Dir->setFinalsConditions(Exprs.FinalsConditions);
1821 Dir->setPreInits(Exprs.PreInits);
1822 return Dir;
1823}
1824
1827 unsigned NumClauses,
1828 unsigned CollapsedNum, EmptyShell) {
1829 return createEmptyDirective<OMPDistributeSimdDirective>(
1830 C, NumClauses, /*HasAssociatedStmt=*/true,
1831 numLoopChildren(CollapsedNum, OMPD_distribute_simd), CollapsedNum);
1832}
1833
1835 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1836 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1837 const HelperExprs &Exprs) {
1838 auto *Dir = createDirective<OMPTargetParallelForSimdDirective>(
1839 C, Clauses, AssociatedStmt,
1840 numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd), StartLoc,
1841 EndLoc, CollapsedNum);
1842 Dir->setIterationVariable(Exprs.IterationVarRef);
1843 Dir->setLastIteration(Exprs.LastIteration);
1844 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1845 Dir->setPreCond(Exprs.PreCond);
1846 Dir->setCond(Exprs.Cond);
1847 Dir->setInit(Exprs.Init);
1848 Dir->setInc(Exprs.Inc);
1849 Dir->setIsLastIterVariable(Exprs.IL);
1850 Dir->setLowerBoundVariable(Exprs.LB);
1851 Dir->setUpperBoundVariable(Exprs.UB);
1852 Dir->setStrideVariable(Exprs.ST);
1853 Dir->setEnsureUpperBound(Exprs.EUB);
1854 Dir->setNextLowerBound(Exprs.NLB);
1855 Dir->setNextUpperBound(Exprs.NUB);
1856 Dir->setNumIterations(Exprs.NumIterations);
1857 Dir->setCounters(Exprs.Counters);
1858 Dir->setPrivateCounters(Exprs.PrivateCounters);
1859 Dir->setInits(Exprs.Inits);
1860 Dir->setUpdates(Exprs.Updates);
1861 Dir->setFinals(Exprs.Finals);
1862 Dir->setDependentCounters(Exprs.DependentCounters);
1863 Dir->setDependentInits(Exprs.DependentInits);
1864 Dir->setFinalsConditions(Exprs.FinalsConditions);
1865 Dir->setPreInits(Exprs.PreInits);
1866 return Dir;
1867}
1868
1871 unsigned NumClauses,
1872 unsigned CollapsedNum,
1873 EmptyShell) {
1874 return createEmptyDirective<OMPTargetParallelForSimdDirective>(
1875 C, NumClauses, /*HasAssociatedStmt=*/true,
1876 numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd),
1877 CollapsedNum);
1878}
1879
1882 SourceLocation EndLoc, unsigned CollapsedNum,
1883 ArrayRef<OMPClause *> Clauses,
1884 Stmt *AssociatedStmt, const HelperExprs &Exprs) {
1885 auto *Dir = createDirective<OMPTargetSimdDirective>(
1886 C, Clauses, AssociatedStmt,
1887 numLoopChildren(CollapsedNum, OMPD_target_simd), StartLoc, EndLoc,
1888 CollapsedNum);
1889 Dir->setIterationVariable(Exprs.IterationVarRef);
1890 Dir->setLastIteration(Exprs.LastIteration);
1891 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1892 Dir->setPreCond(Exprs.PreCond);
1893 Dir->setCond(Exprs.Cond);
1894 Dir->setInit(Exprs.Init);
1895 Dir->setInc(Exprs.Inc);
1896 Dir->setCounters(Exprs.Counters);
1897 Dir->setPrivateCounters(Exprs.PrivateCounters);
1898 Dir->setInits(Exprs.Inits);
1899 Dir->setUpdates(Exprs.Updates);
1900 Dir->setFinals(Exprs.Finals);
1901 Dir->setDependentCounters(Exprs.DependentCounters);
1902 Dir->setDependentInits(Exprs.DependentInits);
1903 Dir->setFinalsConditions(Exprs.FinalsConditions);
1904 Dir->setPreInits(Exprs.PreInits);
1905 return Dir;
1906}
1907
1910 unsigned CollapsedNum, EmptyShell) {
1911 return createEmptyDirective<OMPTargetSimdDirective>(
1912 C, NumClauses, /*HasAssociatedStmt=*/true,
1913 numLoopChildren(CollapsedNum, OMPD_target_simd), CollapsedNum);
1914}
1915
1917 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1918 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1919 const HelperExprs &Exprs) {
1920 auto *Dir = createDirective<OMPTeamsDistributeDirective>(
1921 C, Clauses, AssociatedStmt,
1922 numLoopChildren(CollapsedNum, OMPD_teams_distribute), StartLoc, EndLoc,
1923 CollapsedNum);
1924 Dir->setIterationVariable(Exprs.IterationVarRef);
1925 Dir->setLastIteration(Exprs.LastIteration);
1926 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1927 Dir->setPreCond(Exprs.PreCond);
1928 Dir->setCond(Exprs.Cond);
1929 Dir->setInit(Exprs.Init);
1930 Dir->setInc(Exprs.Inc);
1931 Dir->setIsLastIterVariable(Exprs.IL);
1932 Dir->setLowerBoundVariable(Exprs.LB);
1933 Dir->setUpperBoundVariable(Exprs.UB);
1934 Dir->setStrideVariable(Exprs.ST);
1935 Dir->setEnsureUpperBound(Exprs.EUB);
1936 Dir->setNextLowerBound(Exprs.NLB);
1937 Dir->setNextUpperBound(Exprs.NUB);
1938 Dir->setNumIterations(Exprs.NumIterations);
1939 Dir->setCounters(Exprs.Counters);
1940 Dir->setPrivateCounters(Exprs.PrivateCounters);
1941 Dir->setInits(Exprs.Inits);
1942 Dir->setUpdates(Exprs.Updates);
1943 Dir->setFinals(Exprs.Finals);
1944 Dir->setDependentCounters(Exprs.DependentCounters);
1945 Dir->setDependentInits(Exprs.DependentInits);
1946 Dir->setFinalsConditions(Exprs.FinalsConditions);
1947 Dir->setPreInits(Exprs.PreInits);
1948 return Dir;
1949}
1950
1953 unsigned NumClauses,
1954 unsigned CollapsedNum, EmptyShell) {
1955 return createEmptyDirective<OMPTeamsDistributeDirective>(
1956 C, NumClauses, /*HasAssociatedStmt=*/true,
1957 numLoopChildren(CollapsedNum, OMPD_teams_distribute), CollapsedNum);
1958}
1959
1961 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1962 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1963 const HelperExprs &Exprs) {
1964 auto *Dir = createDirective<OMPTeamsDistributeSimdDirective>(
1965 C, Clauses, AssociatedStmt,
1966 numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), StartLoc,
1967 EndLoc, CollapsedNum);
1968 Dir->setIterationVariable(Exprs.IterationVarRef);
1969 Dir->setLastIteration(Exprs.LastIteration);
1970 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1971 Dir->setPreCond(Exprs.PreCond);
1972 Dir->setCond(Exprs.Cond);
1973 Dir->setInit(Exprs.Init);
1974 Dir->setInc(Exprs.Inc);
1975 Dir->setIsLastIterVariable(Exprs.IL);
1976 Dir->setLowerBoundVariable(Exprs.LB);
1977 Dir->setUpperBoundVariable(Exprs.UB);
1978 Dir->setStrideVariable(Exprs.ST);
1979 Dir->setEnsureUpperBound(Exprs.EUB);
1980 Dir->setNextLowerBound(Exprs.NLB);
1981 Dir->setNextUpperBound(Exprs.NUB);
1982 Dir->setNumIterations(Exprs.NumIterations);
1983 Dir->setCounters(Exprs.Counters);
1984 Dir->setPrivateCounters(Exprs.PrivateCounters);
1985 Dir->setInits(Exprs.Inits);
1986 Dir->setUpdates(Exprs.Updates);
1987 Dir->setFinals(Exprs.Finals);
1988 Dir->setDependentCounters(Exprs.DependentCounters);
1989 Dir->setDependentInits(Exprs.DependentInits);
1990 Dir->setFinalsConditions(Exprs.FinalsConditions);
1991 Dir->setPreInits(Exprs.PreInits);
1992 return Dir;
1993}
1994
1996 const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
1997 EmptyShell) {
1998 return createEmptyDirective<OMPTeamsDistributeSimdDirective>(
1999 C, NumClauses, /*HasAssociatedStmt=*/true,
2000 numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), CollapsedNum);
2001}
2002
2005 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2006 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2007 const HelperExprs &Exprs) {
2008 auto *Dir = createDirective<OMPTeamsDistributeParallelForSimdDirective>(
2009 C, Clauses, AssociatedStmt,
2010 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd),
2011 StartLoc, EndLoc, CollapsedNum);
2012 Dir->setIterationVariable(Exprs.IterationVarRef);
2013 Dir->setLastIteration(Exprs.LastIteration);
2014 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2015 Dir->setPreCond(Exprs.PreCond);
2016 Dir->setCond(Exprs.Cond);
2017 Dir->setInit(Exprs.Init);
2018 Dir->setInc(Exprs.Inc);
2019 Dir->setIsLastIterVariable(Exprs.IL);
2020 Dir->setLowerBoundVariable(Exprs.LB);
2021 Dir->setUpperBoundVariable(Exprs.UB);
2022 Dir->setStrideVariable(Exprs.ST);
2023 Dir->setEnsureUpperBound(Exprs.EUB);
2024 Dir->setNextLowerBound(Exprs.NLB);
2025 Dir->setNextUpperBound(Exprs.NUB);
2026 Dir->setNumIterations(Exprs.NumIterations);
2027 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
2028 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
2029 Dir->setDistInc(Exprs.DistInc);
2030 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
2031 Dir->setCounters(Exprs.Counters);
2032 Dir->setPrivateCounters(Exprs.PrivateCounters);
2033 Dir->setInits(Exprs.Inits);
2034 Dir->setUpdates(Exprs.Updates);
2035 Dir->setFinals(Exprs.Finals);
2036 Dir->setDependentCounters(Exprs.DependentCounters);
2037 Dir->setDependentInits(Exprs.DependentInits);
2038 Dir->setFinalsConditions(Exprs.FinalsConditions);
2039 Dir->setPreInits(Exprs.PreInits);
2040 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
2041 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
2042 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
2043 Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
2044 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
2045 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
2046 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
2047 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
2048 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
2049 return Dir;
2050}
2051
2054 unsigned NumClauses,
2055 unsigned CollapsedNum,
2056 EmptyShell) {
2057 return createEmptyDirective<OMPTeamsDistributeParallelForSimdDirective>(
2058 C, NumClauses, /*HasAssociatedStmt=*/true,
2059 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd),
2060 CollapsedNum);
2061}
2062
2065 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2066 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2067 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
2068 auto *Dir = createDirective<OMPTeamsDistributeParallelForDirective>(
2069 C, Clauses, AssociatedStmt,
2070 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1,
2071 StartLoc, EndLoc, CollapsedNum);
2072 Dir->setIterationVariable(Exprs.IterationVarRef);
2073 Dir->setLastIteration(Exprs.LastIteration);
2074 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2075 Dir->setPreCond(Exprs.PreCond);
2076 Dir->setCond(Exprs.Cond);
2077 Dir->setInit(Exprs.Init);
2078 Dir->setInc(Exprs.Inc);
2079 Dir->setIsLastIterVariable(Exprs.IL);
2080 Dir->setLowerBoundVariable(Exprs.LB);
2081 Dir->setUpperBoundVariable(Exprs.UB);
2082 Dir->setStrideVariable(Exprs.ST);
2083 Dir->setEnsureUpperBound(Exprs.EUB);
2084 Dir->setNextLowerBound(Exprs.NLB);
2085 Dir->setNextUpperBound(Exprs.NUB);
2086 Dir->setNumIterations(Exprs.NumIterations);
2087 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
2088 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
2089 Dir->setDistInc(Exprs.DistInc);
2090 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
2091 Dir->setCounters(Exprs.Counters);
2092 Dir->setPrivateCounters(Exprs.PrivateCounters);
2093 Dir->setInits(Exprs.Inits);
2094 Dir->setUpdates(Exprs.Updates);
2095 Dir->setFinals(Exprs.Finals);
2096 Dir->setDependentCounters(Exprs.DependentCounters);
2097 Dir->setDependentInits(Exprs.DependentInits);
2098 Dir->setFinalsConditions(Exprs.FinalsConditions);
2099 Dir->setPreInits(Exprs.PreInits);
2100 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
2101 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
2102 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
2103 Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
2104 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
2105 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
2106 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
2107 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
2108 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
2109 Dir->setTaskReductionRefExpr(TaskRedRef);
2110 Dir->HasCancel = HasCancel;
2111 return Dir;
2112}
2113
2116 unsigned NumClauses,
2117 unsigned CollapsedNum,
2118 EmptyShell) {
2119 return createEmptyDirective<OMPTeamsDistributeParallelForDirective>(
2120 C, NumClauses, /*HasAssociatedStmt=*/true,
2121 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1,
2122 CollapsedNum);
2123}
2124
2126 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2127 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
2128 return createDirective<OMPTargetTeamsDirective>(C, Clauses, AssociatedStmt,
2129 /*NumChildren=*/0, StartLoc,
2130 EndLoc);
2131}
2132
2135 EmptyShell) {
2136 return createEmptyDirective<OMPTargetTeamsDirective>(
2137 C, NumClauses, /*HasAssociatedStmt=*/true);
2138}
2139
2141 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2142 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2143 const HelperExprs &Exprs) {
2144 auto *Dir = createDirective<OMPTargetTeamsDistributeDirective>(
2145 C, Clauses, AssociatedStmt,
2146 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute), StartLoc,
2147 EndLoc, CollapsedNum);
2148 Dir->setIterationVariable(Exprs.IterationVarRef);
2149 Dir->setLastIteration(Exprs.LastIteration);
2150 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2151 Dir->setPreCond(Exprs.PreCond);
2152 Dir->setCond(Exprs.Cond);
2153 Dir->setInit(Exprs.Init);
2154 Dir->setInc(Exprs.Inc);
2155 Dir->setIsLastIterVariable(Exprs.IL);
2156 Dir->setLowerBoundVariable(Exprs.LB);
2157 Dir->setUpperBoundVariable(Exprs.UB);
2158 Dir->setStrideVariable(Exprs.ST);
2159 Dir->setEnsureUpperBound(Exprs.EUB);
2160 Dir->setNextLowerBound(Exprs.NLB);
2161 Dir->setNextUpperBound(Exprs.NUB);
2162 Dir->setNumIterations(Exprs.NumIterations);
2163 Dir->setCounters(Exprs.Counters);
2164 Dir->setPrivateCounters(Exprs.PrivateCounters);
2165 Dir->setInits(Exprs.Inits);
2166 Dir->setUpdates(Exprs.Updates);
2167 Dir->setFinals(Exprs.Finals);
2168 Dir->setDependentCounters(Exprs.DependentCounters);
2169 Dir->setDependentInits(Exprs.DependentInits);
2170 Dir->setFinalsConditions(Exprs.FinalsConditions);
2171 Dir->setPreInits(Exprs.PreInits);
2172 return Dir;
2173}
2174
2177 unsigned NumClauses,
2178 unsigned CollapsedNum,
2179 EmptyShell) {
2180 return createEmptyDirective<OMPTargetTeamsDistributeDirective>(
2181 C, NumClauses, /*HasAssociatedStmt=*/true,
2182 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute),
2183 CollapsedNum);
2184}
2185
2188 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2189 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2190 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
2191 auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForDirective>(
2192 C, Clauses, AssociatedStmt,
2193 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) +
2194 1,
2195 StartLoc, EndLoc, CollapsedNum);
2196 Dir->setIterationVariable(Exprs.IterationVarRef);
2197 Dir->setLastIteration(Exprs.LastIteration);
2198 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2199 Dir->setPreCond(Exprs.PreCond);
2200 Dir->setCond(Exprs.Cond);
2201 Dir->setInit(Exprs.Init);
2202 Dir->setInc(Exprs.Inc);
2203 Dir->setIsLastIterVariable(Exprs.IL);
2204 Dir->setLowerBoundVariable(Exprs.LB);
2205 Dir->setUpperBoundVariable(Exprs.UB);
2206 Dir->setStrideVariable(Exprs.ST);
2207 Dir->setEnsureUpperBound(Exprs.EUB);
2208 Dir->setNextLowerBound(Exprs.NLB);
2209 Dir->setNextUpperBound(Exprs.NUB);
2210 Dir->setNumIterations(Exprs.NumIterations);
2211 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
2212 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
2213 Dir->setDistInc(Exprs.DistInc);
2214 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
2215 Dir->setCounters(Exprs.Counters);
2216 Dir->setPrivateCounters(Exprs.PrivateCounters);
2217 Dir->setInits(Exprs.Inits);
2218 Dir->setUpdates(Exprs.Updates);
2219 Dir->setFinals(Exprs.Finals);
2220 Dir->setDependentCounters(Exprs.DependentCounters);
2221 Dir->setDependentInits(Exprs.DependentInits);
2222 Dir->setFinalsConditions(Exprs.FinalsConditions);
2223 Dir->setPreInits(Exprs.PreInits);
2224 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
2225 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
2226 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
2227 Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
2228 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
2229 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
2230 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
2231 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
2232 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
2233 Dir->setTaskReductionRefExpr(TaskRedRef);
2234 Dir->HasCancel = HasCancel;
2235 return Dir;
2236}
2237
2240 unsigned NumClauses,
2241 unsigned CollapsedNum,
2242 EmptyShell) {
2243 return createEmptyDirective<OMPTargetTeamsDistributeParallelForDirective>(
2244 C, NumClauses, /*HasAssociatedStmt=*/true,
2245 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) +
2246 1,
2247 CollapsedNum);
2248}
2249
2252 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2253 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2254 const HelperExprs &Exprs) {
2255 auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
2256 C, Clauses, AssociatedStmt,
2257 numLoopChildren(CollapsedNum,
2258 OMPD_target_teams_distribute_parallel_for_simd),
2259 StartLoc, EndLoc, CollapsedNum);
2260 Dir->setIterationVariable(Exprs.IterationVarRef);
2261 Dir->setLastIteration(Exprs.LastIteration);
2262 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2263 Dir->setPreCond(Exprs.PreCond);
2264 Dir->setCond(Exprs.Cond);
2265 Dir->setInit(Exprs.Init);
2266 Dir->setInc(Exprs.Inc);
2267 Dir->setIsLastIterVariable(Exprs.IL);
2268 Dir->setLowerBoundVariable(Exprs.LB);
2269 Dir->setUpperBoundVariable(Exprs.UB);
2270 Dir->setStrideVariable(Exprs.ST);
2271 Dir->setEnsureUpperBound(Exprs.EUB);
2272 Dir->setNextLowerBound(Exprs.NLB);
2273 Dir->setNextUpperBound(Exprs.NUB);
2274 Dir->setNumIterations(Exprs.NumIterations);
2275 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
2276 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
2277 Dir->setDistInc(Exprs.DistInc);
2278 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
2279 Dir->setCounters(Exprs.Counters);
2280 Dir->setPrivateCounters(Exprs.PrivateCounters);
2281 Dir->setInits(Exprs.Inits);
2282 Dir->setUpdates(Exprs.Updates);
2283 Dir->setFinals(Exprs.Finals);
2284 Dir->setDependentCounters(Exprs.DependentCounters);
2285 Dir->setDependentInits(Exprs.DependentInits);
2286 Dir->setFinalsConditions(Exprs.FinalsConditions);
2287 Dir->setPreInits(Exprs.PreInits);
2288 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
2289 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
2290 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
2291 Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
2292 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
2293 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
2294 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
2295 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
2296 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
2297 return Dir;
2298}
2299
2302 const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
2303 EmptyShell) {
2304 return createEmptyDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
2305 C, NumClauses, /*HasAssociatedStmt=*/true,
2306 numLoopChildren(CollapsedNum,
2307 OMPD_target_teams_distribute_parallel_for_simd),
2308 CollapsedNum);
2309}
2310
2313 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2314 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2315 const HelperExprs &Exprs) {
2316 auto *Dir = createDirective<OMPTargetTeamsDistributeSimdDirective>(
2317 C, Clauses, AssociatedStmt,
2318 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd),
2319 StartLoc, EndLoc, CollapsedNum);
2320 Dir->setIterationVariable(Exprs.IterationVarRef);
2321 Dir->setLastIteration(Exprs.LastIteration);
2322 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2323 Dir->setPreCond(Exprs.PreCond);
2324 Dir->setCond(Exprs.Cond);
2325 Dir->setInit(Exprs.Init);
2326 Dir->setInc(Exprs.Inc);
2327 Dir->setIsLastIterVariable(Exprs.IL);
2328 Dir->setLowerBoundVariable(Exprs.LB);
2329 Dir->setUpperBoundVariable(Exprs.UB);
2330 Dir->setStrideVariable(Exprs.ST);
2331 Dir->setEnsureUpperBound(Exprs.EUB);
2332 Dir->setNextLowerBound(Exprs.NLB);
2333 Dir->setNextUpperBound(Exprs.NUB);
2334 Dir->setNumIterations(Exprs.NumIterations);
2335 Dir->setCounters(Exprs.Counters);
2336 Dir->setPrivateCounters(Exprs.PrivateCounters);
2337 Dir->setInits(Exprs.Inits);
2338 Dir->setUpdates(Exprs.Updates);
2339 Dir->setFinals(Exprs.Finals);
2340 Dir->setDependentCounters(Exprs.DependentCounters);
2341 Dir->setDependentInits(Exprs.DependentInits);
2342 Dir->setFinalsConditions(Exprs.FinalsConditions);
2343 Dir->setPreInits(Exprs.PreInits);
2344 return Dir;
2345}
2346
2349 unsigned NumClauses,
2350 unsigned CollapsedNum,
2351 EmptyShell) {
2352 return createEmptyDirective<OMPTargetTeamsDistributeSimdDirective>(
2353 C, NumClauses, /*HasAssociatedStmt=*/true,
2354 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd),
2355 CollapsedNum);
2356}
2357
2360 SourceLocation EndLoc,
2361 ArrayRef<OMPClause *> Clauses) {
2362 return createDirective<OMPInteropDirective>(
2363 C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc,
2364 EndLoc);
2365}
2366
2368 unsigned NumClauses,
2369 EmptyShell) {
2370 return createEmptyDirective<OMPInteropDirective>(C, NumClauses);
2371}
2372
2374 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2375 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2376 SourceLocation TargetCallLoc) {
2377 auto *Dir = createDirective<OMPDispatchDirective>(
2378 C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
2379 Dir->setTargetCallLoc(TargetCallLoc);
2380 return Dir;
2381}
2382
2384 unsigned NumClauses,
2385 EmptyShell) {
2386 return createEmptyDirective<OMPDispatchDirective>(C, NumClauses,
2387 /*HasAssociatedStmt=*/true,
2388 /*NumChildren=*/0);
2389}
2390
2392 SourceLocation StartLoc,
2393 SourceLocation EndLoc,
2394 ArrayRef<OMPClause *> Clauses,
2395 Stmt *AssociatedStmt) {
2396 return createDirective<OMPMaskedDirective>(C, Clauses, AssociatedStmt,
2397 /*NumChildren=*/0, StartLoc,
2398 EndLoc);
2399}
2400
2402 unsigned NumClauses,
2403 EmptyShell) {
2404 return createEmptyDirective<OMPMaskedDirective>(C, NumClauses,
2405 /*HasAssociatedStmt=*/true);
2406}
2407
2409 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2410 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2411 const HelperExprs &Exprs) {
2412 auto *Dir = createDirective<OMPGenericLoopDirective>(
2413 C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_loop),
2414 StartLoc, EndLoc, CollapsedNum);
2415 Dir->setIterationVariable(Exprs.IterationVarRef);
2416 Dir->setLastIteration(Exprs.LastIteration);
2417 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2418 Dir->setPreCond(Exprs.PreCond);
2419 Dir->setCond(Exprs.Cond);
2420 Dir->setInit(Exprs.Init);
2421 Dir->setInc(Exprs.Inc);
2422 Dir->setIsLastIterVariable(Exprs.IL);
2423 Dir->setLowerBoundVariable(Exprs.LB);
2424 Dir->setUpperBoundVariable(Exprs.UB);
2425 Dir->setStrideVariable(Exprs.ST);
2426 Dir->setEnsureUpperBound(Exprs.EUB);
2427 Dir->setNextLowerBound(Exprs.NLB);
2428 Dir->setNextUpperBound(Exprs.NUB);
2429 Dir->setNumIterations(Exprs.NumIterations);
2430 Dir->setCounters(Exprs.Counters);
2431 Dir->setPrivateCounters(Exprs.PrivateCounters);
2432 Dir->setInits(Exprs.Inits);
2433 Dir->setUpdates(Exprs.Updates);
2434 Dir->setFinals(Exprs.Finals);
2435 Dir->setDependentCounters(Exprs.DependentCounters);
2436 Dir->setDependentInits(Exprs.DependentInits);
2437 Dir->setFinalsConditions(Exprs.FinalsConditions);
2438 Dir->setPreInits(Exprs.PreInits);
2439 return Dir;
2440}
2441
2444 unsigned CollapsedNum, EmptyShell) {
2445 return createEmptyDirective<OMPGenericLoopDirective>(
2446 C, NumClauses, /*HasAssociatedStmt=*/true,
2447 numLoopChildren(CollapsedNum, OMPD_loop), CollapsedNum);
2448}
2449
2451 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2452 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2453 const HelperExprs &Exprs) {
2454 auto *Dir = createDirective<OMPTeamsGenericLoopDirective>(
2455 C, Clauses, AssociatedStmt,
2456 numLoopChildren(CollapsedNum, OMPD_teams_loop), StartLoc, EndLoc,
2457 CollapsedNum);
2458 Dir->setIterationVariable(Exprs.IterationVarRef);
2459 Dir->setLastIteration(Exprs.LastIteration);
2460 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2461 Dir->setPreCond(Exprs.PreCond);
2462 Dir->setCond(Exprs.Cond);
2463 Dir->setInit(Exprs.Init);
2464 Dir->setInc(Exprs.Inc);
2465 Dir->setIsLastIterVariable(Exprs.IL);
2466 Dir->setLowerBoundVariable(Exprs.LB);
2467 Dir->setUpperBoundVariable(Exprs.UB);
2468 Dir->setStrideVariable(Exprs.ST);
2469 Dir->setEnsureUpperBound(Exprs.EUB);
2470 Dir->setNextLowerBound(Exprs.NLB);
2471 Dir->setNextUpperBound(Exprs.NUB);
2472 Dir->setNumIterations(Exprs.NumIterations);
2473 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
2474 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
2475 Dir->setDistInc(Exprs.DistInc);
2476 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
2477 Dir->setCounters(Exprs.Counters);
2478 Dir->setPrivateCounters(Exprs.PrivateCounters);
2479 Dir->setInits(Exprs.Inits);
2480 Dir->setUpdates(Exprs.Updates);
2481 Dir->setFinals(Exprs.Finals);
2482 Dir->setDependentCounters(Exprs.DependentCounters);
2483 Dir->setDependentInits(Exprs.DependentInits);
2484 Dir->setFinalsConditions(Exprs.FinalsConditions);
2485 Dir->setPreInits(Exprs.PreInits);
2486 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
2487 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
2488 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
2489 Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
2490 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
2491 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
2492 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
2493 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
2494 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
2495 return Dir;
2496}
2497
2500 unsigned NumClauses,
2501 unsigned CollapsedNum, EmptyShell) {
2502 return createEmptyDirective<OMPTeamsGenericLoopDirective>(
2503 C, NumClauses, /*HasAssociatedStmt=*/true,
2504 numLoopChildren(CollapsedNum, OMPD_teams_loop), CollapsedNum);
2505}
2506
2508 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2509 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2510 const HelperExprs &Exprs, bool CanBeParallelFor) {
2511 auto *Dir = createDirective<OMPTargetTeamsGenericLoopDirective>(
2512 C, Clauses, AssociatedStmt,
2513 numLoopChildren(CollapsedNum, OMPD_target_teams_loop), StartLoc, EndLoc,
2514 CollapsedNum);
2515 Dir->setIterationVariable(Exprs.IterationVarRef);
2516 Dir->setLastIteration(Exprs.LastIteration);
2517 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2518 Dir->setPreCond(Exprs.PreCond);
2519 Dir->setCond(Exprs.Cond);
2520 Dir->setInit(Exprs.Init);
2521 Dir->setInc(Exprs.Inc);
2522 Dir->setIsLastIterVariable(Exprs.IL);
2523 Dir->setLowerBoundVariable(Exprs.LB);
2524 Dir->setUpperBoundVariable(Exprs.UB);
2525 Dir->setStrideVariable(Exprs.ST);
2526 Dir->setEnsureUpperBound(Exprs.EUB);
2527 Dir->setNextLowerBound(Exprs.NLB);
2528 Dir->setNextUpperBound(Exprs.NUB);
2529 Dir->setNumIterations(Exprs.NumIterations);
2530 Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
2531 Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
2532 Dir->setDistInc(Exprs.DistInc);
2533 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
2534 Dir->setCounters(Exprs.Counters);
2535 Dir->setPrivateCounters(Exprs.PrivateCounters);
2536 Dir->setInits(Exprs.Inits);
2537 Dir->setUpdates(Exprs.Updates);
2538 Dir->setFinals(Exprs.Finals);
2539 Dir->setDependentCounters(Exprs.DependentCounters);
2540 Dir->setDependentInits(Exprs.DependentInits);
2541 Dir->setFinalsConditions(Exprs.FinalsConditions);
2542 Dir->setPreInits(Exprs.PreInits);
2543 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
2544 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
2545 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
2546 Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
2547 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
2548 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
2549 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
2550 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
2551 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
2552 Dir->setCanBeParallelFor(CanBeParallelFor);
2553 return Dir;
2554}
2555
2558 unsigned NumClauses,
2559 unsigned CollapsedNum,
2560 EmptyShell) {
2561 return createEmptyDirective<OMPTargetTeamsGenericLoopDirective>(
2562 C, NumClauses, /*HasAssociatedStmt=*/true,
2563 numLoopChildren(CollapsedNum, OMPD_target_teams_loop), CollapsedNum);
2564}
2565
2567 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2568 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2569 const HelperExprs &Exprs) {
2570 auto *Dir = createDirective<OMPParallelGenericLoopDirective>(
2571 C, Clauses, AssociatedStmt,
2572 numLoopChildren(CollapsedNum, OMPD_parallel_loop), StartLoc, EndLoc,
2573 CollapsedNum);
2574 Dir->setIterationVariable(Exprs.IterationVarRef);
2575 Dir->setLastIteration(Exprs.LastIteration);
2576 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2577 Dir->setPreCond(Exprs.PreCond);
2578 Dir->setCond(Exprs.Cond);
2579 Dir->setInit(Exprs.Init);
2580 Dir->setInc(Exprs.Inc);
2581 Dir->setIsLastIterVariable(Exprs.IL);
2582 Dir->setLowerBoundVariable(Exprs.LB);
2583 Dir->setUpperBoundVariable(Exprs.UB);
2584 Dir->setStrideVariable(Exprs.ST);
2585 Dir->setEnsureUpperBound(Exprs.EUB);
2586 Dir->setNextLowerBound(Exprs.NLB);
2587 Dir->setNextUpperBound(Exprs.NUB);
2588 Dir->setNumIterations(Exprs.NumIterations);
2589 Dir->setCounters(Exprs.Counters);
2590 Dir->setPrivateCounters(Exprs.PrivateCounters);
2591 Dir->setInits(Exprs.Inits);
2592 Dir->setUpdates(Exprs.Updates);
2593 Dir->setFinals(Exprs.Finals);
2594 Dir->setDependentCounters(Exprs.DependentCounters);
2595 Dir->setDependentInits(Exprs.DependentInits);
2596 Dir->setFinalsConditions(Exprs.FinalsConditions);
2597 Dir->setPreInits(Exprs.PreInits);
2598 return Dir;
2599}
2600
2602 const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
2603 EmptyShell) {
2604 return createEmptyDirective<OMPParallelGenericLoopDirective>(
2605 C, NumClauses, /*HasAssociatedStmt=*/true,
2606 numLoopChildren(CollapsedNum, OMPD_parallel_loop), CollapsedNum);
2607}
2608
2611 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2612 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2613 const HelperExprs &Exprs) {
2614 auto *Dir = createDirective<OMPTargetParallelGenericLoopDirective>(
2615 C, Clauses, AssociatedStmt,
2616 numLoopChildren(CollapsedNum, OMPD_target_parallel_loop), StartLoc,
2617 EndLoc, CollapsedNum);
2618 Dir->setIterationVariable(Exprs.IterationVarRef);
2619 Dir->setLastIteration(Exprs.LastIteration);
2620 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2621 Dir->setPreCond(Exprs.PreCond);
2622 Dir->setCond(Exprs.Cond);
2623 Dir->setInit(Exprs.Init);
2624 Dir->setInc(Exprs.Inc);
2625 Dir->setIsLastIterVariable(Exprs.IL);
2626 Dir->setLowerBoundVariable(Exprs.LB);
2627 Dir->setUpperBoundVariable(Exprs.UB);
2628 Dir->setStrideVariable(Exprs.ST);
2629 Dir->setEnsureUpperBound(Exprs.EUB);
2630 Dir->setNextLowerBound(Exprs.NLB);
2631 Dir->setNextUpperBound(Exprs.NUB);
2632 Dir->setNumIterations(Exprs.NumIterations);
2633 Dir->setCounters(Exprs.Counters);
2634 Dir->setPrivateCounters(Exprs.PrivateCounters);
2635 Dir->setInits(Exprs.Inits);
2636 Dir->setUpdates(Exprs.Updates);
2637 Dir->setFinals(Exprs.Finals);
2638 Dir->setDependentCounters(Exprs.DependentCounters);
2639 Dir->setDependentInits(Exprs.DependentInits);
2640 Dir->setFinalsConditions(Exprs.FinalsConditions);
2641 Dir->setPreInits(Exprs.PreInits);
2642 return Dir;
2643}
2644
2647 unsigned NumClauses,
2648 unsigned CollapsedNum,
2649 EmptyShell) {
2650 return createEmptyDirective<OMPTargetParallelGenericLoopDirective>(
2651 C, NumClauses, /*HasAssociatedStmt=*/true,
2652 numLoopChildren(CollapsedNum, OMPD_target_parallel_loop), CollapsedNum);
2653}
Defines the clang::ASTContext interface.
This file defines OpenMP AST classes for executable directives and clauses.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:188
This represents one expression.
Definition: Expr.h:112
IfStmt - This represents an if/then/else.
Definition: Stmt.h:2259
static OMPAssumeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Definition: StmtOpenMP.cpp:835
static OMPAssumeDirective * Create(const ASTContext &Ctx, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AStmt)
Definition: StmtOpenMP.cpp:825
This represents '#pragma omp atomic' directive.
Definition: StmtOpenMP.h:2947
static OMPAtomicDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPAtomicDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expressions Exprs)
Creates directive with a list of Clauses and 'x', 'v' and 'expr' parts of the atomic construct (see S...
Definition: StmtOpenMP.cpp:993
This represents '#pragma omp barrier' directive.
Definition: StmtOpenMP.h:2625
static OMPBarrierDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Creates directive.
Definition: StmtOpenMP.cpp:857
static OMPBarrierDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:863
This represents '#pragma omp cancel' directive.
Definition: StmtOpenMP.h:3655
static OMPCancelDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, OpenMPDirectiveKind CancelRegion)
Creates directive.
Definition: StmtOpenMP.cpp:913
static OMPCancelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:923
This represents '#pragma omp cancellation point' directive.
Definition: StmtOpenMP.h:3597
static OMPCancellationPointDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:908
static OMPCancellationPointDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, OpenMPDirectiveKind CancelRegion)
Creates directive.
Definition: StmtOpenMP.cpp:899
Contains data for OpenMP directives: clauses, children expressions/statements (helpers for codegen) a...
void setClauses(ArrayRef< OMPClause * > Clauses)
Sets the list of variables for this clause.
Definition: StmtOpenMP.cpp:27
MutableArrayRef< Stmt * > getChildren()
Definition: StmtOpenMP.cpp:33
This represents '#pragma omp critical' directive.
Definition: StmtOpenMP.h:2076
static OMPCriticalDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:651
static OMPCriticalDirective * Create(const ASTContext &C, const DeclarationNameInfo &Name, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive.
Definition: StmtOpenMP.cpp:642
This represents '#pragma omp depobj' directive.
Definition: StmtOpenMP.h:2841
static OMPDepobjDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:953
static OMPDepobjDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:944
This represents '#pragma omp dispatch' directive.
Definition: StmtOpenMP.h:6030
static OMPDispatchDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, SourceLocation TargetCallLoc)
Creates directive with a list of Clauses.
static OMPDispatchDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp distribute' directive.
Definition: StmtOpenMP.h:4425
static OMPDistributeDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp distribute parallel for' composite directive.
Definition: StmtOpenMP.h:4547
static OMPDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPDistributeParallelForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
This represents '#pragma omp distribute parallel for simd' composite directive.
Definition: StmtOpenMP.h:4643
static OMPDistributeParallelForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp distribute simd' composite directive.
Definition: StmtOpenMP.h:4708
static OMPDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPDistributeSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents '#pragma omp error' directive.
Definition: StmtOpenMP.h:6514
static OMPErrorDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Definition: StmtOpenMP.cpp:842
static OMPErrorDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:851
bool hasAssociatedStmt() const
Returns true if directive has associated statement.
Definition: StmtOpenMP.h:517
const Stmt * getRawStmt() const
Definition: StmtOpenMP.h:592
OMPChildren * Data
Data, associated with the directive.
Definition: StmtOpenMP.h:286
const Stmt * getStructuredBlock() const
Returns the AST node representing OpenMP structured-block of this OpenMP executable directive,...
Definition: StmtOpenMP.h:587
bool isStandaloneDirective() const
Returns whether or not this is a Standalone directive.
Definition: StmtOpenMP.cpp:58
This represents '#pragma omp flush' directive.
Definition: StmtOpenMP.h:2789
static OMPFlushDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:938
static OMPFlushDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:929
This represents '#pragma omp for' directive.
Definition: StmtOpenMP.h:1634
static OMPForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:336
static OMPForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:398
This represents '#pragma omp for simd' directive.
Definition: StmtOpenMP.h:1724
static OMPForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:546
static OMPForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:512
This represents '#pragma omp loop' directive.
Definition: StmtOpenMP.h:6185
static OMPGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with a place for NumClauses clauses.
static OMPGenericLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
Represents the '#pragma omp interchange' loop transformation directive.
Definition: StmtOpenMP.h:5851
static OMPInterchangeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned NumLoops)
Build an empty '#pragma omp interchange' AST node for deserialization.
Definition: StmtOpenMP.cpp:504
static OMPInterchangeDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, unsigned NumLoops, Stmt *AssociatedStmt, Stmt *TransformedStmt, Stmt *PreInits)
Create a new AST node representation for '#pragma omp interchange'.
Definition: StmtOpenMP.cpp:491
This represents '#pragma omp interop' directive.
Definition: StmtOpenMP.h:5977
static OMPInteropDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
static OMPInteropDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive.
static void doForAllLoopsBodies(Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops, llvm::function_ref< void(unsigned, Stmt *, Stmt *)> Callback)
Calls the specified callback function for all the loop bodies in CurStmt, from the outermost loop to ...
Definition: StmtOpenMP.cpp:179
unsigned NumAssociatedLoops
Number of collapsed loops as specified by 'collapse' clause.
Definition: StmtOpenMP.h:687
static Stmt * tryToFindNextInnerLoop(Stmt *CurStmt, bool TryImperfectlyNestedLoops)
Try to find the next loop sub-statement in the specified statement CurStmt.
Definition: StmtOpenMP.cpp:78
static bool doForAllLoops(Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops, llvm::function_ref< bool(unsigned, Stmt *)> Callback, llvm::function_ref< void(OMPLoopTransformationDirective *)> OnTransformationCallback)
Calls the specified callback function for all the loops in CurStmt, from the outermost to the innermo...
Definition: StmtOpenMP.cpp:125
unsigned getLoopsNumber() const
Get number of collapsed loops.
Definition: StmtOpenMP.h:876
void setFinals(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:237
void setDependentCounters(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:243
void setFinalsConditions(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:256
void setInits(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:225
static unsigned numLoopChildren(unsigned CollapsedNum, OpenMPDirectiveKind Kind)
Children number.
Definition: StmtOpenMP.h:1155
void setCounters(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:212
void setDependentInits(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:250
void setUpdates(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:231
void setPrivateCounters(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:218
The base class for all loop transformation directives.
Definition: StmtOpenMP.h:959
Stmt * getPreInits() const
Return preinits statement.
Definition: StmtOpenMP.cpp:385
Stmt * getTransformedStmt() const
Get the de-sugared statements after the loop transformation.
Definition: StmtOpenMP.cpp:372
This represents '#pragma omp masked' directive.
Definition: StmtOpenMP.h:6095
static OMPMaskedDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
static OMPMaskedDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive.
This represents '#pragma omp masked taskloop' directive.
Definition: StmtOpenMP.h:3930
static OMPMaskedTaskLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel)
Creates directive with a list of Clauses.
static OMPMaskedTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp masked taskloop simd' directive.
Definition: StmtOpenMP.h:4071
static OMPMaskedTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPMaskedTaskLoopSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents '#pragma omp master' directive.
Definition: StmtOpenMP.h:2028
static OMPMasterDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt)
Creates directive.
Definition: StmtOpenMP.cpp:627
static OMPMasterDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:636
This represents '#pragma omp master taskloop' directive.
Definition: StmtOpenMP.h:3854
static OMPMasterTaskLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel)
Creates directive with a list of Clauses.
static OMPMasterTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp master taskloop simd' directive.
Definition: StmtOpenMP.h:4006
static OMPMasterTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPMasterTaskLoopSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents '#pragma omp metadirective' directive.
Definition: StmtOpenMP.h:6146
static OMPMetaDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Definition: StmtOpenMP.cpp:273
static OMPMetaDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Stmt *IfStmt)
Definition: StmtOpenMP.cpp:262
This represents '#pragma omp ordered' directive.
Definition: StmtOpenMP.h:2893
static OMPOrderedDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive.
Definition: StmtOpenMP.cpp:974
static OMPOrderedDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, bool IsStandalone, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:984
This represents '#pragma omp parallel' directive.
Definition: StmtOpenMP.h:611
static OMPParallelDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:281
static OMPParallelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:292
This represents '#pragma omp parallel for' directive.
Definition: StmtOpenMP.h:2147
static OMPParallelForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:658
static OMPParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:696
This represents '#pragma omp parallel for simd' directive.
Definition: StmtOpenMP.h:2244
static OMPParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:739
static OMPParallelForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:703
This represents '#pragma omp parallel loop' directive.
Definition: StmtOpenMP.h:6387
static OMPParallelGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPParallelGenericLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents '#pragma omp parallel masked' directive.
Definition: StmtOpenMP.h:2372
static OMPParallelMaskedDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:773
static OMPParallelMaskedDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:763
This represents '#pragma omp parallel masked taskloop' directive.
Definition: StmtOpenMP.h:4215
static OMPParallelMaskedTaskLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel)
Creates directive with a list of Clauses.
static OMPParallelMaskedTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp parallel masked taskloop simd' directive.
Definition: StmtOpenMP.h:4360
static OMPParallelMaskedTaskLoopSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPParallelMaskedTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp parallel master' directive.
Definition: StmtOpenMP.h:2309
static OMPParallelMasterDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:747
static OMPParallelMasterDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:757
This represents '#pragma omp parallel master taskloop' directive.
Definition: StmtOpenMP.h:4137
static OMPParallelMasterTaskLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel)
Creates directive with a list of Clauses.
static OMPParallelMasterTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp parallel master taskloop simd' directive.
Definition: StmtOpenMP.h:4293
static OMPParallelMasterTaskLoopSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPParallelMasterTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp parallel sections' directive.
Definition: StmtOpenMP.h:2436
static OMPParallelSectionsDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:779
static OMPParallelSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:791
Represents the '#pragma omp reverse' loop transformation directive.
Definition: StmtOpenMP.h:5779
static OMPReverseDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt, unsigned NumLoops, Stmt *TransformedStmt, Stmt *PreInits)
Create a new AST node representation for '#pragma omp reverse'.
Definition: StmtOpenMP.cpp:472
static OMPReverseDirective * CreateEmpty(const ASTContext &C, unsigned NumLoops)
Build an empty '#pragma omp reverse' AST node for deserialization.
Definition: StmtOpenMP.cpp:484
This represents '#pragma omp scan' directive.
Definition: StmtOpenMP.h:5924
static OMPScanDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:968
static OMPScanDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:959
This represents '#pragma omp scope' directive.
Definition: StmtOpenMP.h:1925
static OMPScopeDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive.
Definition: StmtOpenMP.cpp:593
static OMPScopeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:603
This represents '#pragma omp section' directive.
Definition: StmtOpenMP.h:1864
static OMPSectionDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:587
void setHasCancel(bool Has)
Set cancel state.
Definition: StmtOpenMP.h:1908
static OMPSectionDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt, bool HasCancel)
Creates directive.
Definition: StmtOpenMP.cpp:575
This represents '#pragma omp sections' directive.
Definition: StmtOpenMP.h:1787
static OMPSectionsDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:555
static OMPSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:567
This represents '#pragma omp simd' directive.
Definition: StmtOpenMP.h:1571
static OMPSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:301
static OMPSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:327
This represents '#pragma omp single' directive.
Definition: StmtOpenMP.h:1977
static OMPSingleDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:610
static OMPSingleDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:620
This represents the '#pragma omp stripe' loop transformation directive.
Definition: StmtOpenMP.h:5625
static OMPStripeDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, unsigned NumLoops, Stmt *AssociatedStmt, Stmt *TransformedStmt, Stmt *PreInits)
Create a new AST node representation for '#pragma omp stripe'.
Definition: StmtOpenMP.cpp:429
static OMPStripeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned NumLoops)
Build an empty '#pragma omp stripe' AST node for deserialization.
Definition: StmtOpenMP.cpp:441
This represents '#pragma omp target data' directive.
Definition: StmtOpenMP.h:3206
static OMPTargetDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
static OMPTargetDataDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
This represents '#pragma omp target' directive.
Definition: StmtOpenMP.h:3152
static OMPTargetDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
static OMPTargetDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp target enter data' directive.
Definition: StmtOpenMP.h:3260
static OMPTargetEnterDataDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
static OMPTargetEnterDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
This represents '#pragma omp target exit data' directive.
Definition: StmtOpenMP.h:3315
static OMPTargetExitDataDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
static OMPTargetExitDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
This represents '#pragma omp target parallel' directive.
Definition: StmtOpenMP.h:3369
static OMPTargetParallelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTargetParallelDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
This represents '#pragma omp target parallel for' directive.
Definition: StmtOpenMP.h:3449
static OMPTargetParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTargetParallelForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
This represents '#pragma omp target parallel for simd' directive.
Definition: StmtOpenMP.h:4774
static OMPTargetParallelForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPTargetParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp target parallel loop' directive.
Definition: StmtOpenMP.h:6452
static OMPTargetParallelGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTargetParallelGenericLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents '#pragma omp target simd' directive.
Definition: StmtOpenMP.h:4841
static OMPTargetSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPTargetSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp target teams' directive.
Definition: StmtOpenMP.h:5199
static OMPTargetTeamsDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
static OMPTargetTeamsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp target teams distribute' combined directive.
Definition: StmtOpenMP.h:5255
static OMPTargetTeamsDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTargetTeamsDistributeDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents '#pragma omp target teams distribute parallel for' combined directive.
Definition: StmtOpenMP.h:5322
static OMPTargetTeamsDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTargetTeamsDistributeParallelForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
This represents '#pragma omp target teams distribute parallel for simd' combined directive.
Definition: StmtOpenMP.h:5420
static OMPTargetTeamsDistributeParallelForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPTargetTeamsDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp target teams distribute simd' combined directive.
Definition: StmtOpenMP.h:5490
static OMPTargetTeamsDistributeSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPTargetTeamsDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp target teams loop' directive.
Definition: StmtOpenMP.h:6312
static OMPTargetTeamsGenericLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool CanBeParallelFor)
Creates directive with a list of Clauses.
static OMPTargetTeamsGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp target update' directive.
Definition: StmtOpenMP.h:4491
static OMPTargetUpdateDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTargetUpdateDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
This represents '#pragma omp task' directive.
Definition: StmtOpenMP.h:2517
static OMPTaskDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:807
static OMPTaskDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, bool HasCancel)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:798
This represents '#pragma omp taskloop' directive.
Definition: StmtOpenMP.h:3715
static OMPTaskLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel)
Creates directive with a list of Clauses.
static OMPTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp taskloop simd' directive.
Definition: StmtOpenMP.h:3788
static OMPTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTaskLoopSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents '#pragma omp taskgroup' directive.
Definition: StmtOpenMP.h:2722
static OMPTaskgroupDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *ReductionRef)
Creates directive.
Definition: StmtOpenMP.cpp:883
static OMPTaskgroupDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:892
This represents '#pragma omp taskwait' directive.
Definition: StmtOpenMP.h:2671
static OMPTaskwaitDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:877
static OMPTaskwaitDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive.
Definition: StmtOpenMP.cpp:869
This represents '#pragma omp taskyield' directive.
Definition: StmtOpenMP.h:2579
static OMPTaskyieldDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:820
static OMPTaskyieldDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Creates directive.
Definition: StmtOpenMP.cpp:814
This represents '#pragma omp teams' directive.
Definition: StmtOpenMP.h:3544
static OMPTeamsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTeamsDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
This represents '#pragma omp teams distribute' directive.
Definition: StmtOpenMP.h:4906
static OMPTeamsDistributeDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPTeamsDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp teams distribute parallel for' composite directive.
Definition: StmtOpenMP.h:5106
static OMPTeamsDistributeParallelForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel)
Creates directive with a list of Clauses.
static OMPTeamsDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp teams distribute parallel for simd' composite directive.
Definition: StmtOpenMP.h:5040
static OMPTeamsDistributeParallelForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPTeamsDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp teams distribute simd' combined directive.
Definition: StmtOpenMP.h:4972
static OMPTeamsDistributeSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
static OMPTeamsDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp teams loop' directive.
Definition: StmtOpenMP.h:6247
static OMPTeamsGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTeamsGenericLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
This represents the '#pragma omp tile' loop transformation directive.
Definition: StmtOpenMP.h:5548
static OMPTileDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned NumLoops)
Build an empty '#pragma omp tile' AST node for deserialization.
Definition: StmtOpenMP.cpp:420
static OMPTileDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, unsigned NumLoops, Stmt *AssociatedStmt, Stmt *TransformedStmt, Stmt *PreInits)
Create a new AST node representation for '#pragma omp tile'.
Definition: StmtOpenMP.cpp:408
This represents the '#pragma omp unroll' loop transformation directive.
Definition: StmtOpenMP.h:5705
static OMPUnrollDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, unsigned NumGeneratedLoops, Stmt *TransformedStmt, Stmt *PreInits)
Create a new AST node representation for '#pragma omp unroll'.
Definition: StmtOpenMP.cpp:450
static OMPUnrollDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses)
Build an empty '#pragma omp unroll' AST node for deserialization.
Definition: StmtOpenMP.cpp:464
Encodes a location in the source.
Stmt - This represents one statement.
Definition: Stmt.h:85
StmtClass getStmtClass() const
Definition: Stmt.h:1472
Stmt * IgnoreContainers(bool IgnoreCaptured=false)
Skip no-op (attributed, compound) container stmts and skip captured stmt at the top,...
Definition: Stmt.cpp:205
The JSON file list parser is used to communicate input to InstallAPI.
llvm::omp::Directive OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:25
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
Expr * E
'expr' part of the associated expression/statement.
Definition: StmtOpenMP.h:3032
Expr * D
'd' part of the associated expression/statement.
Definition: StmtOpenMP.h:3038
Expr * UE
UE Helper expression of the form: 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or 'OpaqueValueExp...
Definition: StmtOpenMP.h:3036
bool IsFailOnly
True if 'v' is updated only when the condition is false (compare capture only).
Definition: StmtOpenMP.h:3047
Expr * X
'x' part of the associated expression/statement.
Definition: StmtOpenMP.h:3026
Expr * Cond
Conditional expression in atomic compare construct.
Definition: StmtOpenMP.h:3040
Expr * V
'v' part of the associated expression/statement.
Definition: StmtOpenMP.h:3028
bool IsPostfixUpdate
True if original value of 'x' must be stored in 'v', not an updated one.
Definition: StmtOpenMP.h:3044
bool IsXLHSInRHSPart
True if UE has the first form and false if the second.
Definition: StmtOpenMP.h:3042
Expr * ParForInDistCond
'omp parallel for' loop condition used when composed with 'omp distribute' in the same construct and ...
Definition: StmtOpenMP.h:735
Expr * LB
DistributeLowerBound - used when composing 'omp distribute' with 'omp for' in a same construct.
Definition: StmtOpenMP.h:709
Expr * Init
Distribute loop iteration variable init used when composing 'omp distribute' with 'omp for' in a same...
Definition: StmtOpenMP.h:719
Expr * NUB
Update of UpperBound for statically scheduled omp loops for outer loop in combined constructs (e....
Definition: StmtOpenMP.h:728
Expr * EUB
DistributeEnsureUpperBound - used when composing 'omp distribute' with 'omp for' in a same construct,...
Definition: StmtOpenMP.h:715
Expr * UB
DistributeUpperBound - used when composing 'omp distribute' with 'omp for' in a same construct.
Definition: StmtOpenMP.h:712
Expr * NLB
Update of LowerBound for statically scheduled omp loops for outer loop in combined constructs (e....
Definition: StmtOpenMP.h:725
Expr * DistCond
Distribute Loop condition used when composing 'omp distribute' with 'omp for' in a same construct whe...
Definition: StmtOpenMP.h:731
Expr * Cond
Distribute Loop condition used when composing 'omp distribute' with 'omp for' in a same construct.
Definition: StmtOpenMP.h:722
The expressions built for the OpenMP loop CodeGen for the whole collapsed loop nest.
Definition: StmtOpenMP.h:740
Expr * LastIteration
Loop last iteration number.
Definition: StmtOpenMP.h:744
SmallVector< Expr *, 4 > DependentInits
List of initializers required for the generation of the non-rectangular loops.
Definition: StmtOpenMP.h:802
SmallVector< Expr *, 4 > Inits
Expressions for loop counters inits for CodeGen.
Definition: StmtOpenMP.h:792
Expr * PrevEUB
PrevEUB - expression similar to EUB but to be used when loop scheduling uses PrevLB and PrevUB (e....
Definition: StmtOpenMP.h:786
Expr * DistInc
DistInc - increment expression for distribute loop when found combined with a further loop level (e....
Definition: StmtOpenMP.h:780
Expr * IL
IsLastIteration - local flag variable passed to runtime.
Definition: StmtOpenMP.h:758
SmallVector< Expr *, 4 > PrivateCounters
PrivateCounters Loop counters.
Definition: StmtOpenMP.h:790
Expr * CalcLastIteration
Calculation of last iteration.
Definition: StmtOpenMP.h:748
SmallVector< Expr *, 4 > Updates
Expressions for loop counters update for CodeGen.
Definition: StmtOpenMP.h:794
Expr * ST
Stride - local variable passed to runtime.
Definition: StmtOpenMP.h:764
SmallVector< Expr *, 4 > Finals
Final loop counter values for GodeGen.
Definition: StmtOpenMP.h:796
SmallVector< Expr *, 4 > FinalsConditions
List of final conditions required for the generation of the non-rectangular loops.
Definition: StmtOpenMP.h:805
Expr * PreCond
Loop pre-condition.
Definition: StmtOpenMP.h:750
Stmt * PreInits
Init statement for all captured expressions.
Definition: StmtOpenMP.h:807
Expr * IterationVarRef
Loop iteration variable.
Definition: StmtOpenMP.h:742
Expr * NumIterations
Loop number of iterations.
Definition: StmtOpenMP.h:746
SmallVector< Expr *, 4 > Counters
Counters Loop counters.
Definition: StmtOpenMP.h:788
Expr * NLB
Update of LowerBound for statically scheduled 'omp for' loops.
Definition: StmtOpenMP.h:768
Expr * PrevUB
PreviousUpperBound - local variable passed to runtime in the enclosing schedule or null if that does ...
Definition: StmtOpenMP.h:776
DistCombinedHelperExprs DistCombinedFields
Expressions used when combining OpenMP loop pragmas.
Definition: StmtOpenMP.h:810
Expr * EUB
EnsureUpperBound – expression UB = min(UB, NumIterations).
Definition: StmtOpenMP.h:766
Expr * UB
UpperBound - local variable passed to runtime.
Definition: StmtOpenMP.h:762
Expr * NUB
Update of UpperBound for statically scheduled 'omp for' loops.
Definition: StmtOpenMP.h:770
Expr * LB
LowerBound - local variable passed to runtime.
Definition: StmtOpenMP.h:760
Expr * PrevLB
PreviousLowerBound - local variable passed to runtime in the enclosing schedule or null if that does ...
Definition: StmtOpenMP.h:773
SmallVector< Expr *, 4 > DependentCounters
List of counters required for the generation of the non-rectangular loops.
Definition: StmtOpenMP.h:799
Expr * Init
Loop iteration variable init.
Definition: StmtOpenMP.h:754
A placeholder type used to construct an empty shell of a type, that will be filled in later (e....
Definition: Stmt.h:1412