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