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                                            /*NumChildre=*/0, StartLoc, EndLoc);
522   Dir->setHasCancel(HasCancel);
523   return Dir;
524 }
525 
526 OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C,
527                                                       EmptyShell) {
528   return createEmptyDirective<OMPSectionDirective>(C, /*NumClauses=*/0,
529                                                    /*HasAssociatedStmt=*/true);
530 }
531 
532 OMPSingleDirective *OMPSingleDirective::Create(const ASTContext &C,
533                                                SourceLocation StartLoc,
534                                                SourceLocation EndLoc,
535                                                ArrayRef<OMPClause *> Clauses,
536                                                Stmt *AssociatedStmt) {
537   return createDirective<OMPSingleDirective>(C, Clauses, AssociatedStmt,
538                                              /*NumChildren=*/0, StartLoc,
539                                              EndLoc);
540 }
541 
542 OMPSingleDirective *OMPSingleDirective::CreateEmpty(const ASTContext &C,
543                                                     unsigned NumClauses,
544                                                     EmptyShell) {
545   return createEmptyDirective<OMPSingleDirective>(C, NumClauses,
546                                                   /*HasAssociatedStmt=*/true);
547 }
548 
549 OMPMasterDirective *OMPMasterDirective::Create(const ASTContext &C,
550                                                SourceLocation StartLoc,
551                                                SourceLocation EndLoc,
552                                                Stmt *AssociatedStmt) {
553   return createDirective<OMPMasterDirective>(C, llvm::None, AssociatedStmt,
554                                              /*NumChildren=*/0, StartLoc,
555                                              EndLoc);
556 }
557 
558 OMPMasterDirective *OMPMasterDirective::CreateEmpty(const ASTContext &C,
559                                                     EmptyShell) {
560   return createEmptyDirective<OMPMasterDirective>(C, /*NumClauses=*/0,
561                                                   /*HasAssociatedStmt=*/true);
562 }
563 
564 OMPCriticalDirective *OMPCriticalDirective::Create(
565     const ASTContext &C, const DeclarationNameInfo &Name,
566     SourceLocation StartLoc, SourceLocation EndLoc,
567     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
568   return createDirective<OMPCriticalDirective>(C, Clauses, AssociatedStmt,
569                                                /*NumChildren=*/0, Name,
570                                                StartLoc, EndLoc);
571 }
572 
573 OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C,
574                                                         unsigned NumClauses,
575                                                         EmptyShell) {
576   return createEmptyDirective<OMPCriticalDirective>(C, NumClauses,
577                                                     /*HasAssociatedStmt=*/true);
578 }
579 
580 OMPParallelForDirective *OMPParallelForDirective::Create(
581     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
582     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
583     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
584   auto *Dir = createDirective<OMPParallelForDirective>(
585       C, Clauses, AssociatedStmt,
586       numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, StartLoc, EndLoc,
587       CollapsedNum);
588   Dir->setIterationVariable(Exprs.IterationVarRef);
589   Dir->setLastIteration(Exprs.LastIteration);
590   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
591   Dir->setPreCond(Exprs.PreCond);
592   Dir->setCond(Exprs.Cond);
593   Dir->setInit(Exprs.Init);
594   Dir->setInc(Exprs.Inc);
595   Dir->setIsLastIterVariable(Exprs.IL);
596   Dir->setLowerBoundVariable(Exprs.LB);
597   Dir->setUpperBoundVariable(Exprs.UB);
598   Dir->setStrideVariable(Exprs.ST);
599   Dir->setEnsureUpperBound(Exprs.EUB);
600   Dir->setNextLowerBound(Exprs.NLB);
601   Dir->setNextUpperBound(Exprs.NUB);
602   Dir->setNumIterations(Exprs.NumIterations);
603   Dir->setCounters(Exprs.Counters);
604   Dir->setPrivateCounters(Exprs.PrivateCounters);
605   Dir->setInits(Exprs.Inits);
606   Dir->setUpdates(Exprs.Updates);
607   Dir->setFinals(Exprs.Finals);
608   Dir->setDependentCounters(Exprs.DependentCounters);
609   Dir->setDependentInits(Exprs.DependentInits);
610   Dir->setFinalsConditions(Exprs.FinalsConditions);
611   Dir->setPreInits(Exprs.PreInits);
612   Dir->setTaskReductionRefExpr(TaskRedRef);
613   Dir->setHasCancel(HasCancel);
614   return Dir;
615 }
616 
617 OMPParallelForDirective *
618 OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
619                                      unsigned CollapsedNum, EmptyShell) {
620   return createEmptyDirective<OMPParallelForDirective>(
621       C, NumClauses, /*HasAssociatedStmt=*/true,
622       numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, CollapsedNum);
623 }
624 
625 OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create(
626     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
627     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
628     const HelperExprs &Exprs) {
629   auto *Dir = createDirective<OMPParallelForSimdDirective>(
630       C, Clauses, AssociatedStmt,
631       numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), StartLoc, EndLoc,
632       CollapsedNum);
633   Dir->setIterationVariable(Exprs.IterationVarRef);
634   Dir->setLastIteration(Exprs.LastIteration);
635   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
636   Dir->setPreCond(Exprs.PreCond);
637   Dir->setCond(Exprs.Cond);
638   Dir->setInit(Exprs.Init);
639   Dir->setInc(Exprs.Inc);
640   Dir->setIsLastIterVariable(Exprs.IL);
641   Dir->setLowerBoundVariable(Exprs.LB);
642   Dir->setUpperBoundVariable(Exprs.UB);
643   Dir->setStrideVariable(Exprs.ST);
644   Dir->setEnsureUpperBound(Exprs.EUB);
645   Dir->setNextLowerBound(Exprs.NLB);
646   Dir->setNextUpperBound(Exprs.NUB);
647   Dir->setNumIterations(Exprs.NumIterations);
648   Dir->setCounters(Exprs.Counters);
649   Dir->setPrivateCounters(Exprs.PrivateCounters);
650   Dir->setInits(Exprs.Inits);
651   Dir->setUpdates(Exprs.Updates);
652   Dir->setFinals(Exprs.Finals);
653   Dir->setDependentCounters(Exprs.DependentCounters);
654   Dir->setDependentInits(Exprs.DependentInits);
655   Dir->setFinalsConditions(Exprs.FinalsConditions);
656   Dir->setPreInits(Exprs.PreInits);
657   return Dir;
658 }
659 
660 OMPParallelForSimdDirective *
661 OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C,
662                                          unsigned NumClauses,
663                                          unsigned CollapsedNum, EmptyShell) {
664   return createEmptyDirective<OMPParallelForSimdDirective>(
665       C, NumClauses, /*HasAssociatedStmt=*/true,
666       numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), CollapsedNum);
667 }
668 
669 OMPParallelMasterDirective *OMPParallelMasterDirective::Create(
670     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
671     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef) {
672   auto *Dir = createDirective<OMPParallelMasterDirective>(
673       C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
674   Dir->setTaskReductionRefExpr(TaskRedRef);
675   return Dir;
676 }
677 
678 OMPParallelMasterDirective *
679 OMPParallelMasterDirective::CreateEmpty(const ASTContext &C,
680                                         unsigned NumClauses, EmptyShell) {
681   return createEmptyDirective<OMPParallelMasterDirective>(
682       C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
683 }
684 
685 OMPParallelSectionsDirective *OMPParallelSectionsDirective::Create(
686     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
687     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
688     bool HasCancel) {
689   auto *Dir = createDirective<OMPParallelSectionsDirective>(
690       C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
691   Dir->setTaskReductionRefExpr(TaskRedRef);
692   Dir->setHasCancel(HasCancel);
693   return Dir;
694 }
695 
696 OMPParallelSectionsDirective *
697 OMPParallelSectionsDirective::CreateEmpty(const ASTContext &C,
698                                           unsigned NumClauses, EmptyShell) {
699   return createEmptyDirective<OMPParallelSectionsDirective>(
700       C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
701 }
702 
703 OMPTaskDirective *
704 OMPTaskDirective::Create(const ASTContext &C, SourceLocation StartLoc,
705                          SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
706                          Stmt *AssociatedStmt, bool HasCancel) {
707   auto *Dir = createDirective<OMPTaskDirective>(
708       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
709   Dir->setHasCancel(HasCancel);
710   return Dir;
711 }
712 
713 OMPTaskDirective *OMPTaskDirective::CreateEmpty(const ASTContext &C,
714                                                 unsigned NumClauses,
715                                                 EmptyShell) {
716   return createEmptyDirective<OMPTaskDirective>(C, NumClauses,
717                                                 /*HasAssociatedStmt=*/true);
718 }
719 
720 OMPTaskyieldDirective *OMPTaskyieldDirective::Create(const ASTContext &C,
721                                                      SourceLocation StartLoc,
722                                                      SourceLocation EndLoc) {
723   return new (C) OMPTaskyieldDirective(StartLoc, EndLoc);
724 }
725 
726 OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C,
727                                                           EmptyShell) {
728   return new (C) OMPTaskyieldDirective();
729 }
730 
731 OMPBarrierDirective *OMPBarrierDirective::Create(const ASTContext &C,
732                                                  SourceLocation StartLoc,
733                                                  SourceLocation EndLoc) {
734   return new (C) OMPBarrierDirective(StartLoc, EndLoc);
735 }
736 
737 OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C,
738                                                       EmptyShell) {
739   return new (C) OMPBarrierDirective();
740 }
741 
742 OMPTaskwaitDirective *OMPTaskwaitDirective::Create(const ASTContext &C,
743                                                    SourceLocation StartLoc,
744                                                    SourceLocation EndLoc) {
745   return new (C) OMPTaskwaitDirective(StartLoc, EndLoc);
746 }
747 
748 OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C,
749                                                         EmptyShell) {
750   return new (C) OMPTaskwaitDirective();
751 }
752 
753 OMPTaskgroupDirective *OMPTaskgroupDirective::Create(
754     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
755     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *ReductionRef) {
756   auto *Dir = createDirective<OMPTaskgroupDirective>(
757       C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
758   Dir->setReductionRef(ReductionRef);
759   return Dir;
760 }
761 
762 OMPTaskgroupDirective *OMPTaskgroupDirective::CreateEmpty(const ASTContext &C,
763                                                           unsigned NumClauses,
764                                                           EmptyShell) {
765   return createEmptyDirective<OMPTaskgroupDirective>(
766       C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
767 }
768 
769 OMPCancellationPointDirective *OMPCancellationPointDirective::Create(
770     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
771     OpenMPDirectiveKind CancelRegion) {
772   auto *Dir = new (C) OMPCancellationPointDirective(StartLoc, EndLoc);
773   Dir->setCancelRegion(CancelRegion);
774   return Dir;
775 }
776 
777 OMPCancellationPointDirective *
778 OMPCancellationPointDirective::CreateEmpty(const ASTContext &C, EmptyShell) {
779   return new (C) OMPCancellationPointDirective();
780 }
781 
782 OMPCancelDirective *
783 OMPCancelDirective::Create(const ASTContext &C, SourceLocation StartLoc,
784                            SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
785                            OpenMPDirectiveKind CancelRegion) {
786   auto *Dir = createDirective<OMPCancelDirective>(
787       C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc,
788       EndLoc);
789   Dir->setCancelRegion(CancelRegion);
790   return Dir;
791 }
792 
793 OMPCancelDirective *OMPCancelDirective::CreateEmpty(const ASTContext &C,
794                                                     unsigned NumClauses,
795                                                     EmptyShell) {
796   return createEmptyDirective<OMPCancelDirective>(C, NumClauses);
797 }
798 
799 OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C,
800                                              SourceLocation StartLoc,
801                                              SourceLocation EndLoc,
802                                              ArrayRef<OMPClause *> Clauses) {
803   return createDirective<OMPFlushDirective>(
804       C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc,
805       EndLoc);
806 }
807 
808 OMPFlushDirective *OMPFlushDirective::CreateEmpty(const ASTContext &C,
809                                                   unsigned NumClauses,
810                                                   EmptyShell) {
811   return createEmptyDirective<OMPFlushDirective>(C, NumClauses);
812 }
813 
814 OMPDepobjDirective *OMPDepobjDirective::Create(const ASTContext &C,
815                                                SourceLocation StartLoc,
816                                                SourceLocation EndLoc,
817                                                ArrayRef<OMPClause *> Clauses) {
818   return createDirective<OMPDepobjDirective>(
819       C, Clauses, /*AssociatedStmt=*/nullptr,
820       /*NumChildren=*/0, StartLoc, EndLoc);
821 }
822 
823 OMPDepobjDirective *OMPDepobjDirective::CreateEmpty(const ASTContext &C,
824                                                     unsigned NumClauses,
825                                                     EmptyShell) {
826   return createEmptyDirective<OMPDepobjDirective>(C, NumClauses);
827 }
828 
829 OMPScanDirective *OMPScanDirective::Create(const ASTContext &C,
830                                            SourceLocation StartLoc,
831                                            SourceLocation EndLoc,
832                                            ArrayRef<OMPClause *> Clauses) {
833   return createDirective<OMPScanDirective>(C, Clauses,
834                                            /*AssociatedStmt=*/nullptr,
835                                            /*NumChildren=*/0, StartLoc, EndLoc);
836 }
837 
838 OMPScanDirective *OMPScanDirective::CreateEmpty(const ASTContext &C,
839                                                 unsigned NumClauses,
840                                                 EmptyShell) {
841   return createEmptyDirective<OMPScanDirective>(C, NumClauses);
842 }
843 
844 OMPOrderedDirective *OMPOrderedDirective::Create(const ASTContext &C,
845                                                  SourceLocation StartLoc,
846                                                  SourceLocation EndLoc,
847                                                  ArrayRef<OMPClause *> Clauses,
848                                                  Stmt *AssociatedStmt) {
849   return createDirective<OMPOrderedDirective>(
850       C, Clauses, cast_or_null<CapturedStmt>(AssociatedStmt),
851       /*NumChildren=*/0, StartLoc, EndLoc);
852 }
853 
854 OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(const ASTContext &C,
855                                                       unsigned NumClauses,
856                                                       bool IsStandalone,
857                                                       EmptyShell) {
858   return createEmptyDirective<OMPOrderedDirective>(C, NumClauses,
859                                                    !IsStandalone);
860 }
861 
862 OMPAtomicDirective *OMPAtomicDirective::Create(
863     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
864     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
865     Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {
866   auto *Dir = createDirective<OMPAtomicDirective>(
867       C, Clauses, AssociatedStmt, /*NumChildren=*/4, StartLoc, EndLoc);
868   Dir->setX(X);
869   Dir->setV(V);
870   Dir->setExpr(E);
871   Dir->setUpdateExpr(UE);
872   Dir->IsXLHSInRHSPart = IsXLHSInRHSPart;
873   Dir->IsPostfixUpdate = IsPostfixUpdate;
874   return Dir;
875 }
876 
877 OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C,
878                                                     unsigned NumClauses,
879                                                     EmptyShell) {
880   return createEmptyDirective<OMPAtomicDirective>(
881       C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/4);
882 }
883 
884 OMPTargetDirective *OMPTargetDirective::Create(const ASTContext &C,
885                                                SourceLocation StartLoc,
886                                                SourceLocation EndLoc,
887                                                ArrayRef<OMPClause *> Clauses,
888                                                Stmt *AssociatedStmt) {
889   return createDirective<OMPTargetDirective>(
890       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
891 }
892 
893 OMPTargetDirective *OMPTargetDirective::CreateEmpty(const ASTContext &C,
894                                                     unsigned NumClauses,
895                                                     EmptyShell) {
896   return createEmptyDirective<OMPTargetDirective>(C, NumClauses,
897                                                   /*HasAssociatedStmt=*/true);
898 }
899 
900 OMPTargetParallelDirective *OMPTargetParallelDirective::Create(
901     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
902     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
903     bool HasCancel) {
904   auto *Dir = createDirective<OMPTargetParallelDirective>(
905       C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
906   Dir->setTaskReductionRefExpr(TaskRedRef);
907   Dir->setHasCancel(HasCancel);
908   return Dir;
909 }
910 
911 OMPTargetParallelDirective *
912 OMPTargetParallelDirective::CreateEmpty(const ASTContext &C,
913                                         unsigned NumClauses, EmptyShell) {
914   return createEmptyDirective<OMPTargetParallelDirective>(
915       C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
916 }
917 
918 OMPTargetParallelForDirective *OMPTargetParallelForDirective::Create(
919     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
920     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
921     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
922   auto *Dir = createDirective<OMPTargetParallelForDirective>(
923       C, Clauses, AssociatedStmt,
924       numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1, StartLoc,
925       EndLoc, CollapsedNum);
926   Dir->setIterationVariable(Exprs.IterationVarRef);
927   Dir->setLastIteration(Exprs.LastIteration);
928   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
929   Dir->setPreCond(Exprs.PreCond);
930   Dir->setCond(Exprs.Cond);
931   Dir->setInit(Exprs.Init);
932   Dir->setInc(Exprs.Inc);
933   Dir->setIsLastIterVariable(Exprs.IL);
934   Dir->setLowerBoundVariable(Exprs.LB);
935   Dir->setUpperBoundVariable(Exprs.UB);
936   Dir->setStrideVariable(Exprs.ST);
937   Dir->setEnsureUpperBound(Exprs.EUB);
938   Dir->setNextLowerBound(Exprs.NLB);
939   Dir->setNextUpperBound(Exprs.NUB);
940   Dir->setNumIterations(Exprs.NumIterations);
941   Dir->setCounters(Exprs.Counters);
942   Dir->setPrivateCounters(Exprs.PrivateCounters);
943   Dir->setInits(Exprs.Inits);
944   Dir->setUpdates(Exprs.Updates);
945   Dir->setFinals(Exprs.Finals);
946   Dir->setDependentCounters(Exprs.DependentCounters);
947   Dir->setDependentInits(Exprs.DependentInits);
948   Dir->setFinalsConditions(Exprs.FinalsConditions);
949   Dir->setPreInits(Exprs.PreInits);
950   Dir->setTaskReductionRefExpr(TaskRedRef);
951   Dir->setHasCancel(HasCancel);
952   return Dir;
953 }
954 
955 OMPTargetParallelForDirective *
956 OMPTargetParallelForDirective::CreateEmpty(const ASTContext &C,
957                                            unsigned NumClauses,
958                                            unsigned CollapsedNum, EmptyShell) {
959   return createEmptyDirective<OMPTargetParallelForDirective>(
960       C, NumClauses, /*HasAssociatedStmt=*/true,
961       numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1,
962       CollapsedNum);
963 }
964 
965 OMPTargetDataDirective *OMPTargetDataDirective::Create(
966     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
967     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
968   return createDirective<OMPTargetDataDirective>(
969       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
970 }
971 
972 OMPTargetDataDirective *OMPTargetDataDirective::CreateEmpty(const ASTContext &C,
973                                                             unsigned N,
974                                                             EmptyShell) {
975   return createEmptyDirective<OMPTargetDataDirective>(
976       C, N, /*HasAssociatedStmt=*/true);
977 }
978 
979 OMPTargetEnterDataDirective *OMPTargetEnterDataDirective::Create(
980     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
981     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
982   return createDirective<OMPTargetEnterDataDirective>(
983       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
984 }
985 
986 OMPTargetEnterDataDirective *
987 OMPTargetEnterDataDirective::CreateEmpty(const ASTContext &C, unsigned N,
988                                          EmptyShell) {
989   return createEmptyDirective<OMPTargetEnterDataDirective>(
990       C, N, /*HasAssociatedStmt=*/true);
991 }
992 
993 OMPTargetExitDataDirective *OMPTargetExitDataDirective::Create(
994     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
995     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
996   return createDirective<OMPTargetExitDataDirective>(
997       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
998 }
999 
1000 OMPTargetExitDataDirective *
1001 OMPTargetExitDataDirective::CreateEmpty(const ASTContext &C, unsigned N,
1002                                         EmptyShell) {
1003   return createEmptyDirective<OMPTargetExitDataDirective>(
1004       C, N, /*HasAssociatedStmt=*/true);
1005 }
1006 
1007 OMPTeamsDirective *OMPTeamsDirective::Create(const ASTContext &C,
1008                                              SourceLocation StartLoc,
1009                                              SourceLocation EndLoc,
1010                                              ArrayRef<OMPClause *> Clauses,
1011                                              Stmt *AssociatedStmt) {
1012   return createDirective<OMPTeamsDirective>(
1013       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
1014 }
1015 
1016 OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C,
1017                                                   unsigned NumClauses,
1018                                                   EmptyShell) {
1019   return createEmptyDirective<OMPTeamsDirective>(C, NumClauses,
1020                                                  /*HasAssociatedStmt=*/true);
1021 }
1022 
1023 OMPTaskLoopDirective *OMPTaskLoopDirective::Create(
1024     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1025     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1026     const HelperExprs &Exprs, bool HasCancel) {
1027   auto *Dir = createDirective<OMPTaskLoopDirective>(
1028       C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_taskloop),
1029       StartLoc, EndLoc, CollapsedNum);
1030   Dir->setIterationVariable(Exprs.IterationVarRef);
1031   Dir->setLastIteration(Exprs.LastIteration);
1032   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1033   Dir->setPreCond(Exprs.PreCond);
1034   Dir->setCond(Exprs.Cond);
1035   Dir->setInit(Exprs.Init);
1036   Dir->setInc(Exprs.Inc);
1037   Dir->setIsLastIterVariable(Exprs.IL);
1038   Dir->setLowerBoundVariable(Exprs.LB);
1039   Dir->setUpperBoundVariable(Exprs.UB);
1040   Dir->setStrideVariable(Exprs.ST);
1041   Dir->setEnsureUpperBound(Exprs.EUB);
1042   Dir->setNextLowerBound(Exprs.NLB);
1043   Dir->setNextUpperBound(Exprs.NUB);
1044   Dir->setNumIterations(Exprs.NumIterations);
1045   Dir->setCounters(Exprs.Counters);
1046   Dir->setPrivateCounters(Exprs.PrivateCounters);
1047   Dir->setInits(Exprs.Inits);
1048   Dir->setUpdates(Exprs.Updates);
1049   Dir->setFinals(Exprs.Finals);
1050   Dir->setDependentCounters(Exprs.DependentCounters);
1051   Dir->setDependentInits(Exprs.DependentInits);
1052   Dir->setFinalsConditions(Exprs.FinalsConditions);
1053   Dir->setPreInits(Exprs.PreInits);
1054   Dir->setHasCancel(HasCancel);
1055   return Dir;
1056 }
1057 
1058 OMPTaskLoopDirective *OMPTaskLoopDirective::CreateEmpty(const ASTContext &C,
1059                                                         unsigned NumClauses,
1060                                                         unsigned CollapsedNum,
1061                                                         EmptyShell) {
1062   return createEmptyDirective<OMPTaskLoopDirective>(
1063       C, NumClauses, /*HasAssociatedStmt=*/true,
1064       numLoopChildren(CollapsedNum, OMPD_taskloop), CollapsedNum);
1065 }
1066 
1067 OMPTaskLoopSimdDirective *OMPTaskLoopSimdDirective::Create(
1068     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1069     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1070     const HelperExprs &Exprs) {
1071   auto *Dir = createDirective<OMPTaskLoopSimdDirective>(
1072       C, Clauses, AssociatedStmt,
1073       numLoopChildren(CollapsedNum, OMPD_taskloop_simd), StartLoc, EndLoc,
1074       CollapsedNum);
1075   Dir->setIterationVariable(Exprs.IterationVarRef);
1076   Dir->setLastIteration(Exprs.LastIteration);
1077   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1078   Dir->setPreCond(Exprs.PreCond);
1079   Dir->setCond(Exprs.Cond);
1080   Dir->setInit(Exprs.Init);
1081   Dir->setInc(Exprs.Inc);
1082   Dir->setIsLastIterVariable(Exprs.IL);
1083   Dir->setLowerBoundVariable(Exprs.LB);
1084   Dir->setUpperBoundVariable(Exprs.UB);
1085   Dir->setStrideVariable(Exprs.ST);
1086   Dir->setEnsureUpperBound(Exprs.EUB);
1087   Dir->setNextLowerBound(Exprs.NLB);
1088   Dir->setNextUpperBound(Exprs.NUB);
1089   Dir->setNumIterations(Exprs.NumIterations);
1090   Dir->setCounters(Exprs.Counters);
1091   Dir->setPrivateCounters(Exprs.PrivateCounters);
1092   Dir->setInits(Exprs.Inits);
1093   Dir->setUpdates(Exprs.Updates);
1094   Dir->setFinals(Exprs.Finals);
1095   Dir->setDependentCounters(Exprs.DependentCounters);
1096   Dir->setDependentInits(Exprs.DependentInits);
1097   Dir->setFinalsConditions(Exprs.FinalsConditions);
1098   Dir->setPreInits(Exprs.PreInits);
1099   return Dir;
1100 }
1101 
1102 OMPTaskLoopSimdDirective *
1103 OMPTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1104                                       unsigned CollapsedNum, EmptyShell) {
1105   return createEmptyDirective<OMPTaskLoopSimdDirective>(
1106       C, NumClauses, /*HasAssociatedStmt=*/true,
1107       numLoopChildren(CollapsedNum, OMPD_taskloop_simd), CollapsedNum);
1108 }
1109 
1110 OMPMasterTaskLoopDirective *OMPMasterTaskLoopDirective::Create(
1111     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1112     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1113     const HelperExprs &Exprs, bool HasCancel) {
1114   auto *Dir = createDirective<OMPMasterTaskLoopDirective>(
1115       C, Clauses, AssociatedStmt,
1116       numLoopChildren(CollapsedNum, OMPD_master_taskloop), StartLoc, EndLoc,
1117       CollapsedNum);
1118   Dir->setIterationVariable(Exprs.IterationVarRef);
1119   Dir->setLastIteration(Exprs.LastIteration);
1120   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1121   Dir->setPreCond(Exprs.PreCond);
1122   Dir->setCond(Exprs.Cond);
1123   Dir->setInit(Exprs.Init);
1124   Dir->setInc(Exprs.Inc);
1125   Dir->setIsLastIterVariable(Exprs.IL);
1126   Dir->setLowerBoundVariable(Exprs.LB);
1127   Dir->setUpperBoundVariable(Exprs.UB);
1128   Dir->setStrideVariable(Exprs.ST);
1129   Dir->setEnsureUpperBound(Exprs.EUB);
1130   Dir->setNextLowerBound(Exprs.NLB);
1131   Dir->setNextUpperBound(Exprs.NUB);
1132   Dir->setNumIterations(Exprs.NumIterations);
1133   Dir->setCounters(Exprs.Counters);
1134   Dir->setPrivateCounters(Exprs.PrivateCounters);
1135   Dir->setInits(Exprs.Inits);
1136   Dir->setUpdates(Exprs.Updates);
1137   Dir->setFinals(Exprs.Finals);
1138   Dir->setDependentCounters(Exprs.DependentCounters);
1139   Dir->setDependentInits(Exprs.DependentInits);
1140   Dir->setFinalsConditions(Exprs.FinalsConditions);
1141   Dir->setPreInits(Exprs.PreInits);
1142   Dir->setHasCancel(HasCancel);
1143   return Dir;
1144 }
1145 
1146 OMPMasterTaskLoopDirective *
1147 OMPMasterTaskLoopDirective::CreateEmpty(const ASTContext &C,
1148                                         unsigned NumClauses,
1149                                         unsigned CollapsedNum, EmptyShell) {
1150   return createEmptyDirective<OMPMasterTaskLoopDirective>(
1151       C, NumClauses, /*HasAssociatedStmt=*/true,
1152       numLoopChildren(CollapsedNum, OMPD_master_taskloop), CollapsedNum);
1153 }
1154 
1155 OMPMasterTaskLoopSimdDirective *OMPMasterTaskLoopSimdDirective::Create(
1156     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1157     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1158     const HelperExprs &Exprs) {
1159   auto *Dir = createDirective<OMPMasterTaskLoopSimdDirective>(
1160       C, Clauses, AssociatedStmt,
1161       numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), StartLoc,
1162       EndLoc, CollapsedNum);
1163   Dir->setIterationVariable(Exprs.IterationVarRef);
1164   Dir->setLastIteration(Exprs.LastIteration);
1165   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1166   Dir->setPreCond(Exprs.PreCond);
1167   Dir->setCond(Exprs.Cond);
1168   Dir->setInit(Exprs.Init);
1169   Dir->setInc(Exprs.Inc);
1170   Dir->setIsLastIterVariable(Exprs.IL);
1171   Dir->setLowerBoundVariable(Exprs.LB);
1172   Dir->setUpperBoundVariable(Exprs.UB);
1173   Dir->setStrideVariable(Exprs.ST);
1174   Dir->setEnsureUpperBound(Exprs.EUB);
1175   Dir->setNextLowerBound(Exprs.NLB);
1176   Dir->setNextUpperBound(Exprs.NUB);
1177   Dir->setNumIterations(Exprs.NumIterations);
1178   Dir->setCounters(Exprs.Counters);
1179   Dir->setPrivateCounters(Exprs.PrivateCounters);
1180   Dir->setInits(Exprs.Inits);
1181   Dir->setUpdates(Exprs.Updates);
1182   Dir->setFinals(Exprs.Finals);
1183   Dir->setDependentCounters(Exprs.DependentCounters);
1184   Dir->setDependentInits(Exprs.DependentInits);
1185   Dir->setFinalsConditions(Exprs.FinalsConditions);
1186   Dir->setPreInits(Exprs.PreInits);
1187   return Dir;
1188 }
1189 
1190 OMPMasterTaskLoopSimdDirective *
1191 OMPMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C,
1192                                             unsigned NumClauses,
1193                                             unsigned CollapsedNum, EmptyShell) {
1194   return createEmptyDirective<OMPMasterTaskLoopSimdDirective>(
1195       C, NumClauses, /*HasAssociatedStmt=*/true,
1196       numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), CollapsedNum);
1197 }
1198 
1199 OMPParallelMasterTaskLoopDirective *OMPParallelMasterTaskLoopDirective::Create(
1200     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1201     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1202     const HelperExprs &Exprs, bool HasCancel) {
1203   auto *Dir = createDirective<OMPParallelMasterTaskLoopDirective>(
1204       C, Clauses, AssociatedStmt,
1205       numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop), StartLoc,
1206       EndLoc, CollapsedNum);
1207   Dir->setIterationVariable(Exprs.IterationVarRef);
1208   Dir->setLastIteration(Exprs.LastIteration);
1209   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1210   Dir->setPreCond(Exprs.PreCond);
1211   Dir->setCond(Exprs.Cond);
1212   Dir->setInit(Exprs.Init);
1213   Dir->setInc(Exprs.Inc);
1214   Dir->setIsLastIterVariable(Exprs.IL);
1215   Dir->setLowerBoundVariable(Exprs.LB);
1216   Dir->setUpperBoundVariable(Exprs.UB);
1217   Dir->setStrideVariable(Exprs.ST);
1218   Dir->setEnsureUpperBound(Exprs.EUB);
1219   Dir->setNextLowerBound(Exprs.NLB);
1220   Dir->setNextUpperBound(Exprs.NUB);
1221   Dir->setNumIterations(Exprs.NumIterations);
1222   Dir->setCounters(Exprs.Counters);
1223   Dir->setPrivateCounters(Exprs.PrivateCounters);
1224   Dir->setInits(Exprs.Inits);
1225   Dir->setUpdates(Exprs.Updates);
1226   Dir->setFinals(Exprs.Finals);
1227   Dir->setDependentCounters(Exprs.DependentCounters);
1228   Dir->setDependentInits(Exprs.DependentInits);
1229   Dir->setFinalsConditions(Exprs.FinalsConditions);
1230   Dir->setPreInits(Exprs.PreInits);
1231   Dir->setHasCancel(HasCancel);
1232   return Dir;
1233 }
1234 
1235 OMPParallelMasterTaskLoopDirective *
1236 OMPParallelMasterTaskLoopDirective::CreateEmpty(const ASTContext &C,
1237                                                 unsigned NumClauses,
1238                                                 unsigned CollapsedNum,
1239                                                 EmptyShell) {
1240   return createEmptyDirective<OMPParallelMasterTaskLoopDirective>(
1241       C, NumClauses, /*HasAssociatedStmt=*/true,
1242       numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop),
1243       CollapsedNum);
1244 }
1245 
1246 OMPParallelMasterTaskLoopSimdDirective *
1247 OMPParallelMasterTaskLoopSimdDirective::Create(
1248     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1249     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1250     const HelperExprs &Exprs) {
1251   auto *Dir = createDirective<OMPParallelMasterTaskLoopSimdDirective>(
1252       C, Clauses, AssociatedStmt,
1253       numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd),
1254       StartLoc, EndLoc, CollapsedNum);
1255   Dir->setIterationVariable(Exprs.IterationVarRef);
1256   Dir->setLastIteration(Exprs.LastIteration);
1257   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1258   Dir->setPreCond(Exprs.PreCond);
1259   Dir->setCond(Exprs.Cond);
1260   Dir->setInit(Exprs.Init);
1261   Dir->setInc(Exprs.Inc);
1262   Dir->setIsLastIterVariable(Exprs.IL);
1263   Dir->setLowerBoundVariable(Exprs.LB);
1264   Dir->setUpperBoundVariable(Exprs.UB);
1265   Dir->setStrideVariable(Exprs.ST);
1266   Dir->setEnsureUpperBound(Exprs.EUB);
1267   Dir->setNextLowerBound(Exprs.NLB);
1268   Dir->setNextUpperBound(Exprs.NUB);
1269   Dir->setNumIterations(Exprs.NumIterations);
1270   Dir->setCounters(Exprs.Counters);
1271   Dir->setPrivateCounters(Exprs.PrivateCounters);
1272   Dir->setInits(Exprs.Inits);
1273   Dir->setUpdates(Exprs.Updates);
1274   Dir->setFinals(Exprs.Finals);
1275   Dir->setDependentCounters(Exprs.DependentCounters);
1276   Dir->setDependentInits(Exprs.DependentInits);
1277   Dir->setFinalsConditions(Exprs.FinalsConditions);
1278   Dir->setPreInits(Exprs.PreInits);
1279   return Dir;
1280 }
1281 
1282 OMPParallelMasterTaskLoopSimdDirective *
1283 OMPParallelMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C,
1284                                                     unsigned NumClauses,
1285                                                     unsigned CollapsedNum,
1286                                                     EmptyShell) {
1287   return createEmptyDirective<OMPParallelMasterTaskLoopSimdDirective>(
1288       C, NumClauses, /*HasAssociatedStmt=*/true,
1289       numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd),
1290       CollapsedNum);
1291 }
1292 
1293 OMPDistributeDirective *OMPDistributeDirective::Create(
1294     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1295     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1296     const HelperExprs &Exprs) {
1297   auto *Dir = createDirective<OMPDistributeDirective>(
1298       C, Clauses, AssociatedStmt,
1299       numLoopChildren(CollapsedNum, OMPD_distribute), StartLoc, EndLoc,
1300       CollapsedNum);
1301   Dir->setIterationVariable(Exprs.IterationVarRef);
1302   Dir->setLastIteration(Exprs.LastIteration);
1303   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1304   Dir->setPreCond(Exprs.PreCond);
1305   Dir->setCond(Exprs.Cond);
1306   Dir->setInit(Exprs.Init);
1307   Dir->setInc(Exprs.Inc);
1308   Dir->setIsLastIterVariable(Exprs.IL);
1309   Dir->setLowerBoundVariable(Exprs.LB);
1310   Dir->setUpperBoundVariable(Exprs.UB);
1311   Dir->setStrideVariable(Exprs.ST);
1312   Dir->setEnsureUpperBound(Exprs.EUB);
1313   Dir->setNextLowerBound(Exprs.NLB);
1314   Dir->setNextUpperBound(Exprs.NUB);
1315   Dir->setNumIterations(Exprs.NumIterations);
1316   Dir->setCounters(Exprs.Counters);
1317   Dir->setPrivateCounters(Exprs.PrivateCounters);
1318   Dir->setInits(Exprs.Inits);
1319   Dir->setUpdates(Exprs.Updates);
1320   Dir->setFinals(Exprs.Finals);
1321   Dir->setDependentCounters(Exprs.DependentCounters);
1322   Dir->setDependentInits(Exprs.DependentInits);
1323   Dir->setFinalsConditions(Exprs.FinalsConditions);
1324   Dir->setPreInits(Exprs.PreInits);
1325   return Dir;
1326 }
1327 
1328 OMPDistributeDirective *
1329 OMPDistributeDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1330                                     unsigned CollapsedNum, EmptyShell) {
1331   return createEmptyDirective<OMPDistributeDirective>(
1332       C, NumClauses, /*HasAssociatedStmt=*/true,
1333       numLoopChildren(CollapsedNum, OMPD_distribute), CollapsedNum);
1334 }
1335 
1336 OMPTargetUpdateDirective *OMPTargetUpdateDirective::Create(
1337     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1338     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1339   return createDirective<OMPTargetUpdateDirective>(C, Clauses, AssociatedStmt,
1340                                                    /*NumChildren=*/0, StartLoc,
1341                                                    EndLoc);
1342 }
1343 
1344 OMPTargetUpdateDirective *
1345 OMPTargetUpdateDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1346                                       EmptyShell) {
1347   return createEmptyDirective<OMPTargetUpdateDirective>(
1348       C, NumClauses, /*HasAssociatedStmt=*/true);
1349 }
1350 
1351 OMPDistributeParallelForDirective *OMPDistributeParallelForDirective::Create(
1352     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1353     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1354     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
1355   auto *Dir = createDirective<OMPDistributeParallelForDirective>(
1356       C, Clauses, AssociatedStmt,
1357       numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1, StartLoc,
1358       EndLoc, CollapsedNum);
1359   Dir->setIterationVariable(Exprs.IterationVarRef);
1360   Dir->setLastIteration(Exprs.LastIteration);
1361   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1362   Dir->setPreCond(Exprs.PreCond);
1363   Dir->setCond(Exprs.Cond);
1364   Dir->setInit(Exprs.Init);
1365   Dir->setInc(Exprs.Inc);
1366   Dir->setIsLastIterVariable(Exprs.IL);
1367   Dir->setLowerBoundVariable(Exprs.LB);
1368   Dir->setUpperBoundVariable(Exprs.UB);
1369   Dir->setStrideVariable(Exprs.ST);
1370   Dir->setEnsureUpperBound(Exprs.EUB);
1371   Dir->setNextLowerBound(Exprs.NLB);
1372   Dir->setNextUpperBound(Exprs.NUB);
1373   Dir->setNumIterations(Exprs.NumIterations);
1374   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1375   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1376   Dir->setDistInc(Exprs.DistInc);
1377   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1378   Dir->setCounters(Exprs.Counters);
1379   Dir->setPrivateCounters(Exprs.PrivateCounters);
1380   Dir->setInits(Exprs.Inits);
1381   Dir->setUpdates(Exprs.Updates);
1382   Dir->setFinals(Exprs.Finals);
1383   Dir->setDependentCounters(Exprs.DependentCounters);
1384   Dir->setDependentInits(Exprs.DependentInits);
1385   Dir->setFinalsConditions(Exprs.FinalsConditions);
1386   Dir->setPreInits(Exprs.PreInits);
1387   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1388   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1389   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1390   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1391   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1392   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1393   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1394   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1395   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1396   Dir->setTaskReductionRefExpr(TaskRedRef);
1397   Dir->HasCancel = HasCancel;
1398   return Dir;
1399 }
1400 
1401 OMPDistributeParallelForDirective *
1402 OMPDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
1403                                                unsigned NumClauses,
1404                                                unsigned CollapsedNum,
1405                                                EmptyShell) {
1406   return createEmptyDirective<OMPDistributeParallelForDirective>(
1407       C, NumClauses, /*HasAssociatedStmt=*/true,
1408       numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1,
1409       CollapsedNum);
1410 }
1411 
1412 OMPDistributeParallelForSimdDirective *
1413 OMPDistributeParallelForSimdDirective::Create(
1414     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1415     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1416     const HelperExprs &Exprs) {
1417   auto *Dir = createDirective<OMPDistributeParallelForSimdDirective>(
1418       C, Clauses, AssociatedStmt,
1419       numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd),
1420       StartLoc, EndLoc, CollapsedNum);
1421   Dir->setIterationVariable(Exprs.IterationVarRef);
1422   Dir->setLastIteration(Exprs.LastIteration);
1423   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1424   Dir->setPreCond(Exprs.PreCond);
1425   Dir->setCond(Exprs.Cond);
1426   Dir->setInit(Exprs.Init);
1427   Dir->setInc(Exprs.Inc);
1428   Dir->setIsLastIterVariable(Exprs.IL);
1429   Dir->setLowerBoundVariable(Exprs.LB);
1430   Dir->setUpperBoundVariable(Exprs.UB);
1431   Dir->setStrideVariable(Exprs.ST);
1432   Dir->setEnsureUpperBound(Exprs.EUB);
1433   Dir->setNextLowerBound(Exprs.NLB);
1434   Dir->setNextUpperBound(Exprs.NUB);
1435   Dir->setNumIterations(Exprs.NumIterations);
1436   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1437   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1438   Dir->setDistInc(Exprs.DistInc);
1439   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1440   Dir->setCounters(Exprs.Counters);
1441   Dir->setPrivateCounters(Exprs.PrivateCounters);
1442   Dir->setInits(Exprs.Inits);
1443   Dir->setUpdates(Exprs.Updates);
1444   Dir->setFinals(Exprs.Finals);
1445   Dir->setDependentCounters(Exprs.DependentCounters);
1446   Dir->setDependentInits(Exprs.DependentInits);
1447   Dir->setFinalsConditions(Exprs.FinalsConditions);
1448   Dir->setPreInits(Exprs.PreInits);
1449   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1450   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1451   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1452   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1453   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1454   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1455   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1456   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1457   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1458   return Dir;
1459 }
1460 
1461 OMPDistributeParallelForSimdDirective *
1462 OMPDistributeParallelForSimdDirective::CreateEmpty(const ASTContext &C,
1463                                                    unsigned NumClauses,
1464                                                    unsigned CollapsedNum,
1465                                                    EmptyShell) {
1466   return createEmptyDirective<OMPDistributeParallelForSimdDirective>(
1467       C, NumClauses, /*HasAssociatedStmt=*/true,
1468       numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd),
1469       CollapsedNum);
1470 }
1471 
1472 OMPDistributeSimdDirective *OMPDistributeSimdDirective::Create(
1473     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1474     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1475     const HelperExprs &Exprs) {
1476   auto *Dir = createDirective<OMPDistributeSimdDirective>(
1477       C, Clauses, AssociatedStmt,
1478       numLoopChildren(CollapsedNum, OMPD_distribute_simd), StartLoc, EndLoc,
1479       CollapsedNum);
1480   Dir->setIterationVariable(Exprs.IterationVarRef);
1481   Dir->setLastIteration(Exprs.LastIteration);
1482   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1483   Dir->setPreCond(Exprs.PreCond);
1484   Dir->setCond(Exprs.Cond);
1485   Dir->setInit(Exprs.Init);
1486   Dir->setInc(Exprs.Inc);
1487   Dir->setIsLastIterVariable(Exprs.IL);
1488   Dir->setLowerBoundVariable(Exprs.LB);
1489   Dir->setUpperBoundVariable(Exprs.UB);
1490   Dir->setStrideVariable(Exprs.ST);
1491   Dir->setEnsureUpperBound(Exprs.EUB);
1492   Dir->setNextLowerBound(Exprs.NLB);
1493   Dir->setNextUpperBound(Exprs.NUB);
1494   Dir->setNumIterations(Exprs.NumIterations);
1495   Dir->setCounters(Exprs.Counters);
1496   Dir->setPrivateCounters(Exprs.PrivateCounters);
1497   Dir->setInits(Exprs.Inits);
1498   Dir->setUpdates(Exprs.Updates);
1499   Dir->setFinals(Exprs.Finals);
1500   Dir->setDependentCounters(Exprs.DependentCounters);
1501   Dir->setDependentInits(Exprs.DependentInits);
1502   Dir->setFinalsConditions(Exprs.FinalsConditions);
1503   Dir->setPreInits(Exprs.PreInits);
1504   return Dir;
1505 }
1506 
1507 OMPDistributeSimdDirective *
1508 OMPDistributeSimdDirective::CreateEmpty(const ASTContext &C,
1509                                         unsigned NumClauses,
1510                                         unsigned CollapsedNum, EmptyShell) {
1511   return createEmptyDirective<OMPDistributeSimdDirective>(
1512       C, NumClauses, /*HasAssociatedStmt=*/true,
1513       numLoopChildren(CollapsedNum, OMPD_distribute_simd), CollapsedNum);
1514 }
1515 
1516 OMPTargetParallelForSimdDirective *OMPTargetParallelForSimdDirective::Create(
1517     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1518     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1519     const HelperExprs &Exprs) {
1520   auto *Dir = createDirective<OMPTargetParallelForSimdDirective>(
1521       C, Clauses, AssociatedStmt,
1522       numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd), StartLoc,
1523       EndLoc, CollapsedNum);
1524   Dir->setIterationVariable(Exprs.IterationVarRef);
1525   Dir->setLastIteration(Exprs.LastIteration);
1526   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1527   Dir->setPreCond(Exprs.PreCond);
1528   Dir->setCond(Exprs.Cond);
1529   Dir->setInit(Exprs.Init);
1530   Dir->setInc(Exprs.Inc);
1531   Dir->setIsLastIterVariable(Exprs.IL);
1532   Dir->setLowerBoundVariable(Exprs.LB);
1533   Dir->setUpperBoundVariable(Exprs.UB);
1534   Dir->setStrideVariable(Exprs.ST);
1535   Dir->setEnsureUpperBound(Exprs.EUB);
1536   Dir->setNextLowerBound(Exprs.NLB);
1537   Dir->setNextUpperBound(Exprs.NUB);
1538   Dir->setNumIterations(Exprs.NumIterations);
1539   Dir->setCounters(Exprs.Counters);
1540   Dir->setPrivateCounters(Exprs.PrivateCounters);
1541   Dir->setInits(Exprs.Inits);
1542   Dir->setUpdates(Exprs.Updates);
1543   Dir->setFinals(Exprs.Finals);
1544   Dir->setDependentCounters(Exprs.DependentCounters);
1545   Dir->setDependentInits(Exprs.DependentInits);
1546   Dir->setFinalsConditions(Exprs.FinalsConditions);
1547   Dir->setPreInits(Exprs.PreInits);
1548   return Dir;
1549 }
1550 
1551 OMPTargetParallelForSimdDirective *
1552 OMPTargetParallelForSimdDirective::CreateEmpty(const ASTContext &C,
1553                                                unsigned NumClauses,
1554                                                unsigned CollapsedNum,
1555                                                EmptyShell) {
1556   return createEmptyDirective<OMPTargetParallelForSimdDirective>(
1557       C, NumClauses, /*HasAssociatedStmt=*/true,
1558       numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd),
1559       CollapsedNum);
1560 }
1561 
1562 OMPTargetSimdDirective *
1563 OMPTargetSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
1564                                SourceLocation EndLoc, unsigned CollapsedNum,
1565                                ArrayRef<OMPClause *> Clauses,
1566                                Stmt *AssociatedStmt, const HelperExprs &Exprs) {
1567   auto *Dir = createDirective<OMPTargetSimdDirective>(
1568       C, Clauses, AssociatedStmt,
1569       numLoopChildren(CollapsedNum, OMPD_target_simd), StartLoc, EndLoc,
1570       CollapsedNum);
1571   Dir->setIterationVariable(Exprs.IterationVarRef);
1572   Dir->setLastIteration(Exprs.LastIteration);
1573   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1574   Dir->setPreCond(Exprs.PreCond);
1575   Dir->setCond(Exprs.Cond);
1576   Dir->setInit(Exprs.Init);
1577   Dir->setInc(Exprs.Inc);
1578   Dir->setCounters(Exprs.Counters);
1579   Dir->setPrivateCounters(Exprs.PrivateCounters);
1580   Dir->setInits(Exprs.Inits);
1581   Dir->setUpdates(Exprs.Updates);
1582   Dir->setFinals(Exprs.Finals);
1583   Dir->setDependentCounters(Exprs.DependentCounters);
1584   Dir->setDependentInits(Exprs.DependentInits);
1585   Dir->setFinalsConditions(Exprs.FinalsConditions);
1586   Dir->setPreInits(Exprs.PreInits);
1587   return Dir;
1588 }
1589 
1590 OMPTargetSimdDirective *
1591 OMPTargetSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1592                                     unsigned CollapsedNum, EmptyShell) {
1593   return createEmptyDirective<OMPTargetSimdDirective>(
1594       C, NumClauses, /*HasAssociatedStmt=*/true,
1595       numLoopChildren(CollapsedNum, OMPD_target_simd), CollapsedNum);
1596 }
1597 
1598 OMPTeamsDistributeDirective *OMPTeamsDistributeDirective::Create(
1599     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1600     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1601     const HelperExprs &Exprs) {
1602   auto *Dir = createDirective<OMPTeamsDistributeDirective>(
1603       C, Clauses, AssociatedStmt,
1604       numLoopChildren(CollapsedNum, OMPD_teams_distribute), StartLoc, EndLoc,
1605       CollapsedNum);
1606   Dir->setIterationVariable(Exprs.IterationVarRef);
1607   Dir->setLastIteration(Exprs.LastIteration);
1608   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1609   Dir->setPreCond(Exprs.PreCond);
1610   Dir->setCond(Exprs.Cond);
1611   Dir->setInit(Exprs.Init);
1612   Dir->setInc(Exprs.Inc);
1613   Dir->setIsLastIterVariable(Exprs.IL);
1614   Dir->setLowerBoundVariable(Exprs.LB);
1615   Dir->setUpperBoundVariable(Exprs.UB);
1616   Dir->setStrideVariable(Exprs.ST);
1617   Dir->setEnsureUpperBound(Exprs.EUB);
1618   Dir->setNextLowerBound(Exprs.NLB);
1619   Dir->setNextUpperBound(Exprs.NUB);
1620   Dir->setNumIterations(Exprs.NumIterations);
1621   Dir->setCounters(Exprs.Counters);
1622   Dir->setPrivateCounters(Exprs.PrivateCounters);
1623   Dir->setInits(Exprs.Inits);
1624   Dir->setUpdates(Exprs.Updates);
1625   Dir->setFinals(Exprs.Finals);
1626   Dir->setDependentCounters(Exprs.DependentCounters);
1627   Dir->setDependentInits(Exprs.DependentInits);
1628   Dir->setFinalsConditions(Exprs.FinalsConditions);
1629   Dir->setPreInits(Exprs.PreInits);
1630   return Dir;
1631 }
1632 
1633 OMPTeamsDistributeDirective *
1634 OMPTeamsDistributeDirective::CreateEmpty(const ASTContext &C,
1635                                          unsigned NumClauses,
1636                                          unsigned CollapsedNum, EmptyShell) {
1637   return createEmptyDirective<OMPTeamsDistributeDirective>(
1638       C, NumClauses, /*HasAssociatedStmt=*/true,
1639       numLoopChildren(CollapsedNum, OMPD_teams_distribute), CollapsedNum);
1640 }
1641 
1642 OMPTeamsDistributeSimdDirective *OMPTeamsDistributeSimdDirective::Create(
1643     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1644     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1645     const HelperExprs &Exprs) {
1646   auto *Dir = createDirective<OMPTeamsDistributeSimdDirective>(
1647       C, Clauses, AssociatedStmt,
1648       numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), StartLoc,
1649       EndLoc, CollapsedNum);
1650   Dir->setIterationVariable(Exprs.IterationVarRef);
1651   Dir->setLastIteration(Exprs.LastIteration);
1652   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1653   Dir->setPreCond(Exprs.PreCond);
1654   Dir->setCond(Exprs.Cond);
1655   Dir->setInit(Exprs.Init);
1656   Dir->setInc(Exprs.Inc);
1657   Dir->setIsLastIterVariable(Exprs.IL);
1658   Dir->setLowerBoundVariable(Exprs.LB);
1659   Dir->setUpperBoundVariable(Exprs.UB);
1660   Dir->setStrideVariable(Exprs.ST);
1661   Dir->setEnsureUpperBound(Exprs.EUB);
1662   Dir->setNextLowerBound(Exprs.NLB);
1663   Dir->setNextUpperBound(Exprs.NUB);
1664   Dir->setNumIterations(Exprs.NumIterations);
1665   Dir->setCounters(Exprs.Counters);
1666   Dir->setPrivateCounters(Exprs.PrivateCounters);
1667   Dir->setInits(Exprs.Inits);
1668   Dir->setUpdates(Exprs.Updates);
1669   Dir->setFinals(Exprs.Finals);
1670   Dir->setDependentCounters(Exprs.DependentCounters);
1671   Dir->setDependentInits(Exprs.DependentInits);
1672   Dir->setFinalsConditions(Exprs.FinalsConditions);
1673   Dir->setPreInits(Exprs.PreInits);
1674   return Dir;
1675 }
1676 
1677 OMPTeamsDistributeSimdDirective *OMPTeamsDistributeSimdDirective::CreateEmpty(
1678     const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
1679     EmptyShell) {
1680   return createEmptyDirective<OMPTeamsDistributeSimdDirective>(
1681       C, NumClauses, /*HasAssociatedStmt=*/true,
1682       numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), CollapsedNum);
1683 }
1684 
1685 OMPTeamsDistributeParallelForSimdDirective *
1686 OMPTeamsDistributeParallelForSimdDirective::Create(
1687     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1688     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1689     const HelperExprs &Exprs) {
1690   auto *Dir = createDirective<OMPTeamsDistributeParallelForSimdDirective>(
1691       C, Clauses, AssociatedStmt,
1692       numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd),
1693       StartLoc, EndLoc, CollapsedNum);
1694   Dir->setIterationVariable(Exprs.IterationVarRef);
1695   Dir->setLastIteration(Exprs.LastIteration);
1696   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1697   Dir->setPreCond(Exprs.PreCond);
1698   Dir->setCond(Exprs.Cond);
1699   Dir->setInit(Exprs.Init);
1700   Dir->setInc(Exprs.Inc);
1701   Dir->setIsLastIterVariable(Exprs.IL);
1702   Dir->setLowerBoundVariable(Exprs.LB);
1703   Dir->setUpperBoundVariable(Exprs.UB);
1704   Dir->setStrideVariable(Exprs.ST);
1705   Dir->setEnsureUpperBound(Exprs.EUB);
1706   Dir->setNextLowerBound(Exprs.NLB);
1707   Dir->setNextUpperBound(Exprs.NUB);
1708   Dir->setNumIterations(Exprs.NumIterations);
1709   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1710   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1711   Dir->setDistInc(Exprs.DistInc);
1712   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1713   Dir->setCounters(Exprs.Counters);
1714   Dir->setPrivateCounters(Exprs.PrivateCounters);
1715   Dir->setInits(Exprs.Inits);
1716   Dir->setUpdates(Exprs.Updates);
1717   Dir->setFinals(Exprs.Finals);
1718   Dir->setDependentCounters(Exprs.DependentCounters);
1719   Dir->setDependentInits(Exprs.DependentInits);
1720   Dir->setFinalsConditions(Exprs.FinalsConditions);
1721   Dir->setPreInits(Exprs.PreInits);
1722   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1723   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1724   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1725   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1726   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1727   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1728   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1729   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1730   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1731   return Dir;
1732 }
1733 
1734 OMPTeamsDistributeParallelForSimdDirective *
1735 OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(const ASTContext &C,
1736                                                         unsigned NumClauses,
1737                                                         unsigned CollapsedNum,
1738                                                         EmptyShell) {
1739   return createEmptyDirective<OMPTeamsDistributeParallelForSimdDirective>(
1740       C, NumClauses, /*HasAssociatedStmt=*/true,
1741       numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd),
1742       CollapsedNum);
1743 }
1744 
1745 OMPTeamsDistributeParallelForDirective *
1746 OMPTeamsDistributeParallelForDirective::Create(
1747     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1748     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1749     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
1750   auto *Dir = createDirective<OMPTeamsDistributeParallelForDirective>(
1751       C, Clauses, AssociatedStmt,
1752       numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1,
1753       StartLoc, EndLoc, CollapsedNum);
1754   Dir->setIterationVariable(Exprs.IterationVarRef);
1755   Dir->setLastIteration(Exprs.LastIteration);
1756   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1757   Dir->setPreCond(Exprs.PreCond);
1758   Dir->setCond(Exprs.Cond);
1759   Dir->setInit(Exprs.Init);
1760   Dir->setInc(Exprs.Inc);
1761   Dir->setIsLastIterVariable(Exprs.IL);
1762   Dir->setLowerBoundVariable(Exprs.LB);
1763   Dir->setUpperBoundVariable(Exprs.UB);
1764   Dir->setStrideVariable(Exprs.ST);
1765   Dir->setEnsureUpperBound(Exprs.EUB);
1766   Dir->setNextLowerBound(Exprs.NLB);
1767   Dir->setNextUpperBound(Exprs.NUB);
1768   Dir->setNumIterations(Exprs.NumIterations);
1769   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1770   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1771   Dir->setDistInc(Exprs.DistInc);
1772   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1773   Dir->setCounters(Exprs.Counters);
1774   Dir->setPrivateCounters(Exprs.PrivateCounters);
1775   Dir->setInits(Exprs.Inits);
1776   Dir->setUpdates(Exprs.Updates);
1777   Dir->setFinals(Exprs.Finals);
1778   Dir->setDependentCounters(Exprs.DependentCounters);
1779   Dir->setDependentInits(Exprs.DependentInits);
1780   Dir->setFinalsConditions(Exprs.FinalsConditions);
1781   Dir->setPreInits(Exprs.PreInits);
1782   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1783   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1784   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1785   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1786   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1787   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1788   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1789   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1790   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1791   Dir->setTaskReductionRefExpr(TaskRedRef);
1792   Dir->HasCancel = HasCancel;
1793   return Dir;
1794 }
1795 
1796 OMPTeamsDistributeParallelForDirective *
1797 OMPTeamsDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
1798                                                     unsigned NumClauses,
1799                                                     unsigned CollapsedNum,
1800                                                     EmptyShell) {
1801   return createEmptyDirective<OMPTeamsDistributeParallelForDirective>(
1802       C, NumClauses, /*HasAssociatedStmt=*/true,
1803       numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1,
1804       CollapsedNum);
1805 }
1806 
1807 OMPTargetTeamsDirective *OMPTargetTeamsDirective::Create(
1808     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1809     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1810   return createDirective<OMPTargetTeamsDirective>(C, Clauses, AssociatedStmt,
1811                                                   /*NumChildren=*/0, StartLoc,
1812                                                   EndLoc);
1813 }
1814 
1815 OMPTargetTeamsDirective *
1816 OMPTargetTeamsDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1817                                      EmptyShell) {
1818   return createEmptyDirective<OMPTargetTeamsDirective>(
1819       C, NumClauses, /*HasAssociatedStmt=*/true);
1820 }
1821 
1822 OMPTargetTeamsDistributeDirective *OMPTargetTeamsDistributeDirective::Create(
1823     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1824     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1825     const HelperExprs &Exprs) {
1826   auto *Dir = createDirective<OMPTargetTeamsDistributeDirective>(
1827       C, Clauses, AssociatedStmt,
1828       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute), StartLoc,
1829       EndLoc, CollapsedNum);
1830   Dir->setIterationVariable(Exprs.IterationVarRef);
1831   Dir->setLastIteration(Exprs.LastIteration);
1832   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1833   Dir->setPreCond(Exprs.PreCond);
1834   Dir->setCond(Exprs.Cond);
1835   Dir->setInit(Exprs.Init);
1836   Dir->setInc(Exprs.Inc);
1837   Dir->setIsLastIterVariable(Exprs.IL);
1838   Dir->setLowerBoundVariable(Exprs.LB);
1839   Dir->setUpperBoundVariable(Exprs.UB);
1840   Dir->setStrideVariable(Exprs.ST);
1841   Dir->setEnsureUpperBound(Exprs.EUB);
1842   Dir->setNextLowerBound(Exprs.NLB);
1843   Dir->setNextUpperBound(Exprs.NUB);
1844   Dir->setNumIterations(Exprs.NumIterations);
1845   Dir->setCounters(Exprs.Counters);
1846   Dir->setPrivateCounters(Exprs.PrivateCounters);
1847   Dir->setInits(Exprs.Inits);
1848   Dir->setUpdates(Exprs.Updates);
1849   Dir->setFinals(Exprs.Finals);
1850   Dir->setDependentCounters(Exprs.DependentCounters);
1851   Dir->setDependentInits(Exprs.DependentInits);
1852   Dir->setFinalsConditions(Exprs.FinalsConditions);
1853   Dir->setPreInits(Exprs.PreInits);
1854   return Dir;
1855 }
1856 
1857 OMPTargetTeamsDistributeDirective *
1858 OMPTargetTeamsDistributeDirective::CreateEmpty(const ASTContext &C,
1859                                                unsigned NumClauses,
1860                                                unsigned CollapsedNum,
1861                                                EmptyShell) {
1862   return createEmptyDirective<OMPTargetTeamsDistributeDirective>(
1863       C, NumClauses, /*HasAssociatedStmt=*/true,
1864       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute),
1865       CollapsedNum);
1866 }
1867 
1868 OMPTargetTeamsDistributeParallelForDirective *
1869 OMPTargetTeamsDistributeParallelForDirective::Create(
1870     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1871     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1872     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
1873   auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForDirective>(
1874       C, Clauses, AssociatedStmt,
1875       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) +
1876           1,
1877       StartLoc, EndLoc, CollapsedNum);
1878   Dir->setIterationVariable(Exprs.IterationVarRef);
1879   Dir->setLastIteration(Exprs.LastIteration);
1880   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1881   Dir->setPreCond(Exprs.PreCond);
1882   Dir->setCond(Exprs.Cond);
1883   Dir->setInit(Exprs.Init);
1884   Dir->setInc(Exprs.Inc);
1885   Dir->setIsLastIterVariable(Exprs.IL);
1886   Dir->setLowerBoundVariable(Exprs.LB);
1887   Dir->setUpperBoundVariable(Exprs.UB);
1888   Dir->setStrideVariable(Exprs.ST);
1889   Dir->setEnsureUpperBound(Exprs.EUB);
1890   Dir->setNextLowerBound(Exprs.NLB);
1891   Dir->setNextUpperBound(Exprs.NUB);
1892   Dir->setNumIterations(Exprs.NumIterations);
1893   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1894   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1895   Dir->setDistInc(Exprs.DistInc);
1896   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1897   Dir->setCounters(Exprs.Counters);
1898   Dir->setPrivateCounters(Exprs.PrivateCounters);
1899   Dir->setInits(Exprs.Inits);
1900   Dir->setUpdates(Exprs.Updates);
1901   Dir->setFinals(Exprs.Finals);
1902   Dir->setDependentCounters(Exprs.DependentCounters);
1903   Dir->setDependentInits(Exprs.DependentInits);
1904   Dir->setFinalsConditions(Exprs.FinalsConditions);
1905   Dir->setPreInits(Exprs.PreInits);
1906   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1907   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1908   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1909   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1910   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1911   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1912   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1913   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1914   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1915   Dir->setTaskReductionRefExpr(TaskRedRef);
1916   Dir->HasCancel = HasCancel;
1917   return Dir;
1918 }
1919 
1920 OMPTargetTeamsDistributeParallelForDirective *
1921 OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
1922                                                           unsigned NumClauses,
1923                                                           unsigned CollapsedNum,
1924                                                           EmptyShell) {
1925   return createEmptyDirective<OMPTargetTeamsDistributeParallelForDirective>(
1926       C, NumClauses, /*HasAssociatedStmt=*/true,
1927       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) +
1928           1,
1929       CollapsedNum);
1930 }
1931 
1932 OMPTargetTeamsDistributeParallelForSimdDirective *
1933 OMPTargetTeamsDistributeParallelForSimdDirective::Create(
1934     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1935     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1936     const HelperExprs &Exprs) {
1937   auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
1938       C, Clauses, AssociatedStmt,
1939       numLoopChildren(CollapsedNum,
1940                       OMPD_target_teams_distribute_parallel_for_simd),
1941       StartLoc, EndLoc, CollapsedNum);
1942   Dir->setIterationVariable(Exprs.IterationVarRef);
1943   Dir->setLastIteration(Exprs.LastIteration);
1944   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1945   Dir->setPreCond(Exprs.PreCond);
1946   Dir->setCond(Exprs.Cond);
1947   Dir->setInit(Exprs.Init);
1948   Dir->setInc(Exprs.Inc);
1949   Dir->setIsLastIterVariable(Exprs.IL);
1950   Dir->setLowerBoundVariable(Exprs.LB);
1951   Dir->setUpperBoundVariable(Exprs.UB);
1952   Dir->setStrideVariable(Exprs.ST);
1953   Dir->setEnsureUpperBound(Exprs.EUB);
1954   Dir->setNextLowerBound(Exprs.NLB);
1955   Dir->setNextUpperBound(Exprs.NUB);
1956   Dir->setNumIterations(Exprs.NumIterations);
1957   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1958   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1959   Dir->setDistInc(Exprs.DistInc);
1960   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1961   Dir->setCounters(Exprs.Counters);
1962   Dir->setPrivateCounters(Exprs.PrivateCounters);
1963   Dir->setInits(Exprs.Inits);
1964   Dir->setUpdates(Exprs.Updates);
1965   Dir->setFinals(Exprs.Finals);
1966   Dir->setDependentCounters(Exprs.DependentCounters);
1967   Dir->setDependentInits(Exprs.DependentInits);
1968   Dir->setFinalsConditions(Exprs.FinalsConditions);
1969   Dir->setPreInits(Exprs.PreInits);
1970   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1971   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1972   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1973   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1974   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1975   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1976   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1977   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1978   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1979   return Dir;
1980 }
1981 
1982 OMPTargetTeamsDistributeParallelForSimdDirective *
1983 OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty(
1984     const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
1985     EmptyShell) {
1986   return createEmptyDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
1987       C, NumClauses, /*HasAssociatedStmt=*/true,
1988       numLoopChildren(CollapsedNum,
1989                       OMPD_target_teams_distribute_parallel_for_simd),
1990       CollapsedNum);
1991 }
1992 
1993 OMPTargetTeamsDistributeSimdDirective *
1994 OMPTargetTeamsDistributeSimdDirective::Create(
1995     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1996     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1997     const HelperExprs &Exprs) {
1998   auto *Dir = createDirective<OMPTargetTeamsDistributeSimdDirective>(
1999       C, Clauses, AssociatedStmt,
2000       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd),
2001       StartLoc, EndLoc, CollapsedNum);
2002   Dir->setIterationVariable(Exprs.IterationVarRef);
2003   Dir->setLastIteration(Exprs.LastIteration);
2004   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2005   Dir->setPreCond(Exprs.PreCond);
2006   Dir->setCond(Exprs.Cond);
2007   Dir->setInit(Exprs.Init);
2008   Dir->setInc(Exprs.Inc);
2009   Dir->setIsLastIterVariable(Exprs.IL);
2010   Dir->setLowerBoundVariable(Exprs.LB);
2011   Dir->setUpperBoundVariable(Exprs.UB);
2012   Dir->setStrideVariable(Exprs.ST);
2013   Dir->setEnsureUpperBound(Exprs.EUB);
2014   Dir->setNextLowerBound(Exprs.NLB);
2015   Dir->setNextUpperBound(Exprs.NUB);
2016   Dir->setNumIterations(Exprs.NumIterations);
2017   Dir->setCounters(Exprs.Counters);
2018   Dir->setPrivateCounters(Exprs.PrivateCounters);
2019   Dir->setInits(Exprs.Inits);
2020   Dir->setUpdates(Exprs.Updates);
2021   Dir->setFinals(Exprs.Finals);
2022   Dir->setDependentCounters(Exprs.DependentCounters);
2023   Dir->setDependentInits(Exprs.DependentInits);
2024   Dir->setFinalsConditions(Exprs.FinalsConditions);
2025   Dir->setPreInits(Exprs.PreInits);
2026   return Dir;
2027 }
2028 
2029 OMPTargetTeamsDistributeSimdDirective *
2030 OMPTargetTeamsDistributeSimdDirective::CreateEmpty(const ASTContext &C,
2031                                                    unsigned NumClauses,
2032                                                    unsigned CollapsedNum,
2033                                                    EmptyShell) {
2034   return createEmptyDirective<OMPTargetTeamsDistributeSimdDirective>(
2035       C, NumClauses, /*HasAssociatedStmt=*/true,
2036       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd),
2037       CollapsedNum);
2038 }
2039 
2040 OMPInteropDirective *
2041 OMPInteropDirective::Create(const ASTContext &C, SourceLocation StartLoc,
2042                             SourceLocation EndLoc,
2043                             ArrayRef<OMPClause *> Clauses) {
2044   return createDirective<OMPInteropDirective>(
2045       C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc,
2046       EndLoc);
2047 }
2048 
2049 OMPInteropDirective *OMPInteropDirective::CreateEmpty(const ASTContext &C,
2050                                                       unsigned NumClauses,
2051                                                       EmptyShell) {
2052   return createEmptyDirective<OMPInteropDirective>(C, NumClauses);
2053 }
2054 
2055 OMPDispatchDirective *OMPDispatchDirective::Create(
2056     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2057     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2058     SourceLocation TargetCallLoc) {
2059   auto *Dir = createDirective<OMPDispatchDirective>(
2060       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
2061   Dir->setTargetCallLoc(TargetCallLoc);
2062   return Dir;
2063 }
2064 
2065 OMPDispatchDirective *OMPDispatchDirective::CreateEmpty(const ASTContext &C,
2066                                                         unsigned NumClauses,
2067                                                         EmptyShell) {
2068   return createEmptyDirective<OMPDispatchDirective>(C, NumClauses,
2069                                                     /*HasAssociatedStmt=*/true,
2070                                                     /*NumChildren=*/0);
2071 }
2072 
2073 OMPMaskedDirective *OMPMaskedDirective::Create(const ASTContext &C,
2074                                                SourceLocation StartLoc,
2075                                                SourceLocation EndLoc,
2076                                                ArrayRef<OMPClause *> Clauses,
2077                                                Stmt *AssociatedStmt) {
2078   return createDirective<OMPMaskedDirective>(C, Clauses, AssociatedStmt,
2079                                              /*NumChildren=*/0, StartLoc,
2080                                              EndLoc);
2081 }
2082 
2083 OMPMaskedDirective *OMPMaskedDirective::CreateEmpty(const ASTContext &C,
2084                                                     unsigned NumClauses,
2085                                                     EmptyShell) {
2086   return createEmptyDirective<OMPMaskedDirective>(C, NumClauses,
2087                                                   /*HasAssociatedStmt=*/true);
2088 }
2089 
2090 OMPGenericLoopDirective *OMPGenericLoopDirective::Create(
2091     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2092     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2093     const HelperExprs &Exprs) {
2094   auto *Dir = createDirective<OMPGenericLoopDirective>(
2095       C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_loop),
2096       StartLoc, EndLoc, CollapsedNum);
2097   Dir->setIterationVariable(Exprs.IterationVarRef);
2098   Dir->setLastIteration(Exprs.LastIteration);
2099   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
2100   Dir->setPreCond(Exprs.PreCond);
2101   Dir->setCond(Exprs.Cond);
2102   Dir->setInit(Exprs.Init);
2103   Dir->setInc(Exprs.Inc);
2104   Dir->setIsLastIterVariable(Exprs.IL);
2105   Dir->setLowerBoundVariable(Exprs.LB);
2106   Dir->setUpperBoundVariable(Exprs.UB);
2107   Dir->setStrideVariable(Exprs.ST);
2108   Dir->setEnsureUpperBound(Exprs.EUB);
2109   Dir->setNextLowerBound(Exprs.NLB);
2110   Dir->setNextUpperBound(Exprs.NUB);
2111   Dir->setNumIterations(Exprs.NumIterations);
2112   Dir->setCounters(Exprs.Counters);
2113   Dir->setPrivateCounters(Exprs.PrivateCounters);
2114   Dir->setInits(Exprs.Inits);
2115   Dir->setUpdates(Exprs.Updates);
2116   Dir->setFinals(Exprs.Finals);
2117   Dir->setDependentCounters(Exprs.DependentCounters);
2118   Dir->setDependentInits(Exprs.DependentInits);
2119   Dir->setFinalsConditions(Exprs.FinalsConditions);
2120   Dir->setPreInits(Exprs.PreInits);
2121   return Dir;
2122 }
2123 
2124 OMPGenericLoopDirective *
2125 OMPGenericLoopDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
2126                                      unsigned CollapsedNum, EmptyShell) {
2127   return createEmptyDirective<OMPGenericLoopDirective>(
2128       C, NumClauses, /*HasAssociatedStmt=*/true,
2129       numLoopChildren(CollapsedNum, OMPD_loop), CollapsedNum);
2130 }
2131