contrib/llvm-project/clang/lib/AST/StmtOpenMP.cpp

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