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