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