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