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