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 OMPMasterTaskLoopSimdDirective *OMPMasterTaskLoopSimdDirective::Create(
1180     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1181     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1182     const HelperExprs &Exprs) {
1183   auto *Dir = createDirective<OMPMasterTaskLoopSimdDirective>(
1184       C, Clauses, AssociatedStmt,
1185       numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), StartLoc,
1186       EndLoc, 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   return Dir;
1212 }
1213 
1214 OMPMasterTaskLoopSimdDirective *
1215 OMPMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C,
1216                                             unsigned NumClauses,
1217                                             unsigned CollapsedNum, EmptyShell) {
1218   return createEmptyDirective<OMPMasterTaskLoopSimdDirective>(
1219       C, NumClauses, /*HasAssociatedStmt=*/true,
1220       numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), CollapsedNum);
1221 }
1222 
1223 OMPParallelMasterTaskLoopDirective *OMPParallelMasterTaskLoopDirective::Create(
1224     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1225     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1226     const HelperExprs &Exprs, bool HasCancel) {
1227   auto *Dir = createDirective<OMPParallelMasterTaskLoopDirective>(
1228       C, Clauses, AssociatedStmt,
1229       numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop), StartLoc,
1230       EndLoc, CollapsedNum);
1231   Dir->setIterationVariable(Exprs.IterationVarRef);
1232   Dir->setLastIteration(Exprs.LastIteration);
1233   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1234   Dir->setPreCond(Exprs.PreCond);
1235   Dir->setCond(Exprs.Cond);
1236   Dir->setInit(Exprs.Init);
1237   Dir->setInc(Exprs.Inc);
1238   Dir->setIsLastIterVariable(Exprs.IL);
1239   Dir->setLowerBoundVariable(Exprs.LB);
1240   Dir->setUpperBoundVariable(Exprs.UB);
1241   Dir->setStrideVariable(Exprs.ST);
1242   Dir->setEnsureUpperBound(Exprs.EUB);
1243   Dir->setNextLowerBound(Exprs.NLB);
1244   Dir->setNextUpperBound(Exprs.NUB);
1245   Dir->setNumIterations(Exprs.NumIterations);
1246   Dir->setCounters(Exprs.Counters);
1247   Dir->setPrivateCounters(Exprs.PrivateCounters);
1248   Dir->setInits(Exprs.Inits);
1249   Dir->setUpdates(Exprs.Updates);
1250   Dir->setFinals(Exprs.Finals);
1251   Dir->setDependentCounters(Exprs.DependentCounters);
1252   Dir->setDependentInits(Exprs.DependentInits);
1253   Dir->setFinalsConditions(Exprs.FinalsConditions);
1254   Dir->setPreInits(Exprs.PreInits);
1255   Dir->setHasCancel(HasCancel);
1256   return Dir;
1257 }
1258 
1259 OMPParallelMasterTaskLoopDirective *
1260 OMPParallelMasterTaskLoopDirective::CreateEmpty(const ASTContext &C,
1261                                                 unsigned NumClauses,
1262                                                 unsigned CollapsedNum,
1263                                                 EmptyShell) {
1264   return createEmptyDirective<OMPParallelMasterTaskLoopDirective>(
1265       C, NumClauses, /*HasAssociatedStmt=*/true,
1266       numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop),
1267       CollapsedNum);
1268 }
1269 
1270 OMPParallelMasterTaskLoopSimdDirective *
1271 OMPParallelMasterTaskLoopSimdDirective::Create(
1272     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1273     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1274     const HelperExprs &Exprs) {
1275   auto *Dir = createDirective<OMPParallelMasterTaskLoopSimdDirective>(
1276       C, Clauses, AssociatedStmt,
1277       numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd),
1278       StartLoc, EndLoc, CollapsedNum);
1279   Dir->setIterationVariable(Exprs.IterationVarRef);
1280   Dir->setLastIteration(Exprs.LastIteration);
1281   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1282   Dir->setPreCond(Exprs.PreCond);
1283   Dir->setCond(Exprs.Cond);
1284   Dir->setInit(Exprs.Init);
1285   Dir->setInc(Exprs.Inc);
1286   Dir->setIsLastIterVariable(Exprs.IL);
1287   Dir->setLowerBoundVariable(Exprs.LB);
1288   Dir->setUpperBoundVariable(Exprs.UB);
1289   Dir->setStrideVariable(Exprs.ST);
1290   Dir->setEnsureUpperBound(Exprs.EUB);
1291   Dir->setNextLowerBound(Exprs.NLB);
1292   Dir->setNextUpperBound(Exprs.NUB);
1293   Dir->setNumIterations(Exprs.NumIterations);
1294   Dir->setCounters(Exprs.Counters);
1295   Dir->setPrivateCounters(Exprs.PrivateCounters);
1296   Dir->setInits(Exprs.Inits);
1297   Dir->setUpdates(Exprs.Updates);
1298   Dir->setFinals(Exprs.Finals);
1299   Dir->setDependentCounters(Exprs.DependentCounters);
1300   Dir->setDependentInits(Exprs.DependentInits);
1301   Dir->setFinalsConditions(Exprs.FinalsConditions);
1302   Dir->setPreInits(Exprs.PreInits);
1303   return Dir;
1304 }
1305 
1306 OMPParallelMasterTaskLoopSimdDirective *
1307 OMPParallelMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C,
1308                                                     unsigned NumClauses,
1309                                                     unsigned CollapsedNum,
1310                                                     EmptyShell) {
1311   return createEmptyDirective<OMPParallelMasterTaskLoopSimdDirective>(
1312       C, NumClauses, /*HasAssociatedStmt=*/true,
1313       numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd),
1314       CollapsedNum);
1315 }
1316 
1317 OMPDistributeDirective *OMPDistributeDirective::Create(
1318     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1319     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1320     const HelperExprs &Exprs) {
1321   auto *Dir = createDirective<OMPDistributeDirective>(
1322       C, Clauses, AssociatedStmt,
1323       numLoopChildren(CollapsedNum, OMPD_distribute), StartLoc, EndLoc,
1324       CollapsedNum);
1325   Dir->setIterationVariable(Exprs.IterationVarRef);
1326   Dir->setLastIteration(Exprs.LastIteration);
1327   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1328   Dir->setPreCond(Exprs.PreCond);
1329   Dir->setCond(Exprs.Cond);
1330   Dir->setInit(Exprs.Init);
1331   Dir->setInc(Exprs.Inc);
1332   Dir->setIsLastIterVariable(Exprs.IL);
1333   Dir->setLowerBoundVariable(Exprs.LB);
1334   Dir->setUpperBoundVariable(Exprs.UB);
1335   Dir->setStrideVariable(Exprs.ST);
1336   Dir->setEnsureUpperBound(Exprs.EUB);
1337   Dir->setNextLowerBound(Exprs.NLB);
1338   Dir->setNextUpperBound(Exprs.NUB);
1339   Dir->setNumIterations(Exprs.NumIterations);
1340   Dir->setCounters(Exprs.Counters);
1341   Dir->setPrivateCounters(Exprs.PrivateCounters);
1342   Dir->setInits(Exprs.Inits);
1343   Dir->setUpdates(Exprs.Updates);
1344   Dir->setFinals(Exprs.Finals);
1345   Dir->setDependentCounters(Exprs.DependentCounters);
1346   Dir->setDependentInits(Exprs.DependentInits);
1347   Dir->setFinalsConditions(Exprs.FinalsConditions);
1348   Dir->setPreInits(Exprs.PreInits);
1349   return Dir;
1350 }
1351 
1352 OMPDistributeDirective *
1353 OMPDistributeDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1354                                     unsigned CollapsedNum, EmptyShell) {
1355   return createEmptyDirective<OMPDistributeDirective>(
1356       C, NumClauses, /*HasAssociatedStmt=*/true,
1357       numLoopChildren(CollapsedNum, OMPD_distribute), CollapsedNum);
1358 }
1359 
1360 OMPTargetUpdateDirective *OMPTargetUpdateDirective::Create(
1361     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1362     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1363   return createDirective<OMPTargetUpdateDirective>(C, Clauses, AssociatedStmt,
1364                                                    /*NumChildren=*/0, StartLoc,
1365                                                    EndLoc);
1366 }
1367 
1368 OMPTargetUpdateDirective *
1369 OMPTargetUpdateDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1370                                       EmptyShell) {
1371   return createEmptyDirective<OMPTargetUpdateDirective>(
1372       C, NumClauses, /*HasAssociatedStmt=*/true);
1373 }
1374 
1375 OMPDistributeParallelForDirective *OMPDistributeParallelForDirective::Create(
1376     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1377     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1378     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
1379   auto *Dir = createDirective<OMPDistributeParallelForDirective>(
1380       C, Clauses, AssociatedStmt,
1381       numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1, StartLoc,
1382       EndLoc, CollapsedNum);
1383   Dir->setIterationVariable(Exprs.IterationVarRef);
1384   Dir->setLastIteration(Exprs.LastIteration);
1385   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1386   Dir->setPreCond(Exprs.PreCond);
1387   Dir->setCond(Exprs.Cond);
1388   Dir->setInit(Exprs.Init);
1389   Dir->setInc(Exprs.Inc);
1390   Dir->setIsLastIterVariable(Exprs.IL);
1391   Dir->setLowerBoundVariable(Exprs.LB);
1392   Dir->setUpperBoundVariable(Exprs.UB);
1393   Dir->setStrideVariable(Exprs.ST);
1394   Dir->setEnsureUpperBound(Exprs.EUB);
1395   Dir->setNextLowerBound(Exprs.NLB);
1396   Dir->setNextUpperBound(Exprs.NUB);
1397   Dir->setNumIterations(Exprs.NumIterations);
1398   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1399   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1400   Dir->setDistInc(Exprs.DistInc);
1401   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1402   Dir->setCounters(Exprs.Counters);
1403   Dir->setPrivateCounters(Exprs.PrivateCounters);
1404   Dir->setInits(Exprs.Inits);
1405   Dir->setUpdates(Exprs.Updates);
1406   Dir->setFinals(Exprs.Finals);
1407   Dir->setDependentCounters(Exprs.DependentCounters);
1408   Dir->setDependentInits(Exprs.DependentInits);
1409   Dir->setFinalsConditions(Exprs.FinalsConditions);
1410   Dir->setPreInits(Exprs.PreInits);
1411   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1412   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1413   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1414   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1415   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1416   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1417   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1418   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1419   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1420   Dir->setTaskReductionRefExpr(TaskRedRef);
1421   Dir->HasCancel = HasCancel;
1422   return Dir;
1423 }
1424 
1425 OMPDistributeParallelForDirective *
1426 OMPDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
1427                                                unsigned NumClauses,
1428                                                unsigned CollapsedNum,
1429                                                EmptyShell) {
1430   return createEmptyDirective<OMPDistributeParallelForDirective>(
1431       C, NumClauses, /*HasAssociatedStmt=*/true,
1432       numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1,
1433       CollapsedNum);
1434 }
1435 
1436 OMPDistributeParallelForSimdDirective *
1437 OMPDistributeParallelForSimdDirective::Create(
1438     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1439     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1440     const HelperExprs &Exprs) {
1441   auto *Dir = createDirective<OMPDistributeParallelForSimdDirective>(
1442       C, Clauses, AssociatedStmt,
1443       numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd),
1444       StartLoc, EndLoc, CollapsedNum);
1445   Dir->setIterationVariable(Exprs.IterationVarRef);
1446   Dir->setLastIteration(Exprs.LastIteration);
1447   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1448   Dir->setPreCond(Exprs.PreCond);
1449   Dir->setCond(Exprs.Cond);
1450   Dir->setInit(Exprs.Init);
1451   Dir->setInc(Exprs.Inc);
1452   Dir->setIsLastIterVariable(Exprs.IL);
1453   Dir->setLowerBoundVariable(Exprs.LB);
1454   Dir->setUpperBoundVariable(Exprs.UB);
1455   Dir->setStrideVariable(Exprs.ST);
1456   Dir->setEnsureUpperBound(Exprs.EUB);
1457   Dir->setNextLowerBound(Exprs.NLB);
1458   Dir->setNextUpperBound(Exprs.NUB);
1459   Dir->setNumIterations(Exprs.NumIterations);
1460   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1461   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1462   Dir->setDistInc(Exprs.DistInc);
1463   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1464   Dir->setCounters(Exprs.Counters);
1465   Dir->setPrivateCounters(Exprs.PrivateCounters);
1466   Dir->setInits(Exprs.Inits);
1467   Dir->setUpdates(Exprs.Updates);
1468   Dir->setFinals(Exprs.Finals);
1469   Dir->setDependentCounters(Exprs.DependentCounters);
1470   Dir->setDependentInits(Exprs.DependentInits);
1471   Dir->setFinalsConditions(Exprs.FinalsConditions);
1472   Dir->setPreInits(Exprs.PreInits);
1473   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1474   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1475   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1476   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1477   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1478   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1479   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1480   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1481   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1482   return Dir;
1483 }
1484 
1485 OMPDistributeParallelForSimdDirective *
1486 OMPDistributeParallelForSimdDirective::CreateEmpty(const ASTContext &C,
1487                                                    unsigned NumClauses,
1488                                                    unsigned CollapsedNum,
1489                                                    EmptyShell) {
1490   return createEmptyDirective<OMPDistributeParallelForSimdDirective>(
1491       C, NumClauses, /*HasAssociatedStmt=*/true,
1492       numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd),
1493       CollapsedNum);
1494 }
1495 
1496 OMPDistributeSimdDirective *OMPDistributeSimdDirective::Create(
1497     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1498     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1499     const HelperExprs &Exprs) {
1500   auto *Dir = createDirective<OMPDistributeSimdDirective>(
1501       C, Clauses, AssociatedStmt,
1502       numLoopChildren(CollapsedNum, OMPD_distribute_simd), StartLoc, EndLoc,
1503       CollapsedNum);
1504   Dir->setIterationVariable(Exprs.IterationVarRef);
1505   Dir->setLastIteration(Exprs.LastIteration);
1506   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1507   Dir->setPreCond(Exprs.PreCond);
1508   Dir->setCond(Exprs.Cond);
1509   Dir->setInit(Exprs.Init);
1510   Dir->setInc(Exprs.Inc);
1511   Dir->setIsLastIterVariable(Exprs.IL);
1512   Dir->setLowerBoundVariable(Exprs.LB);
1513   Dir->setUpperBoundVariable(Exprs.UB);
1514   Dir->setStrideVariable(Exprs.ST);
1515   Dir->setEnsureUpperBound(Exprs.EUB);
1516   Dir->setNextLowerBound(Exprs.NLB);
1517   Dir->setNextUpperBound(Exprs.NUB);
1518   Dir->setNumIterations(Exprs.NumIterations);
1519   Dir->setCounters(Exprs.Counters);
1520   Dir->setPrivateCounters(Exprs.PrivateCounters);
1521   Dir->setInits(Exprs.Inits);
1522   Dir->setUpdates(Exprs.Updates);
1523   Dir->setFinals(Exprs.Finals);
1524   Dir->setDependentCounters(Exprs.DependentCounters);
1525   Dir->setDependentInits(Exprs.DependentInits);
1526   Dir->setFinalsConditions(Exprs.FinalsConditions);
1527   Dir->setPreInits(Exprs.PreInits);
1528   return Dir;
1529 }
1530 
1531 OMPDistributeSimdDirective *
1532 OMPDistributeSimdDirective::CreateEmpty(const ASTContext &C,
1533                                         unsigned NumClauses,
1534                                         unsigned CollapsedNum, EmptyShell) {
1535   return createEmptyDirective<OMPDistributeSimdDirective>(
1536       C, NumClauses, /*HasAssociatedStmt=*/true,
1537       numLoopChildren(CollapsedNum, OMPD_distribute_simd), CollapsedNum);
1538 }
1539 
1540 OMPTargetParallelForSimdDirective *OMPTargetParallelForSimdDirective::Create(
1541     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1542     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1543     const HelperExprs &Exprs) {
1544   auto *Dir = createDirective<OMPTargetParallelForSimdDirective>(
1545       C, Clauses, AssociatedStmt,
1546       numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd), StartLoc,
1547       EndLoc, CollapsedNum);
1548   Dir->setIterationVariable(Exprs.IterationVarRef);
1549   Dir->setLastIteration(Exprs.LastIteration);
1550   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1551   Dir->setPreCond(Exprs.PreCond);
1552   Dir->setCond(Exprs.Cond);
1553   Dir->setInit(Exprs.Init);
1554   Dir->setInc(Exprs.Inc);
1555   Dir->setIsLastIterVariable(Exprs.IL);
1556   Dir->setLowerBoundVariable(Exprs.LB);
1557   Dir->setUpperBoundVariable(Exprs.UB);
1558   Dir->setStrideVariable(Exprs.ST);
1559   Dir->setEnsureUpperBound(Exprs.EUB);
1560   Dir->setNextLowerBound(Exprs.NLB);
1561   Dir->setNextUpperBound(Exprs.NUB);
1562   Dir->setNumIterations(Exprs.NumIterations);
1563   Dir->setCounters(Exprs.Counters);
1564   Dir->setPrivateCounters(Exprs.PrivateCounters);
1565   Dir->setInits(Exprs.Inits);
1566   Dir->setUpdates(Exprs.Updates);
1567   Dir->setFinals(Exprs.Finals);
1568   Dir->setDependentCounters(Exprs.DependentCounters);
1569   Dir->setDependentInits(Exprs.DependentInits);
1570   Dir->setFinalsConditions(Exprs.FinalsConditions);
1571   Dir->setPreInits(Exprs.PreInits);
1572   return Dir;
1573 }
1574 
1575 OMPTargetParallelForSimdDirective *
1576 OMPTargetParallelForSimdDirective::CreateEmpty(const ASTContext &C,
1577                                                unsigned NumClauses,
1578                                                unsigned CollapsedNum,
1579                                                EmptyShell) {
1580   return createEmptyDirective<OMPTargetParallelForSimdDirective>(
1581       C, NumClauses, /*HasAssociatedStmt=*/true,
1582       numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd),
1583       CollapsedNum);
1584 }
1585 
1586 OMPTargetSimdDirective *
1587 OMPTargetSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
1588                                SourceLocation EndLoc, unsigned CollapsedNum,
1589                                ArrayRef<OMPClause *> Clauses,
1590                                Stmt *AssociatedStmt, const HelperExprs &Exprs) {
1591   auto *Dir = createDirective<OMPTargetSimdDirective>(
1592       C, Clauses, AssociatedStmt,
1593       numLoopChildren(CollapsedNum, OMPD_target_simd), StartLoc, EndLoc,
1594       CollapsedNum);
1595   Dir->setIterationVariable(Exprs.IterationVarRef);
1596   Dir->setLastIteration(Exprs.LastIteration);
1597   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1598   Dir->setPreCond(Exprs.PreCond);
1599   Dir->setCond(Exprs.Cond);
1600   Dir->setInit(Exprs.Init);
1601   Dir->setInc(Exprs.Inc);
1602   Dir->setCounters(Exprs.Counters);
1603   Dir->setPrivateCounters(Exprs.PrivateCounters);
1604   Dir->setInits(Exprs.Inits);
1605   Dir->setUpdates(Exprs.Updates);
1606   Dir->setFinals(Exprs.Finals);
1607   Dir->setDependentCounters(Exprs.DependentCounters);
1608   Dir->setDependentInits(Exprs.DependentInits);
1609   Dir->setFinalsConditions(Exprs.FinalsConditions);
1610   Dir->setPreInits(Exprs.PreInits);
1611   return Dir;
1612 }
1613 
1614 OMPTargetSimdDirective *
1615 OMPTargetSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1616                                     unsigned CollapsedNum, EmptyShell) {
1617   return createEmptyDirective<OMPTargetSimdDirective>(
1618       C, NumClauses, /*HasAssociatedStmt=*/true,
1619       numLoopChildren(CollapsedNum, OMPD_target_simd), CollapsedNum);
1620 }
1621 
1622 OMPTeamsDistributeDirective *OMPTeamsDistributeDirective::Create(
1623     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1624     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1625     const HelperExprs &Exprs) {
1626   auto *Dir = createDirective<OMPTeamsDistributeDirective>(
1627       C, Clauses, AssociatedStmt,
1628       numLoopChildren(CollapsedNum, OMPD_teams_distribute), StartLoc, EndLoc,
1629       CollapsedNum);
1630   Dir->setIterationVariable(Exprs.IterationVarRef);
1631   Dir->setLastIteration(Exprs.LastIteration);
1632   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1633   Dir->setPreCond(Exprs.PreCond);
1634   Dir->setCond(Exprs.Cond);
1635   Dir->setInit(Exprs.Init);
1636   Dir->setInc(Exprs.Inc);
1637   Dir->setIsLastIterVariable(Exprs.IL);
1638   Dir->setLowerBoundVariable(Exprs.LB);
1639   Dir->setUpperBoundVariable(Exprs.UB);
1640   Dir->setStrideVariable(Exprs.ST);
1641   Dir->setEnsureUpperBound(Exprs.EUB);
1642   Dir->setNextLowerBound(Exprs.NLB);
1643   Dir->setNextUpperBound(Exprs.NUB);
1644   Dir->setNumIterations(Exprs.NumIterations);
1645   Dir->setCounters(Exprs.Counters);
1646   Dir->setPrivateCounters(Exprs.PrivateCounters);
1647   Dir->setInits(Exprs.Inits);
1648   Dir->setUpdates(Exprs.Updates);
1649   Dir->setFinals(Exprs.Finals);
1650   Dir->setDependentCounters(Exprs.DependentCounters);
1651   Dir->setDependentInits(Exprs.DependentInits);
1652   Dir->setFinalsConditions(Exprs.FinalsConditions);
1653   Dir->setPreInits(Exprs.PreInits);
1654   return Dir;
1655 }
1656 
1657 OMPTeamsDistributeDirective *
1658 OMPTeamsDistributeDirective::CreateEmpty(const ASTContext &C,
1659                                          unsigned NumClauses,
1660                                          unsigned CollapsedNum, EmptyShell) {
1661   return createEmptyDirective<OMPTeamsDistributeDirective>(
1662       C, NumClauses, /*HasAssociatedStmt=*/true,
1663       numLoopChildren(CollapsedNum, OMPD_teams_distribute), CollapsedNum);
1664 }
1665 
1666 OMPTeamsDistributeSimdDirective *OMPTeamsDistributeSimdDirective::Create(
1667     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1668     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1669     const HelperExprs &Exprs) {
1670   auto *Dir = createDirective<OMPTeamsDistributeSimdDirective>(
1671       C, Clauses, AssociatedStmt,
1672       numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), StartLoc,
1673       EndLoc, CollapsedNum);
1674   Dir->setIterationVariable(Exprs.IterationVarRef);
1675   Dir->setLastIteration(Exprs.LastIteration);
1676   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1677   Dir->setPreCond(Exprs.PreCond);
1678   Dir->setCond(Exprs.Cond);
1679   Dir->setInit(Exprs.Init);
1680   Dir->setInc(Exprs.Inc);
1681   Dir->setIsLastIterVariable(Exprs.IL);
1682   Dir->setLowerBoundVariable(Exprs.LB);
1683   Dir->setUpperBoundVariable(Exprs.UB);
1684   Dir->setStrideVariable(Exprs.ST);
1685   Dir->setEnsureUpperBound(Exprs.EUB);
1686   Dir->setNextLowerBound(Exprs.NLB);
1687   Dir->setNextUpperBound(Exprs.NUB);
1688   Dir->setNumIterations(Exprs.NumIterations);
1689   Dir->setCounters(Exprs.Counters);
1690   Dir->setPrivateCounters(Exprs.PrivateCounters);
1691   Dir->setInits(Exprs.Inits);
1692   Dir->setUpdates(Exprs.Updates);
1693   Dir->setFinals(Exprs.Finals);
1694   Dir->setDependentCounters(Exprs.DependentCounters);
1695   Dir->setDependentInits(Exprs.DependentInits);
1696   Dir->setFinalsConditions(Exprs.FinalsConditions);
1697   Dir->setPreInits(Exprs.PreInits);
1698   return Dir;
1699 }
1700 
1701 OMPTeamsDistributeSimdDirective *OMPTeamsDistributeSimdDirective::CreateEmpty(
1702     const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
1703     EmptyShell) {
1704   return createEmptyDirective<OMPTeamsDistributeSimdDirective>(
1705       C, NumClauses, /*HasAssociatedStmt=*/true,
1706       numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), CollapsedNum);
1707 }
1708 
1709 OMPTeamsDistributeParallelForSimdDirective *
1710 OMPTeamsDistributeParallelForSimdDirective::Create(
1711     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1712     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1713     const HelperExprs &Exprs) {
1714   auto *Dir = createDirective<OMPTeamsDistributeParallelForSimdDirective>(
1715       C, Clauses, AssociatedStmt,
1716       numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd),
1717       StartLoc, EndLoc, CollapsedNum);
1718   Dir->setIterationVariable(Exprs.IterationVarRef);
1719   Dir->setLastIteration(Exprs.LastIteration);
1720   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1721   Dir->setPreCond(Exprs.PreCond);
1722   Dir->setCond(Exprs.Cond);
1723   Dir->setInit(Exprs.Init);
1724   Dir->setInc(Exprs.Inc);
1725   Dir->setIsLastIterVariable(Exprs.IL);
1726   Dir->setLowerBoundVariable(Exprs.LB);
1727   Dir->setUpperBoundVariable(Exprs.UB);
1728   Dir->setStrideVariable(Exprs.ST);
1729   Dir->setEnsureUpperBound(Exprs.EUB);
1730   Dir->setNextLowerBound(Exprs.NLB);
1731   Dir->setNextUpperBound(Exprs.NUB);
1732   Dir->setNumIterations(Exprs.NumIterations);
1733   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1734   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1735   Dir->setDistInc(Exprs.DistInc);
1736   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1737   Dir->setCounters(Exprs.Counters);
1738   Dir->setPrivateCounters(Exprs.PrivateCounters);
1739   Dir->setInits(Exprs.Inits);
1740   Dir->setUpdates(Exprs.Updates);
1741   Dir->setFinals(Exprs.Finals);
1742   Dir->setDependentCounters(Exprs.DependentCounters);
1743   Dir->setDependentInits(Exprs.DependentInits);
1744   Dir->setFinalsConditions(Exprs.FinalsConditions);
1745   Dir->setPreInits(Exprs.PreInits);
1746   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1747   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1748   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1749   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1750   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1751   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1752   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1753   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1754   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1755   return Dir;
1756 }
1757 
1758 OMPTeamsDistributeParallelForSimdDirective *
1759 OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(const ASTContext &C,
1760                                                         unsigned NumClauses,
1761                                                         unsigned CollapsedNum,
1762                                                         EmptyShell) {
1763   return createEmptyDirective<OMPTeamsDistributeParallelForSimdDirective>(
1764       C, NumClauses, /*HasAssociatedStmt=*/true,
1765       numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd),
1766       CollapsedNum);
1767 }
1768 
1769 OMPTeamsDistributeParallelForDirective *
1770 OMPTeamsDistributeParallelForDirective::Create(
1771     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1772     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1773     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
1774   auto *Dir = createDirective<OMPTeamsDistributeParallelForDirective>(
1775       C, Clauses, AssociatedStmt,
1776       numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1,
1777       StartLoc, EndLoc, CollapsedNum);
1778   Dir->setIterationVariable(Exprs.IterationVarRef);
1779   Dir->setLastIteration(Exprs.LastIteration);
1780   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1781   Dir->setPreCond(Exprs.PreCond);
1782   Dir->setCond(Exprs.Cond);
1783   Dir->setInit(Exprs.Init);
1784   Dir->setInc(Exprs.Inc);
1785   Dir->setIsLastIterVariable(Exprs.IL);
1786   Dir->setLowerBoundVariable(Exprs.LB);
1787   Dir->setUpperBoundVariable(Exprs.UB);
1788   Dir->setStrideVariable(Exprs.ST);
1789   Dir->setEnsureUpperBound(Exprs.EUB);
1790   Dir->setNextLowerBound(Exprs.NLB);
1791   Dir->setNextUpperBound(Exprs.NUB);
1792   Dir->setNumIterations(Exprs.NumIterations);
1793   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1794   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1795   Dir->setDistInc(Exprs.DistInc);
1796   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1797   Dir->setCounters(Exprs.Counters);
1798   Dir->setPrivateCounters(Exprs.PrivateCounters);
1799   Dir->setInits(Exprs.Inits);
1800   Dir->setUpdates(Exprs.Updates);
1801   Dir->setFinals(Exprs.Finals);
1802   Dir->setDependentCounters(Exprs.DependentCounters);
1803   Dir->setDependentInits(Exprs.DependentInits);
1804   Dir->setFinalsConditions(Exprs.FinalsConditions);
1805   Dir->setPreInits(Exprs.PreInits);
1806   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1807   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1808   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1809   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1810   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1811   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1812   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1813   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1814   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1815   Dir->setTaskReductionRefExpr(TaskRedRef);
1816   Dir->HasCancel = HasCancel;
1817   return Dir;
1818 }
1819 
1820 OMPTeamsDistributeParallelForDirective *
1821 OMPTeamsDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
1822                                                     unsigned NumClauses,
1823                                                     unsigned CollapsedNum,
1824                                                     EmptyShell) {
1825   return createEmptyDirective<OMPTeamsDistributeParallelForDirective>(
1826       C, NumClauses, /*HasAssociatedStmt=*/true,
1827       numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1,
1828       CollapsedNum);
1829 }
1830 
1831 OMPTargetTeamsDirective *OMPTargetTeamsDirective::Create(
1832     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1833     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1834   return createDirective<OMPTargetTeamsDirective>(C, Clauses, AssociatedStmt,
1835                                                   /*NumChildren=*/0, StartLoc,
1836                                                   EndLoc);
1837 }
1838 
1839 OMPTargetTeamsDirective *
1840 OMPTargetTeamsDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1841                                      EmptyShell) {
1842   return createEmptyDirective<OMPTargetTeamsDirective>(
1843       C, NumClauses, /*HasAssociatedStmt=*/true);
1844 }
1845 
1846 OMPTargetTeamsDistributeDirective *OMPTargetTeamsDistributeDirective::Create(
1847     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1848     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1849     const HelperExprs &Exprs) {
1850   auto *Dir = createDirective<OMPTargetTeamsDistributeDirective>(
1851       C, Clauses, AssociatedStmt,
1852       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute), StartLoc,
1853       EndLoc, CollapsedNum);
1854   Dir->setIterationVariable(Exprs.IterationVarRef);
1855   Dir->setLastIteration(Exprs.LastIteration);
1856   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1857   Dir->setPreCond(Exprs.PreCond);
1858   Dir->setCond(Exprs.Cond);
1859   Dir->setInit(Exprs.Init);
1860   Dir->setInc(Exprs.Inc);
1861   Dir->setIsLastIterVariable(Exprs.IL);
1862   Dir->setLowerBoundVariable(Exprs.LB);
1863   Dir->setUpperBoundVariable(Exprs.UB);
1864   Dir->setStrideVariable(Exprs.ST);
1865   Dir->setEnsureUpperBound(Exprs.EUB);
1866   Dir->setNextLowerBound(Exprs.NLB);
1867   Dir->setNextUpperBound(Exprs.NUB);
1868   Dir->setNumIterations(Exprs.NumIterations);
1869   Dir->setCounters(Exprs.Counters);
1870   Dir->setPrivateCounters(Exprs.PrivateCounters);
1871   Dir->setInits(Exprs.Inits);
1872   Dir->setUpdates(Exprs.Updates);
1873   Dir->setFinals(Exprs.Finals);
1874   Dir->setDependentCounters(Exprs.DependentCounters);
1875   Dir->setDependentInits(Exprs.DependentInits);
1876   Dir->setFinalsConditions(Exprs.FinalsConditions);
1877   Dir->setPreInits(Exprs.PreInits);
1878   return Dir;
1879 }
1880 
1881 OMPTargetTeamsDistributeDirective *
1882 OMPTargetTeamsDistributeDirective::CreateEmpty(const ASTContext &C,
1883                                                unsigned NumClauses,
1884                                                unsigned CollapsedNum,
1885                                                EmptyShell) {
1886   return createEmptyDirective<OMPTargetTeamsDistributeDirective>(
1887       C, NumClauses, /*HasAssociatedStmt=*/true,
1888       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute),
1889       CollapsedNum);
1890 }
1891 
1892 OMPTargetTeamsDistributeParallelForDirective *
1893 OMPTargetTeamsDistributeParallelForDirective::Create(
1894     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1895     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1896     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
1897   auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForDirective>(
1898       C, Clauses, AssociatedStmt,
1899       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) +
1900           1,
1901       StartLoc, EndLoc, CollapsedNum);
1902   Dir->setIterationVariable(Exprs.IterationVarRef);
1903   Dir->setLastIteration(Exprs.LastIteration);
1904   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1905   Dir->setPreCond(Exprs.PreCond);
1906   Dir->setCond(Exprs.Cond);
1907   Dir->setInit(Exprs.Init);
1908   Dir->setInc(Exprs.Inc);
1909   Dir->setIsLastIterVariable(Exprs.IL);
1910   Dir->setLowerBoundVariable(Exprs.LB);
1911   Dir->setUpperBoundVariable(Exprs.UB);
1912   Dir->setStrideVariable(Exprs.ST);
1913   Dir->setEnsureUpperBound(Exprs.EUB);
1914   Dir->setNextLowerBound(Exprs.NLB);
1915   Dir->setNextUpperBound(Exprs.NUB);
1916   Dir->setNumIterations(Exprs.NumIterations);
1917   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1918   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1919   Dir->setDistInc(Exprs.DistInc);
1920   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1921   Dir->setCounters(Exprs.Counters);
1922   Dir->setPrivateCounters(Exprs.PrivateCounters);
1923   Dir->setInits(Exprs.Inits);
1924   Dir->setUpdates(Exprs.Updates);
1925   Dir->setFinals(Exprs.Finals);
1926   Dir->setDependentCounters(Exprs.DependentCounters);
1927   Dir->setDependentInits(Exprs.DependentInits);
1928   Dir->setFinalsConditions(Exprs.FinalsConditions);
1929   Dir->setPreInits(Exprs.PreInits);
1930   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1931   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1932   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1933   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1934   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1935   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1936   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1937   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1938   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1939   Dir->setTaskReductionRefExpr(TaskRedRef);
1940   Dir->HasCancel = HasCancel;
1941   return Dir;
1942 }
1943 
1944 OMPTargetTeamsDistributeParallelForDirective *
1945 OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
1946                                                           unsigned NumClauses,
1947                                                           unsigned CollapsedNum,
1948                                                           EmptyShell) {
1949   return createEmptyDirective<OMPTargetTeamsDistributeParallelForDirective>(
1950       C, NumClauses, /*HasAssociatedStmt=*/true,
1951       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) +
1952           1,
1953       CollapsedNum);
1954 }
1955 
1956 OMPTargetTeamsDistributeParallelForSimdDirective *
1957 OMPTargetTeamsDistributeParallelForSimdDirective::Create(
1958     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1959     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1960     const HelperExprs &Exprs) {
1961   auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
1962       C, Clauses, AssociatedStmt,
1963       numLoopChildren(CollapsedNum,
1964                       OMPD_target_teams_distribute_parallel_for_simd),
1965       StartLoc, EndLoc, CollapsedNum);
1966   Dir->setIterationVariable(Exprs.IterationVarRef);
1967   Dir->setLastIteration(Exprs.LastIteration);
1968   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1969   Dir->setPreCond(Exprs.PreCond);
1970   Dir->setCond(Exprs.Cond);
1971   Dir->setInit(Exprs.Init);
1972   Dir->setInc(Exprs.Inc);
1973   Dir->setIsLastIterVariable(Exprs.IL);
1974   Dir->setLowerBoundVariable(Exprs.LB);
1975   Dir->setUpperBoundVariable(Exprs.UB);
1976   Dir->setStrideVariable(Exprs.ST);
1977   Dir->setEnsureUpperBound(Exprs.EUB);
1978   Dir->setNextLowerBound(Exprs.NLB);
1979   Dir->setNextUpperBound(Exprs.NUB);
1980   Dir->setNumIterations(Exprs.NumIterations);
1981   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1982   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1983   Dir->setDistInc(Exprs.DistInc);
1984   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1985   Dir->setCounters(Exprs.Counters);
1986   Dir->setPrivateCounters(Exprs.PrivateCounters);
1987   Dir->setInits(Exprs.Inits);
1988   Dir->setUpdates(Exprs.Updates);
1989   Dir->setFinals(Exprs.Finals);
1990   Dir->setDependentCounters(Exprs.DependentCounters);
1991   Dir->setDependentInits(Exprs.DependentInits);
1992   Dir->setFinalsConditions(Exprs.FinalsConditions);
1993   Dir->setPreInits(Exprs.PreInits);
1994   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1995   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1996   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1997   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1998   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1999   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
2000   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
2001   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
2002   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
2003   return Dir;
2004 }
2005 
2006 OMPTargetTeamsDistributeParallelForSimdDirective *
2007 OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty(
2008     const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
2009     EmptyShell) {
2010   return createEmptyDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
2011       C, NumClauses, /*HasAssociatedStmt=*/true,
2012       numLoopChildren(CollapsedNum,
2013                       OMPD_target_teams_distribute_parallel_for_simd),
2014       CollapsedNum);
2015 }
2016 
2017 OMPTargetTeamsDistributeSimdDirective *
2018 OMPTargetTeamsDistributeSimdDirective::Create(
2019     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2020     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2021     const HelperExprs &Exprs) {
2022   auto *Dir = createDirective<OMPTargetTeamsDistributeSimdDirective>(
2023       C, Clauses, AssociatedStmt,
2024       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd),
2025       StartLoc, EndLoc, CollapsedNum);
2026   Dir->setIterationVariable(Exprs.IterationVarRef);
2027   Dir->setLastIteration(Exprs.LastIteration);
2028   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2029   Dir->setPreCond(Exprs.PreCond);
2030   Dir->setCond(Exprs.Cond);
2031   Dir->setInit(Exprs.Init);
2032   Dir->setInc(Exprs.Inc);
2033   Dir->setIsLastIterVariable(Exprs.IL);
2034   Dir->setLowerBoundVariable(Exprs.LB);
2035   Dir->setUpperBoundVariable(Exprs.UB);
2036   Dir->setStrideVariable(Exprs.ST);
2037   Dir->setEnsureUpperBound(Exprs.EUB);
2038   Dir->setNextLowerBound(Exprs.NLB);
2039   Dir->setNextUpperBound(Exprs.NUB);
2040   Dir->setNumIterations(Exprs.NumIterations);
2041   Dir->setCounters(Exprs.Counters);
2042   Dir->setPrivateCounters(Exprs.PrivateCounters);
2043   Dir->setInits(Exprs.Inits);
2044   Dir->setUpdates(Exprs.Updates);
2045   Dir->setFinals(Exprs.Finals);
2046   Dir->setDependentCounters(Exprs.DependentCounters);
2047   Dir->setDependentInits(Exprs.DependentInits);
2048   Dir->setFinalsConditions(Exprs.FinalsConditions);
2049   Dir->setPreInits(Exprs.PreInits);
2050   return Dir;
2051 }
2052 
2053 OMPTargetTeamsDistributeSimdDirective *
2054 OMPTargetTeamsDistributeSimdDirective::CreateEmpty(const ASTContext &C,
2055                                                    unsigned NumClauses,
2056                                                    unsigned CollapsedNum,
2057                                                    EmptyShell) {
2058   return createEmptyDirective<OMPTargetTeamsDistributeSimdDirective>(
2059       C, NumClauses, /*HasAssociatedStmt=*/true,
2060       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd),
2061       CollapsedNum);
2062 }
2063 
2064 OMPInteropDirective *
2065 OMPInteropDirective::Create(const ASTContext &C, SourceLocation StartLoc,
2066                             SourceLocation EndLoc,
2067                             ArrayRef<OMPClause *> Clauses) {
2068   return createDirective<OMPInteropDirective>(
2069       C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc,
2070       EndLoc);
2071 }
2072 
2073 OMPInteropDirective *OMPInteropDirective::CreateEmpty(const ASTContext &C,
2074                                                       unsigned NumClauses,
2075                                                       EmptyShell) {
2076   return createEmptyDirective<OMPInteropDirective>(C, NumClauses);
2077 }
2078 
2079 OMPDispatchDirective *OMPDispatchDirective::Create(
2080     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2081     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2082     SourceLocation TargetCallLoc) {
2083   auto *Dir = createDirective<OMPDispatchDirective>(
2084       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
2085   Dir->setTargetCallLoc(TargetCallLoc);
2086   return Dir;
2087 }
2088 
2089 OMPDispatchDirective *OMPDispatchDirective::CreateEmpty(const ASTContext &C,
2090                                                         unsigned NumClauses,
2091                                                         EmptyShell) {
2092   return createEmptyDirective<OMPDispatchDirective>(C, NumClauses,
2093                                                     /*HasAssociatedStmt=*/true,
2094                                                     /*NumChildren=*/0);
2095 }
2096 
2097 OMPMaskedDirective *OMPMaskedDirective::Create(const ASTContext &C,
2098                                                SourceLocation StartLoc,
2099                                                SourceLocation EndLoc,
2100                                                ArrayRef<OMPClause *> Clauses,
2101                                                Stmt *AssociatedStmt) {
2102   return createDirective<OMPMaskedDirective>(C, Clauses, AssociatedStmt,
2103                                              /*NumChildren=*/0, StartLoc,
2104                                              EndLoc);
2105 }
2106 
2107 OMPMaskedDirective *OMPMaskedDirective::CreateEmpty(const ASTContext &C,
2108                                                     unsigned NumClauses,
2109                                                     EmptyShell) {
2110   return createEmptyDirective<OMPMaskedDirective>(C, NumClauses,
2111                                                   /*HasAssociatedStmt=*/true);
2112 }
2113 
2114 OMPGenericLoopDirective *OMPGenericLoopDirective::Create(
2115     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2116     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2117     const HelperExprs &Exprs) {
2118   auto *Dir = createDirective<OMPGenericLoopDirective>(
2119       C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_loop),
2120       StartLoc, EndLoc, CollapsedNum);
2121   Dir->setIterationVariable(Exprs.IterationVarRef);
2122   Dir->setLastIteration(Exprs.LastIteration);
2123   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2124   Dir->setPreCond(Exprs.PreCond);
2125   Dir->setCond(Exprs.Cond);
2126   Dir->setInit(Exprs.Init);
2127   Dir->setInc(Exprs.Inc);
2128   Dir->setIsLastIterVariable(Exprs.IL);
2129   Dir->setLowerBoundVariable(Exprs.LB);
2130   Dir->setUpperBoundVariable(Exprs.UB);
2131   Dir->setStrideVariable(Exprs.ST);
2132   Dir->setEnsureUpperBound(Exprs.EUB);
2133   Dir->setNextLowerBound(Exprs.NLB);
2134   Dir->setNextUpperBound(Exprs.NUB);
2135   Dir->setNumIterations(Exprs.NumIterations);
2136   Dir->setCounters(Exprs.Counters);
2137   Dir->setPrivateCounters(Exprs.PrivateCounters);
2138   Dir->setInits(Exprs.Inits);
2139   Dir->setUpdates(Exprs.Updates);
2140   Dir->setFinals(Exprs.Finals);
2141   Dir->setDependentCounters(Exprs.DependentCounters);
2142   Dir->setDependentInits(Exprs.DependentInits);
2143   Dir->setFinalsConditions(Exprs.FinalsConditions);
2144   Dir->setPreInits(Exprs.PreInits);
2145   return Dir;
2146 }
2147 
2148 OMPGenericLoopDirective *
2149 OMPGenericLoopDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
2150                                      unsigned CollapsedNum, EmptyShell) {
2151   return createEmptyDirective<OMPGenericLoopDirective>(
2152       C, NumClauses, /*HasAssociatedStmt=*/true,
2153       numLoopChildren(CollapsedNum, OMPD_loop), CollapsedNum);
2154 }
2155 
2156 OMPTeamsGenericLoopDirective *OMPTeamsGenericLoopDirective::Create(
2157     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2158     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2159     const HelperExprs &Exprs) {
2160   auto *Dir = createDirective<OMPTeamsGenericLoopDirective>(
2161       C, Clauses, AssociatedStmt,
2162       numLoopChildren(CollapsedNum, OMPD_teams_loop), StartLoc, EndLoc,
2163       CollapsedNum);
2164   Dir->setIterationVariable(Exprs.IterationVarRef);
2165   Dir->setLastIteration(Exprs.LastIteration);
2166   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2167   Dir->setPreCond(Exprs.PreCond);
2168   Dir->setCond(Exprs.Cond);
2169   Dir->setInit(Exprs.Init);
2170   Dir->setInc(Exprs.Inc);
2171   Dir->setIsLastIterVariable(Exprs.IL);
2172   Dir->setLowerBoundVariable(Exprs.LB);
2173   Dir->setUpperBoundVariable(Exprs.UB);
2174   Dir->setStrideVariable(Exprs.ST);
2175   Dir->setEnsureUpperBound(Exprs.EUB);
2176   Dir->setNextLowerBound(Exprs.NLB);
2177   Dir->setNextUpperBound(Exprs.NUB);
2178   Dir->setNumIterations(Exprs.NumIterations);
2179   Dir->setCounters(Exprs.Counters);
2180   Dir->setPrivateCounters(Exprs.PrivateCounters);
2181   Dir->setInits(Exprs.Inits);
2182   Dir->setUpdates(Exprs.Updates);
2183   Dir->setFinals(Exprs.Finals);
2184   Dir->setDependentCounters(Exprs.DependentCounters);
2185   Dir->setDependentInits(Exprs.DependentInits);
2186   Dir->setFinalsConditions(Exprs.FinalsConditions);
2187   Dir->setPreInits(Exprs.PreInits);
2188   return Dir;
2189 }
2190 
2191 OMPTeamsGenericLoopDirective *
2192 OMPTeamsGenericLoopDirective::CreateEmpty(const ASTContext &C,
2193                                           unsigned NumClauses,
2194                                           unsigned CollapsedNum, EmptyShell) {
2195   return createEmptyDirective<OMPTeamsGenericLoopDirective>(
2196       C, NumClauses, /*HasAssociatedStmt=*/true,
2197       numLoopChildren(CollapsedNum, OMPD_teams_loop), CollapsedNum);
2198 }
2199 
2200 OMPTargetTeamsGenericLoopDirective *OMPTargetTeamsGenericLoopDirective::Create(
2201     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2202     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2203     const HelperExprs &Exprs) {
2204   auto *Dir = createDirective<OMPTargetTeamsGenericLoopDirective>(
2205       C, Clauses, AssociatedStmt,
2206       numLoopChildren(CollapsedNum, OMPD_target_teams_loop), StartLoc, EndLoc,
2207       CollapsedNum);
2208   Dir->setIterationVariable(Exprs.IterationVarRef);
2209   Dir->setLastIteration(Exprs.LastIteration);
2210   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2211   Dir->setPreCond(Exprs.PreCond);
2212   Dir->setCond(Exprs.Cond);
2213   Dir->setInit(Exprs.Init);
2214   Dir->setInc(Exprs.Inc);
2215   Dir->setIsLastIterVariable(Exprs.IL);
2216   Dir->setLowerBoundVariable(Exprs.LB);
2217   Dir->setUpperBoundVariable(Exprs.UB);
2218   Dir->setStrideVariable(Exprs.ST);
2219   Dir->setEnsureUpperBound(Exprs.EUB);
2220   Dir->setNextLowerBound(Exprs.NLB);
2221   Dir->setNextUpperBound(Exprs.NUB);
2222   Dir->setNumIterations(Exprs.NumIterations);
2223   Dir->setCounters(Exprs.Counters);
2224   Dir->setPrivateCounters(Exprs.PrivateCounters);
2225   Dir->setInits(Exprs.Inits);
2226   Dir->setUpdates(Exprs.Updates);
2227   Dir->setFinals(Exprs.Finals);
2228   Dir->setDependentCounters(Exprs.DependentCounters);
2229   Dir->setDependentInits(Exprs.DependentInits);
2230   Dir->setFinalsConditions(Exprs.FinalsConditions);
2231   Dir->setPreInits(Exprs.PreInits);
2232   return Dir;
2233 }
2234 
2235 OMPTargetTeamsGenericLoopDirective *
2236 OMPTargetTeamsGenericLoopDirective::CreateEmpty(const ASTContext &C,
2237                                                 unsigned NumClauses,
2238                                                 unsigned CollapsedNum,
2239                                                 EmptyShell) {
2240   return createEmptyDirective<OMPTargetTeamsGenericLoopDirective>(
2241       C, NumClauses, /*HasAssociatedStmt=*/true,
2242       numLoopChildren(CollapsedNum, OMPD_target_teams_loop), CollapsedNum);
2243 }
2244 
2245 OMPParallelGenericLoopDirective *OMPParallelGenericLoopDirective::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<OMPParallelGenericLoopDirective>(
2250       C, Clauses, AssociatedStmt,
2251       numLoopChildren(CollapsedNum, OMPD_parallel_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 OMPParallelGenericLoopDirective *OMPParallelGenericLoopDirective::CreateEmpty(
2281     const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
2282     EmptyShell) {
2283   return createEmptyDirective<OMPParallelGenericLoopDirective>(
2284       C, NumClauses, /*HasAssociatedStmt=*/true,
2285       numLoopChildren(CollapsedNum, OMPD_parallel_loop), CollapsedNum);
2286 }
2287 
2288 OMPTargetParallelGenericLoopDirective *
2289 OMPTargetParallelGenericLoopDirective::Create(
2290     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2291     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2292     const HelperExprs &Exprs) {
2293   auto *Dir = createDirective<OMPTargetParallelGenericLoopDirective>(
2294       C, Clauses, AssociatedStmt,
2295       numLoopChildren(CollapsedNum, OMPD_target_parallel_loop), StartLoc,
2296       EndLoc, CollapsedNum);
2297   Dir->setIterationVariable(Exprs.IterationVarRef);
2298   Dir->setLastIteration(Exprs.LastIteration);
2299   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2300   Dir->setPreCond(Exprs.PreCond);
2301   Dir->setCond(Exprs.Cond);
2302   Dir->setInit(Exprs.Init);
2303   Dir->setInc(Exprs.Inc);
2304   Dir->setIsLastIterVariable(Exprs.IL);
2305   Dir->setLowerBoundVariable(Exprs.LB);
2306   Dir->setUpperBoundVariable(Exprs.UB);
2307   Dir->setStrideVariable(Exprs.ST);
2308   Dir->setEnsureUpperBound(Exprs.EUB);
2309   Dir->setNextLowerBound(Exprs.NLB);
2310   Dir->setNextUpperBound(Exprs.NUB);
2311   Dir->setNumIterations(Exprs.NumIterations);
2312   Dir->setCounters(Exprs.Counters);
2313   Dir->setPrivateCounters(Exprs.PrivateCounters);
2314   Dir->setInits(Exprs.Inits);
2315   Dir->setUpdates(Exprs.Updates);
2316   Dir->setFinals(Exprs.Finals);
2317   Dir->setDependentCounters(Exprs.DependentCounters);
2318   Dir->setDependentInits(Exprs.DependentInits);
2319   Dir->setFinalsConditions(Exprs.FinalsConditions);
2320   Dir->setPreInits(Exprs.PreInits);
2321   return Dir;
2322 }
2323 
2324 OMPTargetParallelGenericLoopDirective *
2325 OMPTargetParallelGenericLoopDirective::CreateEmpty(const ASTContext &C,
2326                                                    unsigned NumClauses,
2327                                                    unsigned CollapsedNum,
2328                                                    EmptyShell) {
2329   return createEmptyDirective<OMPTargetParallelGenericLoopDirective>(
2330       C, NumClauses, /*HasAssociatedStmt=*/true,
2331       numLoopChildren(CollapsedNum, OMPD_target_parallel_loop), CollapsedNum);
2332 }
2333