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