contrib/llvm/tools/clang/lib/AST/StmtOpenMP.cpp

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