//===--- StmtOpenMP.cpp - Classes for OpenMP directives -------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file implements the subclesses of Stmt class declared in StmtOpenMP.h

//

//===----------------------------------------------------------------------===//

#include "clang/AST/ASTContext.h"

#include "clang/AST/StmtOpenMP.h"

using namespace clang;

using namespace llvm::omp;

size_t OMPChildren::size(unsigned NumClauses, bool HasAssociatedStmt,

                         unsigned NumChildren) {

  return llvm::alignTo(

      totalSizeToAlloc<OMPClause *, Stmt *>(

          NumClauses, NumChildren + (HasAssociatedStmt ? 
1300k
 : 
06.96k
)),

      alignof(OMPChildren));

}

void OMPChildren::setClauses(ArrayRef<OMPClause *> Clauses) {

  assert(Clauses.size() == NumClauses &&

         "Number of clauses is not the same as the preallocated buffer");

  llvm::copy(Clauses, getTrailingObjects<OMPClause *>());

}

MutableArrayRef<Stmt *> OMPChildren::getChildren() {

  return llvm::makeMutableArrayRef(getTrailingObjects<Stmt *>(), NumChildren);

}

OMPChildren *OMPChildren::Create(void *Mem, ArrayRef<OMPClause *> Clauses) {

  auto *Data = CreateEmpty(Mem, Clauses.size());

  Data->setClauses(Clauses);

  return Data;

}

OMPChildren *OMPChildren::Create(void *Mem, ArrayRef<OMPClause *> Clauses,

                                 Stmt *S, unsigned NumChildren) {

  auto *Data = CreateEmpty(Mem, Clauses.size(), S, NumChildren);

  Data->setClauses(Clauses);

  if (S)

    Data->setAssociatedStmt(S);

  return Data;

}

OMPChildren *OMPChildren::CreateEmpty(void *Mem, unsigned NumClauses,

                                      bool HasAssociatedStmt,

                                      unsigned NumChildren) {

  return new (Mem) OMPChildren(NumClauses, NumChildren, HasAssociatedStmt);

}

bool OMPExecutableDirective::isStandaloneDirective() const {

  // Special case: 'omp target enter data', 'omp target exit data',

  // 'omp target update' are stand-alone directives, but for implementation

  // reasons they have empty synthetic structured block, to simplify codegen.

  if (isa<OMPTargetEnterDataDirective>(this) ||

      
isa<OMPTargetExitDataDirective>(this)31.2k
 ||

      
isa<OMPTargetUpdateDirective>(this)30.7k
)

    return true;

  return !hasAssociatedStmt();

}

Stmt *OMPExecutableDirective::getStructuredBlock() {

  assert(!isStandaloneDirective() &&

         "Standalone Executable Directives don't have Structured Blocks.");

  if (auto *LD = dyn_cast<OMPLoopDirective>(this))

    return LD->getBody();

  return getRawStmt();

}

Stmt *

OMPLoopBasedDirective::tryToFindNextInnerLoop(Stmt *CurStmt,

                                              bool TryImperfectlyNestedLoops) {

  Stmt *OrigStmt = CurStmt;

  CurStmt = CurStmt->IgnoreContainers();

  // Additional work for imperfectly nested loops, introduced in OpenMP 5.0.

  if (TryImperfectlyNestedLoops) {

    if (auto *CS = dyn_cast<CompoundStmt>(CurStmt)) {

      CurStmt = nullptr;

      SmallVector<CompoundStmt *, 4> Statements(1, CS);

      SmallVector<CompoundStmt *, 4> NextStatements;

      while (!Statements.empty()) {

        CS = Statements.pop_back_val();

        if (!CS)

          continue;

        
for (Stmt *S : CS->body())13.7k
 {

          if (!S)

            continue;

          if (auto *CanonLoop = dyn_cast<OMPCanonicalLoop>(S))

            S = CanonLoop->getLoopStmt();

          if (isa<ForStmt>(S) || 
isa<CXXForRangeStmt>(S)22.5k
 ||

              
(22.5k
isa<OMPLoopBasedDirective>(S)22.5k
 && 
!isa<OMPLoopDirective>(S)37
)) {

            // Only single loop construct is allowed.

            if (CurStmt) {

              CurStmt = OrigStmt;

              break;

            }

            CurStmt = S;

            continue;

          }

          S = S->IgnoreContainers();

          if (auto *InnerCS = dyn_cast_or_null<CompoundStmt>(S))

            NextStatements.push_back(InnerCS);

        }

        if (Statements.empty()) {

          // Found single inner loop or multiple loops - exit.

          if (CurStmt)

            break;

          Statements.swap(NextStatements);

        }

      }

      if (!CurStmt)

        CurStmt = OrigStmt;

    }

  }

  return CurStmt;

}

bool OMPLoopBasedDirective::doForAllLoops(

    Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops,

    llvm::function_ref<bool(unsigned, Stmt *)> Callback,

    llvm::function_ref<void(OMPLoopBasedDirective *)>

        OnTransformationCallback) {

  CurStmt = CurStmt->IgnoreContainers();

  for (unsigned Cnt = 0; Cnt < NumLoops; 
++Cnt162k
) {

    while (true) {

      auto *OrigStmt = CurStmt;

      if (auto *Dir = dyn_cast<OMPTileDirective>(OrigStmt)) {

        OnTransformationCallback(Dir);

        CurStmt = Dir->getTransformedStmt();

      } else if (auto *Dir = dyn_cast<OMPUnrollDirective>(OrigStmt)) {

        OnTransformationCallback(Dir);

        CurStmt = Dir->getTransformedStmt();

      } else {

        break;

      }

      if (!CurStmt) {

        // May happen if the loop transformation does not result in a generated

        // loop (such as full unrolling).

        CurStmt = OrigStmt;

        break;

      }

    }

    if (auto *CanonLoop = dyn_cast<OMPCanonicalLoop>(CurStmt))

      CurStmt = CanonLoop->getLoopStmt();

    if (Callback(Cnt, CurStmt))

      return false;

    // Move on to the next nested for loop, or to the loop body.

    // OpenMP [2.8.1, simd construct, Restrictions]

    // All loops associated with the construct must be perfectly nested; that

    // is, there must be no intervening code nor any OpenMP directive between

    // any two loops.

    if (auto *For = dyn_cast<ForStmt>(CurStmt)) {

      CurStmt = For->getBody();

    } else {

      assert(isa<CXXForRangeStmt>(CurStmt) &&

             "Expected canonical for or range-based for loops.");

      CurStmt = cast<CXXForRangeStmt>(CurStmt)->getBody();

    }

    CurStmt = OMPLoopBasedDirective::tryToFindNextInnerLoop(

        CurStmt, TryImperfectlyNestedLoops);

  }

  return true;

}

void OMPLoopBasedDirective::doForAllLoopsBodies(

    Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops,

    llvm::function_ref<void(unsigned, Stmt *, Stmt *)> Callback) {

  bool Res = OMPLoopBasedDirective::doForAllLoops(

      CurStmt, TryImperfectlyNestedLoops, NumLoops,

      [Callback](unsigned Cnt, Stmt *Loop) {

        Stmt *Body = nullptr;

        if (auto *For = dyn_cast<ForStmt>(Loop)) {

          Body = For->getBody();

        } else {

          assert(isa<CXXForRangeStmt>(Loop) &&

                 "Expected canonical for or range-based for loops.");

          Body = cast<CXXForRangeStmt>(Loop)->getBody();

        }

        if (auto *CanonLoop = dyn_cast<OMPCanonicalLoop>(Body))

          Body = CanonLoop->getLoopStmt();

        Callback(Cnt, Loop, Body);

        return false;

      });

  assert(Res && "Expected only loops");

  (void)Res;

}

Stmt *OMPLoopDirective::getBody() {

  // This relies on the loop form is already checked by Sema.

  Stmt *Body = nullptr;

  OMPLoopBasedDirective::doForAllLoopsBodies(

      Data->getRawStmt(), /*TryImperfectlyNestedLoops=*/true,

      NumAssociatedLoops,

      [&Body](unsigned, Stmt *, Stmt *BodyStmt) { Body = BodyStmt; });

  return Body;

}

void OMPLoopDirective::setCounters(ArrayRef<Expr *> A) {

  assert(A.size() == getLoopsNumber() &&

         "Number of loop counters is not the same as the collapsed number");

  llvm::copy(A, getCounters().begin());

}

void OMPLoopDirective::setPrivateCounters(ArrayRef<Expr *> A) {

  assert(A.size() == getLoopsNumber() && "Number of loop private counters "

                                         "is not the same as the collapsed "

                                         "number");

  llvm::copy(A, getPrivateCounters().begin());

}

void OMPLoopDirective::setInits(ArrayRef<Expr *> A) {

  assert(A.size() == getLoopsNumber() &&

         "Number of counter inits is not the same as the collapsed number");

  llvm::copy(A, getInits().begin());

}

void OMPLoopDirective::setUpdates(ArrayRef<Expr *> A) {

  assert(A.size() == getLoopsNumber() &&

         "Number of counter updates is not the same as the collapsed number");

  llvm::copy(A, getUpdates().begin());

}

void OMPLoopDirective::setFinals(ArrayRef<Expr *> A) {

  assert(A.size() == getLoopsNumber() &&

         "Number of counter finals is not the same as the collapsed number");

  llvm::copy(A, getFinals().begin());

}

void OMPLoopDirective::setDependentCounters(ArrayRef<Expr *> A) {

  assert(

      A.size() == getLoopsNumber() &&

      "Number of dependent counters is not the same as the collapsed number");

  llvm::copy(A, getDependentCounters().begin());

}

void OMPLoopDirective::setDependentInits(ArrayRef<Expr *> A) {

  assert(A.size() == getLoopsNumber() &&

         "Number of dependent inits is not the same as the collapsed number");

  llvm::copy(A, getDependentInits().begin());

}

void OMPLoopDirective::setFinalsConditions(ArrayRef<Expr *> A) {

  assert(A.size() == getLoopsNumber() &&

         "Number of finals conditions is not the same as the collapsed number");

  llvm::copy(A, getFinalsConditions().begin());

}

OMPParallelDirective *OMPParallelDirective::Create(

    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,

    ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,

    bool HasCancel) {

  auto *Dir = createDirective<OMPParallelDirective>(

      C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);

  Dir->setTaskReductionRefExpr(TaskRedRef);

  Dir->setHasCancel(HasCancel);

  return Dir;

}

OMPParallelDirective *OMPParallelDirective::CreateEmpty(const ASTContext &C,

                                                        unsigned NumClauses,

                                                        EmptyShell) {

  return createEmptyDirective<OMPParallelDirective>(C, NumClauses,

                                                    /*HasAssociatedStmt=*/true,

                                                    /*NumChildren=*/1);

}

OMPSimdDirective *

OMPSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,

                         SourceLocation EndLoc, unsigned CollapsedNum,

                         ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,

                         const HelperExprs &Exprs) {

  auto *Dir = createDirective<OMPSimdDirective>(

      C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_simd),

      StartLoc, EndLoc, CollapsedNum);

  Dir->setIterationVariable(Exprs.IterationVarRef);

  Dir->setLastIteration(Exprs.LastIteration);

  Dir->setCalcLastIteration(Exprs.CalcLastIteration);

  Dir->setPreCond(Exprs.PreCond);

  Dir->setCond(Exprs.Cond);

  Dir->setInit(Exprs.Init);

  Dir->setInc(Exprs.Inc);

  Dir->setCounters(Exprs.Counters);

  Dir->setPrivateCounters(Exprs.PrivateCounters);

  Dir->setInits(Exprs.Inits);

  Dir->setUpdates(Exprs.Updates);

  Dir->setFinals(Exprs.Finals);

  Dir->setDependentCounters(Exprs.DependentCounters);

  Dir->setDependentInits(Exprs.DependentInits);

  Dir->setFinalsConditions(Exprs.FinalsConditions);

  Dir->setPreInits(Exprs.PreInits);

  return Dir;

}

OMPSimdDirective *OMPSimdDirective::CreateEmpty(const ASTContext &C,

                                                unsigned NumClauses,

                                                unsigned CollapsedNum,

                                                EmptyShell) {

  return createEmptyDirective<OMPSimdDirective>(

      C, NumClauses, /*HasAssociatedStmt=*/true,

      numLoopChildren(CollapsedNum, OMPD_simd), CollapsedNum);

}

OMPForDirective *OMPForDirective::Create(

    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,

    unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,

    const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {

  auto *Dir = createDirective<OMPForDirective>(

      C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for) + 1,

      StartLoc, EndLoc, CollapsedNum);

  Dir->setIterationVariable(Exprs.IterationVarRef);

  Dir->setLastIteration(Exprs.LastIteration);

  Dir->setCalcLastIteration(Exprs.CalcLastIteration);

  Dir->setPreCond(Exprs.PreCond);

  Dir->setCond(Exprs.Cond);

  Dir->setInit(Exprs.Init);

  Dir->setInc(Exprs.Inc);

  Dir->setIsLastIterVariable(Exprs.IL);

  Dir->setLowerBoundVariable(Exprs.LB);

  Dir->setUpperBoundVariable(Exprs.UB);

  Dir->setStrideVariable(Exprs.ST);

  Dir->setEnsureUpperBound(Exprs.EUB);

  Dir->setNextLowerBound(Exprs.NLB);

  Dir->setNextUpperBound(Exprs.NUB);

  Dir->setNumIterations(Exprs.NumIterations);

  Dir->setCounters(Exprs.Counters);

  Dir->setPrivateCounters(Exprs.PrivateCounters);

  Dir->setInits(Exprs.Inits);

  Dir->setUpdates(Exprs.Updates);

  Dir->setFinals(Exprs.Finals);

  Dir->setDependentCounters(Exprs.DependentCounters);

  Dir->setDependentInits(Exprs.DependentInits);

  Dir->setFinalsConditions(Exprs.FinalsConditions);

  Dir->setPreInits(Exprs.PreInits);

  Dir->setTaskReductionRefExpr(TaskRedRef);

  Dir->setHasCancel(HasCancel);

  return Dir;

}

OMPForDirective *OMPForDirective::CreateEmpty(const ASTContext &C,

                                              unsigned NumClauses,

                                              unsigned CollapsedNum,

                                              EmptyShell) {

  return createEmptyDirective<OMPForDirective>(

      C, NumClauses, /*HasAssociatedStmt=*/true,

      numLoopChildren(CollapsedNum, OMPD_for) + 1, CollapsedNum);

}

OMPTileDirective *

OMPTileDirective::Create(const ASTContext &C, SourceLocation StartLoc,

                         SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,

                         unsigned NumLoops, Stmt *AssociatedStmt,

                         Stmt *TransformedStmt, Stmt *PreInits) {

  OMPTileDirective *Dir = createDirective<OMPTileDirective>(

      C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc,

      NumLoops);

  Dir->setTransformedStmt(TransformedStmt);

  Dir->setPreInits(PreInits);

  return Dir;

}

OMPTileDirective *OMPTileDirective::CreateEmpty(const ASTContext &C,

                                                unsigned NumClauses,

                                                unsigned NumLoops) {

  return createEmptyDirective<OMPTileDirective>(

      C, NumClauses, /*HasAssociatedStmt=*/true, TransformedStmtOffset + 1,

      SourceLocation(), SourceLocation(), NumLoops);

}

OMPUnrollDirective *

OMPUnrollDirective::Create(const ASTContext &C, SourceLocation StartLoc,

                           SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,

                           Stmt *AssociatedStmt, Stmt *TransformedStmt,

                           Stmt *PreInits) {

  auto *Dir = createDirective<OMPUnrollDirective>(

      C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc);

  Dir->setTransformedStmt(TransformedStmt);

  Dir->setPreInits(PreInits);

  return Dir;

}

OMPUnrollDirective *OMPUnrollDirective::CreateEmpty(const ASTContext &C,

                                                    unsigned NumClauses) {

  return createEmptyDirective<OMPUnrollDirective>(

      C, NumClauses, /*HasAssociatedStmt=*/true, TransformedStmtOffset + 1,

      SourceLocation(), SourceLocation());

}

OMPForSimdDirective *

OMPForSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,

                            SourceLocation EndLoc, unsigned CollapsedNum,

                            ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,

                            const HelperExprs &Exprs) {

  auto *Dir = createDirective<OMPForSimdDirective>(

      C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for_simd),

      StartLoc, EndLoc, CollapsedNum);

  Dir->setIterationVariable(Exprs.IterationVarRef);

  Dir->setLastIteration(Exprs.LastIteration);

  Dir->setCalcLastIteration(Exprs.CalcLastIteration);

  Dir->setPreCond(Exprs.PreCond);

  Dir->setCond(Exprs.Cond);

  Dir->setInit(Exprs.Init);

  Dir->setInc(Exprs.Inc);

  Dir->setIsLastIterVariable(Exprs.IL);

  Dir->setLowerBoundVariable(Exprs.LB);

  Dir->setUpperBoundVariable(Exprs.UB);

  Dir->setStrideVariable(Exprs.ST);

  Dir->setEnsureUpperBound(Exprs.EUB);

  Dir->setNextLowerBound(Exprs.NLB);

  Dir->setNextUpperBound(Exprs.NUB);

  Dir->setNumIterations(Exprs.NumIterations);

  Dir->setCounters(Exprs.Counters);

  Dir->setPrivateCounters(Exprs.PrivateCounters);

  Dir->setInits(Exprs.Inits);

  Dir->setUpdates(Exprs.Updates);

  Dir->setFinals(Exprs.Finals);

  Dir->setDependentCounters(Exprs.DependentCounters);

  Dir->setDependentInits(Exprs.DependentInits);

  Dir->setFinalsConditions(Exprs.FinalsConditions);

  Dir->setPreInits(Exprs.PreInits);

  return Dir;

}

OMPForSimdDirective *OMPForSimdDirective::CreateEmpty(const ASTContext &C,

                                                      unsigned NumClauses,

                                                      unsigned CollapsedNum,

                                                      EmptyShell) {

  return createEmptyDirective<OMPForSimdDirective>(

      C, NumClauses, /*HasAssociatedStmt=*/true,

      numLoopChildren(CollapsedNum, OMPD_for_simd), CollapsedNum);

}

OMPSectionsDirective *OMPSectionsDirective::Create(

    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,

    ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,

    bool HasCancel) {

  auto *Dir = createDirective<OMPSectionsDirective>(C, Clauses, AssociatedStmt,

                                                    /*NumChildren=*/1, StartLoc,

                                                    EndLoc);

  Dir->setTaskReductionRefExpr(TaskRedRef);

  Dir->setHasCancel(HasCancel);

  return Dir;

}

OMPSectionsDirective *OMPSectionsDirective::CreateEmpty(const ASTContext &C,

                                                        unsigned NumClauses,

                                                        EmptyShell) {

  return createEmptyDirective<OMPSectionsDirective>(C, NumClauses,

                                                    /*HasAssociatedStmt=*/true,

                                                    /*NumChildren=*/1);

}

OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C,

                                                 SourceLocation StartLoc,

                                                 SourceLocation EndLoc,

                                                 Stmt *AssociatedStmt,

                                                 bool HasCancel) {

  auto *Dir =

      createDirective<OMPSectionDirective>(C, llvm::None, AssociatedStmt,

                                           /*NumChildre=*/0, StartLoc, EndLoc);

  Dir->setHasCancel(HasCancel);

  return Dir;

}

OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C,

                                                      EmptyShell) {

  return createEmptyDirective<OMPSectionDirective>(C, /*NumClauses=*/0,

                                                   /*HasAssociatedStmt=*/true);

}

OMPSingleDirective *OMPSingleDirective::Create(const ASTContext &C,

                                               SourceLocation StartLoc,

                                               SourceLocation EndLoc,

                                               ArrayRef<OMPClause *> Clauses,

                                               Stmt *AssociatedStmt) {

  return createDirective<OMPSingleDirective>(C, Clauses, AssociatedStmt,

                                             /*NumChildren=*/0, StartLoc,

                                             EndLoc);

}

OMPSingleDirective *OMPSingleDirective::CreateEmpty(const ASTContext &C,

                                                    unsigned NumClauses,

                                                    EmptyShell) {

  return createEmptyDirective<OMPSingleDirective>(C, NumClauses,

                                                  /*HasAssociatedStmt=*/true);

}

OMPMasterDirective *OMPMasterDirective::Create(const ASTContext &C,

                                               SourceLocation StartLoc,

                                               SourceLocation EndLoc,

                                               Stmt *AssociatedStmt) {

  return createDirective<OMPMasterDirective>(C, llvm::None, AssociatedStmt,

                                             /*NumChildren=*/0, StartLoc,

                                             EndLoc);

}

OMPMasterDirective *OMPMasterDirective::CreateEmpty(const ASTContext &C,

                                                    EmptyShell) {

  return createEmptyDirective<OMPMasterDirective>(C, /*NumClauses=*/0,

                                                  /*HasAssociatedStmt=*/true);

}

OMPCriticalDirective *OMPCriticalDirective::Create(

    const ASTContext &C, const DeclarationNameInfo &Name,

    SourceLocation StartLoc, SourceLocation EndLoc,

    ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {

  return createDirective<OMPCriticalDirective>(C, Clauses, AssociatedStmt,

                                               /*NumChildren=*/0, Name,

                                               StartLoc, EndLoc);

}

OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C,

                                                        unsigned NumClauses,

                                                        EmptyShell) {

  return createEmptyDirective<OMPCriticalDirective>(C, NumClauses,

                                                    /*HasAssociatedStmt=*/true);

}

OMPParallelForDirective *OMPParallelForDirective::Create(

    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,

    unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,

    const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {

  auto *Dir = createDirective<OMPParallelForDirective>(

      C, Clauses, AssociatedStmt,

      numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, StartLoc, EndLoc,

      CollapsedNum);

  Dir->setIterationVariable(Exprs.IterationVarRef);

  Dir->setLastIteration(Exprs.LastIteration);

  Dir->setCalcLastIteration(Exprs.CalcLastIteration);

  Dir->setPreCond(Exprs.PreCond);

  Dir->setCond(Exprs.Cond);

  Dir->setInit(Exprs.Init);

  Dir->setInc(Exprs.Inc);

  Dir->setIsLastIterVariable(Exprs.IL);

  Dir->setLowerBoundVariable(Exprs.LB);

  Dir->setUpperBoundVariable(Exprs.UB);

  Dir->setStrideVariable(Exprs.ST);

  Dir->setEnsureUpperBound(Exprs.EUB);

  Dir->setNextLowerBound(Exprs.NLB);

  Dir->setNextUpperBound(Exprs.NUB);

  Dir->setNumIterations(Exprs.NumIterations);

  Dir->setCounters(Exprs.Counters);

  Dir->setPrivateCounters(Exprs.PrivateCounters);

  Dir->setInits(Exprs.Inits);

  Dir->setUpdates(Exprs.Updates);

  Dir->setFinals(Exprs.Finals);

  Dir->setDependentCounters(Exprs.DependentCounters);

  Dir->setDependentInits(Exprs.DependentInits);

  Dir->setFinalsConditions(Exprs.FinalsConditions);

  Dir->setPreInits(Exprs.PreInits);

  Dir->setTaskReductionRefExpr(TaskRedRef);

  Dir->setHasCancel(HasCancel);

  return Dir;

}

OMPParallelForDirective *

OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,

                                     unsigned CollapsedNum, EmptyShell) {

  return createEmptyDirective<OMPParallelForDirective>(

      C, NumClauses, /*HasAssociatedStmt=*/true,

      numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, CollapsedNum);

}

OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create(

    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,

    unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,

    const HelperExprs &Exprs) {

  auto *Dir = createDirective<OMPParallelForSimdDirective>(

      C, Clauses, AssociatedStmt,

      numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), StartLoc, EndLoc,

      CollapsedNum);

  Dir->setIterationVariable(Exprs.IterationVarRef);

  Dir->setLastIteration(Exprs.LastIteration);

  Dir->setCalcLastIteration(Exprs.CalcLastIteration);

  Dir->setPreCond(Exprs.PreCond);

  Dir->setCond(Exprs.Cond);

  Dir->setInit(Exprs.Init);

  Dir->setInc(Exprs.Inc);

  Dir->setIsLastIterVariable(Exprs.IL);

  Dir->setLowerBoundVariable(Exprs.LB);

  Dir->setUpperBoundVariable(Exprs.UB);

  Dir->setStrideVariable(Exprs.ST);

  Dir->setEnsureUpperBound(Exprs.EUB);

  Dir->setNextLowerBound(Exprs.NLB);

  Dir->setNextUpperBound(Exprs.NUB);

  Dir->setNumIterations(Exprs.NumIterations);

  Dir->setCounters(Exprs.Counters);

  Dir->setPrivateCounters(Exprs.PrivateCounters);

  Dir->setInits(Exprs.Inits);

  Dir->setUpdates(Exprs.Updates);

  Dir->setFinals(Exprs.Finals);

  Dir->setDependentCounters(Exprs.DependentCounters);

  Dir->setDependentInits(Exprs.DependentInits);

  Dir->setFinalsConditions(Exprs.FinalsConditions);

  Dir->setPreInits(Exprs.PreInits);

  return Dir;

}

OMPParallelForSimdDirective *

OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C,

                                         unsigned NumClauses,

                                         unsigned CollapsedNum, EmptyShell) {

  return createEmptyDirective<OMPParallelForSimdDirective>(

      C, NumClauses, /*HasAssociatedStmt=*/true,

      numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), CollapsedNum);

}

OMPParallelMasterDirective *OMPParallelMasterDirective::Create(

    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,

    ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef) {

  auto *Dir = createDirective<OMPParallelMasterDirective>(

      C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);

  Dir->setTaskReductionRefExpr(TaskRedRef);

  return Dir;

}

OMPParallelMasterDirective *

OMPParallelMasterDirective::CreateEmpty(const ASTContext &C,

                                        unsigned NumClauses, EmptyShell) {

  return createEmptyDirective<OMPParallelMasterDirective>(

      C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);

}

OMPParallelSectionsDirective *OMPParallelSectionsDirective::Create(

    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,

    ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,

    bool HasCancel) {

  auto *Dir = createDirective<OMPParallelSectionsDirective>(

      C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);

  Dir->setTaskReductionRefExpr(TaskRedRef);

  Dir->setHasCancel(HasCancel);

  return Dir;

}

OMPParallelSectionsDirective *

OMPParallelSectionsDirective::CreateEmpty(const ASTContext &C,

                                          unsigned NumClauses, EmptyShell) {

  return createEmptyDirective<OMPParallelSectionsDirective>(

      C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);

}

OMPTaskDirective *

OMPTaskDirective::Create(const ASTContext &C, SourceLocation StartLoc,

                         SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,

                         Stmt *AssociatedStmt, bool HasCancel) {

  auto *Dir = createDirective<OMPTaskDirective>(

      C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);

  Dir->setHasCancel(HasCancel);

  return Dir;

}

OMPTaskDirective *OMPTaskDirective::CreateEmpty(const ASTContext &C,

                                                unsigned NumClauses,

                                                EmptyShell) {

  return createEmptyDirective<OMPTaskDirective>(C, NumClauses,

                                                /*HasAssociatedStmt=*/true);

}

OMPTaskyieldDirective *OMPTaskyieldDirective::Create(const ASTContext &C,

                                                     SourceLocation StartLoc,

                                                     SourceLocation EndLoc) {

  return new (C) OMPTaskyieldDirective(StartLoc, EndLoc);

}

OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C,

                                                          EmptyShell) {

  return new (C) OMPTaskyieldDirective();

}

OMPBarrierDirective *OMPBarrierDirective::Create(const ASTContext &C,

                                                 SourceLocation StartLoc,

                                                 SourceLocation EndLoc) {

  return new (C) OMPBarrierDirective(StartLoc, EndLoc);

}

OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C,

                                                      EmptyShell) {

  return new (C) OMPBarrierDirective();

}

OMPTaskwaitDirective *OMPTaskwaitDirective::Create(const ASTContext &C,

                                                   SourceLocation StartLoc,

                                                   SourceLocation EndLoc) {

  return new (C) OMPTaskwaitDirective(StartLoc, EndLoc);

}

OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C,

                                                        EmptyShell) {

  return new (C) OMPTaskwaitDirective();

}

OMPTaskgroupDirective *OMPTaskgroupDirective::Create(

    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,

    ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *ReductionRef) {

  auto *Dir = createDirective<OMPTaskgroupDirective>(

      C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);

  Dir->setReductionRef(ReductionRef);

  return Dir;

}

OMPTaskgroupDirective *OMPTaskgroupDirective::CreateEmpty(const ASTContext &C,

                                                          unsigned NumClauses,

                                                          EmptyShell) {

  return createEmptyDirective<OMPTaskgroupDirective>(

      C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);

}

OMPCancellationPointDirective *OMPCancellationPointDirective::Create(

    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,

    OpenMPDirectiveKind CancelRegion) {

  auto *Dir = new (C) OMPCancellationPointDirective(StartLoc, EndLoc);

  Dir->setCancelRegion(CancelRegion);

  return Dir;

}

OMPCancellationPointDirective *

OMPCancellationPointDirective::CreateEmpty(const ASTContext &C, EmptyShell) {

  return new (C) OMPCancellationPointDirective();

}

OMPCancelDirective *

OMPCancelDirective::Create(const ASTContext &C, SourceLocation StartLoc,

                           SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,

                           OpenMPDirectiveKind CancelRegion) {

  auto *Dir = createDirective<OMPCancelDirective>(

      C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc,

      EndLoc);

  Dir->setCancelRegion(CancelRegion);

  return Dir;

}

OMPCancelDirective *OMPCancelDirective::CreateEmpty(const ASTContext &C,

                                                    unsigned NumClauses,

                                                    EmptyShell) {

  return createEmptyDirective<OMPCancelDirective>(C, NumClauses);

}

OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C,

                                             SourceLocation StartLoc,

                                             SourceLocation EndLoc,

                                             ArrayRef<OMPClause *> Clauses) {

  return createDirective<OMPFlushDirective>(

      C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc,

      EndLoc);

}

OMPFlushDirective *OMPFlushDirective::CreateEmpty(const ASTContext &C,

                                                  unsigned NumClauses,

                                                  EmptyShell) {

  return createEmptyDirective<OMPFlushDirective>(C, NumClauses);

}

OMPDepobjDirective *OMPDepobjDirective::Create(const ASTContext &C,

                                               SourceLocation StartLoc,

                                               SourceLocation EndLoc,

                                               ArrayRef<OMPClause *> Clauses) {

  return createDirective<OMPDepobjDirective>(

      C, Clauses, /*AssociatedStmt=*/nullptr,

      /*NumChildren=*/0, StartLoc, EndLoc);

}

OMPDepobjDirective *OMPDepobjDirective::CreateEmpty(const ASTContext &C,

                                                    unsigned NumClauses,

                                                    EmptyShell) {

  return createEmptyDirective<OMPDepobjDirective>(C, NumClauses);

}

OMPScanDirective *OMPScanDirective::Create(const ASTContext &C,

                                           SourceLocation StartLoc,

                                           SourceLocation EndLoc,

                                           ArrayRef<OMPClause *> Clauses) {

  return createDirective<OMPScanDirective>(C, Clauses,

                                           /*AssociatedStmt=*/nullptr,

                                           /*NumChildren=*/0, StartLoc, EndLoc);

}

OMPScanDirective *OMPScanDirective::CreateEmpty(const ASTContext &C,

                                                unsigned NumClauses,

                                                EmptyShell) {

  return createEmptyDirective<OMPScanDirective>(C, NumClauses);

}

OMPOrderedDirective *OMPOrderedDirective::Create(const ASTContext &C,

                                                 SourceLocation StartLoc,

                                                 SourceLocation EndLoc,

                                                 ArrayRef<OMPClause *> Clauses,

                                                 Stmt *AssociatedStmt) {

  return createDirective<OMPOrderedDirective>(

      C, Clauses, cast_or_null<CapturedStmt>(AssociatedStmt),

      /*NumChildren=*/0, StartLoc, EndLoc);

}

OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(const ASTContext &C,

                                                      unsigned NumClauses,

                                                      bool IsStandalone,

                                                      EmptyShell) {

  return createEmptyDirective<OMPOrderedDirective>(C, NumClauses,

                                                   !IsStandalone);

}

OMPAtomicDirective *OMPAtomicDirective::Create(

    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,

    ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,

    Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {

  auto *Dir = createDirective<OMPAtomicDirective>(

      C, Clauses, AssociatedStmt, /*NumChildren=*/4, StartLoc, EndLoc);

  Dir->setX(X);

  Dir->setV(V);

  Dir->setExpr(E);

  Dir->setUpdateExpr(UE);

  Dir->IsXLHSInRHSPart = IsXLHSInRHSPart;

  Dir->IsPostfixUpdate = IsPostfixUpdate;

  return Dir;

}

OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C,

                                                    unsigned NumClauses,

                                                    EmptyShell) {

  return createEmptyDirective<OMPAtomicDirective>(

      C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/4);

}

OMPTargetDirective *OMPTargetDirective::Create(const ASTContext &C,

                                               SourceLocation StartLoc,

                                               SourceLocation EndLoc,

                                               ArrayRef<OMPClause *> Clauses,

                                               Stmt *AssociatedStmt) {

  return createDirective<OMPTargetDirective>(

      C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);

}

OMPTargetDirective *OMPTargetDirective::CreateEmpty(const ASTContext &C,

                                                    unsigned NumClauses,

                                                    EmptyShell) {

  return createEmptyDirective<OMPTargetDirective>(C, NumClauses,

                                                  /*HasAssociatedStmt=*/true);

}

OMPTargetParallelDirective *OMPTargetParallelDirective::Create(

    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,

    ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,

    bool HasCancel) {

  auto *Dir = createDirective<OMPTargetParallelDirective>(

      C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);

  Dir->setTaskReductionRefExpr(TaskRedRef);

  Dir->setHasCancel(HasCancel);

  return Dir;

}

OMPTargetParallelDirective *

OMPTargetParallelDirective::CreateEmpty(const ASTContext &C,

                                        unsigned NumClauses, EmptyShell) {

  return createEmptyDirective<OMPTargetParallelDirective>(

      C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);

}

OMPTargetParallelForDirective *OMPTargetParallelForDirective::Create(

    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,

    unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,

    const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {

  auto *Dir = createDirective<OMPTargetParallelForDirective>(

      C, Clauses, AssociatedStmt,

      numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1, StartLoc,

      EndLoc, CollapsedNum);

  Dir->setIterationVariable(Exprs.IterationVarRef);

  Dir->setLastIteration(Exprs.LastIteration);

  Dir->setCalcLastIteration(Exprs.CalcLastIteration);

  Dir->setPreCond(Exprs.PreCond);

  Dir->setCond(Exprs.Cond);

  Dir->setInit(Exprs.Init);

  Dir->setInc(Exprs.Inc);

  Dir->setIsLastIterVariable(Exprs.IL);

  Dir->setLowerBoundVariable(Exprs.LB);

  Dir->setUpperBoundVariable(Exprs.UB);

  Dir->setStrideVariable(Exprs.ST);

  Dir->setEnsureUpperBound(Exprs.EUB);

  Dir->setNextLowerBound(Exprs.NLB);

  Dir->setNextUpperBound(Exprs.NUB);

  Dir->setNumIterations(Exprs.NumIterations);

  Dir->setCounters(Exprs.Counters);

  Dir->setPrivateCounters(Exprs.PrivateCounters);

  Dir->setInits(Exprs.Inits);

  Dir->setUpdates(Exprs.Updates);

  Dir->setFinals(Exprs.Finals);

  Dir->setDependentCounters(Exprs.DependentCounters);

  Dir->setDependentInits(Exprs.DependentInits);

  Dir->setFinalsConditions(Exprs.FinalsConditions);

  Dir->setPreInits(Exprs.PreInits);

  Dir->setTaskReductionRefExpr(TaskRedRef);

  Dir->setHasCancel(HasCancel);

  return Dir;

}

OMPTargetParallelForDirective *

OMPTargetParallelForDirective::CreateEmpty(const ASTContext &C,

                                           unsigned NumClauses,

                                           unsigned CollapsedNum, EmptyShell) {

  return createEmptyDirective<OMPTargetParallelForDirective>(

      C, NumClauses, /*HasAssociatedStmt=*/true,

      numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1,

      CollapsedNum);

}

OMPTargetDataDirective *OMPTargetDataDirective::Create(

    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,

    ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {

  return createDirective<OMPTargetDataDirective>(

      C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);

}

OMPTargetDataDirective *OMPTargetDataDirective::CreateEmpty(const ASTContext &C,

                                                            unsigned N,

                                                            EmptyShell) {

  return createEmptyDirective<OMPTargetDataDirective>(

      C, N, /*HasAssociatedStmt=*/true);

}

OMPTargetEnterDataDirective *OMPTargetEnterDataDirective::Create(

    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,

    ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {

  return createDirective<OMPTargetEnterDataDirective>(

      C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);

}

OMPTargetEnterDataDirective *

OMPTargetEnterDataDirective::CreateEmpty(const ASTContext &C, unsigned N,

                                         EmptyShell) {

  return createEmptyDirective<OMPTargetEnterDataDirective>(

      C, N, /*HasAssociatedStmt=*/true);

}

OMPTargetExitDataDirective *OMPTargetExitDataDirective::Create(

    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,

    ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {

  return createDirective<OMPTargetExitDataDirective>(

      C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);

}

OMPTargetExitDataDirective *

OMPTargetExitDataDirective::CreateEmpty(const ASTContext &C, unsigned N,

                                        EmptyShell) {

  return createEmptyDirective<OMPTargetExitDataDirective>(

      C, N, /*HasAssociatedStmt=*/true);

}

OMPTeamsDirective *OMPTeamsDirective::Create(const ASTContext &C,

                                             SourceLocation StartLoc,

                                             SourceLocation EndLoc,

                                             ArrayRef<OMPClause *> Clauses,

                                             Stmt *AssociatedStmt) {

  return createDirective<OMPTeamsDirective>(

      C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);

}

OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C,

                                                  unsigned NumClauses,

                                                  EmptyShell) {

  return createEmptyDirective<OMPTeamsDirective>(C, NumClauses,

                                                 /*HasAssociatedStmt=*/true);

}

OMPTaskLoopDirective *OMPTaskLoopDirective::Create(

    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,

    unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,

    const HelperExprs &Exprs, bool HasCancel) {

  auto *Dir = createDirective<OMPTaskLoopDirective>(

      C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_taskloop),

      StartLoc, EndLoc, CollapsedNum);

  Dir->setIterationVariable(Exprs.IterationVarRef);

  Dir->setLastIteration(Exprs.LastIteration);

  Dir->setCalcLastIteration(Exprs.CalcLastIteration);

  Dir->setPreCond(Exprs.PreCond);

  Dir->setCond(Exprs.Cond);

  Dir->setInit(Exprs.Init);

  Dir->setInc(Exprs.Inc);

  Dir->setIsLastIterVariable(Exprs.IL);

  Dir->setLowerBoundVariable(Exprs.LB);

  Dir->setUpperBoundVariable(Exprs.UB);

  Dir->setStrideVariable(Exprs.ST);

  Dir->setEnsureUpperBound(Exprs.EUB);

  Dir->setNextLowerBound(Exprs.NLB);

  Dir->setNextUpperBound(Exprs.NUB);

  Dir->setNumIterations(Exprs.NumIterations);

  Dir->setCounters(Exprs.Counters);

  Dir->setPrivateCounters(Exprs.PrivateCounters);

  Dir->setInits(Exprs.Inits);

  Dir->setUpdates(Exprs.Updates);

  Dir->setFinals(Exprs.Finals);

  Dir->setDependentCounters(Exprs.DependentCounters);

  Dir->setDependentInits(Exprs.DependentInits);

  Dir->setFinalsConditions(Exprs.FinalsConditions);

  Dir->setPreInits(Exprs.PreInits);

  Dir->setHasCancel(HasCancel);

  return Dir;

}

OMPTaskLoopDirective *OMPTaskLoopDirective::CreateEmpty(const ASTContext &C,

                                                        unsigned NumClauses,

                                                        unsigned CollapsedNum,

                                                        EmptyShell) {

  return createEmptyDirective<OMPTaskLoopDirective>(

      C, NumClauses, /*HasAssociatedStmt=*/true,

      numLoopChildren(CollapsedNum, OMPD_taskloop), CollapsedNum);

}

OMPTaskLoopSimdDirective *OMPTaskLoopSimdDirective::Create(

    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,

    unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,

    const HelperExprs &Exprs) {

  auto *Dir = createDirective<OMPTaskLoopSimdDirective>(

      C, Clauses, AssociatedStmt,

      numLoopChildren(CollapsedNum, OMPD_taskloop_simd), StartLoc, EndLoc,

      CollapsedNum);

  Dir->setIterationVariable(Exprs.IterationVarRef);

  Dir->setLastIteration(Exprs.LastIteration);

  Dir->setCalcLastIteration(Exprs.CalcLastIteration);

  Dir->setPreCond(Exprs.PreCond);

  Dir->setCond(Exprs.Cond);

  Dir->setInit(Exprs.Init);

  Dir->setInc(Exprs.Inc);

  Dir->setIsLastIterVariable(Exprs.IL);

  Dir->setLowerBoundVariable(Exprs.LB);

  Dir->setUpperBoundVariable(Exprs.UB);

  Dir->setStrideVariable(Exprs.ST);

  Dir->setEnsureUpperBound(Exprs.EUB);

  Dir->setNextLowerBound(Exprs.NLB);