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