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

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