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