clang/lib/AST/OpenMPClause.cpp - toolchain/llvm-project - Gitiles

 //===--- OpenMPClause.cpp - Classes for OpenMP clauses --------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the subclesses of Stmt class declared in OpenMPClause.h
 //
 //===----------------------------------------------------------------------===//

 #include "clang/AST/OpenMPClause.h"

 #include "clang/AST/ASTContext.h"

 using namespace clang;

 OMPClause::child_range OMPClause::children() {
   switch (getClauseKind()) {
   default:
     break;
 #define OPENMP_CLAUSE(Name, Class)                                             \
   case OMPC_##Name:                                                            \
     return static_cast<Class *>(this)->children();
 #include "clang/Basic/OpenMPKinds.def"
   }
   llvm_unreachable("unknown OMPClause");
 }

 OMPClauseWithPreInit *OMPClauseWithPreInit::get(OMPClause *C) {
   auto *Res = OMPClauseWithPreInit::get(const_cast<const OMPClause *>(C));
   return Res ? const_cast<OMPClauseWithPreInit *>(Res) : nullptr;
 }

 const OMPClauseWithPreInit *OMPClauseWithPreInit::get(const OMPClause *C) {
   switch (C->getClauseKind()) {
   case OMPC_schedule:
     return static_cast<const OMPScheduleClause *>(C);
   case OMPC_dist_schedule:
     return static_cast<const OMPDistScheduleClause *>(C);
   case OMPC_firstprivate:
     return static_cast<const OMPFirstprivateClause *>(C);
   case OMPC_lastprivate:
     return static_cast<const OMPLastprivateClause *>(C);
   case OMPC_reduction:
     return static_cast<const OMPReductionClause *>(C);
   case OMPC_linear:
     return static_cast<const OMPLinearClause *>(C);
   case OMPC_default:
   case OMPC_proc_bind:
   case OMPC_if:
   case OMPC_final:
   case OMPC_num_threads:
   case OMPC_safelen:
   case OMPC_simdlen:
   case OMPC_collapse:
   case OMPC_private:
   case OMPC_shared:
   case OMPC_aligned:
   case OMPC_copyin:
   case OMPC_copyprivate:
   case OMPC_ordered:
   case OMPC_nowait:
   case OMPC_untied:
   case OMPC_mergeable:
   case OMPC_threadprivate:
   case OMPC_flush:
   case OMPC_read:
   case OMPC_write:
   case OMPC_update:
   case OMPC_capture:
   case OMPC_seq_cst:
   case OMPC_depend:
   case OMPC_device:
   case OMPC_threads:
   case OMPC_simd:
   case OMPC_map:
   case OMPC_num_teams:
   case OMPC_thread_limit:
   case OMPC_priority:
   case OMPC_grainsize:
   case OMPC_nogroup:
   case OMPC_num_tasks:
   case OMPC_hint:
   case OMPC_defaultmap:
   case OMPC_unknown:
     break;
   }

   return nullptr;
 }

 OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(OMPClause *C) {
   auto *Res = OMPClauseWithPostUpdate::get(const_cast<const OMPClause *>(C));
   return Res ? const_cast<OMPClauseWithPostUpdate *>(Res) : nullptr;
 }

 const OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(const OMPClause *C) {
   switch (C->getClauseKind()) {
   case OMPC_lastprivate:
     return static_cast<const OMPLastprivateClause *>(C);
   case OMPC_reduction:
     return static_cast<const OMPReductionClause *>(C);
   case OMPC_linear:
     return static_cast<const OMPLinearClause *>(C);
   case OMPC_schedule:
   case OMPC_dist_schedule:
   case OMPC_firstprivate:
   case OMPC_default:
   case OMPC_proc_bind:
   case OMPC_if:
   case OMPC_final:
   case OMPC_num_threads:
   case OMPC_safelen:
   case OMPC_simdlen:
   case OMPC_collapse:
   case OMPC_private:
   case OMPC_shared:
   case OMPC_aligned:
   case OMPC_copyin:
   case OMPC_copyprivate:
   case OMPC_ordered:
   case OMPC_nowait:
   case OMPC_untied:
   case OMPC_mergeable:
   case OMPC_threadprivate:
   case OMPC_flush:
   case OMPC_read:
   case OMPC_write:
   case OMPC_update:
   case OMPC_capture:
   case OMPC_seq_cst:
   case OMPC_depend:
   case OMPC_device:
   case OMPC_threads:
   case OMPC_simd:
   case OMPC_map:
   case OMPC_num_teams:
   case OMPC_thread_limit:
   case OMPC_priority:
   case OMPC_grainsize:
   case OMPC_nogroup:
   case OMPC_num_tasks:
   case OMPC_hint:
   case OMPC_defaultmap:
   case OMPC_unknown:
     break;
   }

   return nullptr;
 }

 void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
   assert(VL.size() == varlist_size() &&
          "Number of private copies is not the same as the preallocated buffer");
   std::copy(VL.begin(), VL.end(), varlist_end());
 }

 OMPPrivateClause *
 OMPPrivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
                          SourceLocation LParenLoc, SourceLocation EndLoc,
                          ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) {
   // Allocate space for private variables and initializer expressions.
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * VL.size()));
   OMPPrivateClause *Clause =
       new (Mem) OMPPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
   Clause->setVarRefs(VL);
   Clause->setPrivateCopies(PrivateVL);
   return Clause;
 }

 OMPPrivateClause *OMPPrivateClause::CreateEmpty(const ASTContext &C,
                                                 unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * N));
   return new (Mem) OMPPrivateClause(N);
 }

 void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
   assert(VL.size() == varlist_size() &&
          "Number of private copies is not the same as the preallocated buffer");
   std::copy(VL.begin(), VL.end(), varlist_end());
 }

 void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) {
   assert(VL.size() == varlist_size() &&
          "Number of inits is not the same as the preallocated buffer");
   std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
 }

 OMPFirstprivateClause *
 OMPFirstprivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
                               SourceLocation LParenLoc, SourceLocation EndLoc,
                               ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
                               ArrayRef<Expr *> InitVL, Stmt *PreInit) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * VL.size()));
   OMPFirstprivateClause *Clause =
       new (Mem) OMPFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
   Clause->setVarRefs(VL);
   Clause->setPrivateCopies(PrivateVL);
   Clause->setInits(InitVL);
   Clause->setPreInitStmt(PreInit);
   return Clause;
 }

 OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C,
                                                           unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * N));
   return new (Mem) OMPFirstprivateClause(N);
 }

 void OMPLastprivateClause::setPrivateCopies(ArrayRef<Expr *> PrivateCopies) {
   assert(PrivateCopies.size() == varlist_size() &&
          "Number of private copies is not the same as the preallocated buffer");
   std::copy(PrivateCopies.begin(), PrivateCopies.end(), varlist_end());
 }

 void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
                                               "not the same as the "
                                               "preallocated buffer");
   std::copy(SrcExprs.begin(), SrcExprs.end(), getPrivateCopies().end());
 }

 void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
   assert(DstExprs.size() == varlist_size() && "Number of destination "
                                               "expressions is not the same as "
                                               "the preallocated buffer");
   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
 }

 void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
   assert(AssignmentOps.size() == varlist_size() &&
          "Number of assignment expressions is not the same as the preallocated "
          "buffer");
   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
             getDestinationExprs().end());
 }

 OMPLastprivateClause *OMPLastprivateClause::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps, Stmt *PreInit,
     Expr *PostUpdate) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
   OMPLastprivateClause *Clause =
       new (Mem) OMPLastprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
   Clause->setVarRefs(VL);
   Clause->setSourceExprs(SrcExprs);
   Clause->setDestinationExprs(DstExprs);
   Clause->setAssignmentOps(AssignmentOps);
   Clause->setPreInitStmt(PreInit);
   Clause->setPostUpdateExpr(PostUpdate);
   return Clause;
 }

 OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C,
                                                         unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
   return new (Mem) OMPLastprivateClause(N);
 }

 OMPSharedClause *OMPSharedClause::Create(const ASTContext &C,
                                          SourceLocation StartLoc,
                                          SourceLocation LParenLoc,
                                          SourceLocation EndLoc,
                                          ArrayRef<Expr *> VL) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
   OMPSharedClause *Clause =
       new (Mem) OMPSharedClause(StartLoc, LParenLoc, EndLoc, VL.size());
   Clause->setVarRefs(VL);
   return Clause;
 }

 OMPSharedClause *OMPSharedClause::CreateEmpty(const ASTContext &C, unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
   return new (Mem) OMPSharedClause(N);
 }

 void OMPLinearClause::setPrivates(ArrayRef<Expr *> PL) {
   assert(PL.size() == varlist_size() &&
          "Number of privates is not the same as the preallocated buffer");
   std::copy(PL.begin(), PL.end(), varlist_end());
 }

 void OMPLinearClause::setInits(ArrayRef<Expr *> IL) {
   assert(IL.size() == varlist_size() &&
          "Number of inits is not the same as the preallocated buffer");
   std::copy(IL.begin(), IL.end(), getPrivates().end());
 }

 void OMPLinearClause::setUpdates(ArrayRef<Expr *> UL) {
   assert(UL.size() == varlist_size() &&
          "Number of updates is not the same as the preallocated buffer");
   std::copy(UL.begin(), UL.end(), getInits().end());
 }

 void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) {
   assert(FL.size() == varlist_size() &&
          "Number of final updates is not the same as the preallocated buffer");
   std::copy(FL.begin(), FL.end(), getUpdates().end());
 }

 OMPLinearClause *OMPLinearClause::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
     OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
     SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
     ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
     Stmt *PreInit, Expr *PostUpdate) {
   // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
   // (Step and CalcStep).
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2));
   OMPLinearClause *Clause = new (Mem) OMPLinearClause(
       StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc, EndLoc, VL.size());
   Clause->setVarRefs(VL);
   Clause->setPrivates(PL);
   Clause->setInits(IL);
   // Fill update and final expressions with zeroes, they are provided later,
   // after the directive construction.
   std::fill(Clause->getInits().end(), Clause->getInits().end() + VL.size(),
             nullptr);
   std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(),
             nullptr);
   Clause->setStep(Step);
   Clause->setCalcStep(CalcStep);
   Clause->setPreInitStmt(PreInit);
   Clause->setPostUpdateExpr(PostUpdate);
   return Clause;
 }

 OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C,
                                               unsigned NumVars) {
   // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
   // (Step and CalcStep).
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2));
   return new (Mem) OMPLinearClause(NumVars);
 }

 OMPAlignedClause *
 OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc,
                          SourceLocation LParenLoc, SourceLocation ColonLoc,
                          SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
   OMPAlignedClause *Clause = new (Mem)
       OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
   Clause->setVarRefs(VL);
   Clause->setAlignment(A);
   return Clause;
 }

 OMPAlignedClause *OMPAlignedClause::CreateEmpty(const ASTContext &C,
                                                 unsigned NumVars) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumVars + 1));
   return new (Mem) OMPAlignedClause(NumVars);
 }

 void OMPCopyinClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
                                               "not the same as the "
                                               "preallocated buffer");
   std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
 }

 void OMPCopyinClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
   assert(DstExprs.size() == varlist_size() && "Number of destination "
                                               "expressions is not the same as "
                                               "the preallocated buffer");
   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
 }

 void OMPCopyinClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
   assert(AssignmentOps.size() == varlist_size() &&
          "Number of assignment expressions is not the same as the preallocated "
          "buffer");
   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
             getDestinationExprs().end());
 }

 OMPCopyinClause *OMPCopyinClause::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
   OMPCopyinClause *Clause =
       new (Mem) OMPCopyinClause(StartLoc, LParenLoc, EndLoc, VL.size());
   Clause->setVarRefs(VL);
   Clause->setSourceExprs(SrcExprs);
   Clause->setDestinationExprs(DstExprs);
   Clause->setAssignmentOps(AssignmentOps);
   return Clause;
 }

 OMPCopyinClause *OMPCopyinClause::CreateEmpty(const ASTContext &C, unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
   return new (Mem) OMPCopyinClause(N);
 }

 void OMPCopyprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
                                               "not the same as the "
                                               "preallocated buffer");
   std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
 }

 void OMPCopyprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
   assert(DstExprs.size() == varlist_size() && "Number of destination "
                                               "expressions is not the same as "
                                               "the preallocated buffer");
   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
 }

 void OMPCopyprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
   assert(AssignmentOps.size() == varlist_size() &&
          "Number of assignment expressions is not the same as the preallocated "
          "buffer");
   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
             getDestinationExprs().end());
 }

 OMPCopyprivateClause *OMPCopyprivateClause::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
   OMPCopyprivateClause *Clause =
       new (Mem) OMPCopyprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
   Clause->setVarRefs(VL);
   Clause->setSourceExprs(SrcExprs);
   Clause->setDestinationExprs(DstExprs);
   Clause->setAssignmentOps(AssignmentOps);
   return Clause;
 }

 OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(const ASTContext &C,
                                                         unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
   return new (Mem) OMPCopyprivateClause(N);
 }

 void OMPReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
   assert(Privates.size() == varlist_size() &&
          "Number of private copies is not the same as the preallocated buffer");
   std::copy(Privates.begin(), Privates.end(), varlist_end());
 }

 void OMPReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
   assert(
       LHSExprs.size() == varlist_size() &&
       "Number of LHS expressions is not the same as the preallocated buffer");
   std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
 }

 void OMPReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
   assert(
       RHSExprs.size() == varlist_size() &&
       "Number of RHS expressions is not the same as the preallocated buffer");
   std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
 }

 void OMPReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
   assert(ReductionOps.size() == varlist_size() && "Number of reduction "
                                                   "expressions is not the same "
                                                   "as the preallocated buffer");
   std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
 }

 OMPReductionClause *OMPReductionClause::Create(
     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
     SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
     NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
     ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
     ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
     Expr *PostUpdate) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
   OMPReductionClause *Clause = new (Mem) OMPReductionClause(
       StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
   Clause->setVarRefs(VL);
   Clause->setPrivates(Privates);
   Clause->setLHSExprs(LHSExprs);
   Clause->setRHSExprs(RHSExprs);
   Clause->setReductionOps(ReductionOps);
   Clause->setPreInitStmt(PreInit);
   Clause->setPostUpdateExpr(PostUpdate);
   return Clause;
 }

 OMPReductionClause *OMPReductionClause::CreateEmpty(const ASTContext &C,
                                                     unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
   return new (Mem) OMPReductionClause(N);
 }

 OMPFlushClause *OMPFlushClause::Create(const ASTContext &C,
                                        SourceLocation StartLoc,
                                        SourceLocation LParenLoc,
                                        SourceLocation EndLoc,
                                        ArrayRef<Expr *> VL) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
   OMPFlushClause *Clause =
       new (Mem) OMPFlushClause(StartLoc, LParenLoc, EndLoc, VL.size());
   Clause->setVarRefs(VL);
   return Clause;
 }

 OMPFlushClause *OMPFlushClause::CreateEmpty(const ASTContext &C, unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
   return new (Mem) OMPFlushClause(N);
 }

 OMPDependClause *
 OMPDependClause::Create(const ASTContext &C, SourceLocation StartLoc,
                         SourceLocation LParenLoc, SourceLocation EndLoc,
                         OpenMPDependClauseKind DepKind, SourceLocation DepLoc,
                         SourceLocation ColonLoc, ArrayRef<Expr *> VL) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
   OMPDependClause *Clause =
       new (Mem) OMPDependClause(StartLoc, LParenLoc, EndLoc, VL.size());
   Clause->setVarRefs(VL);
   Clause->setDependencyKind(DepKind);
   Clause->setDependencyLoc(DepLoc);
   Clause->setColonLoc(ColonLoc);
   return Clause;
 }

 OMPDependClause *OMPDependClause::CreateEmpty(const ASTContext &C, unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
   return new (Mem) OMPDependClause(N);
 }

 OMPMapClause *OMPMapClause::Create(const ASTContext &C, SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc, ArrayRef<Expr *> VL,
                                    OpenMPMapClauseKind TypeModifier,
                                    OpenMPMapClauseKind Type,
                                    bool TypeIsImplicit,
                                    SourceLocation TypeLoc) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
   OMPMapClause *Clause =
       new (Mem) OMPMapClause(TypeModifier, Type, TypeIsImplicit, TypeLoc,
                              StartLoc, LParenLoc, EndLoc, VL.size());
   Clause->setVarRefs(VL);
   Clause->setMapTypeModifier(TypeModifier);
   Clause->setMapType(Type);
   Clause->setMapLoc(TypeLoc);
   return Clause;
 }

 OMPMapClause *OMPMapClause::CreateEmpty(const ASTContext &C, unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
   return new (Mem) OMPMapClause(N);
 }
	//===--- OpenMPClause.cpp - Classes for OpenMP clauses --------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//
	//
	// This file implements the subclesses of Stmt class declared in OpenMPClause.h
	//
	//===----------------------------------------------------------------------===//

	#include "clang/AST/OpenMPClause.h"

	#include "clang/AST/ASTContext.h"

	using namespace clang;

	OMPClause::child_range OMPClause::children() {
	switch (getClauseKind()) {
	default:
	break;
	#define OPENMP_CLAUSE(Name, Class) \
	case OMPC_##Name: \
	return static_cast<Class *>(this)->children();
	#include "clang/Basic/OpenMPKinds.def"
	}
	llvm_unreachable("unknown OMPClause");
	}

	OMPClauseWithPreInit OMPClauseWithPreInit::get(OMPClause C) {
	auto Res = OMPClauseWithPreInit::get(const_cast<const OMPClause >(C));
	return Res ? const_cast<OMPClauseWithPreInit *>(Res) : nullptr;
	}

	const OMPClauseWithPreInit OMPClauseWithPreInit::get(const OMPClause C) {
	switch (C->getClauseKind()) {
	case OMPC_schedule:
	return static_cast<const OMPScheduleClause *>(C);
	case OMPC_dist_schedule:
	return static_cast<const OMPDistScheduleClause *>(C);
	case OMPC_firstprivate:
	return static_cast<const OMPFirstprivateClause *>(C);
	case OMPC_lastprivate:
	return static_cast<const OMPLastprivateClause *>(C);
	case OMPC_reduction:
	return static_cast<const OMPReductionClause *>(C);
	case OMPC_linear:
	return static_cast<const OMPLinearClause *>(C);
	case OMPC_default:
	case OMPC_proc_bind:
	case OMPC_if:
	case OMPC_final:
	case OMPC_num_threads:
	case OMPC_safelen:
	case OMPC_simdlen:
	case OMPC_collapse:
	case OMPC_private:
	case OMPC_shared:
	case OMPC_aligned:
	case OMPC_copyin:
	case OMPC_copyprivate:
	case OMPC_ordered:
	case OMPC_nowait:
	case OMPC_untied:
	case OMPC_mergeable:
	case OMPC_threadprivate:
	case OMPC_flush:
	case OMPC_read:
	case OMPC_write:
	case OMPC_update:
	case OMPC_capture:
	case OMPC_seq_cst:
	case OMPC_depend:
	case OMPC_device:
	case OMPC_threads:
	case OMPC_simd:
	case OMPC_map:
	case OMPC_num_teams:
	case OMPC_thread_limit:
	case OMPC_priority:
	case OMPC_grainsize:
	case OMPC_nogroup:
	case OMPC_num_tasks:
	case OMPC_hint:
	case OMPC_defaultmap:
	case OMPC_unknown:
	break;
	}

	return nullptr;
	}

	OMPClauseWithPostUpdate OMPClauseWithPostUpdate::get(OMPClause C) {
	auto Res = OMPClauseWithPostUpdate::get(const_cast<const OMPClause >(C));
	return Res ? const_cast<OMPClauseWithPostUpdate *>(Res) : nullptr;
	}

	const OMPClauseWithPostUpdate OMPClauseWithPostUpdate::get(const OMPClause C) {
	switch (C->getClauseKind()) {
	case OMPC_lastprivate:
	return static_cast<const OMPLastprivateClause *>(C);
	case OMPC_reduction:
	return static_cast<const OMPReductionClause *>(C);
	case OMPC_linear:
	return static_cast<const OMPLinearClause *>(C);
	case OMPC_schedule:
	case OMPC_dist_schedule:
	case OMPC_firstprivate:
	case OMPC_default:
	case OMPC_proc_bind:
	case OMPC_if:
	case OMPC_final:
	case OMPC_num_threads:
	case OMPC_safelen:
	case OMPC_simdlen:
	case OMPC_collapse:
	case OMPC_private:
	case OMPC_shared:
	case OMPC_aligned:
	case OMPC_copyin:
	case OMPC_copyprivate:
	case OMPC_ordered:
	case OMPC_nowait:
	case OMPC_untied:
	case OMPC_mergeable:
	case OMPC_threadprivate:
	case OMPC_flush:
	case OMPC_read:
	case OMPC_write:
	case OMPC_update:
	case OMPC_capture:
	case OMPC_seq_cst:
	case OMPC_depend:
	case OMPC_device:
	case OMPC_threads:
	case OMPC_simd:
	case OMPC_map:
	case OMPC_num_teams:
	case OMPC_thread_limit:
	case OMPC_priority:
	case OMPC_grainsize:
	case OMPC_nogroup:
	case OMPC_num_tasks:
	case OMPC_hint:
	case OMPC_defaultmap:
	case OMPC_unknown:
	break;
	}

	return nullptr;
	}

	void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
	assert(VL.size() == varlist_size() &&
	"Number of private copies is not the same as the preallocated buffer");
	std::copy(VL.begin(), VL.end(), varlist_end());
	}

	OMPPrivateClause *
	OMPPrivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
	SourceLocation LParenLoc, SourceLocation EndLoc,
	ArrayRef<Expr > VL, ArrayRef<Expr > PrivateVL) {
	// Allocate space for private variables and initializer expressions.
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(2 * VL.size()));
	OMPPrivateClause *Clause =
	new (Mem) OMPPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
	Clause->setVarRefs(VL);
	Clause->setPrivateCopies(PrivateVL);
	return Clause;
	}

	OMPPrivateClause *OMPPrivateClause::CreateEmpty(const ASTContext &C,
	unsigned N) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(2 * N));
	return new (Mem) OMPPrivateClause(N);
	}

	void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
	assert(VL.size() == varlist_size() &&
	"Number of private copies is not the same as the preallocated buffer");
	std::copy(VL.begin(), VL.end(), varlist_end());
	}

	void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) {
	assert(VL.size() == varlist_size() &&
	"Number of inits is not the same as the preallocated buffer");
	std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
	}

	OMPFirstprivateClause *
	OMPFirstprivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
	SourceLocation LParenLoc, SourceLocation EndLoc,
	ArrayRef<Expr > VL, ArrayRef<Expr > PrivateVL,
	ArrayRef<Expr > InitVL, Stmt PreInit) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(3 * VL.size()));
	OMPFirstprivateClause *Clause =
	new (Mem) OMPFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
	Clause->setVarRefs(VL);
	Clause->setPrivateCopies(PrivateVL);
	Clause->setInits(InitVL);
	Clause->setPreInitStmt(PreInit);
	return Clause;
	}

	OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C,
	unsigned N) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(3 * N));
	return new (Mem) OMPFirstprivateClause(N);
	}

	void OMPLastprivateClause::setPrivateCopies(ArrayRef<Expr *> PrivateCopies) {
	assert(PrivateCopies.size() == varlist_size() &&
	"Number of private copies is not the same as the preallocated buffer");
	std::copy(PrivateCopies.begin(), PrivateCopies.end(), varlist_end());
	}

	void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
	assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
	"not the same as the "
	"preallocated buffer");
	std::copy(SrcExprs.begin(), SrcExprs.end(), getPrivateCopies().end());
	}

	void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
	assert(DstExprs.size() == varlist_size() && "Number of destination "
	"expressions is not the same as "
	"the preallocated buffer");
	std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
	}

	void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
	assert(AssignmentOps.size() == varlist_size() &&
	"Number of assignment expressions is not the same as the preallocated "
	"buffer");
	std::copy(AssignmentOps.begin(), AssignmentOps.end(),
	getDestinationExprs().end());
	}

	OMPLastprivateClause *OMPLastprivateClause::Create(
	const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
	SourceLocation EndLoc, ArrayRef<Expr > VL, ArrayRef<Expr > SrcExprs,
	ArrayRef<Expr > DstExprs, ArrayRef<Expr > AssignmentOps, Stmt *PreInit,
	Expr *PostUpdate) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(5 * VL.size()));
	OMPLastprivateClause *Clause =
	new (Mem) OMPLastprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
	Clause->setVarRefs(VL);
	Clause->setSourceExprs(SrcExprs);
	Clause->setDestinationExprs(DstExprs);
	Clause->setAssignmentOps(AssignmentOps);
	Clause->setPreInitStmt(PreInit);
	Clause->setPostUpdateExpr(PostUpdate);
	return Clause;
	}

	OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C,
	unsigned N) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(5 * N));
	return new (Mem) OMPLastprivateClause(N);
	}

	OMPSharedClause *OMPSharedClause::Create(const ASTContext &C,
	SourceLocation StartLoc,
	SourceLocation LParenLoc,
	SourceLocation EndLoc,
	ArrayRef<Expr *> VL) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(VL.size()));
	OMPSharedClause *Clause =
	new (Mem) OMPSharedClause(StartLoc, LParenLoc, EndLoc, VL.size());
	Clause->setVarRefs(VL);
	return Clause;
	}

	OMPSharedClause *OMPSharedClause::CreateEmpty(const ASTContext &C, unsigned N) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(N));
	return new (Mem) OMPSharedClause(N);
	}

	void OMPLinearClause::setPrivates(ArrayRef<Expr *> PL) {
	assert(PL.size() == varlist_size() &&
	"Number of privates is not the same as the preallocated buffer");
	std::copy(PL.begin(), PL.end(), varlist_end());
	}

	void OMPLinearClause::setInits(ArrayRef<Expr *> IL) {
	assert(IL.size() == varlist_size() &&
	"Number of inits is not the same as the preallocated buffer");
	std::copy(IL.begin(), IL.end(), getPrivates().end());
	}

	void OMPLinearClause::setUpdates(ArrayRef<Expr *> UL) {
	assert(UL.size() == varlist_size() &&
	"Number of updates is not the same as the preallocated buffer");
	std::copy(UL.begin(), UL.end(), getInits().end());
	}

	void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) {
	assert(FL.size() == varlist_size() &&
	"Number of final updates is not the same as the preallocated buffer");
	std::copy(FL.begin(), FL.end(), getUpdates().end());
	}

	OMPLinearClause *OMPLinearClause::Create(
	const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
	OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
	SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
	ArrayRef<Expr > PL, ArrayRef<Expr > IL, Expr Step, Expr CalcStep,
	Stmt PreInit, Expr PostUpdate) {
	// Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
	// (Step and CalcStep).
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(5 * VL.size() + 2));
	OMPLinearClause *Clause = new (Mem) OMPLinearClause(
	StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc, EndLoc, VL.size());
	Clause->setVarRefs(VL);
	Clause->setPrivates(PL);
	Clause->setInits(IL);
	// Fill update and final expressions with zeroes, they are provided later,
	// after the directive construction.
	std::fill(Clause->getInits().end(), Clause->getInits().end() + VL.size(),
	nullptr);
	std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(),
	nullptr);
	Clause->setStep(Step);
	Clause->setCalcStep(CalcStep);
	Clause->setPreInitStmt(PreInit);
	Clause->setPostUpdateExpr(PostUpdate);
	return Clause;
	}

	OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C,
	unsigned NumVars) {
	// Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
	// (Step and CalcStep).
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(5 * NumVars + 2));
	return new (Mem) OMPLinearClause(NumVars);
	}

	OMPAlignedClause *
	OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc,
	SourceLocation LParenLoc, SourceLocation ColonLoc,
	SourceLocation EndLoc, ArrayRef<Expr > VL, Expr A) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(VL.size() + 1));
	OMPAlignedClause *Clause = new (Mem)
	OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
	Clause->setVarRefs(VL);
	Clause->setAlignment(A);
	return Clause;
	}

	OMPAlignedClause *OMPAlignedClause::CreateEmpty(const ASTContext &C,
	unsigned NumVars) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(NumVars + 1));
	return new (Mem) OMPAlignedClause(NumVars);
	}

	void OMPCopyinClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
	assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
	"not the same as the "
	"preallocated buffer");
	std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
	}

	void OMPCopyinClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
	assert(DstExprs.size() == varlist_size() && "Number of destination "
	"expressions is not the same as "
	"the preallocated buffer");
	std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
	}

	void OMPCopyinClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
	assert(AssignmentOps.size() == varlist_size() &&
	"Number of assignment expressions is not the same as the preallocated "
	"buffer");
	std::copy(AssignmentOps.begin(), AssignmentOps.end(),
	getDestinationExprs().end());
	}

	OMPCopyinClause *OMPCopyinClause::Create(
	const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
	SourceLocation EndLoc, ArrayRef<Expr > VL, ArrayRef<Expr > SrcExprs,
	ArrayRef<Expr > DstExprs, ArrayRef<Expr > AssignmentOps) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(4 * VL.size()));
	OMPCopyinClause *Clause =
	new (Mem) OMPCopyinClause(StartLoc, LParenLoc, EndLoc, VL.size());
	Clause->setVarRefs(VL);
	Clause->setSourceExprs(SrcExprs);
	Clause->setDestinationExprs(DstExprs);
	Clause->setAssignmentOps(AssignmentOps);
	return Clause;
	}

	OMPCopyinClause *OMPCopyinClause::CreateEmpty(const ASTContext &C, unsigned N) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(4 * N));
	return new (Mem) OMPCopyinClause(N);
	}

	void OMPCopyprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
	assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
	"not the same as the "
	"preallocated buffer");
	std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
	}

	void OMPCopyprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
	assert(DstExprs.size() == varlist_size() && "Number of destination "
	"expressions is not the same as "
	"the preallocated buffer");
	std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
	}

	void OMPCopyprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
	assert(AssignmentOps.size() == varlist_size() &&
	"Number of assignment expressions is not the same as the preallocated "
	"buffer");
	std::copy(AssignmentOps.begin(), AssignmentOps.end(),
	getDestinationExprs().end());
	}

	OMPCopyprivateClause *OMPCopyprivateClause::Create(
	const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
	SourceLocation EndLoc, ArrayRef<Expr > VL, ArrayRef<Expr > SrcExprs,
	ArrayRef<Expr > DstExprs, ArrayRef<Expr > AssignmentOps) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(4 * VL.size()));
	OMPCopyprivateClause *Clause =
	new (Mem) OMPCopyprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
	Clause->setVarRefs(VL);
	Clause->setSourceExprs(SrcExprs);
	Clause->setDestinationExprs(DstExprs);
	Clause->setAssignmentOps(AssignmentOps);
	return Clause;
	}

	OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(const ASTContext &C,
	unsigned N) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(4 * N));
	return new (Mem) OMPCopyprivateClause(N);
	}

	void OMPReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
	assert(Privates.size() == varlist_size() &&
	"Number of private copies is not the same as the preallocated buffer");
	std::copy(Privates.begin(), Privates.end(), varlist_end());
	}

	void OMPReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
	assert(
	LHSExprs.size() == varlist_size() &&
	"Number of LHS expressions is not the same as the preallocated buffer");
	std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
	}

	void OMPReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
	assert(
	RHSExprs.size() == varlist_size() &&
	"Number of RHS expressions is not the same as the preallocated buffer");
	std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
	}

	void OMPReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
	assert(ReductionOps.size() == varlist_size() && "Number of reduction "
	"expressions is not the same "
	"as the preallocated buffer");
	std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
	}

	OMPReductionClause *OMPReductionClause::Create(
	const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
	SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
	NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
	ArrayRef<Expr > Privates, ArrayRef<Expr > LHSExprs,
	ArrayRef<Expr > RHSExprs, ArrayRef<Expr > ReductionOps, Stmt *PreInit,
	Expr *PostUpdate) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(5 * VL.size()));
	OMPReductionClause *Clause = new (Mem) OMPReductionClause(
	StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
	Clause->setVarRefs(VL);
	Clause->setPrivates(Privates);
	Clause->setLHSExprs(LHSExprs);
	Clause->setRHSExprs(RHSExprs);
	Clause->setReductionOps(ReductionOps);
	Clause->setPreInitStmt(PreInit);
	Clause->setPostUpdateExpr(PostUpdate);
	return Clause;
	}

	OMPReductionClause *OMPReductionClause::CreateEmpty(const ASTContext &C,
	unsigned N) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(5 * N));
	return new (Mem) OMPReductionClause(N);
	}

	OMPFlushClause *OMPFlushClause::Create(const ASTContext &C,
	SourceLocation StartLoc,
	SourceLocation LParenLoc,
	SourceLocation EndLoc,
	ArrayRef<Expr *> VL) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(VL.size()));
	OMPFlushClause *Clause =
	new (Mem) OMPFlushClause(StartLoc, LParenLoc, EndLoc, VL.size());
	Clause->setVarRefs(VL);
	return Clause;
	}

	OMPFlushClause *OMPFlushClause::CreateEmpty(const ASTContext &C, unsigned N) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(N));
	return new (Mem) OMPFlushClause(N);
	}

	OMPDependClause *
	OMPDependClause::Create(const ASTContext &C, SourceLocation StartLoc,
	SourceLocation LParenLoc, SourceLocation EndLoc,
	OpenMPDependClauseKind DepKind, SourceLocation DepLoc,
	SourceLocation ColonLoc, ArrayRef<Expr *> VL) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(VL.size()));
	OMPDependClause *Clause =
	new (Mem) OMPDependClause(StartLoc, LParenLoc, EndLoc, VL.size());
	Clause->setVarRefs(VL);
	Clause->setDependencyKind(DepKind);
	Clause->setDependencyLoc(DepLoc);
	Clause->setColonLoc(ColonLoc);
	return Clause;
	}

	OMPDependClause *OMPDependClause::CreateEmpty(const ASTContext &C, unsigned N) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(N));
	return new (Mem) OMPDependClause(N);
	}

	OMPMapClause *OMPMapClause::Create(const ASTContext &C, SourceLocation StartLoc,
	SourceLocation LParenLoc,
	SourceLocation EndLoc, ArrayRef<Expr *> VL,
	OpenMPMapClauseKind TypeModifier,
	OpenMPMapClauseKind Type,
	bool TypeIsImplicit,
	SourceLocation TypeLoc) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(VL.size()));
	OMPMapClause *Clause =
	new (Mem) OMPMapClause(TypeModifier, Type, TypeIsImplicit, TypeLoc,
	StartLoc, LParenLoc, EndLoc, VL.size());
	Clause->setVarRefs(VL);
	Clause->setMapTypeModifier(TypeModifier);
	Clause->setMapType(Type);
	Clause->setMapLoc(TypeLoc);
	return Clause;
	}

	OMPMapClause *OMPMapClause::CreateEmpty(const ASTContext &C, unsigned N) {
	void Mem = C.Allocate(totalSizeToAlloc<Expr >(N));
	return new (Mem) OMPMapClause(N);
	}