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(OMPLoopBasedDirective *)>
129         OnTransformationCallback) {
130   CurStmt = CurStmt->IgnoreContainers();
131   for (unsigned Cnt = 0; Cnt < NumLoops; ++Cnt) {
132     while (true) {
133       auto *OrigStmt = CurStmt;
134       if (auto *Dir = dyn_cast<OMPTileDirective>(OrigStmt)) {
135         OnTransformationCallback(Dir);
136         CurStmt = Dir->getTransformedStmt();
137       } else if (auto *Dir = dyn_cast<OMPUnrollDirective>(OrigStmt)) {
138         OnTransformationCallback(Dir);
139         CurStmt = Dir->getTransformedStmt();
140       } else {
141         break;
142       }
143 
144       if (!CurStmt) {
145         // May happen if the loop transformation does not result in a generated
146         // loop (such as full unrolling).
147         CurStmt = OrigStmt;
148         break;
149       }
150     }
151     if (auto *CanonLoop = dyn_cast<OMPCanonicalLoop>(CurStmt))
152       CurStmt = CanonLoop->getLoopStmt();
153     if (Callback(Cnt, CurStmt))
154       return false;
155     // Move on to the next nested for loop, or to the loop body.
156     // OpenMP [2.8.1, simd construct, Restrictions]
157     // All loops associated with the construct must be perfectly nested; that
158     // is, there must be no intervening code nor any OpenMP directive between
159     // any two loops.
160     if (auto *For = dyn_cast<ForStmt>(CurStmt)) {
161       CurStmt = For->getBody();
162     } else {
163       assert(isa<CXXForRangeStmt>(CurStmt) &&
164              "Expected canonical for or range-based for loops.");
165       CurStmt = cast<CXXForRangeStmt>(CurStmt)->getBody();
166     }
167     CurStmt = OMPLoopBasedDirective::tryToFindNextInnerLoop(
168         CurStmt, TryImperfectlyNestedLoops);
169   }
170   return true;
171 }
172 
173 void OMPLoopBasedDirective::doForAllLoopsBodies(
174     Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops,
175     llvm::function_ref<void(unsigned, Stmt *, Stmt *)> Callback) {
176   bool Res = OMPLoopBasedDirective::doForAllLoops(
177       CurStmt, TryImperfectlyNestedLoops, NumLoops,
178       [Callback](unsigned Cnt, Stmt *Loop) {
179         Stmt *Body = nullptr;
180         if (auto *For = dyn_cast<ForStmt>(Loop)) {
181           Body = For->getBody();
182         } else {
183           assert(isa<CXXForRangeStmt>(Loop) &&
184                  "Expected canonical for or range-based for loops.");
185           Body = cast<CXXForRangeStmt>(Loop)->getBody();
186         }
187         if (auto *CanonLoop = dyn_cast<OMPCanonicalLoop>(Body))
188           Body = CanonLoop->getLoopStmt();
189         Callback(Cnt, Loop, Body);
190         return false;
191       });
192   assert(Res && "Expected only loops");
193   (void)Res;
194 }
195 
196 Stmt *OMPLoopDirective::getBody() {
197   // This relies on the loop form is already checked by Sema.
198   Stmt *Body = nullptr;
199   OMPLoopBasedDirective::doForAllLoopsBodies(
200       Data->getRawStmt(), /*TryImperfectlyNestedLoops=*/true,
201       NumAssociatedLoops,
202       [&Body](unsigned, Stmt *, Stmt *BodyStmt) { Body = BodyStmt; });
203   return Body;
204 }
205 
206 void OMPLoopDirective::setCounters(ArrayRef<Expr *> A) {
207   assert(A.size() == getLoopsNumber() &&
208          "Number of loop counters is not the same as the collapsed number");
209   llvm::copy(A, getCounters().begin());
210 }
211 
212 void OMPLoopDirective::setPrivateCounters(ArrayRef<Expr *> A) {
213   assert(A.size() == getLoopsNumber() && "Number of loop private counters "
214                                          "is not the same as the collapsed "
215                                          "number");
216   llvm::copy(A, getPrivateCounters().begin());
217 }
218 
219 void OMPLoopDirective::setInits(ArrayRef<Expr *> A) {
220   assert(A.size() == getLoopsNumber() &&
221          "Number of counter inits is not the same as the collapsed number");
222   llvm::copy(A, getInits().begin());
223 }
224 
225 void OMPLoopDirective::setUpdates(ArrayRef<Expr *> A) {
226   assert(A.size() == getLoopsNumber() &&
227          "Number of counter updates is not the same as the collapsed number");
228   llvm::copy(A, getUpdates().begin());
229 }
230 
231 void OMPLoopDirective::setFinals(ArrayRef<Expr *> A) {
232   assert(A.size() == getLoopsNumber() &&
233          "Number of counter finals is not the same as the collapsed number");
234   llvm::copy(A, getFinals().begin());
235 }
236 
237 void OMPLoopDirective::setDependentCounters(ArrayRef<Expr *> A) {
238   assert(
239       A.size() == getLoopsNumber() &&
240       "Number of dependent counters is not the same as the collapsed number");
241   llvm::copy(A, getDependentCounters().begin());
242 }
243 
244 void OMPLoopDirective::setDependentInits(ArrayRef<Expr *> A) {
245   assert(A.size() == getLoopsNumber() &&
246          "Number of dependent inits is not the same as the collapsed number");
247   llvm::copy(A, getDependentInits().begin());
248 }
249 
250 void OMPLoopDirective::setFinalsConditions(ArrayRef<Expr *> A) {
251   assert(A.size() == getLoopsNumber() &&
252          "Number of finals conditions is not the same as the collapsed number");
253   llvm::copy(A, getFinalsConditions().begin());
254 }
255 
256 OMPMetaDirective *OMPMetaDirective::Create(const ASTContext &C,
257                                            SourceLocation StartLoc,
258                                            SourceLocation EndLoc,
259                                            ArrayRef<OMPClause *> Clauses,
260                                            Stmt *AssociatedStmt, Stmt *IfStmt) {
261   auto *Dir = createDirective<OMPMetaDirective>(
262       C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
263   Dir->setIfStmt(IfStmt);
264   return Dir;
265 }
266 
267 OMPMetaDirective *OMPMetaDirective::CreateEmpty(const ASTContext &C,
268                                                 unsigned NumClauses,
269                                                 EmptyShell) {
270   return createEmptyDirective<OMPMetaDirective>(C, NumClauses,
271                                                 /*HasAssociatedStmt=*/true,
272                                                 /*NumChildren=*/1);
273 }
274 
275 OMPParallelDirective *OMPParallelDirective::Create(
276     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
277     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
278     bool HasCancel) {
279   auto *Dir = createDirective<OMPParallelDirective>(
280       C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
281   Dir->setTaskReductionRefExpr(TaskRedRef);
282   Dir->setHasCancel(HasCancel);
283   return Dir;
284 }
285 
286 OMPParallelDirective *OMPParallelDirective::CreateEmpty(const ASTContext &C,
287                                                         unsigned NumClauses,
288                                                         EmptyShell) {
289   return createEmptyDirective<OMPParallelDirective>(C, NumClauses,
290                                                     /*HasAssociatedStmt=*/true,
291                                                     /*NumChildren=*/1);
292 }
293 
294 OMPSimdDirective *
295 OMPSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
296                          SourceLocation EndLoc, unsigned CollapsedNum,
297                          ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
298                          const HelperExprs &Exprs) {
299   auto *Dir = createDirective<OMPSimdDirective>(
300       C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_simd),
301       StartLoc, EndLoc, CollapsedNum);
302   Dir->setIterationVariable(Exprs.IterationVarRef);
303   Dir->setLastIteration(Exprs.LastIteration);
304   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
305   Dir->setPreCond(Exprs.PreCond);
306   Dir->setCond(Exprs.Cond);
307   Dir->setInit(Exprs.Init);
308   Dir->setInc(Exprs.Inc);
309   Dir->setCounters(Exprs.Counters);
310   Dir->setPrivateCounters(Exprs.PrivateCounters);
311   Dir->setInits(Exprs.Inits);
312   Dir->setUpdates(Exprs.Updates);
313   Dir->setFinals(Exprs.Finals);
314   Dir->setDependentCounters(Exprs.DependentCounters);
315   Dir->setDependentInits(Exprs.DependentInits);
316   Dir->setFinalsConditions(Exprs.FinalsConditions);
317   Dir->setPreInits(Exprs.PreInits);
318   return Dir;
319 }
320 
321 OMPSimdDirective *OMPSimdDirective::CreateEmpty(const ASTContext &C,
322                                                 unsigned NumClauses,
323                                                 unsigned CollapsedNum,
324                                                 EmptyShell) {
325   return createEmptyDirective<OMPSimdDirective>(
326       C, NumClauses, /*HasAssociatedStmt=*/true,
327       numLoopChildren(CollapsedNum, OMPD_simd), CollapsedNum);
328 }
329 
330 OMPForDirective *OMPForDirective::Create(
331     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
332     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
333     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
334   auto *Dir = createDirective<OMPForDirective>(
335       C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for) + 1,
336       StartLoc, EndLoc, CollapsedNum);
337   Dir->setIterationVariable(Exprs.IterationVarRef);
338   Dir->setLastIteration(Exprs.LastIteration);
339   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
340   Dir->setPreCond(Exprs.PreCond);
341   Dir->setCond(Exprs.Cond);
342   Dir->setInit(Exprs.Init);
343   Dir->setInc(Exprs.Inc);
344   Dir->setIsLastIterVariable(Exprs.IL);
345   Dir->setLowerBoundVariable(Exprs.LB);
346   Dir->setUpperBoundVariable(Exprs.UB);
347   Dir->setStrideVariable(Exprs.ST);
348   Dir->setEnsureUpperBound(Exprs.EUB);
349   Dir->setNextLowerBound(Exprs.NLB);
350   Dir->setNextUpperBound(Exprs.NUB);
351   Dir->setNumIterations(Exprs.NumIterations);
352   Dir->setCounters(Exprs.Counters);
353   Dir->setPrivateCounters(Exprs.PrivateCounters);
354   Dir->setInits(Exprs.Inits);
355   Dir->setUpdates(Exprs.Updates);
356   Dir->setFinals(Exprs.Finals);
357   Dir->setDependentCounters(Exprs.DependentCounters);
358   Dir->setDependentInits(Exprs.DependentInits);
359   Dir->setFinalsConditions(Exprs.FinalsConditions);
360   Dir->setPreInits(Exprs.PreInits);
361   Dir->setTaskReductionRefExpr(TaskRedRef);
362   Dir->setHasCancel(HasCancel);
363   return Dir;
364 }
365 
366 OMPForDirective *OMPForDirective::CreateEmpty(const ASTContext &C,
367                                               unsigned NumClauses,
368                                               unsigned CollapsedNum,
369                                               EmptyShell) {
370   return createEmptyDirective<OMPForDirective>(
371       C, NumClauses, /*HasAssociatedStmt=*/true,
372       numLoopChildren(CollapsedNum, OMPD_for) + 1, CollapsedNum);
373 }
374 
375 OMPTileDirective *
376 OMPTileDirective::Create(const ASTContext &C, SourceLocation StartLoc,
377                          SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
378                          unsigned NumLoops, Stmt *AssociatedStmt,
379                          Stmt *TransformedStmt, Stmt *PreInits) {
380   OMPTileDirective *Dir = createDirective<OMPTileDirective>(
381       C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc,
382       NumLoops);
383   Dir->setTransformedStmt(TransformedStmt);
384   Dir->setPreInits(PreInits);
385   return Dir;
386 }
387 
388 OMPTileDirective *OMPTileDirective::CreateEmpty(const ASTContext &C,
389                                                 unsigned NumClauses,
390                                                 unsigned NumLoops) {
391   return createEmptyDirective<OMPTileDirective>(
392       C, NumClauses, /*HasAssociatedStmt=*/true, TransformedStmtOffset + 1,
393       SourceLocation(), SourceLocation(), NumLoops);
394 }
395 
396 OMPUnrollDirective *
397 OMPUnrollDirective::Create(const ASTContext &C, SourceLocation StartLoc,
398                            SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
399                            Stmt *AssociatedStmt, Stmt *TransformedStmt,
400                            Stmt *PreInits) {
401   auto *Dir = createDirective<OMPUnrollDirective>(
402       C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc);
403   Dir->setTransformedStmt(TransformedStmt);
404   Dir->setPreInits(PreInits);
405   return Dir;
406 }
407 
408 OMPUnrollDirective *OMPUnrollDirective::CreateEmpty(const ASTContext &C,
409                                                     unsigned NumClauses) {
410   return createEmptyDirective<OMPUnrollDirective>(
411       C, NumClauses, /*HasAssociatedStmt=*/true, TransformedStmtOffset + 1,
412       SourceLocation(), SourceLocation());
413 }
414 
415 OMPForSimdDirective *
416 OMPForSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
417                             SourceLocation EndLoc, unsigned CollapsedNum,
418                             ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
419                             const HelperExprs &Exprs) {
420   auto *Dir = createDirective<OMPForSimdDirective>(
421       C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for_simd),
422       StartLoc, EndLoc, CollapsedNum);
423   Dir->setIterationVariable(Exprs.IterationVarRef);
424   Dir->setLastIteration(Exprs.LastIteration);
425   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
426   Dir->setPreCond(Exprs.PreCond);
427   Dir->setCond(Exprs.Cond);
428   Dir->setInit(Exprs.Init);
429   Dir->setInc(Exprs.Inc);
430   Dir->setIsLastIterVariable(Exprs.IL);
431   Dir->setLowerBoundVariable(Exprs.LB);
432   Dir->setUpperBoundVariable(Exprs.UB);
433   Dir->setStrideVariable(Exprs.ST);
434   Dir->setEnsureUpperBound(Exprs.EUB);
435   Dir->setNextLowerBound(Exprs.NLB);
436   Dir->setNextUpperBound(Exprs.NUB);
437   Dir->setNumIterations(Exprs.NumIterations);
438   Dir->setCounters(Exprs.Counters);
439   Dir->setPrivateCounters(Exprs.PrivateCounters);
440   Dir->setInits(Exprs.Inits);
441   Dir->setUpdates(Exprs.Updates);
442   Dir->setFinals(Exprs.Finals);
443   Dir->setDependentCounters(Exprs.DependentCounters);
444   Dir->setDependentInits(Exprs.DependentInits);
445   Dir->setFinalsConditions(Exprs.FinalsConditions);
446   Dir->setPreInits(Exprs.PreInits);
447   return Dir;
448 }
449 
450 OMPForSimdDirective *OMPForSimdDirective::CreateEmpty(const ASTContext &C,
451                                                       unsigned NumClauses,
452                                                       unsigned CollapsedNum,
453                                                       EmptyShell) {
454   return createEmptyDirective<OMPForSimdDirective>(
455       C, NumClauses, /*HasAssociatedStmt=*/true,
456       numLoopChildren(CollapsedNum, OMPD_for_simd), CollapsedNum);
457 }
458 
459 OMPSectionsDirective *OMPSectionsDirective::Create(
460     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
461     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
462     bool HasCancel) {
463   auto *Dir = createDirective<OMPSectionsDirective>(C, Clauses, AssociatedStmt,
464                                                     /*NumChildren=*/1, StartLoc,
465                                                     EndLoc);
466   Dir->setTaskReductionRefExpr(TaskRedRef);
467   Dir->setHasCancel(HasCancel);
468   return Dir;
469 }
470 
471 OMPSectionsDirective *OMPSectionsDirective::CreateEmpty(const ASTContext &C,
472                                                         unsigned NumClauses,
473                                                         EmptyShell) {
474   return createEmptyDirective<OMPSectionsDirective>(C, NumClauses,
475                                                     /*HasAssociatedStmt=*/true,
476                                                     /*NumChildren=*/1);
477 }
478 
479 OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C,
480                                                  SourceLocation StartLoc,
481                                                  SourceLocation EndLoc,
482                                                  Stmt *AssociatedStmt,
483                                                  bool HasCancel) {
484   auto *Dir =
485       createDirective<OMPSectionDirective>(C, llvm::None, AssociatedStmt,
486                                            /*NumChildre=*/0, StartLoc, EndLoc);
487   Dir->setHasCancel(HasCancel);
488   return Dir;
489 }
490 
491 OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C,
492                                                       EmptyShell) {
493   return createEmptyDirective<OMPSectionDirective>(C, /*NumClauses=*/0,
494                                                    /*HasAssociatedStmt=*/true);
495 }
496 
497 OMPSingleDirective *OMPSingleDirective::Create(const ASTContext &C,
498                                                SourceLocation StartLoc,
499                                                SourceLocation EndLoc,
500                                                ArrayRef<OMPClause *> Clauses,
501                                                Stmt *AssociatedStmt) {
502   return createDirective<OMPSingleDirective>(C, Clauses, AssociatedStmt,
503                                              /*NumChildren=*/0, StartLoc,
504                                              EndLoc);
505 }
506 
507 OMPSingleDirective *OMPSingleDirective::CreateEmpty(const ASTContext &C,
508                                                     unsigned NumClauses,
509                                                     EmptyShell) {
510   return createEmptyDirective<OMPSingleDirective>(C, NumClauses,
511                                                   /*HasAssociatedStmt=*/true);
512 }
513 
514 OMPMasterDirective *OMPMasterDirective::Create(const ASTContext &C,
515                                                SourceLocation StartLoc,
516                                                SourceLocation EndLoc,
517                                                Stmt *AssociatedStmt) {
518   return createDirective<OMPMasterDirective>(C, llvm::None, AssociatedStmt,
519                                              /*NumChildren=*/0, StartLoc,
520                                              EndLoc);
521 }
522 
523 OMPMasterDirective *OMPMasterDirective::CreateEmpty(const ASTContext &C,
524                                                     EmptyShell) {
525   return createEmptyDirective<OMPMasterDirective>(C, /*NumClauses=*/0,
526                                                   /*HasAssociatedStmt=*/true);
527 }
528 
529 OMPCriticalDirective *OMPCriticalDirective::Create(
530     const ASTContext &C, const DeclarationNameInfo &Name,
531     SourceLocation StartLoc, SourceLocation EndLoc,
532     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
533   return createDirective<OMPCriticalDirective>(C, Clauses, AssociatedStmt,
534                                                /*NumChildren=*/0, Name,
535                                                StartLoc, EndLoc);
536 }
537 
538 OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C,
539                                                         unsigned NumClauses,
540                                                         EmptyShell) {
541   return createEmptyDirective<OMPCriticalDirective>(C, NumClauses,
542                                                     /*HasAssociatedStmt=*/true);
543 }
544 
545 OMPParallelForDirective *OMPParallelForDirective::Create(
546     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
547     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
548     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
549   auto *Dir = createDirective<OMPParallelForDirective>(
550       C, Clauses, AssociatedStmt,
551       numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, StartLoc, EndLoc,
552       CollapsedNum);
553   Dir->setIterationVariable(Exprs.IterationVarRef);
554   Dir->setLastIteration(Exprs.LastIteration);
555   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
556   Dir->setPreCond(Exprs.PreCond);
557   Dir->setCond(Exprs.Cond);
558   Dir->setInit(Exprs.Init);
559   Dir->setInc(Exprs.Inc);
560   Dir->setIsLastIterVariable(Exprs.IL);
561   Dir->setLowerBoundVariable(Exprs.LB);
562   Dir->setUpperBoundVariable(Exprs.UB);
563   Dir->setStrideVariable(Exprs.ST);
564   Dir->setEnsureUpperBound(Exprs.EUB);
565   Dir->setNextLowerBound(Exprs.NLB);
566   Dir->setNextUpperBound(Exprs.NUB);
567   Dir->setNumIterations(Exprs.NumIterations);
568   Dir->setCounters(Exprs.Counters);
569   Dir->setPrivateCounters(Exprs.PrivateCounters);
570   Dir->setInits(Exprs.Inits);
571   Dir->setUpdates(Exprs.Updates);
572   Dir->setFinals(Exprs.Finals);
573   Dir->setDependentCounters(Exprs.DependentCounters);
574   Dir->setDependentInits(Exprs.DependentInits);
575   Dir->setFinalsConditions(Exprs.FinalsConditions);
576   Dir->setPreInits(Exprs.PreInits);
577   Dir->setTaskReductionRefExpr(TaskRedRef);
578   Dir->setHasCancel(HasCancel);
579   return Dir;
580 }
581 
582 OMPParallelForDirective *
583 OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
584                                      unsigned CollapsedNum, EmptyShell) {
585   return createEmptyDirective<OMPParallelForDirective>(
586       C, NumClauses, /*HasAssociatedStmt=*/true,
587       numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, CollapsedNum);
588 }
589 
590 OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create(
591     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
592     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
593     const HelperExprs &Exprs) {
594   auto *Dir = createDirective<OMPParallelForSimdDirective>(
595       C, Clauses, AssociatedStmt,
596       numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), StartLoc, EndLoc,
597       CollapsedNum);
598   Dir->setIterationVariable(Exprs.IterationVarRef);
599   Dir->setLastIteration(Exprs.LastIteration);
600   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
601   Dir->setPreCond(Exprs.PreCond);
602   Dir->setCond(Exprs.Cond);
603   Dir->setInit(Exprs.Init);
604   Dir->setInc(Exprs.Inc);
605   Dir->setIsLastIterVariable(Exprs.IL);
606   Dir->setLowerBoundVariable(Exprs.LB);
607   Dir->setUpperBoundVariable(Exprs.UB);
608   Dir->setStrideVariable(Exprs.ST);
609   Dir->setEnsureUpperBound(Exprs.EUB);
610   Dir->setNextLowerBound(Exprs.NLB);
611   Dir->setNextUpperBound(Exprs.NUB);
612   Dir->setNumIterations(Exprs.NumIterations);
613   Dir->setCounters(Exprs.Counters);
614   Dir->setPrivateCounters(Exprs.PrivateCounters);
615   Dir->setInits(Exprs.Inits);
616   Dir->setUpdates(Exprs.Updates);
617   Dir->setFinals(Exprs.Finals);
618   Dir->setDependentCounters(Exprs.DependentCounters);
619   Dir->setDependentInits(Exprs.DependentInits);
620   Dir->setFinalsConditions(Exprs.FinalsConditions);
621   Dir->setPreInits(Exprs.PreInits);
622   return Dir;
623 }
624 
625 OMPParallelForSimdDirective *
626 OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C,
627                                          unsigned NumClauses,
628                                          unsigned CollapsedNum, EmptyShell) {
629   return createEmptyDirective<OMPParallelForSimdDirective>(
630       C, NumClauses, /*HasAssociatedStmt=*/true,
631       numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), CollapsedNum);
632 }
633 
634 OMPParallelMasterDirective *OMPParallelMasterDirective::Create(
635     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
636     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef) {
637   auto *Dir = createDirective<OMPParallelMasterDirective>(
638       C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
639   Dir->setTaskReductionRefExpr(TaskRedRef);
640   return Dir;
641 }
642 
643 OMPParallelMasterDirective *
644 OMPParallelMasterDirective::CreateEmpty(const ASTContext &C,
645                                         unsigned NumClauses, EmptyShell) {
646   return createEmptyDirective<OMPParallelMasterDirective>(
647       C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
648 }
649 
650 OMPParallelSectionsDirective *OMPParallelSectionsDirective::Create(
651     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
652     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
653     bool HasCancel) {
654   auto *Dir = createDirective<OMPParallelSectionsDirective>(
655       C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
656   Dir->setTaskReductionRefExpr(TaskRedRef);
657   Dir->setHasCancel(HasCancel);
658   return Dir;
659 }
660 
661 OMPParallelSectionsDirective *
662 OMPParallelSectionsDirective::CreateEmpty(const ASTContext &C,
663                                           unsigned NumClauses, EmptyShell) {
664   return createEmptyDirective<OMPParallelSectionsDirective>(
665       C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
666 }
667 
668 OMPTaskDirective *
669 OMPTaskDirective::Create(const ASTContext &C, SourceLocation StartLoc,
670                          SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
671                          Stmt *AssociatedStmt, bool HasCancel) {
672   auto *Dir = createDirective<OMPTaskDirective>(
673       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
674   Dir->setHasCancel(HasCancel);
675   return Dir;
676 }
677 
678 OMPTaskDirective *OMPTaskDirective::CreateEmpty(const ASTContext &C,
679                                                 unsigned NumClauses,
680                                                 EmptyShell) {
681   return createEmptyDirective<OMPTaskDirective>(C, NumClauses,
682                                                 /*HasAssociatedStmt=*/true);
683 }
684 
685 OMPTaskyieldDirective *OMPTaskyieldDirective::Create(const ASTContext &C,
686                                                      SourceLocation StartLoc,
687                                                      SourceLocation EndLoc) {
688   return new (C) OMPTaskyieldDirective(StartLoc, EndLoc);
689 }
690 
691 OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C,
692                                                           EmptyShell) {
693   return new (C) OMPTaskyieldDirective();
694 }
695 
696 OMPBarrierDirective *OMPBarrierDirective::Create(const ASTContext &C,
697                                                  SourceLocation StartLoc,
698                                                  SourceLocation EndLoc) {
699   return new (C) OMPBarrierDirective(StartLoc, EndLoc);
700 }
701 
702 OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C,
703                                                       EmptyShell) {
704   return new (C) OMPBarrierDirective();
705 }
706 
707 OMPTaskwaitDirective *OMPTaskwaitDirective::Create(const ASTContext &C,
708                                                    SourceLocation StartLoc,
709                                                    SourceLocation EndLoc) {
710   return new (C) OMPTaskwaitDirective(StartLoc, EndLoc);
711 }
712 
713 OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C,
714                                                         EmptyShell) {
715   return new (C) OMPTaskwaitDirective();
716 }
717 
718 OMPTaskgroupDirective *OMPTaskgroupDirective::Create(
719     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
720     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *ReductionRef) {
721   auto *Dir = createDirective<OMPTaskgroupDirective>(
722       C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
723   Dir->setReductionRef(ReductionRef);
724   return Dir;
725 }
726 
727 OMPTaskgroupDirective *OMPTaskgroupDirective::CreateEmpty(const ASTContext &C,
728                                                           unsigned NumClauses,
729                                                           EmptyShell) {
730   return createEmptyDirective<OMPTaskgroupDirective>(
731       C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
732 }
733 
734 OMPCancellationPointDirective *OMPCancellationPointDirective::Create(
735     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
736     OpenMPDirectiveKind CancelRegion) {
737   auto *Dir = new (C) OMPCancellationPointDirective(StartLoc, EndLoc);
738   Dir->setCancelRegion(CancelRegion);
739   return Dir;
740 }
741 
742 OMPCancellationPointDirective *
743 OMPCancellationPointDirective::CreateEmpty(const ASTContext &C, EmptyShell) {
744   return new (C) OMPCancellationPointDirective();
745 }
746 
747 OMPCancelDirective *
748 OMPCancelDirective::Create(const ASTContext &C, SourceLocation StartLoc,
749                            SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
750                            OpenMPDirectiveKind CancelRegion) {
751   auto *Dir = createDirective<OMPCancelDirective>(
752       C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc,
753       EndLoc);
754   Dir->setCancelRegion(CancelRegion);
755   return Dir;
756 }
757 
758 OMPCancelDirective *OMPCancelDirective::CreateEmpty(const ASTContext &C,
759                                                     unsigned NumClauses,
760                                                     EmptyShell) {
761   return createEmptyDirective<OMPCancelDirective>(C, NumClauses);
762 }
763 
764 OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C,
765                                              SourceLocation StartLoc,
766                                              SourceLocation EndLoc,
767                                              ArrayRef<OMPClause *> Clauses) {
768   return createDirective<OMPFlushDirective>(
769       C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc,
770       EndLoc);
771 }
772 
773 OMPFlushDirective *OMPFlushDirective::CreateEmpty(const ASTContext &C,
774                                                   unsigned NumClauses,
775                                                   EmptyShell) {
776   return createEmptyDirective<OMPFlushDirective>(C, NumClauses);
777 }
778 
779 OMPDepobjDirective *OMPDepobjDirective::Create(const ASTContext &C,
780                                                SourceLocation StartLoc,
781                                                SourceLocation EndLoc,
782                                                ArrayRef<OMPClause *> Clauses) {
783   return createDirective<OMPDepobjDirective>(
784       C, Clauses, /*AssociatedStmt=*/nullptr,
785       /*NumChildren=*/0, StartLoc, EndLoc);
786 }
787 
788 OMPDepobjDirective *OMPDepobjDirective::CreateEmpty(const ASTContext &C,
789                                                     unsigned NumClauses,
790                                                     EmptyShell) {
791   return createEmptyDirective<OMPDepobjDirective>(C, NumClauses);
792 }
793 
794 OMPScanDirective *OMPScanDirective::Create(const ASTContext &C,
795                                            SourceLocation StartLoc,
796                                            SourceLocation EndLoc,
797                                            ArrayRef<OMPClause *> Clauses) {
798   return createDirective<OMPScanDirective>(C, Clauses,
799                                            /*AssociatedStmt=*/nullptr,
800                                            /*NumChildren=*/0, StartLoc, EndLoc);
801 }
802 
803 OMPScanDirective *OMPScanDirective::CreateEmpty(const ASTContext &C,
804                                                 unsigned NumClauses,
805                                                 EmptyShell) {
806   return createEmptyDirective<OMPScanDirective>(C, NumClauses);
807 }
808 
809 OMPOrderedDirective *OMPOrderedDirective::Create(const ASTContext &C,
810                                                  SourceLocation StartLoc,
811                                                  SourceLocation EndLoc,
812                                                  ArrayRef<OMPClause *> Clauses,
813                                                  Stmt *AssociatedStmt) {
814   return createDirective<OMPOrderedDirective>(
815       C, Clauses, cast_or_null<CapturedStmt>(AssociatedStmt),
816       /*NumChildren=*/0, StartLoc, EndLoc);
817 }
818 
819 OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(const ASTContext &C,
820                                                       unsigned NumClauses,
821                                                       bool IsStandalone,
822                                                       EmptyShell) {
823   return createEmptyDirective<OMPOrderedDirective>(C, NumClauses,
824                                                    !IsStandalone);
825 }
826 
827 OMPAtomicDirective *OMPAtomicDirective::Create(
828     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
829     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
830     Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {
831   auto *Dir = createDirective<OMPAtomicDirective>(
832       C, Clauses, AssociatedStmt, /*NumChildren=*/4, StartLoc, EndLoc);
833   Dir->setX(X);
834   Dir->setV(V);
835   Dir->setExpr(E);
836   Dir->setUpdateExpr(UE);
837   Dir->IsXLHSInRHSPart = IsXLHSInRHSPart;
838   Dir->IsPostfixUpdate = IsPostfixUpdate;
839   return Dir;
840 }
841 
842 OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C,
843                                                     unsigned NumClauses,
844                                                     EmptyShell) {
845   return createEmptyDirective<OMPAtomicDirective>(
846       C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/4);
847 }
848 
849 OMPTargetDirective *OMPTargetDirective::Create(const ASTContext &C,
850                                                SourceLocation StartLoc,
851                                                SourceLocation EndLoc,
852                                                ArrayRef<OMPClause *> Clauses,
853                                                Stmt *AssociatedStmt) {
854   return createDirective<OMPTargetDirective>(
855       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
856 }
857 
858 OMPTargetDirective *OMPTargetDirective::CreateEmpty(const ASTContext &C,
859                                                     unsigned NumClauses,
860                                                     EmptyShell) {
861   return createEmptyDirective<OMPTargetDirective>(C, NumClauses,
862                                                   /*HasAssociatedStmt=*/true);
863 }
864 
865 OMPTargetParallelDirective *OMPTargetParallelDirective::Create(
866     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
867     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
868     bool HasCancel) {
869   auto *Dir = createDirective<OMPTargetParallelDirective>(
870       C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
871   Dir->setTaskReductionRefExpr(TaskRedRef);
872   Dir->setHasCancel(HasCancel);
873   return Dir;
874 }
875 
876 OMPTargetParallelDirective *
877 OMPTargetParallelDirective::CreateEmpty(const ASTContext &C,
878                                         unsigned NumClauses, EmptyShell) {
879   return createEmptyDirective<OMPTargetParallelDirective>(
880       C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
881 }
882 
883 OMPTargetParallelForDirective *OMPTargetParallelForDirective::Create(
884     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
885     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
886     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
887   auto *Dir = createDirective<OMPTargetParallelForDirective>(
888       C, Clauses, AssociatedStmt,
889       numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1, StartLoc,
890       EndLoc, CollapsedNum);
891   Dir->setIterationVariable(Exprs.IterationVarRef);
892   Dir->setLastIteration(Exprs.LastIteration);
893   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
894   Dir->setPreCond(Exprs.PreCond);
895   Dir->setCond(Exprs.Cond);
896   Dir->setInit(Exprs.Init);
897   Dir->setInc(Exprs.Inc);
898   Dir->setIsLastIterVariable(Exprs.IL);
899   Dir->setLowerBoundVariable(Exprs.LB);
900   Dir->setUpperBoundVariable(Exprs.UB);
901   Dir->setStrideVariable(Exprs.ST);
902   Dir->setEnsureUpperBound(Exprs.EUB);
903   Dir->setNextLowerBound(Exprs.NLB);
904   Dir->setNextUpperBound(Exprs.NUB);
905   Dir->setNumIterations(Exprs.NumIterations);
906   Dir->setCounters(Exprs.Counters);
907   Dir->setPrivateCounters(Exprs.PrivateCounters);
908   Dir->setInits(Exprs.Inits);
909   Dir->setUpdates(Exprs.Updates);
910   Dir->setFinals(Exprs.Finals);
911   Dir->setDependentCounters(Exprs.DependentCounters);
912   Dir->setDependentInits(Exprs.DependentInits);
913   Dir->setFinalsConditions(Exprs.FinalsConditions);
914   Dir->setPreInits(Exprs.PreInits);
915   Dir->setTaskReductionRefExpr(TaskRedRef);
916   Dir->setHasCancel(HasCancel);
917   return Dir;
918 }
919 
920 OMPTargetParallelForDirective *
921 OMPTargetParallelForDirective::CreateEmpty(const ASTContext &C,
922                                            unsigned NumClauses,
923                                            unsigned CollapsedNum, EmptyShell) {
924   return createEmptyDirective<OMPTargetParallelForDirective>(
925       C, NumClauses, /*HasAssociatedStmt=*/true,
926       numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1,
927       CollapsedNum);
928 }
929 
930 OMPTargetDataDirective *OMPTargetDataDirective::Create(
931     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
932     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
933   return createDirective<OMPTargetDataDirective>(
934       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
935 }
936 
937 OMPTargetDataDirective *OMPTargetDataDirective::CreateEmpty(const ASTContext &C,
938                                                             unsigned N,
939                                                             EmptyShell) {
940   return createEmptyDirective<OMPTargetDataDirective>(
941       C, N, /*HasAssociatedStmt=*/true);
942 }
943 
944 OMPTargetEnterDataDirective *OMPTargetEnterDataDirective::Create(
945     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
946     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
947   return createDirective<OMPTargetEnterDataDirective>(
948       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
949 }
950 
951 OMPTargetEnterDataDirective *
952 OMPTargetEnterDataDirective::CreateEmpty(const ASTContext &C, unsigned N,
953                                          EmptyShell) {
954   return createEmptyDirective<OMPTargetEnterDataDirective>(
955       C, N, /*HasAssociatedStmt=*/true);
956 }
957 
958 OMPTargetExitDataDirective *OMPTargetExitDataDirective::Create(
959     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
960     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
961   return createDirective<OMPTargetExitDataDirective>(
962       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
963 }
964 
965 OMPTargetExitDataDirective *
966 OMPTargetExitDataDirective::CreateEmpty(const ASTContext &C, unsigned N,
967                                         EmptyShell) {
968   return createEmptyDirective<OMPTargetExitDataDirective>(
969       C, N, /*HasAssociatedStmt=*/true);
970 }
971 
972 OMPTeamsDirective *OMPTeamsDirective::Create(const ASTContext &C,
973                                              SourceLocation StartLoc,
974                                              SourceLocation EndLoc,
975                                              ArrayRef<OMPClause *> Clauses,
976                                              Stmt *AssociatedStmt) {
977   return createDirective<OMPTeamsDirective>(
978       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
979 }
980 
981 OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C,
982                                                   unsigned NumClauses,
983                                                   EmptyShell) {
984   return createEmptyDirective<OMPTeamsDirective>(C, NumClauses,
985                                                  /*HasAssociatedStmt=*/true);
986 }
987 
988 OMPTaskLoopDirective *OMPTaskLoopDirective::Create(
989     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
990     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
991     const HelperExprs &Exprs, bool HasCancel) {
992   auto *Dir = createDirective<OMPTaskLoopDirective>(
993       C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_taskloop),
994       StartLoc, EndLoc, CollapsedNum);
995   Dir->setIterationVariable(Exprs.IterationVarRef);
996   Dir->setLastIteration(Exprs.LastIteration);
997   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
998   Dir->setPreCond(Exprs.PreCond);
999   Dir->setCond(Exprs.Cond);
1000   Dir->setInit(Exprs.Init);
1001   Dir->setInc(Exprs.Inc);
1002   Dir->setIsLastIterVariable(Exprs.IL);
1003   Dir->setLowerBoundVariable(Exprs.LB);
1004   Dir->setUpperBoundVariable(Exprs.UB);
1005   Dir->setStrideVariable(Exprs.ST);
1006   Dir->setEnsureUpperBound(Exprs.EUB);
1007   Dir->setNextLowerBound(Exprs.NLB);
1008   Dir->setNextUpperBound(Exprs.NUB);
1009   Dir->setNumIterations(Exprs.NumIterations);
1010   Dir->setCounters(Exprs.Counters);
1011   Dir->setPrivateCounters(Exprs.PrivateCounters);
1012   Dir->setInits(Exprs.Inits);
1013   Dir->setUpdates(Exprs.Updates);
1014   Dir->setFinals(Exprs.Finals);
1015   Dir->setDependentCounters(Exprs.DependentCounters);
1016   Dir->setDependentInits(Exprs.DependentInits);
1017   Dir->setFinalsConditions(Exprs.FinalsConditions);
1018   Dir->setPreInits(Exprs.PreInits);
1019   Dir->setHasCancel(HasCancel);
1020   return Dir;
1021 }
1022 
1023 OMPTaskLoopDirective *OMPTaskLoopDirective::CreateEmpty(const ASTContext &C,
1024                                                         unsigned NumClauses,
1025                                                         unsigned CollapsedNum,
1026                                                         EmptyShell) {
1027   return createEmptyDirective<OMPTaskLoopDirective>(
1028       C, NumClauses, /*HasAssociatedStmt=*/true,
1029       numLoopChildren(CollapsedNum, OMPD_taskloop), CollapsedNum);
1030 }
1031 
1032 OMPTaskLoopSimdDirective *OMPTaskLoopSimdDirective::Create(
1033     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1034     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1035     const HelperExprs &Exprs) {
1036   auto *Dir = createDirective<OMPTaskLoopSimdDirective>(
1037       C, Clauses, AssociatedStmt,
1038       numLoopChildren(CollapsedNum, OMPD_taskloop_simd), StartLoc, EndLoc,
1039       CollapsedNum);
1040   Dir->setIterationVariable(Exprs.IterationVarRef);
1041   Dir->setLastIteration(Exprs.LastIteration);
1042   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1043   Dir->setPreCond(Exprs.PreCond);
1044   Dir->setCond(Exprs.Cond);
1045   Dir->setInit(Exprs.Init);
1046   Dir->setInc(Exprs.Inc);
1047   Dir->setIsLastIterVariable(Exprs.IL);
1048   Dir->setLowerBoundVariable(Exprs.LB);
1049   Dir->setUpperBoundVariable(Exprs.UB);
1050   Dir->setStrideVariable(Exprs.ST);
1051   Dir->setEnsureUpperBound(Exprs.EUB);
1052   Dir->setNextLowerBound(Exprs.NLB);
1053   Dir->setNextUpperBound(Exprs.NUB);
1054   Dir->setNumIterations(Exprs.NumIterations);
1055   Dir->setCounters(Exprs.Counters);
1056   Dir->setPrivateCounters(Exprs.PrivateCounters);
1057   Dir->setInits(Exprs.Inits);
1058   Dir->setUpdates(Exprs.Updates);
1059   Dir->setFinals(Exprs.Finals);
1060   Dir->setDependentCounters(Exprs.DependentCounters);
1061   Dir->setDependentInits(Exprs.DependentInits);
1062   Dir->setFinalsConditions(Exprs.FinalsConditions);
1063   Dir->setPreInits(Exprs.PreInits);
1064   return Dir;
1065 }
1066 
1067 OMPTaskLoopSimdDirective *
1068 OMPTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1069                                       unsigned CollapsedNum, EmptyShell) {
1070   return createEmptyDirective<OMPTaskLoopSimdDirective>(
1071       C, NumClauses, /*HasAssociatedStmt=*/true,
1072       numLoopChildren(CollapsedNum, OMPD_taskloop_simd), CollapsedNum);
1073 }
1074 
1075 OMPMasterTaskLoopDirective *OMPMasterTaskLoopDirective::Create(
1076     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1077     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1078     const HelperExprs &Exprs, bool HasCancel) {
1079   auto *Dir = createDirective<OMPMasterTaskLoopDirective>(
1080       C, Clauses, AssociatedStmt,
1081       numLoopChildren(CollapsedNum, OMPD_master_taskloop), StartLoc, EndLoc,
1082       CollapsedNum);
1083   Dir->setIterationVariable(Exprs.IterationVarRef);
1084   Dir->setLastIteration(Exprs.LastIteration);
1085   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1086   Dir->setPreCond(Exprs.PreCond);
1087   Dir->setCond(Exprs.Cond);
1088   Dir->setInit(Exprs.Init);
1089   Dir->setInc(Exprs.Inc);
1090   Dir->setIsLastIterVariable(Exprs.IL);
1091   Dir->setLowerBoundVariable(Exprs.LB);
1092   Dir->setUpperBoundVariable(Exprs.UB);
1093   Dir->setStrideVariable(Exprs.ST);
1094   Dir->setEnsureUpperBound(Exprs.EUB);
1095   Dir->setNextLowerBound(Exprs.NLB);
1096   Dir->setNextUpperBound(Exprs.NUB);
1097   Dir->setNumIterations(Exprs.NumIterations);
1098   Dir->setCounters(Exprs.Counters);
1099   Dir->setPrivateCounters(Exprs.PrivateCounters);
1100   Dir->setInits(Exprs.Inits);
1101   Dir->setUpdates(Exprs.Updates);
1102   Dir->setFinals(Exprs.Finals);
1103   Dir->setDependentCounters(Exprs.DependentCounters);
1104   Dir->setDependentInits(Exprs.DependentInits);
1105   Dir->setFinalsConditions(Exprs.FinalsConditions);
1106   Dir->setPreInits(Exprs.PreInits);
1107   Dir->setHasCancel(HasCancel);
1108   return Dir;
1109 }
1110 
1111 OMPMasterTaskLoopDirective *
1112 OMPMasterTaskLoopDirective::CreateEmpty(const ASTContext &C,
1113                                         unsigned NumClauses,
1114                                         unsigned CollapsedNum, EmptyShell) {
1115   return createEmptyDirective<OMPMasterTaskLoopDirective>(
1116       C, NumClauses, /*HasAssociatedStmt=*/true,
1117       numLoopChildren(CollapsedNum, OMPD_master_taskloop), CollapsedNum);
1118 }
1119 
1120 OMPMasterTaskLoopSimdDirective *OMPMasterTaskLoopSimdDirective::Create(
1121     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1122     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1123     const HelperExprs &Exprs) {
1124   auto *Dir = createDirective<OMPMasterTaskLoopSimdDirective>(
1125       C, Clauses, AssociatedStmt,
1126       numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), StartLoc,
1127       EndLoc, CollapsedNum);
1128   Dir->setIterationVariable(Exprs.IterationVarRef);
1129   Dir->setLastIteration(Exprs.LastIteration);
1130   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1131   Dir->setPreCond(Exprs.PreCond);
1132   Dir->setCond(Exprs.Cond);
1133   Dir->setInit(Exprs.Init);
1134   Dir->setInc(Exprs.Inc);
1135   Dir->setIsLastIterVariable(Exprs.IL);
1136   Dir->setLowerBoundVariable(Exprs.LB);
1137   Dir->setUpperBoundVariable(Exprs.UB);
1138   Dir->setStrideVariable(Exprs.ST);
1139   Dir->setEnsureUpperBound(Exprs.EUB);
1140   Dir->setNextLowerBound(Exprs.NLB);
1141   Dir->setNextUpperBound(Exprs.NUB);
1142   Dir->setNumIterations(Exprs.NumIterations);
1143   Dir->setCounters(Exprs.Counters);
1144   Dir->setPrivateCounters(Exprs.PrivateCounters);
1145   Dir->setInits(Exprs.Inits);
1146   Dir->setUpdates(Exprs.Updates);
1147   Dir->setFinals(Exprs.Finals);
1148   Dir->setDependentCounters(Exprs.DependentCounters);
1149   Dir->setDependentInits(Exprs.DependentInits);
1150   Dir->setFinalsConditions(Exprs.FinalsConditions);
1151   Dir->setPreInits(Exprs.PreInits);
1152   return Dir;
1153 }
1154 
1155 OMPMasterTaskLoopSimdDirective *
1156 OMPMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C,
1157                                             unsigned NumClauses,
1158                                             unsigned CollapsedNum, EmptyShell) {
1159   return createEmptyDirective<OMPMasterTaskLoopSimdDirective>(
1160       C, NumClauses, /*HasAssociatedStmt=*/true,
1161       numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), CollapsedNum);
1162 }
1163 
1164 OMPParallelMasterTaskLoopDirective *OMPParallelMasterTaskLoopDirective::Create(
1165     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1166     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1167     const HelperExprs &Exprs, bool HasCancel) {
1168   auto *Dir = createDirective<OMPParallelMasterTaskLoopDirective>(
1169       C, Clauses, AssociatedStmt,
1170       numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop), StartLoc,
1171       EndLoc, CollapsedNum);
1172   Dir->setIterationVariable(Exprs.IterationVarRef);
1173   Dir->setLastIteration(Exprs.LastIteration);
1174   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1175   Dir->setPreCond(Exprs.PreCond);
1176   Dir->setCond(Exprs.Cond);
1177   Dir->setInit(Exprs.Init);
1178   Dir->setInc(Exprs.Inc);
1179   Dir->setIsLastIterVariable(Exprs.IL);
1180   Dir->setLowerBoundVariable(Exprs.LB);
1181   Dir->setUpperBoundVariable(Exprs.UB);
1182   Dir->setStrideVariable(Exprs.ST);
1183   Dir->setEnsureUpperBound(Exprs.EUB);
1184   Dir->setNextLowerBound(Exprs.NLB);
1185   Dir->setNextUpperBound(Exprs.NUB);
1186   Dir->setNumIterations(Exprs.NumIterations);
1187   Dir->setCounters(Exprs.Counters);
1188   Dir->setPrivateCounters(Exprs.PrivateCounters);
1189   Dir->setInits(Exprs.Inits);
1190   Dir->setUpdates(Exprs.Updates);
1191   Dir->setFinals(Exprs.Finals);
1192   Dir->setDependentCounters(Exprs.DependentCounters);
1193   Dir->setDependentInits(Exprs.DependentInits);
1194   Dir->setFinalsConditions(Exprs.FinalsConditions);
1195   Dir->setPreInits(Exprs.PreInits);
1196   Dir->setHasCancel(HasCancel);
1197   return Dir;
1198 }
1199 
1200 OMPParallelMasterTaskLoopDirective *
1201 OMPParallelMasterTaskLoopDirective::CreateEmpty(const ASTContext &C,
1202                                                 unsigned NumClauses,
1203                                                 unsigned CollapsedNum,
1204                                                 EmptyShell) {
1205   return createEmptyDirective<OMPParallelMasterTaskLoopDirective>(
1206       C, NumClauses, /*HasAssociatedStmt=*/true,
1207       numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop),
1208       CollapsedNum);
1209 }
1210 
1211 OMPParallelMasterTaskLoopSimdDirective *
1212 OMPParallelMasterTaskLoopSimdDirective::Create(
1213     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1214     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1215     const HelperExprs &Exprs) {
1216   auto *Dir = createDirective<OMPParallelMasterTaskLoopSimdDirective>(
1217       C, Clauses, AssociatedStmt,
1218       numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd),
1219       StartLoc, EndLoc, CollapsedNum);
1220   Dir->setIterationVariable(Exprs.IterationVarRef);
1221   Dir->setLastIteration(Exprs.LastIteration);
1222   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1223   Dir->setPreCond(Exprs.PreCond);
1224   Dir->setCond(Exprs.Cond);
1225   Dir->setInit(Exprs.Init);
1226   Dir->setInc(Exprs.Inc);
1227   Dir->setIsLastIterVariable(Exprs.IL);
1228   Dir->setLowerBoundVariable(Exprs.LB);
1229   Dir->setUpperBoundVariable(Exprs.UB);
1230   Dir->setStrideVariable(Exprs.ST);
1231   Dir->setEnsureUpperBound(Exprs.EUB);
1232   Dir->setNextLowerBound(Exprs.NLB);
1233   Dir->setNextUpperBound(Exprs.NUB);
1234   Dir->setNumIterations(Exprs.NumIterations);
1235   Dir->setCounters(Exprs.Counters);
1236   Dir->setPrivateCounters(Exprs.PrivateCounters);
1237   Dir->setInits(Exprs.Inits);
1238   Dir->setUpdates(Exprs.Updates);
1239   Dir->setFinals(Exprs.Finals);
1240   Dir->setDependentCounters(Exprs.DependentCounters);
1241   Dir->setDependentInits(Exprs.DependentInits);
1242   Dir->setFinalsConditions(Exprs.FinalsConditions);
1243   Dir->setPreInits(Exprs.PreInits);
1244   return Dir;
1245 }
1246 
1247 OMPParallelMasterTaskLoopSimdDirective *
1248 OMPParallelMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C,
1249                                                     unsigned NumClauses,
1250                                                     unsigned CollapsedNum,
1251                                                     EmptyShell) {
1252   return createEmptyDirective<OMPParallelMasterTaskLoopSimdDirective>(
1253       C, NumClauses, /*HasAssociatedStmt=*/true,
1254       numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd),
1255       CollapsedNum);
1256 }
1257 
1258 OMPDistributeDirective *OMPDistributeDirective::Create(
1259     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1260     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1261     const HelperExprs &Exprs) {
1262   auto *Dir = createDirective<OMPDistributeDirective>(
1263       C, Clauses, AssociatedStmt,
1264       numLoopChildren(CollapsedNum, OMPD_distribute), StartLoc, EndLoc,
1265       CollapsedNum);
1266   Dir->setIterationVariable(Exprs.IterationVarRef);
1267   Dir->setLastIteration(Exprs.LastIteration);
1268   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1269   Dir->setPreCond(Exprs.PreCond);
1270   Dir->setCond(Exprs.Cond);
1271   Dir->setInit(Exprs.Init);
1272   Dir->setInc(Exprs.Inc);
1273   Dir->setIsLastIterVariable(Exprs.IL);
1274   Dir->setLowerBoundVariable(Exprs.LB);
1275   Dir->setUpperBoundVariable(Exprs.UB);
1276   Dir->setStrideVariable(Exprs.ST);
1277   Dir->setEnsureUpperBound(Exprs.EUB);
1278   Dir->setNextLowerBound(Exprs.NLB);
1279   Dir->setNextUpperBound(Exprs.NUB);
1280   Dir->setNumIterations(Exprs.NumIterations);
1281   Dir->setCounters(Exprs.Counters);
1282   Dir->setPrivateCounters(Exprs.PrivateCounters);
1283   Dir->setInits(Exprs.Inits);
1284   Dir->setUpdates(Exprs.Updates);
1285   Dir->setFinals(Exprs.Finals);
1286   Dir->setDependentCounters(Exprs.DependentCounters);
1287   Dir->setDependentInits(Exprs.DependentInits);
1288   Dir->setFinalsConditions(Exprs.FinalsConditions);
1289   Dir->setPreInits(Exprs.PreInits);
1290   return Dir;
1291 }
1292 
1293 OMPDistributeDirective *
1294 OMPDistributeDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1295                                     unsigned CollapsedNum, EmptyShell) {
1296   return createEmptyDirective<OMPDistributeDirective>(
1297       C, NumClauses, /*HasAssociatedStmt=*/true,
1298       numLoopChildren(CollapsedNum, OMPD_distribute), CollapsedNum);
1299 }
1300 
1301 OMPTargetUpdateDirective *OMPTargetUpdateDirective::Create(
1302     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1303     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1304   return createDirective<OMPTargetUpdateDirective>(C, Clauses, AssociatedStmt,
1305                                                    /*NumChildren=*/0, StartLoc,
1306                                                    EndLoc);
1307 }
1308 
1309 OMPTargetUpdateDirective *
1310 OMPTargetUpdateDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1311                                       EmptyShell) {
1312   return createEmptyDirective<OMPTargetUpdateDirective>(
1313       C, NumClauses, /*HasAssociatedStmt=*/true);
1314 }
1315 
1316 OMPDistributeParallelForDirective *OMPDistributeParallelForDirective::Create(
1317     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1318     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1319     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
1320   auto *Dir = createDirective<OMPDistributeParallelForDirective>(
1321       C, Clauses, AssociatedStmt,
1322       numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1, StartLoc,
1323       EndLoc, CollapsedNum);
1324   Dir->setIterationVariable(Exprs.IterationVarRef);
1325   Dir->setLastIteration(Exprs.LastIteration);
1326   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1327   Dir->setPreCond(Exprs.PreCond);
1328   Dir->setCond(Exprs.Cond);
1329   Dir->setInit(Exprs.Init);
1330   Dir->setInc(Exprs.Inc);
1331   Dir->setIsLastIterVariable(Exprs.IL);
1332   Dir->setLowerBoundVariable(Exprs.LB);
1333   Dir->setUpperBoundVariable(Exprs.UB);
1334   Dir->setStrideVariable(Exprs.ST);
1335   Dir->setEnsureUpperBound(Exprs.EUB);
1336   Dir->setNextLowerBound(Exprs.NLB);
1337   Dir->setNextUpperBound(Exprs.NUB);
1338   Dir->setNumIterations(Exprs.NumIterations);
1339   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1340   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1341   Dir->setDistInc(Exprs.DistInc);
1342   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1343   Dir->setCounters(Exprs.Counters);
1344   Dir->setPrivateCounters(Exprs.PrivateCounters);
1345   Dir->setInits(Exprs.Inits);
1346   Dir->setUpdates(Exprs.Updates);
1347   Dir->setFinals(Exprs.Finals);
1348   Dir->setDependentCounters(Exprs.DependentCounters);
1349   Dir->setDependentInits(Exprs.DependentInits);
1350   Dir->setFinalsConditions(Exprs.FinalsConditions);
1351   Dir->setPreInits(Exprs.PreInits);
1352   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1353   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1354   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1355   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1356   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1357   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1358   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1359   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1360   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1361   Dir->setTaskReductionRefExpr(TaskRedRef);
1362   Dir->HasCancel = HasCancel;
1363   return Dir;
1364 }
1365 
1366 OMPDistributeParallelForDirective *
1367 OMPDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
1368                                                unsigned NumClauses,
1369                                                unsigned CollapsedNum,
1370                                                EmptyShell) {
1371   return createEmptyDirective<OMPDistributeParallelForDirective>(
1372       C, NumClauses, /*HasAssociatedStmt=*/true,
1373       numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1,
1374       CollapsedNum);
1375 }
1376 
1377 OMPDistributeParallelForSimdDirective *
1378 OMPDistributeParallelForSimdDirective::Create(
1379     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1380     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1381     const HelperExprs &Exprs) {
1382   auto *Dir = createDirective<OMPDistributeParallelForSimdDirective>(
1383       C, Clauses, AssociatedStmt,
1384       numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd),
1385       StartLoc, EndLoc, CollapsedNum);
1386   Dir->setIterationVariable(Exprs.IterationVarRef);
1387   Dir->setLastIteration(Exprs.LastIteration);
1388   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1389   Dir->setPreCond(Exprs.PreCond);
1390   Dir->setCond(Exprs.Cond);
1391   Dir->setInit(Exprs.Init);
1392   Dir->setInc(Exprs.Inc);
1393   Dir->setIsLastIterVariable(Exprs.IL);
1394   Dir->setLowerBoundVariable(Exprs.LB);
1395   Dir->setUpperBoundVariable(Exprs.UB);
1396   Dir->setStrideVariable(Exprs.ST);
1397   Dir->setEnsureUpperBound(Exprs.EUB);
1398   Dir->setNextLowerBound(Exprs.NLB);
1399   Dir->setNextUpperBound(Exprs.NUB);
1400   Dir->setNumIterations(Exprs.NumIterations);
1401   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1402   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1403   Dir->setDistInc(Exprs.DistInc);
1404   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1405   Dir->setCounters(Exprs.Counters);
1406   Dir->setPrivateCounters(Exprs.PrivateCounters);
1407   Dir->setInits(Exprs.Inits);
1408   Dir->setUpdates(Exprs.Updates);
1409   Dir->setFinals(Exprs.Finals);
1410   Dir->setDependentCounters(Exprs.DependentCounters);
1411   Dir->setDependentInits(Exprs.DependentInits);
1412   Dir->setFinalsConditions(Exprs.FinalsConditions);
1413   Dir->setPreInits(Exprs.PreInits);
1414   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1415   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1416   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1417   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1418   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1419   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1420   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1421   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1422   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1423   return Dir;
1424 }
1425 
1426 OMPDistributeParallelForSimdDirective *
1427 OMPDistributeParallelForSimdDirective::CreateEmpty(const ASTContext &C,
1428                                                    unsigned NumClauses,
1429                                                    unsigned CollapsedNum,
1430                                                    EmptyShell) {
1431   return createEmptyDirective<OMPDistributeParallelForSimdDirective>(
1432       C, NumClauses, /*HasAssociatedStmt=*/true,
1433       numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd),
1434       CollapsedNum);
1435 }
1436 
1437 OMPDistributeSimdDirective *OMPDistributeSimdDirective::Create(
1438     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1439     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1440     const HelperExprs &Exprs) {
1441   auto *Dir = createDirective<OMPDistributeSimdDirective>(
1442       C, Clauses, AssociatedStmt,
1443       numLoopChildren(CollapsedNum, OMPD_distribute_simd), StartLoc, EndLoc,
1444       CollapsedNum);
1445   Dir->setIterationVariable(Exprs.IterationVarRef);
1446   Dir->setLastIteration(Exprs.LastIteration);
1447   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1448   Dir->setPreCond(Exprs.PreCond);
1449   Dir->setCond(Exprs.Cond);
1450   Dir->setInit(Exprs.Init);
1451   Dir->setInc(Exprs.Inc);
1452   Dir->setIsLastIterVariable(Exprs.IL);
1453   Dir->setLowerBoundVariable(Exprs.LB);
1454   Dir->setUpperBoundVariable(Exprs.UB);
1455   Dir->setStrideVariable(Exprs.ST);
1456   Dir->setEnsureUpperBound(Exprs.EUB);
1457   Dir->setNextLowerBound(Exprs.NLB);
1458   Dir->setNextUpperBound(Exprs.NUB);
1459   Dir->setNumIterations(Exprs.NumIterations);
1460   Dir->setCounters(Exprs.Counters);
1461   Dir->setPrivateCounters(Exprs.PrivateCounters);
1462   Dir->setInits(Exprs.Inits);
1463   Dir->setUpdates(Exprs.Updates);
1464   Dir->setFinals(Exprs.Finals);
1465   Dir->setDependentCounters(Exprs.DependentCounters);
1466   Dir->setDependentInits(Exprs.DependentInits);
1467   Dir->setFinalsConditions(Exprs.FinalsConditions);
1468   Dir->setPreInits(Exprs.PreInits);
1469   return Dir;
1470 }
1471 
1472 OMPDistributeSimdDirective *
1473 OMPDistributeSimdDirective::CreateEmpty(const ASTContext &C,
1474                                         unsigned NumClauses,
1475                                         unsigned CollapsedNum, EmptyShell) {
1476   return createEmptyDirective<OMPDistributeSimdDirective>(
1477       C, NumClauses, /*HasAssociatedStmt=*/true,
1478       numLoopChildren(CollapsedNum, OMPD_distribute_simd), CollapsedNum);
1479 }
1480 
1481 OMPTargetParallelForSimdDirective *OMPTargetParallelForSimdDirective::Create(
1482     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1483     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1484     const HelperExprs &Exprs) {
1485   auto *Dir = createDirective<OMPTargetParallelForSimdDirective>(
1486       C, Clauses, AssociatedStmt,
1487       numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd), StartLoc,
1488       EndLoc, CollapsedNum);
1489   Dir->setIterationVariable(Exprs.IterationVarRef);
1490   Dir->setLastIteration(Exprs.LastIteration);
1491   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1492   Dir->setPreCond(Exprs.PreCond);
1493   Dir->setCond(Exprs.Cond);
1494   Dir->setInit(Exprs.Init);
1495   Dir->setInc(Exprs.Inc);
1496   Dir->setIsLastIterVariable(Exprs.IL);
1497   Dir->setLowerBoundVariable(Exprs.LB);
1498   Dir->setUpperBoundVariable(Exprs.UB);
1499   Dir->setStrideVariable(Exprs.ST);
1500   Dir->setEnsureUpperBound(Exprs.EUB);
1501   Dir->setNextLowerBound(Exprs.NLB);
1502   Dir->setNextUpperBound(Exprs.NUB);
1503   Dir->setNumIterations(Exprs.NumIterations);
1504   Dir->setCounters(Exprs.Counters);
1505   Dir->setPrivateCounters(Exprs.PrivateCounters);
1506   Dir->setInits(Exprs.Inits);
1507   Dir->setUpdates(Exprs.Updates);
1508   Dir->setFinals(Exprs.Finals);
1509   Dir->setDependentCounters(Exprs.DependentCounters);
1510   Dir->setDependentInits(Exprs.DependentInits);
1511   Dir->setFinalsConditions(Exprs.FinalsConditions);
1512   Dir->setPreInits(Exprs.PreInits);
1513   return Dir;
1514 }
1515 
1516 OMPTargetParallelForSimdDirective *
1517 OMPTargetParallelForSimdDirective::CreateEmpty(const ASTContext &C,
1518                                                unsigned NumClauses,
1519                                                unsigned CollapsedNum,
1520                                                EmptyShell) {
1521   return createEmptyDirective<OMPTargetParallelForSimdDirective>(
1522       C, NumClauses, /*HasAssociatedStmt=*/true,
1523       numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd),
1524       CollapsedNum);
1525 }
1526 
1527 OMPTargetSimdDirective *
1528 OMPTargetSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
1529                                SourceLocation EndLoc, unsigned CollapsedNum,
1530                                ArrayRef<OMPClause *> Clauses,
1531                                Stmt *AssociatedStmt, const HelperExprs &Exprs) {
1532   auto *Dir = createDirective<OMPTargetSimdDirective>(
1533       C, Clauses, AssociatedStmt,
1534       numLoopChildren(CollapsedNum, OMPD_target_simd), StartLoc, EndLoc,
1535       CollapsedNum);
1536   Dir->setIterationVariable(Exprs.IterationVarRef);
1537   Dir->setLastIteration(Exprs.LastIteration);
1538   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1539   Dir->setPreCond(Exprs.PreCond);
1540   Dir->setCond(Exprs.Cond);
1541   Dir->setInit(Exprs.Init);
1542   Dir->setInc(Exprs.Inc);
1543   Dir->setCounters(Exprs.Counters);
1544   Dir->setPrivateCounters(Exprs.PrivateCounters);
1545   Dir->setInits(Exprs.Inits);
1546   Dir->setUpdates(Exprs.Updates);
1547   Dir->setFinals(Exprs.Finals);
1548   Dir->setDependentCounters(Exprs.DependentCounters);
1549   Dir->setDependentInits(Exprs.DependentInits);
1550   Dir->setFinalsConditions(Exprs.FinalsConditions);
1551   Dir->setPreInits(Exprs.PreInits);
1552   return Dir;
1553 }
1554 
1555 OMPTargetSimdDirective *
1556 OMPTargetSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1557                                     unsigned CollapsedNum, EmptyShell) {
1558   return createEmptyDirective<OMPTargetSimdDirective>(
1559       C, NumClauses, /*HasAssociatedStmt=*/true,
1560       numLoopChildren(CollapsedNum, OMPD_target_simd), CollapsedNum);
1561 }
1562 
1563 OMPTeamsDistributeDirective *OMPTeamsDistributeDirective::Create(
1564     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1565     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1566     const HelperExprs &Exprs) {
1567   auto *Dir = createDirective<OMPTeamsDistributeDirective>(
1568       C, Clauses, AssociatedStmt,
1569       numLoopChildren(CollapsedNum, OMPD_teams_distribute), StartLoc, EndLoc,
1570       CollapsedNum);
1571   Dir->setIterationVariable(Exprs.IterationVarRef);
1572   Dir->setLastIteration(Exprs.LastIteration);
1573   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1574   Dir->setPreCond(Exprs.PreCond);
1575   Dir->setCond(Exprs.Cond);
1576   Dir->setInit(Exprs.Init);
1577   Dir->setInc(Exprs.Inc);
1578   Dir->setIsLastIterVariable(Exprs.IL);
1579   Dir->setLowerBoundVariable(Exprs.LB);
1580   Dir->setUpperBoundVariable(Exprs.UB);
1581   Dir->setStrideVariable(Exprs.ST);
1582   Dir->setEnsureUpperBound(Exprs.EUB);
1583   Dir->setNextLowerBound(Exprs.NLB);
1584   Dir->setNextUpperBound(Exprs.NUB);
1585   Dir->setNumIterations(Exprs.NumIterations);
1586   Dir->setCounters(Exprs.Counters);
1587   Dir->setPrivateCounters(Exprs.PrivateCounters);
1588   Dir->setInits(Exprs.Inits);
1589   Dir->setUpdates(Exprs.Updates);
1590   Dir->setFinals(Exprs.Finals);
1591   Dir->setDependentCounters(Exprs.DependentCounters);
1592   Dir->setDependentInits(Exprs.DependentInits);
1593   Dir->setFinalsConditions(Exprs.FinalsConditions);
1594   Dir->setPreInits(Exprs.PreInits);
1595   return Dir;
1596 }
1597 
1598 OMPTeamsDistributeDirective *
1599 OMPTeamsDistributeDirective::CreateEmpty(const ASTContext &C,
1600                                          unsigned NumClauses,
1601                                          unsigned CollapsedNum, EmptyShell) {
1602   return createEmptyDirective<OMPTeamsDistributeDirective>(
1603       C, NumClauses, /*HasAssociatedStmt=*/true,
1604       numLoopChildren(CollapsedNum, OMPD_teams_distribute), CollapsedNum);
1605 }
1606 
1607 OMPTeamsDistributeSimdDirective *OMPTeamsDistributeSimdDirective::Create(
1608     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1609     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1610     const HelperExprs &Exprs) {
1611   auto *Dir = createDirective<OMPTeamsDistributeSimdDirective>(
1612       C, Clauses, AssociatedStmt,
1613       numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), StartLoc,
1614       EndLoc, CollapsedNum);
1615   Dir->setIterationVariable(Exprs.IterationVarRef);
1616   Dir->setLastIteration(Exprs.LastIteration);
1617   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1618   Dir->setPreCond(Exprs.PreCond);
1619   Dir->setCond(Exprs.Cond);
1620   Dir->setInit(Exprs.Init);
1621   Dir->setInc(Exprs.Inc);
1622   Dir->setIsLastIterVariable(Exprs.IL);
1623   Dir->setLowerBoundVariable(Exprs.LB);
1624   Dir->setUpperBoundVariable(Exprs.UB);
1625   Dir->setStrideVariable(Exprs.ST);
1626   Dir->setEnsureUpperBound(Exprs.EUB);
1627   Dir->setNextLowerBound(Exprs.NLB);
1628   Dir->setNextUpperBound(Exprs.NUB);
1629   Dir->setNumIterations(Exprs.NumIterations);
1630   Dir->setCounters(Exprs.Counters);
1631   Dir->setPrivateCounters(Exprs.PrivateCounters);
1632   Dir->setInits(Exprs.Inits);
1633   Dir->setUpdates(Exprs.Updates);
1634   Dir->setFinals(Exprs.Finals);
1635   Dir->setDependentCounters(Exprs.DependentCounters);
1636   Dir->setDependentInits(Exprs.DependentInits);
1637   Dir->setFinalsConditions(Exprs.FinalsConditions);
1638   Dir->setPreInits(Exprs.PreInits);
1639   return Dir;
1640 }
1641 
1642 OMPTeamsDistributeSimdDirective *OMPTeamsDistributeSimdDirective::CreateEmpty(
1643     const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
1644     EmptyShell) {
1645   return createEmptyDirective<OMPTeamsDistributeSimdDirective>(
1646       C, NumClauses, /*HasAssociatedStmt=*/true,
1647       numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), CollapsedNum);
1648 }
1649 
1650 OMPTeamsDistributeParallelForSimdDirective *
1651 OMPTeamsDistributeParallelForSimdDirective::Create(
1652     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1653     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1654     const HelperExprs &Exprs) {
1655   auto *Dir = createDirective<OMPTeamsDistributeParallelForSimdDirective>(
1656       C, Clauses, AssociatedStmt,
1657       numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd),
1658       StartLoc, EndLoc, CollapsedNum);
1659   Dir->setIterationVariable(Exprs.IterationVarRef);
1660   Dir->setLastIteration(Exprs.LastIteration);
1661   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1662   Dir->setPreCond(Exprs.PreCond);
1663   Dir->setCond(Exprs.Cond);
1664   Dir->setInit(Exprs.Init);
1665   Dir->setInc(Exprs.Inc);
1666   Dir->setIsLastIterVariable(Exprs.IL);
1667   Dir->setLowerBoundVariable(Exprs.LB);
1668   Dir->setUpperBoundVariable(Exprs.UB);
1669   Dir->setStrideVariable(Exprs.ST);
1670   Dir->setEnsureUpperBound(Exprs.EUB);
1671   Dir->setNextLowerBound(Exprs.NLB);
1672   Dir->setNextUpperBound(Exprs.NUB);
1673   Dir->setNumIterations(Exprs.NumIterations);
1674   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1675   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1676   Dir->setDistInc(Exprs.DistInc);
1677   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1678   Dir->setCounters(Exprs.Counters);
1679   Dir->setPrivateCounters(Exprs.PrivateCounters);
1680   Dir->setInits(Exprs.Inits);
1681   Dir->setUpdates(Exprs.Updates);
1682   Dir->setFinals(Exprs.Finals);
1683   Dir->setDependentCounters(Exprs.DependentCounters);
1684   Dir->setDependentInits(Exprs.DependentInits);
1685   Dir->setFinalsConditions(Exprs.FinalsConditions);
1686   Dir->setPreInits(Exprs.PreInits);
1687   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1688   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1689   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1690   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1691   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1692   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1693   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1694   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1695   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1696   return Dir;
1697 }
1698 
1699 OMPTeamsDistributeParallelForSimdDirective *
1700 OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(const ASTContext &C,
1701                                                         unsigned NumClauses,
1702                                                         unsigned CollapsedNum,
1703                                                         EmptyShell) {
1704   return createEmptyDirective<OMPTeamsDistributeParallelForSimdDirective>(
1705       C, NumClauses, /*HasAssociatedStmt=*/true,
1706       numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd),
1707       CollapsedNum);
1708 }
1709 
1710 OMPTeamsDistributeParallelForDirective *
1711 OMPTeamsDistributeParallelForDirective::Create(
1712     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1713     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1714     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
1715   auto *Dir = createDirective<OMPTeamsDistributeParallelForDirective>(
1716       C, Clauses, AssociatedStmt,
1717       numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1,
1718       StartLoc, EndLoc, CollapsedNum);
1719   Dir->setIterationVariable(Exprs.IterationVarRef);
1720   Dir->setLastIteration(Exprs.LastIteration);
1721   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1722   Dir->setPreCond(Exprs.PreCond);
1723   Dir->setCond(Exprs.Cond);
1724   Dir->setInit(Exprs.Init);
1725   Dir->setInc(Exprs.Inc);
1726   Dir->setIsLastIterVariable(Exprs.IL);
1727   Dir->setLowerBoundVariable(Exprs.LB);
1728   Dir->setUpperBoundVariable(Exprs.UB);
1729   Dir->setStrideVariable(Exprs.ST);
1730   Dir->setEnsureUpperBound(Exprs.EUB);
1731   Dir->setNextLowerBound(Exprs.NLB);
1732   Dir->setNextUpperBound(Exprs.NUB);
1733   Dir->setNumIterations(Exprs.NumIterations);
1734   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1735   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1736   Dir->setDistInc(Exprs.DistInc);
1737   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
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   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1748   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1749   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1750   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1751   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1752   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1753   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1754   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1755   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1756   Dir->setTaskReductionRefExpr(TaskRedRef);
1757   Dir->HasCancel = HasCancel;
1758   return Dir;
1759 }
1760 
1761 OMPTeamsDistributeParallelForDirective *
1762 OMPTeamsDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
1763                                                     unsigned NumClauses,
1764                                                     unsigned CollapsedNum,
1765                                                     EmptyShell) {
1766   return createEmptyDirective<OMPTeamsDistributeParallelForDirective>(
1767       C, NumClauses, /*HasAssociatedStmt=*/true,
1768       numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1,
1769       CollapsedNum);
1770 }
1771 
1772 OMPTargetTeamsDirective *OMPTargetTeamsDirective::Create(
1773     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1774     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1775   return createDirective<OMPTargetTeamsDirective>(C, Clauses, AssociatedStmt,
1776                                                   /*NumChildren=*/0, StartLoc,
1777                                                   EndLoc);
1778 }
1779 
1780 OMPTargetTeamsDirective *
1781 OMPTargetTeamsDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1782                                      EmptyShell) {
1783   return createEmptyDirective<OMPTargetTeamsDirective>(
1784       C, NumClauses, /*HasAssociatedStmt=*/true);
1785 }
1786 
1787 OMPTargetTeamsDistributeDirective *OMPTargetTeamsDistributeDirective::Create(
1788     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1789     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1790     const HelperExprs &Exprs) {
1791   auto *Dir = createDirective<OMPTargetTeamsDistributeDirective>(
1792       C, Clauses, AssociatedStmt,
1793       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute), StartLoc,
1794       EndLoc, CollapsedNum);
1795   Dir->setIterationVariable(Exprs.IterationVarRef);
1796   Dir->setLastIteration(Exprs.LastIteration);
1797   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1798   Dir->setPreCond(Exprs.PreCond);
1799   Dir->setCond(Exprs.Cond);
1800   Dir->setInit(Exprs.Init);
1801   Dir->setInc(Exprs.Inc);
1802   Dir->setIsLastIterVariable(Exprs.IL);
1803   Dir->setLowerBoundVariable(Exprs.LB);
1804   Dir->setUpperBoundVariable(Exprs.UB);
1805   Dir->setStrideVariable(Exprs.ST);
1806   Dir->setEnsureUpperBound(Exprs.EUB);
1807   Dir->setNextLowerBound(Exprs.NLB);
1808   Dir->setNextUpperBound(Exprs.NUB);
1809   Dir->setNumIterations(Exprs.NumIterations);
1810   Dir->setCounters(Exprs.Counters);
1811   Dir->setPrivateCounters(Exprs.PrivateCounters);
1812   Dir->setInits(Exprs.Inits);
1813   Dir->setUpdates(Exprs.Updates);
1814   Dir->setFinals(Exprs.Finals);
1815   Dir->setDependentCounters(Exprs.DependentCounters);
1816   Dir->setDependentInits(Exprs.DependentInits);
1817   Dir->setFinalsConditions(Exprs.FinalsConditions);
1818   Dir->setPreInits(Exprs.PreInits);
1819   return Dir;
1820 }
1821 
1822 OMPTargetTeamsDistributeDirective *
1823 OMPTargetTeamsDistributeDirective::CreateEmpty(const ASTContext &C,
1824                                                unsigned NumClauses,
1825                                                unsigned CollapsedNum,
1826                                                EmptyShell) {
1827   return createEmptyDirective<OMPTargetTeamsDistributeDirective>(
1828       C, NumClauses, /*HasAssociatedStmt=*/true,
1829       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute),
1830       CollapsedNum);
1831 }
1832 
1833 OMPTargetTeamsDistributeParallelForDirective *
1834 OMPTargetTeamsDistributeParallelForDirective::Create(
1835     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1836     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1837     const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
1838   auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForDirective>(
1839       C, Clauses, AssociatedStmt,
1840       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) +
1841           1,
1842       StartLoc, EndLoc, CollapsedNum);
1843   Dir->setIterationVariable(Exprs.IterationVarRef);
1844   Dir->setLastIteration(Exprs.LastIteration);
1845   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1846   Dir->setPreCond(Exprs.PreCond);
1847   Dir->setCond(Exprs.Cond);
1848   Dir->setInit(Exprs.Init);
1849   Dir->setInc(Exprs.Inc);
1850   Dir->setIsLastIterVariable(Exprs.IL);
1851   Dir->setLowerBoundVariable(Exprs.LB);
1852   Dir->setUpperBoundVariable(Exprs.UB);
1853   Dir->setStrideVariable(Exprs.ST);
1854   Dir->setEnsureUpperBound(Exprs.EUB);
1855   Dir->setNextLowerBound(Exprs.NLB);
1856   Dir->setNextUpperBound(Exprs.NUB);
1857   Dir->setNumIterations(Exprs.NumIterations);
1858   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1859   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1860   Dir->setDistInc(Exprs.DistInc);
1861   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1862   Dir->setCounters(Exprs.Counters);
1863   Dir->setPrivateCounters(Exprs.PrivateCounters);
1864   Dir->setInits(Exprs.Inits);
1865   Dir->setUpdates(Exprs.Updates);
1866   Dir->setFinals(Exprs.Finals);
1867   Dir->setDependentCounters(Exprs.DependentCounters);
1868   Dir->setDependentInits(Exprs.DependentInits);
1869   Dir->setFinalsConditions(Exprs.FinalsConditions);
1870   Dir->setPreInits(Exprs.PreInits);
1871   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1872   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1873   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1874   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1875   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1876   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1877   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1878   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1879   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1880   Dir->setTaskReductionRefExpr(TaskRedRef);
1881   Dir->HasCancel = HasCancel;
1882   return Dir;
1883 }
1884 
1885 OMPTargetTeamsDistributeParallelForDirective *
1886 OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
1887                                                           unsigned NumClauses,
1888                                                           unsigned CollapsedNum,
1889                                                           EmptyShell) {
1890   return createEmptyDirective<OMPTargetTeamsDistributeParallelForDirective>(
1891       C, NumClauses, /*HasAssociatedStmt=*/true,
1892       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) +
1893           1,
1894       CollapsedNum);
1895 }
1896 
1897 OMPTargetTeamsDistributeParallelForSimdDirective *
1898 OMPTargetTeamsDistributeParallelForSimdDirective::Create(
1899     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1900     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1901     const HelperExprs &Exprs) {
1902   auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
1903       C, Clauses, AssociatedStmt,
1904       numLoopChildren(CollapsedNum,
1905                       OMPD_target_teams_distribute_parallel_for_simd),
1906       StartLoc, EndLoc, CollapsedNum);
1907   Dir->setIterationVariable(Exprs.IterationVarRef);
1908   Dir->setLastIteration(Exprs.LastIteration);
1909   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1910   Dir->setPreCond(Exprs.PreCond);
1911   Dir->setCond(Exprs.Cond);
1912   Dir->setInit(Exprs.Init);
1913   Dir->setInc(Exprs.Inc);
1914   Dir->setIsLastIterVariable(Exprs.IL);
1915   Dir->setLowerBoundVariable(Exprs.LB);
1916   Dir->setUpperBoundVariable(Exprs.UB);
1917   Dir->setStrideVariable(Exprs.ST);
1918   Dir->setEnsureUpperBound(Exprs.EUB);
1919   Dir->setNextLowerBound(Exprs.NLB);
1920   Dir->setNextUpperBound(Exprs.NUB);
1921   Dir->setNumIterations(Exprs.NumIterations);
1922   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1923   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1924   Dir->setDistInc(Exprs.DistInc);
1925   Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1926   Dir->setCounters(Exprs.Counters);
1927   Dir->setPrivateCounters(Exprs.PrivateCounters);
1928   Dir->setInits(Exprs.Inits);
1929   Dir->setUpdates(Exprs.Updates);
1930   Dir->setFinals(Exprs.Finals);
1931   Dir->setDependentCounters(Exprs.DependentCounters);
1932   Dir->setDependentInits(Exprs.DependentInits);
1933   Dir->setFinalsConditions(Exprs.FinalsConditions);
1934   Dir->setPreInits(Exprs.PreInits);
1935   Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB);
1936   Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB);
1937   Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB);
1938   Dir->setCombinedInit(Exprs.DistCombinedFields.Init);
1939   Dir->setCombinedCond(Exprs.DistCombinedFields.Cond);
1940   Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB);
1941   Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB);
1942   Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond);
1943   Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond);
1944   return Dir;
1945 }
1946 
1947 OMPTargetTeamsDistributeParallelForSimdDirective *
1948 OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty(
1949     const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
1950     EmptyShell) {
1951   return createEmptyDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
1952       C, NumClauses, /*HasAssociatedStmt=*/true,
1953       numLoopChildren(CollapsedNum,
1954                       OMPD_target_teams_distribute_parallel_for_simd),
1955       CollapsedNum);
1956 }
1957 
1958 OMPTargetTeamsDistributeSimdDirective *
1959 OMPTargetTeamsDistributeSimdDirective::Create(
1960     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1961     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1962     const HelperExprs &Exprs) {
1963   auto *Dir = createDirective<OMPTargetTeamsDistributeSimdDirective>(
1964       C, Clauses, AssociatedStmt,
1965       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd),
1966       StartLoc, EndLoc, CollapsedNum);
1967   Dir->setIterationVariable(Exprs.IterationVarRef);
1968   Dir->setLastIteration(Exprs.LastIteration);
1969   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1970   Dir->setPreCond(Exprs.PreCond);
1971   Dir->setCond(Exprs.Cond);
1972   Dir->setInit(Exprs.Init);
1973   Dir->setInc(Exprs.Inc);
1974   Dir->setIsLastIterVariable(Exprs.IL);
1975   Dir->setLowerBoundVariable(Exprs.LB);
1976   Dir->setUpperBoundVariable(Exprs.UB);
1977   Dir->setStrideVariable(Exprs.ST);
1978   Dir->setEnsureUpperBound(Exprs.EUB);
1979   Dir->setNextLowerBound(Exprs.NLB);
1980   Dir->setNextUpperBound(Exprs.NUB);
1981   Dir->setNumIterations(Exprs.NumIterations);
1982   Dir->setCounters(Exprs.Counters);
1983   Dir->setPrivateCounters(Exprs.PrivateCounters);
1984   Dir->setInits(Exprs.Inits);
1985   Dir->setUpdates(Exprs.Updates);
1986   Dir->setFinals(Exprs.Finals);
1987   Dir->setDependentCounters(Exprs.DependentCounters);
1988   Dir->setDependentInits(Exprs.DependentInits);
1989   Dir->setFinalsConditions(Exprs.FinalsConditions);
1990   Dir->setPreInits(Exprs.PreInits);
1991   return Dir;
1992 }
1993 
1994 OMPTargetTeamsDistributeSimdDirective *
1995 OMPTargetTeamsDistributeSimdDirective::CreateEmpty(const ASTContext &C,
1996                                                    unsigned NumClauses,
1997                                                    unsigned CollapsedNum,
1998                                                    EmptyShell) {
1999   return createEmptyDirective<OMPTargetTeamsDistributeSimdDirective>(
2000       C, NumClauses, /*HasAssociatedStmt=*/true,
2001       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd),
2002       CollapsedNum);
2003 }
2004 
2005 OMPInteropDirective *
2006 OMPInteropDirective::Create(const ASTContext &C, SourceLocation StartLoc,
2007                             SourceLocation EndLoc,
2008                             ArrayRef<OMPClause *> Clauses) {
2009   return createDirective<OMPInteropDirective>(
2010       C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc,
2011       EndLoc);
2012 }
2013 
2014 OMPInteropDirective *OMPInteropDirective::CreateEmpty(const ASTContext &C,
2015                                                       unsigned NumClauses,
2016                                                       EmptyShell) {
2017   return createEmptyDirective<OMPInteropDirective>(C, NumClauses);
2018 }
2019 
2020 OMPDispatchDirective *OMPDispatchDirective::Create(
2021     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2022     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2023     SourceLocation TargetCallLoc) {
2024   auto *Dir = createDirective<OMPDispatchDirective>(
2025       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
2026   Dir->setTargetCallLoc(TargetCallLoc);
2027   return Dir;
2028 }
2029 
2030 OMPDispatchDirective *OMPDispatchDirective::CreateEmpty(const ASTContext &C,
2031                                                         unsigned NumClauses,
2032                                                         EmptyShell) {
2033   return createEmptyDirective<OMPDispatchDirective>(C, NumClauses,
2034                                                     /*HasAssociatedStmt=*/true,
2035                                                     /*NumChildren=*/0);
2036 }
2037 
2038 OMPMaskedDirective *OMPMaskedDirective::Create(const ASTContext &C,
2039                                                SourceLocation StartLoc,
2040                                                SourceLocation EndLoc,
2041                                                ArrayRef<OMPClause *> Clauses,
2042                                                Stmt *AssociatedStmt) {
2043   return createDirective<OMPMaskedDirective>(C, Clauses, AssociatedStmt,
2044                                              /*NumChildren=*/0, StartLoc,
2045                                              EndLoc);
2046 }
2047 
2048 OMPMaskedDirective *OMPMaskedDirective::CreateEmpty(const ASTContext &C,
2049                                                     unsigned NumClauses,
2050                                                     EmptyShell) {
2051   return createEmptyDirective<OMPMaskedDirective>(C, NumClauses,
2052                                                   /*HasAssociatedStmt=*/true);
2053 }
2054