Home | History | Annotate | Download | only in AST 
      1 //===--- StmtOpenMP.cpp - Classes for OpenMP directives -------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This file implements the subclesses of Stmt class declared in StmtOpenMP.h
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "clang/AST/StmtOpenMP.h"
     15 
     16 #include "clang/AST/ASTContext.h"
     17 
     18 using namespace clang;
     19 
     20 void OMPExecutableDirective::setClauses(ArrayRef<OMPClause *> Clauses) {
     21   assert(Clauses.size() == getNumClauses() &&
     22          "Number of clauses is not the same as the preallocated buffer");
     23   std::copy(Clauses.begin(), Clauses.end(), getClauses().begin());
     24 }
     25 
     26 void OMPLoopDirective::setCounters(ArrayRef<Expr *> A) {
     27   assert(A.size() == getCollapsedNumber() &&
     28          "Number of loop counters is not the same as the collapsed number");
     29   std::copy(A.begin(), A.end(), getCounters().begin());
     30 }
     31 
     32 void OMPLoopDirective::setPrivateCounters(ArrayRef<Expr *> A) {
     33   assert(A.size() == getCollapsedNumber() && "Number of loop private counters "
     34                                              "is not the same as the collapsed "
     35                                              "number");
     36   std::copy(A.begin(), A.end(), getPrivateCounters().begin());
     37 }
     38 
     39 void OMPLoopDirective::setInits(ArrayRef<Expr *> A) {
     40   assert(A.size() == getCollapsedNumber() &&
     41          "Number of counter inits is not the same as the collapsed number");
     42   std::copy(A.begin(), A.end(), getInits().begin());
     43 }
     44 
     45 void OMPLoopDirective::setUpdates(ArrayRef<Expr *> A) {
     46   assert(A.size() == getCollapsedNumber() &&
     47          "Number of counter updates is not the same as the collapsed number");
     48   std::copy(A.begin(), A.end(), getUpdates().begin());
     49 }
     50 
     51 void OMPLoopDirective::setFinals(ArrayRef<Expr *> A) {
     52   assert(A.size() == getCollapsedNumber() &&
     53          "Number of counter finals is not the same as the collapsed number");
     54   std::copy(A.begin(), A.end(), getFinals().begin());
     55 }
     56 
     57 OMPParallelDirective *OMPParallelDirective::Create(
     58     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
     59     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
     60   unsigned Size =
     61       llvm::alignTo(sizeof(OMPParallelDirective), llvm::alignOf<OMPClause *>());
     62   void *Mem =
     63       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
     64   OMPParallelDirective *Dir =
     65       new (Mem) OMPParallelDirective(StartLoc, EndLoc, Clauses.size());
     66   Dir->setClauses(Clauses);
     67   Dir->setAssociatedStmt(AssociatedStmt);
     68   Dir->setHasCancel(HasCancel);
     69   return Dir;
     70 }
     71 
     72 OMPParallelDirective *OMPParallelDirective::CreateEmpty(const ASTContext &C,
     73                                                         unsigned NumClauses,
     74                                                         EmptyShell) {
     75   unsigned Size =
     76       llvm::alignTo(sizeof(OMPParallelDirective), llvm::alignOf<OMPClause *>());
     77   void *Mem =
     78       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
     79   return new (Mem) OMPParallelDirective(NumClauses);
     80 }
     81 
     82 OMPSimdDirective *
     83 OMPSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
     84                          SourceLocation EndLoc, unsigned CollapsedNum,
     85                          ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     86                          const HelperExprs &Exprs) {
     87   unsigned Size =
     88       llvm::alignTo(sizeof(OMPSimdDirective), llvm::alignOf<OMPClause *>());
     89   void *Mem =
     90       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
     91                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
     92   OMPSimdDirective *Dir = new (Mem)
     93       OMPSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
     94   Dir->setClauses(Clauses);
     95   Dir->setAssociatedStmt(AssociatedStmt);
     96   Dir->setIterationVariable(Exprs.IterationVarRef);
     97   Dir->setLastIteration(Exprs.LastIteration);
     98   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
     99   Dir->setPreCond(Exprs.PreCond);
    100   Dir->setCond(Exprs.Cond);
    101   Dir->setInit(Exprs.Init);
    102   Dir->setInc(Exprs.Inc);
    103   Dir->setCounters(Exprs.Counters);
    104   Dir->setPrivateCounters(Exprs.PrivateCounters);
    105   Dir->setInits(Exprs.Inits);
    106   Dir->setUpdates(Exprs.Updates);
    107   Dir->setFinals(Exprs.Finals);
    108   Dir->setPreInits(Exprs.PreInits);
    109   return Dir;
    110 }
    111 
    112 OMPSimdDirective *OMPSimdDirective::CreateEmpty(const ASTContext &C,
    113                                                 unsigned NumClauses,
    114                                                 unsigned CollapsedNum,
    115                                                 EmptyShell) {
    116   unsigned Size =
    117       llvm::alignTo(sizeof(OMPSimdDirective), llvm::alignOf<OMPClause *>());
    118   void *Mem =
    119       C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
    120                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
    121   return new (Mem) OMPSimdDirective(CollapsedNum, NumClauses);
    122 }
    123 
    124 OMPForDirective *
    125 OMPForDirective::Create(const ASTContext &C, SourceLocation StartLoc,
    126                         SourceLocation EndLoc, unsigned CollapsedNum,
    127                         ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
    128                         const HelperExprs &Exprs, bool HasCancel) {
    129   unsigned Size =
    130       llvm::alignTo(sizeof(OMPForDirective), llvm::alignOf<OMPClause *>());
    131   void *Mem =
    132       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
    133                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
    134   OMPForDirective *Dir =
    135       new (Mem) OMPForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
    136   Dir->setClauses(Clauses);
    137   Dir->setAssociatedStmt(AssociatedStmt);
    138   Dir->setIterationVariable(Exprs.IterationVarRef);
    139   Dir->setLastIteration(Exprs.LastIteration);
    140   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
    141   Dir->setPreCond(Exprs.PreCond);
    142   Dir->setCond(Exprs.Cond);
    143   Dir->setInit(Exprs.Init);
    144   Dir->setInc(Exprs.Inc);
    145   Dir->setIsLastIterVariable(Exprs.IL);
    146   Dir->setLowerBoundVariable(Exprs.LB);
    147   Dir->setUpperBoundVariable(Exprs.UB);
    148   Dir->setStrideVariable(Exprs.ST);
    149   Dir->setEnsureUpperBound(Exprs.EUB);
    150   Dir->setNextLowerBound(Exprs.NLB);
    151   Dir->setNextUpperBound(Exprs.NUB);
    152   Dir->setNumIterations(Exprs.NumIterations);
    153   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
    154   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
    155   Dir->setCounters(Exprs.Counters);
    156   Dir->setPrivateCounters(Exprs.PrivateCounters);
    157   Dir->setInits(Exprs.Inits);
    158   Dir->setUpdates(Exprs.Updates);
    159   Dir->setFinals(Exprs.Finals);
    160   Dir->setPreInits(Exprs.PreInits);
    161   Dir->setHasCancel(HasCancel);
    162   return Dir;
    163 }
    164 
    165 OMPForDirective *OMPForDirective::CreateEmpty(const ASTContext &C,
    166                                               unsigned NumClauses,
    167                                               unsigned CollapsedNum,
    168                                               EmptyShell) {
    169   unsigned Size =
    170       llvm::alignTo(sizeof(OMPForDirective), llvm::alignOf<OMPClause *>());
    171   void *Mem =
    172       C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
    173                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
    174   return new (Mem) OMPForDirective(CollapsedNum, NumClauses);
    175 }
    176 
    177 OMPForSimdDirective *
    178 OMPForSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
    179                             SourceLocation EndLoc, unsigned CollapsedNum,
    180                             ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
    181                             const HelperExprs &Exprs) {
    182   unsigned Size =
    183       llvm::alignTo(sizeof(OMPForSimdDirective), llvm::alignOf<OMPClause *>());
    184   void *Mem =
    185       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
    186                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
    187   OMPForSimdDirective *Dir = new (Mem)
    188       OMPForSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
    189   Dir->setClauses(Clauses);
    190   Dir->setAssociatedStmt(AssociatedStmt);
    191   Dir->setIterationVariable(Exprs.IterationVarRef);
    192   Dir->setLastIteration(Exprs.LastIteration);
    193   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
    194   Dir->setPreCond(Exprs.PreCond);
    195   Dir->setCond(Exprs.Cond);
    196   Dir->setInit(Exprs.Init);
    197   Dir->setInc(Exprs.Inc);
    198   Dir->setIsLastIterVariable(Exprs.IL);
    199   Dir->setLowerBoundVariable(Exprs.LB);
    200   Dir->setUpperBoundVariable(Exprs.UB);
    201   Dir->setStrideVariable(Exprs.ST);
    202   Dir->setEnsureUpperBound(Exprs.EUB);
    203   Dir->setNextLowerBound(Exprs.NLB);
    204   Dir->setNextUpperBound(Exprs.NUB);
    205   Dir->setNumIterations(Exprs.NumIterations);
    206   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
    207   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
    208   Dir->setCounters(Exprs.Counters);
    209   Dir->setPrivateCounters(Exprs.PrivateCounters);
    210   Dir->setInits(Exprs.Inits);
    211   Dir->setUpdates(Exprs.Updates);
    212   Dir->setFinals(Exprs.Finals);
    213   Dir->setPreInits(Exprs.PreInits);
    214   return Dir;
    215 }
    216 
    217 OMPForSimdDirective *OMPForSimdDirective::CreateEmpty(const ASTContext &C,
    218                                                       unsigned NumClauses,
    219                                                       unsigned CollapsedNum,
    220                                                       EmptyShell) {
    221   unsigned Size =
    222       llvm::alignTo(sizeof(OMPForSimdDirective), llvm::alignOf<OMPClause *>());
    223   void *Mem =
    224       C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
    225                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
    226   return new (Mem) OMPForSimdDirective(CollapsedNum, NumClauses);
    227 }
    228 
    229 OMPSectionsDirective *OMPSectionsDirective::Create(
    230     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
    231     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
    232   unsigned Size =
    233       llvm::alignTo(sizeof(OMPSectionsDirective), llvm::alignOf<OMPClause *>());
    234   void *Mem =
    235       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
    236   OMPSectionsDirective *Dir =
    237       new (Mem) OMPSectionsDirective(StartLoc, EndLoc, Clauses.size());
    238   Dir->setClauses(Clauses);
    239   Dir->setAssociatedStmt(AssociatedStmt);
    240   Dir->setHasCancel(HasCancel);
    241   return Dir;
    242 }
    243 
    244 OMPSectionsDirective *OMPSectionsDirective::CreateEmpty(const ASTContext &C,
    245                                                         unsigned NumClauses,
    246                                                         EmptyShell) {
    247   unsigned Size =
    248       llvm::alignTo(sizeof(OMPSectionsDirective), llvm::alignOf<OMPClause *>());
    249   void *Mem =
    250       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
    251   return new (Mem) OMPSectionsDirective(NumClauses);
    252 }
    253 
    254 OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C,
    255                                                  SourceLocation StartLoc,
    256                                                  SourceLocation EndLoc,
    257                                                  Stmt *AssociatedStmt,
    258                                                  bool HasCancel) {
    259   unsigned Size =
    260       llvm::alignTo(sizeof(OMPSectionDirective), llvm::alignOf<Stmt *>());
    261   void *Mem = C.Allocate(Size + sizeof(Stmt *));
    262   OMPSectionDirective *Dir = new (Mem) OMPSectionDirective(StartLoc, EndLoc);
    263   Dir->setAssociatedStmt(AssociatedStmt);
    264   Dir->setHasCancel(HasCancel);
    265   return Dir;
    266 }
    267 
    268 OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C,
    269                                                       EmptyShell) {
    270   unsigned Size =
    271       llvm::alignTo(sizeof(OMPSectionDirective), llvm::alignOf<Stmt *>());
    272   void *Mem = C.Allocate(Size + sizeof(Stmt *));
    273   return new (Mem) OMPSectionDirective();
    274 }
    275 
    276 OMPSingleDirective *OMPSingleDirective::Create(const ASTContext &C,
    277                                                SourceLocation StartLoc,
    278                                                SourceLocation EndLoc,
    279                                                ArrayRef<OMPClause *> Clauses,
    280                                                Stmt *AssociatedStmt) {
    281   unsigned Size =
    282       llvm::alignTo(sizeof(OMPSingleDirective), llvm::alignOf<OMPClause *>());
    283   void *Mem =
    284       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
    285   OMPSingleDirective *Dir =
    286       new (Mem) OMPSingleDirective(StartLoc, EndLoc, Clauses.size());
    287   Dir->setClauses(Clauses);
    288   Dir->setAssociatedStmt(AssociatedStmt);
    289   return Dir;
    290 }
    291 
    292 OMPSingleDirective *OMPSingleDirective::CreateEmpty(const ASTContext &C,
    293                                                     unsigned NumClauses,
    294                                                     EmptyShell) {
    295   unsigned Size =
    296       llvm::alignTo(sizeof(OMPSingleDirective), llvm::alignOf<OMPClause *>());
    297   void *Mem =
    298       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
    299   return new (Mem) OMPSingleDirective(NumClauses);
    300 }
    301 
    302 OMPMasterDirective *OMPMasterDirective::Create(const ASTContext &C,
    303                                                SourceLocation StartLoc,
    304                                                SourceLocation EndLoc,
    305                                                Stmt *AssociatedStmt) {
    306   unsigned Size =
    307       llvm::alignTo(sizeof(OMPMasterDirective), llvm::alignOf<Stmt *>());
    308   void *Mem = C.Allocate(Size + sizeof(Stmt *));
    309   OMPMasterDirective *Dir = new (Mem) OMPMasterDirective(StartLoc, EndLoc);
    310   Dir->setAssociatedStmt(AssociatedStmt);
    311   return Dir;
    312 }
    313 
    314 OMPMasterDirective *OMPMasterDirective::CreateEmpty(const ASTContext &C,
    315                                                     EmptyShell) {
    316   unsigned Size =
    317       llvm::alignTo(sizeof(OMPMasterDirective), llvm::alignOf<Stmt *>());
    318   void *Mem = C.Allocate(Size + sizeof(Stmt *));
    319   return new (Mem) OMPMasterDirective();
    320 }
    321 
    322 OMPCriticalDirective *OMPCriticalDirective::Create(
    323     const ASTContext &C, const DeclarationNameInfo &Name,
    324     SourceLocation StartLoc, SourceLocation EndLoc,
    325     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
    326   unsigned Size =
    327       llvm::alignTo(sizeof(OMPCriticalDirective), llvm::alignOf<OMPClause *>());
    328   void *Mem =
    329       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
    330   OMPCriticalDirective *Dir =
    331       new (Mem) OMPCriticalDirective(Name, StartLoc, EndLoc, Clauses.size());
    332   Dir->setClauses(Clauses);
    333   Dir->setAssociatedStmt(AssociatedStmt);
    334   return Dir;
    335 }
    336 
    337 OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C,
    338                                                         unsigned NumClauses,
    339                                                         EmptyShell) {
    340   unsigned Size =
    341       llvm::alignTo(sizeof(OMPCriticalDirective), llvm::alignOf<OMPClause *>());
    342   void *Mem =
    343       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
    344   return new (Mem) OMPCriticalDirective(NumClauses);
    345 }
    346 
    347 OMPParallelForDirective *OMPParallelForDirective::Create(
    348     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
    349     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
    350     const HelperExprs &Exprs, bool HasCancel) {
    351   unsigned Size = llvm::alignTo(sizeof(OMPParallelForDirective),
    352                                 llvm::alignOf<OMPClause *>());
    353   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
    354                          sizeof(Stmt *) *
    355                              numLoopChildren(CollapsedNum, OMPD_parallel_for));
    356   OMPParallelForDirective *Dir = new (Mem)
    357       OMPParallelForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
    358   Dir->setClauses(Clauses);
    359   Dir->setAssociatedStmt(AssociatedStmt);
    360   Dir->setIterationVariable(Exprs.IterationVarRef);
    361   Dir->setLastIteration(Exprs.LastIteration);
    362   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
    363   Dir->setPreCond(Exprs.PreCond);
    364   Dir->setCond(Exprs.Cond);
    365   Dir->setInit(Exprs.Init);
    366   Dir->setInc(Exprs.Inc);
    367   Dir->setIsLastIterVariable(Exprs.IL);
    368   Dir->setLowerBoundVariable(Exprs.LB);
    369   Dir->setUpperBoundVariable(Exprs.UB);
    370   Dir->setStrideVariable(Exprs.ST);
    371   Dir->setEnsureUpperBound(Exprs.EUB);
    372   Dir->setNextLowerBound(Exprs.NLB);
    373   Dir->setNextUpperBound(Exprs.NUB);
    374   Dir->setNumIterations(Exprs.NumIterations);
    375   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
    376   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
    377   Dir->setCounters(Exprs.Counters);
    378   Dir->setPrivateCounters(Exprs.PrivateCounters);
    379   Dir->setInits(Exprs.Inits);
    380   Dir->setUpdates(Exprs.Updates);
    381   Dir->setFinals(Exprs.Finals);
    382   Dir->setPreInits(Exprs.PreInits);
    383   Dir->setHasCancel(HasCancel);
    384   return Dir;
    385 }
    386 
    387 OMPParallelForDirective *
    388 OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
    389                                      unsigned CollapsedNum, EmptyShell) {
    390   unsigned Size = llvm::alignTo(sizeof(OMPParallelForDirective),
    391                                 llvm::alignOf<OMPClause *>());
    392   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
    393                          sizeof(Stmt *) *
    394                              numLoopChildren(CollapsedNum, OMPD_parallel_for));
    395   return new (Mem) OMPParallelForDirective(CollapsedNum, NumClauses);
    396 }
    397 
    398 OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create(
    399     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
    400     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
    401     const HelperExprs &Exprs) {
    402   unsigned Size = llvm::alignTo(sizeof(OMPParallelForSimdDirective),
    403                                 llvm::alignOf<OMPClause *>());
    404   void *Mem = C.Allocate(
    405       Size + sizeof(OMPClause *) * Clauses.size() +
    406       sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
    407   OMPParallelForSimdDirective *Dir = new (Mem) OMPParallelForSimdDirective(
    408       StartLoc, EndLoc, CollapsedNum, Clauses.size());
    409   Dir->setClauses(Clauses);
    410   Dir->setAssociatedStmt(AssociatedStmt);
    411   Dir->setIterationVariable(Exprs.IterationVarRef);
    412   Dir->setLastIteration(Exprs.LastIteration);
    413   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
    414   Dir->setPreCond(Exprs.PreCond);
    415   Dir->setCond(Exprs.Cond);
    416   Dir->setInit(Exprs.Init);
    417   Dir->setInc(Exprs.Inc);
    418   Dir->setIsLastIterVariable(Exprs.IL);
    419   Dir->setLowerBoundVariable(Exprs.LB);
    420   Dir->setUpperBoundVariable(Exprs.UB);
    421   Dir->setStrideVariable(Exprs.ST);
    422   Dir->setEnsureUpperBound(Exprs.EUB);
    423   Dir->setNextLowerBound(Exprs.NLB);
    424   Dir->setNextUpperBound(Exprs.NUB);
    425   Dir->setNumIterations(Exprs.NumIterations);
    426   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
    427   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
    428   Dir->setCounters(Exprs.Counters);
    429   Dir->setPrivateCounters(Exprs.PrivateCounters);
    430   Dir->setInits(Exprs.Inits);
    431   Dir->setUpdates(Exprs.Updates);
    432   Dir->setFinals(Exprs.Finals);
    433   Dir->setPreInits(Exprs.PreInits);
    434   return Dir;
    435 }
    436 
    437 OMPParallelForSimdDirective *
    438 OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C,
    439                                          unsigned NumClauses,
    440                                          unsigned CollapsedNum, EmptyShell) {
    441   unsigned Size = llvm::alignTo(sizeof(OMPParallelForSimdDirective),
    442                                 llvm::alignOf<OMPClause *>());
    443   void *Mem = C.Allocate(
    444       Size + sizeof(OMPClause *) * NumClauses +
    445       sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
    446   return new (Mem) OMPParallelForSimdDirective(CollapsedNum, NumClauses);
    447 }
    448 
    449 OMPParallelSectionsDirective *OMPParallelSectionsDirective::Create(
    450     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
    451     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
    452   unsigned Size = llvm::alignTo(sizeof(OMPParallelSectionsDirective),
    453                                 llvm::alignOf<OMPClause *>());
    454   void *Mem =
    455       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
    456   OMPParallelSectionsDirective *Dir =
    457       new (Mem) OMPParallelSectionsDirective(StartLoc, EndLoc, Clauses.size());
    458   Dir->setClauses(Clauses);
    459   Dir->setAssociatedStmt(AssociatedStmt);
    460   Dir->setHasCancel(HasCancel);
    461   return Dir;
    462 }
    463 
    464 OMPParallelSectionsDirective *
    465 OMPParallelSectionsDirective::CreateEmpty(const ASTContext &C,
    466                                           unsigned NumClauses, EmptyShell) {
    467   unsigned Size = llvm::alignTo(sizeof(OMPParallelSectionsDirective),
    468                                 llvm::alignOf<OMPClause *>());
    469   void *Mem =
    470       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
    471   return new (Mem) OMPParallelSectionsDirective(NumClauses);
    472 }
    473 
    474 OMPTaskDirective *
    475 OMPTaskDirective::Create(const ASTContext &C, SourceLocation StartLoc,
    476                          SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
    477                          Stmt *AssociatedStmt, bool HasCancel) {
    478   unsigned Size =
    479       llvm::alignTo(sizeof(OMPTaskDirective), llvm::alignOf<OMPClause *>());
    480   void *Mem =
    481       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
    482   OMPTaskDirective *Dir =
    483       new (Mem) OMPTaskDirective(StartLoc, EndLoc, Clauses.size());
    484   Dir->setClauses(Clauses);
    485   Dir->setAssociatedStmt(AssociatedStmt);
    486   Dir->setHasCancel(HasCancel);
    487   return Dir;
    488 }
    489 
    490 OMPTaskDirective *OMPTaskDirective::CreateEmpty(const ASTContext &C,
    491                                                 unsigned NumClauses,
    492                                                 EmptyShell) {
    493   unsigned Size =
    494       llvm::alignTo(sizeof(OMPTaskDirective), llvm::alignOf<OMPClause *>());
    495   void *Mem =
    496       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
    497   return new (Mem) OMPTaskDirective(NumClauses);
    498 }
    499 
    500 OMPTaskyieldDirective *OMPTaskyieldDirective::Create(const ASTContext &C,
    501                                                      SourceLocation StartLoc,
    502                                                      SourceLocation EndLoc) {
    503   void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
    504   OMPTaskyieldDirective *Dir =
    505       new (Mem) OMPTaskyieldDirective(StartLoc, EndLoc);
    506   return Dir;
    507 }
    508 
    509 OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C,
    510                                                           EmptyShell) {
    511   void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
    512   return new (Mem) OMPTaskyieldDirective();
    513 }
    514 
    515 OMPBarrierDirective *OMPBarrierDirective::Create(const ASTContext &C,
    516                                                  SourceLocation StartLoc,
    517                                                  SourceLocation EndLoc) {
    518   void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
    519   OMPBarrierDirective *Dir = new (Mem) OMPBarrierDirective(StartLoc, EndLoc);
    520   return Dir;
    521 }
    522 
    523 OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C,
    524                                                       EmptyShell) {
    525   void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
    526   return new (Mem) OMPBarrierDirective();
    527 }
    528 
    529 OMPTaskwaitDirective *OMPTaskwaitDirective::Create(const ASTContext &C,
    530                                                    SourceLocation StartLoc,
    531                                                    SourceLocation EndLoc) {
    532   void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
    533   OMPTaskwaitDirective *Dir = new (Mem) OMPTaskwaitDirective(StartLoc, EndLoc);
    534   return Dir;
    535 }
    536 
    537 OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C,
    538                                                         EmptyShell) {
    539   void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
    540   return new (Mem) OMPTaskwaitDirective();
    541 }
    542 
    543 OMPTaskgroupDirective *OMPTaskgroupDirective::Create(const ASTContext &C,
    544                                                      SourceLocation StartLoc,
    545                                                      SourceLocation EndLoc,
    546                                                      Stmt *AssociatedStmt) {
    547   unsigned Size =
    548       llvm::alignTo(sizeof(OMPTaskgroupDirective), llvm::alignOf<Stmt *>());
    549   void *Mem = C.Allocate(Size + sizeof(Stmt *));
    550   OMPTaskgroupDirective *Dir =
    551       new (Mem) OMPTaskgroupDirective(StartLoc, EndLoc);
    552   Dir->setAssociatedStmt(AssociatedStmt);
    553   return Dir;
    554 }
    555 
    556 OMPTaskgroupDirective *OMPTaskgroupDirective::CreateEmpty(const ASTContext &C,
    557                                                           EmptyShell) {
    558   unsigned Size =
    559       llvm::alignTo(sizeof(OMPTaskgroupDirective), llvm::alignOf<Stmt *>());
    560   void *Mem = C.Allocate(Size + sizeof(Stmt *));
    561   return new (Mem) OMPTaskgroupDirective();
    562 }
    563 
    564 OMPCancellationPointDirective *OMPCancellationPointDirective::Create(
    565     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
    566     OpenMPDirectiveKind CancelRegion) {
    567   unsigned Size = llvm::alignTo(sizeof(OMPCancellationPointDirective),
    568                                 llvm::alignOf<Stmt *>());
    569   void *Mem = C.Allocate(Size);
    570   OMPCancellationPointDirective *Dir =
    571       new (Mem) OMPCancellationPointDirective(StartLoc, EndLoc);
    572   Dir->setCancelRegion(CancelRegion);
    573   return Dir;
    574 }
    575 
    576 OMPCancellationPointDirective *
    577 OMPCancellationPointDirective::CreateEmpty(const ASTContext &C, EmptyShell) {
    578   unsigned Size = llvm::alignTo(sizeof(OMPCancellationPointDirective),
    579                                 llvm::alignOf<Stmt *>());
    580   void *Mem = C.Allocate(Size);
    581   return new (Mem) OMPCancellationPointDirective();
    582 }
    583 
    584 OMPCancelDirective *
    585 OMPCancelDirective::Create(const ASTContext &C, SourceLocation StartLoc,
    586                            SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
    587                            OpenMPDirectiveKind CancelRegion) {
    588   unsigned Size = llvm::alignTo(sizeof(OMPCancelDirective) +
    589                                     sizeof(OMPClause *) * Clauses.size(),
    590                                 llvm::alignOf<Stmt *>());
    591   void *Mem = C.Allocate(Size);
    592   OMPCancelDirective *Dir =
    593       new (Mem) OMPCancelDirective(StartLoc, EndLoc, Clauses.size());
    594   Dir->setClauses(Clauses);
    595   Dir->setCancelRegion(CancelRegion);
    596   return Dir;
    597 }
    598 
    599 OMPCancelDirective *OMPCancelDirective::CreateEmpty(const ASTContext &C,
    600                                                     unsigned NumClauses,
    601                                                     EmptyShell) {
    602   unsigned Size = llvm::alignTo(sizeof(OMPCancelDirective) +
    603                                     sizeof(OMPClause *) * NumClauses,
    604                                 llvm::alignOf<Stmt *>());
    605   void *Mem = C.Allocate(Size);
    606   return new (Mem) OMPCancelDirective(NumClauses);
    607 }
    608 
    609 OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C,
    610                                              SourceLocation StartLoc,
    611                                              SourceLocation EndLoc,
    612                                              ArrayRef<OMPClause *> Clauses) {
    613   unsigned Size =
    614       llvm::alignTo(sizeof(OMPFlushDirective), llvm::alignOf<OMPClause *>());
    615   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size());
    616   OMPFlushDirective *Dir =
    617       new (Mem) OMPFlushDirective(StartLoc, EndLoc, Clauses.size());
    618   Dir->setClauses(Clauses);
    619   return Dir;
    620 }
    621 
    622 OMPFlushDirective *OMPFlushDirective::CreateEmpty(const ASTContext &C,
    623                                                   unsigned NumClauses,
    624                                                   EmptyShell) {
    625   unsigned Size =
    626       llvm::alignTo(sizeof(OMPFlushDirective), llvm::alignOf<OMPClause *>());
    627   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses);
    628   return new (Mem) OMPFlushDirective(NumClauses);
    629 }
    630 
    631 OMPOrderedDirective *OMPOrderedDirective::Create(const ASTContext &C,
    632                                                  SourceLocation StartLoc,
    633                                                  SourceLocation EndLoc,
    634                                                  ArrayRef<OMPClause *> Clauses,
    635                                                  Stmt *AssociatedStmt) {
    636   unsigned Size =
    637       llvm::alignTo(sizeof(OMPOrderedDirective), llvm::alignOf<OMPClause *>());
    638   void *Mem =
    639       C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * Clauses.size());
    640   OMPOrderedDirective *Dir =
    641       new (Mem) OMPOrderedDirective(StartLoc, EndLoc, Clauses.size());
    642   Dir->setClauses(Clauses);
    643   Dir->setAssociatedStmt(AssociatedStmt);
    644   return Dir;
    645 }
    646 
    647 OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(const ASTContext &C,
    648                                                       unsigned NumClauses,
    649                                                       EmptyShell) {
    650   unsigned Size =
    651       llvm::alignTo(sizeof(OMPOrderedDirective), llvm::alignOf<OMPClause *>());
    652   void *Mem =
    653       C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * NumClauses);
    654   return new (Mem) OMPOrderedDirective(NumClauses);
    655 }
    656 
    657 OMPAtomicDirective *OMPAtomicDirective::Create(
    658     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
    659     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
    660     Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {
    661   unsigned Size =
    662       llvm::alignTo(sizeof(OMPAtomicDirective), llvm::alignOf<OMPClause *>());
    663   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
    664                          5 * sizeof(Stmt *));
    665   OMPAtomicDirective *Dir =
    666       new (Mem) OMPAtomicDirective(StartLoc, EndLoc, Clauses.size());
    667   Dir->setClauses(Clauses);
    668   Dir->setAssociatedStmt(AssociatedStmt);
    669   Dir->setX(X);
    670   Dir->setV(V);
    671   Dir->setExpr(E);
    672   Dir->setUpdateExpr(UE);
    673   Dir->IsXLHSInRHSPart = IsXLHSInRHSPart;
    674   Dir->IsPostfixUpdate = IsPostfixUpdate;
    675   return Dir;
    676 }
    677 
    678 OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C,
    679                                                     unsigned NumClauses,
    680                                                     EmptyShell) {
    681   unsigned Size =
    682       llvm::alignTo(sizeof(OMPAtomicDirective), llvm::alignOf<OMPClause *>());
    683   void *Mem =
    684       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 5 * sizeof(Stmt *));
    685   return new (Mem) OMPAtomicDirective(NumClauses);
    686 }
    687 
    688 OMPTargetDirective *OMPTargetDirective::Create(const ASTContext &C,
    689                                                SourceLocation StartLoc,
    690                                                SourceLocation EndLoc,
    691                                                ArrayRef<OMPClause *> Clauses,
    692                                                Stmt *AssociatedStmt) {
    693   unsigned Size =
    694       llvm::alignTo(sizeof(OMPTargetDirective), llvm::alignOf<OMPClause *>());
    695   void *Mem =
    696       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
    697   OMPTargetDirective *Dir =
    698       new (Mem) OMPTargetDirective(StartLoc, EndLoc, Clauses.size());
    699   Dir->setClauses(Clauses);
    700   Dir->setAssociatedStmt(AssociatedStmt);
    701   return Dir;
    702 }
    703 
    704 OMPTargetDirective *OMPTargetDirective::CreateEmpty(const ASTContext &C,
    705                                                     unsigned NumClauses,
    706                                                     EmptyShell) {
    707   unsigned Size =
    708       llvm::alignTo(sizeof(OMPTargetDirective), llvm::alignOf<OMPClause *>());
    709   void *Mem =
    710       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
    711   return new (Mem) OMPTargetDirective(NumClauses);
    712 }
    713 
    714 OMPTargetParallelDirective *OMPTargetParallelDirective::Create(
    715     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
    716     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
    717   unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelDirective),
    718                                 llvm::alignOf<OMPClause *>());
    719   void *Mem =
    720       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
    721   OMPTargetParallelDirective *Dir =
    722       new (Mem) OMPTargetParallelDirective(StartLoc, EndLoc, Clauses.size());
    723   Dir->setClauses(Clauses);
    724   Dir->setAssociatedStmt(AssociatedStmt);
    725   return Dir;
    726 }
    727 
    728 OMPTargetParallelDirective *
    729 OMPTargetParallelDirective::CreateEmpty(const ASTContext &C,
    730                                         unsigned NumClauses, EmptyShell) {
    731   unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelDirective),
    732                                 llvm::alignOf<OMPClause *>());
    733   void *Mem =
    734       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
    735   return new (Mem) OMPTargetParallelDirective(NumClauses);
    736 }
    737 
    738 OMPTargetParallelForDirective *OMPTargetParallelForDirective::Create(
    739     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
    740     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
    741     const HelperExprs &Exprs, bool HasCancel) {
    742   unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForDirective),
    743                                 llvm::alignOf<OMPClause *>());
    744   void *Mem = C.Allocate(
    745       Size + sizeof(OMPClause *) * Clauses.size() +
    746       sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_parallel_for));
    747   OMPTargetParallelForDirective *Dir = new (Mem) OMPTargetParallelForDirective(
    748       StartLoc, EndLoc, CollapsedNum, Clauses.size());
    749   Dir->setClauses(Clauses);
    750   Dir->setAssociatedStmt(AssociatedStmt);
    751   Dir->setIterationVariable(Exprs.IterationVarRef);
    752   Dir->setLastIteration(Exprs.LastIteration);
    753   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
    754   Dir->setPreCond(Exprs.PreCond);
    755   Dir->setCond(Exprs.Cond);
    756   Dir->setInit(Exprs.Init);
    757   Dir->setInc(Exprs.Inc);
    758   Dir->setIsLastIterVariable(Exprs.IL);
    759   Dir->setLowerBoundVariable(Exprs.LB);
    760   Dir->setUpperBoundVariable(Exprs.UB);
    761   Dir->setStrideVariable(Exprs.ST);
    762   Dir->setEnsureUpperBound(Exprs.EUB);
    763   Dir->setNextLowerBound(Exprs.NLB);
    764   Dir->setNextUpperBound(Exprs.NUB);
    765   Dir->setNumIterations(Exprs.NumIterations);
    766   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
    767   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
    768   Dir->setCounters(Exprs.Counters);
    769   Dir->setPrivateCounters(Exprs.PrivateCounters);
    770   Dir->setInits(Exprs.Inits);
    771   Dir->setUpdates(Exprs.Updates);
    772   Dir->setFinals(Exprs.Finals);
    773   Dir->setPreInits(Exprs.PreInits);
    774   Dir->setHasCancel(HasCancel);
    775   return Dir;
    776 }
    777 
    778 OMPTargetParallelForDirective *
    779 OMPTargetParallelForDirective::CreateEmpty(const ASTContext &C,
    780                                            unsigned NumClauses,
    781                                            unsigned CollapsedNum, EmptyShell) {
    782   unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForDirective),
    783                                 llvm::alignOf<OMPClause *>());
    784   void *Mem = C.Allocate(
    785       Size + sizeof(OMPClause *) * NumClauses +
    786       sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_parallel_for));
    787   return new (Mem) OMPTargetParallelForDirective(CollapsedNum, NumClauses);
    788 }
    789 
    790 OMPTargetDataDirective *OMPTargetDataDirective::Create(
    791     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
    792     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
    793   void *Mem = C.Allocate(llvm::alignTo(sizeof(OMPTargetDataDirective),
    794                                        llvm::alignOf<OMPClause *>()) +
    795                          sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
    796   OMPTargetDataDirective *Dir =
    797       new (Mem) OMPTargetDataDirective(StartLoc, EndLoc, Clauses.size());
    798   Dir->setClauses(Clauses);
    799   Dir->setAssociatedStmt(AssociatedStmt);
    800   return Dir;
    801 }
    802 
    803 OMPTargetDataDirective *OMPTargetDataDirective::CreateEmpty(const ASTContext &C,
    804                                                             unsigned N,
    805                                                             EmptyShell) {
    806   void *Mem = C.Allocate(llvm::alignTo(sizeof(OMPTargetDataDirective),
    807                                        llvm::alignOf<OMPClause *>()) +
    808                          sizeof(OMPClause *) * N + sizeof(Stmt *));
    809   return new (Mem) OMPTargetDataDirective(N);
    810 }
    811 
    812 OMPTargetEnterDataDirective *OMPTargetEnterDataDirective::Create(
    813     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
    814     ArrayRef<OMPClause *> Clauses) {
    815   void *Mem = C.Allocate(llvm::alignTo(sizeof(OMPTargetEnterDataDirective),
    816                                        llvm::alignOf<OMPClause *>()) +
    817                          sizeof(OMPClause *) * Clauses.size());
    818   OMPTargetEnterDataDirective *Dir =
    819       new (Mem) OMPTargetEnterDataDirective(StartLoc, EndLoc, Clauses.size());
    820   Dir->setClauses(Clauses);
    821   return Dir;
    822 }
    823 
    824 OMPTargetEnterDataDirective *
    825 OMPTargetEnterDataDirective::CreateEmpty(const ASTContext &C, unsigned N,
    826                                          EmptyShell) {
    827   void *Mem = C.Allocate(llvm::alignTo(sizeof(OMPTargetEnterDataDirective),
    828                                        llvm::alignOf<OMPClause *>()) +
    829                          sizeof(OMPClause *) * N);
    830   return new (Mem) OMPTargetEnterDataDirective(N);
    831 }
    832 
    833 OMPTargetExitDataDirective *
    834 OMPTargetExitDataDirective::Create(const ASTContext &C, SourceLocation StartLoc,
    835                                    SourceLocation EndLoc,
    836                                    ArrayRef<OMPClause *> Clauses) {
    837   void *Mem = C.Allocate(llvm::alignTo(sizeof(OMPTargetExitDataDirective),
    838                                        llvm::alignOf<OMPClause *>()) +
    839                          sizeof(OMPClause *) * Clauses.size());
    840   OMPTargetExitDataDirective *Dir =
    841       new (Mem) OMPTargetExitDataDirective(StartLoc, EndLoc, Clauses.size());
    842   Dir->setClauses(Clauses);
    843   return Dir;
    844 }
    845 
    846 OMPTargetExitDataDirective *
    847 OMPTargetExitDataDirective::CreateEmpty(const ASTContext &C, unsigned N,
    848                                         EmptyShell) {
    849   void *Mem = C.Allocate(llvm::alignTo(sizeof(OMPTargetExitDataDirective),
    850                                        llvm::alignOf<OMPClause *>()) +
    851                          sizeof(OMPClause *) * N);
    852   return new (Mem) OMPTargetExitDataDirective(N);
    853 }
    854 
    855 OMPTeamsDirective *OMPTeamsDirective::Create(const ASTContext &C,
    856                                              SourceLocation StartLoc,
    857                                              SourceLocation EndLoc,
    858                                              ArrayRef<OMPClause *> Clauses,
    859                                              Stmt *AssociatedStmt) {
    860   unsigned Size =
    861       llvm::alignTo(sizeof(OMPTeamsDirective), llvm::alignOf<OMPClause *>());
    862   void *Mem =
    863       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
    864   OMPTeamsDirective *Dir =
    865       new (Mem) OMPTeamsDirective(StartLoc, EndLoc, Clauses.size());
    866   Dir->setClauses(Clauses);
    867   Dir->setAssociatedStmt(AssociatedStmt);
    868   return Dir;
    869 }
    870 
    871 OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C,
    872                                                   unsigned NumClauses,
    873                                                   EmptyShell) {
    874   unsigned Size =
    875       llvm::alignTo(sizeof(OMPTeamsDirective), llvm::alignOf<OMPClause *>());
    876   void *Mem =
    877       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
    878   return new (Mem) OMPTeamsDirective(NumClauses);
    879 }
    880 
    881 OMPTaskLoopDirective *OMPTaskLoopDirective::Create(
    882     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
    883     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
    884     const HelperExprs &Exprs) {
    885   unsigned Size =
    886       llvm::alignTo(sizeof(OMPTaskLoopDirective), llvm::alignOf<OMPClause *>());
    887   void *Mem =
    888       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
    889                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
    890   OMPTaskLoopDirective *Dir = new (Mem)
    891       OMPTaskLoopDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
    892   Dir->setClauses(Clauses);
    893   Dir->setAssociatedStmt(AssociatedStmt);
    894   Dir->setIterationVariable(Exprs.IterationVarRef);
    895   Dir->setLastIteration(Exprs.LastIteration);
    896   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
    897   Dir->setPreCond(Exprs.PreCond);
    898   Dir->setCond(Exprs.Cond);
    899   Dir->setInit(Exprs.Init);
    900   Dir->setInc(Exprs.Inc);
    901   Dir->setIsLastIterVariable(Exprs.IL);
    902   Dir->setLowerBoundVariable(Exprs.LB);
    903   Dir->setUpperBoundVariable(Exprs.UB);
    904   Dir->setStrideVariable(Exprs.ST);
    905   Dir->setEnsureUpperBound(Exprs.EUB);
    906   Dir->setNextLowerBound(Exprs.NLB);
    907   Dir->setNextUpperBound(Exprs.NUB);
    908   Dir->setNumIterations(Exprs.NumIterations);
    909   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
    910   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
    911   Dir->setCounters(Exprs.Counters);
    912   Dir->setPrivateCounters(Exprs.PrivateCounters);
    913   Dir->setInits(Exprs.Inits);
    914   Dir->setUpdates(Exprs.Updates);
    915   Dir->setFinals(Exprs.Finals);
    916   Dir->setPreInits(Exprs.PreInits);
    917   return Dir;
    918 }
    919 
    920 OMPTaskLoopDirective *OMPTaskLoopDirective::CreateEmpty(const ASTContext &C,
    921                                                         unsigned NumClauses,
    922                                                         unsigned CollapsedNum,
    923                                                         EmptyShell) {
    924   unsigned Size =
    925       llvm::alignTo(sizeof(OMPTaskLoopDirective), llvm::alignOf<OMPClause *>());
    926   void *Mem =
    927       C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
    928                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
    929   return new (Mem) OMPTaskLoopDirective(CollapsedNum, NumClauses);
    930 }
    931 
    932 OMPTaskLoopSimdDirective *OMPTaskLoopSimdDirective::Create(
    933     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
    934     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
    935     const HelperExprs &Exprs) {
    936   unsigned Size = llvm::alignTo(sizeof(OMPTaskLoopSimdDirective),
    937                                 llvm::alignOf<OMPClause *>());
    938   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
    939                          sizeof(Stmt *) *
    940                              numLoopChildren(CollapsedNum, OMPD_taskloop_simd));
    941   OMPTaskLoopSimdDirective *Dir = new (Mem)
    942       OMPTaskLoopSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
    943   Dir->setClauses(Clauses);
    944   Dir->setAssociatedStmt(AssociatedStmt);
    945   Dir->setIterationVariable(Exprs.IterationVarRef);
    946   Dir->setLastIteration(Exprs.LastIteration);
    947   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
    948   Dir->setPreCond(Exprs.PreCond);
    949   Dir->setCond(Exprs.Cond);
    950   Dir->setInit(Exprs.Init);
    951   Dir->setInc(Exprs.Inc);
    952   Dir->setIsLastIterVariable(Exprs.IL);
    953   Dir->setLowerBoundVariable(Exprs.LB);
    954   Dir->setUpperBoundVariable(Exprs.UB);
    955   Dir->setStrideVariable(Exprs.ST);
    956   Dir->setEnsureUpperBound(Exprs.EUB);
    957   Dir->setNextLowerBound(Exprs.NLB);
    958   Dir->setNextUpperBound(Exprs.NUB);
    959   Dir->setNumIterations(Exprs.NumIterations);
    960   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
    961   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
    962   Dir->setCounters(Exprs.Counters);
    963   Dir->setPrivateCounters(Exprs.PrivateCounters);
    964   Dir->setInits(Exprs.Inits);
    965   Dir->setUpdates(Exprs.Updates);
    966   Dir->setFinals(Exprs.Finals);
    967   Dir->setPreInits(Exprs.PreInits);
    968   return Dir;
    969 }
    970 
    971 OMPTaskLoopSimdDirective *
    972 OMPTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
    973                                       unsigned CollapsedNum, EmptyShell) {
    974   unsigned Size = llvm::alignTo(sizeof(OMPTaskLoopSimdDirective),
    975                                 llvm::alignOf<OMPClause *>());
    976   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
    977                          sizeof(Stmt *) *
    978                              numLoopChildren(CollapsedNum, OMPD_taskloop_simd));
    979   return new (Mem) OMPTaskLoopSimdDirective(CollapsedNum, NumClauses);
    980 }
    981 
    982 OMPDistributeDirective *OMPDistributeDirective::Create(
    983     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
    984     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
    985     const HelperExprs &Exprs) {
    986   unsigned Size = llvm::alignTo(sizeof(OMPDistributeDirective),
    987                                 llvm::alignOf<OMPClause *>());
    988   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
    989                          sizeof(Stmt *) *
    990                              numLoopChildren(CollapsedNum, OMPD_distribute));
    991   OMPDistributeDirective *Dir = new (Mem)
    992       OMPDistributeDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
    993   Dir->setClauses(Clauses);
    994   Dir->setAssociatedStmt(AssociatedStmt);
    995   Dir->setIterationVariable(Exprs.IterationVarRef);
    996   Dir->setLastIteration(Exprs.LastIteration);
    997   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
    998   Dir->setPreCond(Exprs.PreCond);
    999   Dir->setCond(Exprs.Cond);
   1000   Dir->setInit(Exprs.Init);
   1001   Dir->setInc(Exprs.Inc);
   1002   Dir->setIsLastIterVariable(Exprs.IL);
   1003   Dir->setLowerBoundVariable(Exprs.LB);
   1004   Dir->setUpperBoundVariable(Exprs.UB);
   1005   Dir->setStrideVariable(Exprs.ST);
   1006   Dir->setEnsureUpperBound(Exprs.EUB);
   1007   Dir->setNextLowerBound(Exprs.NLB);
   1008   Dir->setNextUpperBound(Exprs.NUB);
   1009   Dir->setNumIterations(Exprs.NumIterations);
   1010   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
   1011   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
   1012   Dir->setCounters(Exprs.Counters);
   1013   Dir->setPrivateCounters(Exprs.PrivateCounters);
   1014   Dir->setInits(Exprs.Inits);
   1015   Dir->setUpdates(Exprs.Updates);
   1016   Dir->setFinals(Exprs.Finals);
   1017   Dir->setPreInits(Exprs.PreInits);
   1018   return Dir;
   1019 }
   1020 
   1021 OMPDistributeDirective *
   1022 OMPDistributeDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
   1023                                     unsigned CollapsedNum, EmptyShell) {
   1024   unsigned Size = llvm::alignTo(sizeof(OMPDistributeDirective),
   1025                                 llvm::alignOf<OMPClause *>());
   1026   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
   1027                          sizeof(Stmt *) *
   1028                              numLoopChildren(CollapsedNum, OMPD_distribute));
   1029   return new (Mem) OMPDistributeDirective(CollapsedNum, NumClauses);
   1030 }
   1031 
   1032 OMPTargetUpdateDirective *
   1033 OMPTargetUpdateDirective::Create(const ASTContext &C, SourceLocation StartLoc,
   1034                                  SourceLocation EndLoc,
   1035                                  ArrayRef<OMPClause *> Clauses) {
   1036   unsigned Size = llvm::alignTo(sizeof(OMPTargetUpdateDirective),
   1037                                 llvm::alignOf<OMPClause *>());
   1038   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size());
   1039   OMPTargetUpdateDirective *Dir =
   1040       new (Mem) OMPTargetUpdateDirective(StartLoc, EndLoc, Clauses.size());
   1041   Dir->setClauses(Clauses);
   1042   return Dir;
   1043 }
   1044 
   1045 OMPTargetUpdateDirective *
   1046 OMPTargetUpdateDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
   1047                                       EmptyShell) {
   1048   unsigned Size = llvm::alignTo(sizeof(OMPTargetUpdateDirective),
   1049                                 llvm::alignOf<OMPClause *>());
   1050   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses);
   1051   return new (Mem) OMPTargetUpdateDirective(NumClauses);
   1052 }
   1053 
   1054 OMPDistributeParallelForDirective *OMPDistributeParallelForDirective::Create(
   1055     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
   1056     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
   1057     const HelperExprs &Exprs) {
   1058   unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForDirective),
   1059                                 llvm::alignOf<OMPClause *>());
   1060   void *Mem = C.Allocate(
   1061       Size + sizeof(OMPClause *) * Clauses.size() +
   1062       sizeof(Stmt *) *
   1063           numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for));
   1064   OMPDistributeParallelForDirective *Dir =
   1065       new (Mem) OMPDistributeParallelForDirective(StartLoc, EndLoc,
   1066                                                   CollapsedNum, Clauses.size());
   1067   Dir->setClauses(Clauses);
   1068   Dir->setAssociatedStmt(AssociatedStmt);
   1069   Dir->setIterationVariable(Exprs.IterationVarRef);
   1070   Dir->setLastIteration(Exprs.LastIteration);
   1071   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   1072   Dir->setPreCond(Exprs.PreCond);
   1073   Dir->setCond(Exprs.Cond);
   1074   Dir->setInit(Exprs.Init);
   1075   Dir->setInc(Exprs.Inc);
   1076   Dir->setIsLastIterVariable(Exprs.IL);
   1077   Dir->setLowerBoundVariable(Exprs.LB);
   1078   Dir->setUpperBoundVariable(Exprs.UB);
   1079   Dir->setStrideVariable(Exprs.ST);
   1080   Dir->setEnsureUpperBound(Exprs.EUB);
   1081   Dir->setNextLowerBound(Exprs.NLB);
   1082   Dir->setNextUpperBound(Exprs.NUB);
   1083   Dir->setNumIterations(Exprs.NumIterations);
   1084   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
   1085   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
   1086   Dir->setCounters(Exprs.Counters);
   1087   Dir->setPrivateCounters(Exprs.PrivateCounters);
   1088   Dir->setInits(Exprs.Inits);
   1089   Dir->setUpdates(Exprs.Updates);
   1090   Dir->setFinals(Exprs.Finals);
   1091   Dir->setPreInits(Exprs.PreInits);
   1092   return Dir;
   1093 }
   1094 
   1095 OMPDistributeParallelForDirective *
   1096 OMPDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
   1097                                                unsigned NumClauses,
   1098                                                unsigned CollapsedNum,
   1099                                                EmptyShell) {
   1100   unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForDirective),
   1101                                 llvm::alignOf<OMPClause *>());
   1102   void *Mem = C.Allocate(
   1103       Size + sizeof(OMPClause *) * NumClauses +
   1104       sizeof(Stmt *) *
   1105           numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for));
   1106   return new (Mem) OMPDistributeParallelForDirective(CollapsedNum, NumClauses);
   1107 }
   1108 
   1109 OMPDistributeParallelForSimdDirective *
   1110 OMPDistributeParallelForSimdDirective::Create(
   1111     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
   1112     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
   1113     const HelperExprs &Exprs) {
   1114   unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForSimdDirective),
   1115                                 llvm::alignOf<OMPClause *>());
   1116   void *Mem = C.Allocate(
   1117       Size + sizeof(OMPClause *) * Clauses.size() +
   1118       sizeof(Stmt *) *
   1119           numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd));
   1120   OMPDistributeParallelForSimdDirective *Dir = new (Mem)
   1121       OMPDistributeParallelForSimdDirective(StartLoc, EndLoc, CollapsedNum,
   1122                                             Clauses.size());
   1123   Dir->setClauses(Clauses);
   1124   Dir->setAssociatedStmt(AssociatedStmt);
   1125   Dir->setIterationVariable(Exprs.IterationVarRef);
   1126   Dir->setLastIteration(Exprs.LastIteration);
   1127   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   1128   Dir->setPreCond(Exprs.PreCond);
   1129   Dir->setCond(Exprs.Cond);
   1130   Dir->setInit(Exprs.Init);
   1131   Dir->setInc(Exprs.Inc);
   1132   Dir->setIsLastIterVariable(Exprs.IL);
   1133   Dir->setLowerBoundVariable(Exprs.LB);
   1134   Dir->setUpperBoundVariable(Exprs.UB);
   1135   Dir->setStrideVariable(Exprs.ST);
   1136   Dir->setEnsureUpperBound(Exprs.EUB);
   1137   Dir->setNextLowerBound(Exprs.NLB);
   1138   Dir->setNextUpperBound(Exprs.NUB);
   1139   Dir->setNumIterations(Exprs.NumIterations);
   1140   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
   1141   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
   1142   Dir->setCounters(Exprs.Counters);
   1143   Dir->setPrivateCounters(Exprs.PrivateCounters);
   1144   Dir->setInits(Exprs.Inits);
   1145   Dir->setUpdates(Exprs.Updates);
   1146   Dir->setFinals(Exprs.Finals);
   1147   Dir->setPreInits(Exprs.PreInits);
   1148   return Dir;
   1149 }
   1150 
   1151 OMPDistributeParallelForSimdDirective *
   1152 OMPDistributeParallelForSimdDirective::CreateEmpty(const ASTContext &C,
   1153                                                    unsigned NumClauses,
   1154                                                    unsigned CollapsedNum,
   1155                                                    EmptyShell) {
   1156   unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForSimdDirective),
   1157                                 llvm::alignOf<OMPClause *>());
   1158   void *Mem = C.Allocate(
   1159       Size + sizeof(OMPClause *) * NumClauses +
   1160       sizeof(Stmt *) *
   1161           numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd));
   1162   return new (Mem)
   1163       OMPDistributeParallelForSimdDirective(CollapsedNum, NumClauses);
   1164 }
   1165 
   1166 OMPDistributeSimdDirective *OMPDistributeSimdDirective::Create(
   1167     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
   1168     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
   1169     const HelperExprs &Exprs) {
   1170   unsigned Size = llvm::alignTo(sizeof(OMPDistributeSimdDirective),
   1171                                 llvm::alignOf<OMPClause *>());
   1172   void *Mem = C.Allocate(
   1173       Size + sizeof(OMPClause *) * Clauses.size() +
   1174       sizeof(Stmt *) *
   1175           numLoopChildren(CollapsedNum, OMPD_distribute_simd));
   1176   OMPDistributeSimdDirective *Dir = new (Mem) OMPDistributeSimdDirective(
   1177       StartLoc, EndLoc, CollapsedNum, Clauses.size());
   1178   Dir->setClauses(Clauses);
   1179   Dir->setAssociatedStmt(AssociatedStmt);
   1180   Dir->setIterationVariable(Exprs.IterationVarRef);
   1181   Dir->setLastIteration(Exprs.LastIteration);
   1182   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   1183   Dir->setPreCond(Exprs.PreCond);
   1184   Dir->setCond(Exprs.Cond);
   1185   Dir->setInit(Exprs.Init);
   1186   Dir->setInc(Exprs.Inc);
   1187   Dir->setIsLastIterVariable(Exprs.IL);
   1188   Dir->setLowerBoundVariable(Exprs.LB);
   1189   Dir->setUpperBoundVariable(Exprs.UB);
   1190   Dir->setStrideVariable(Exprs.ST);
   1191   Dir->setEnsureUpperBound(Exprs.EUB);
   1192   Dir->setNextLowerBound(Exprs.NLB);
   1193   Dir->setNextUpperBound(Exprs.NUB);
   1194   Dir->setNumIterations(Exprs.NumIterations);
   1195   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
   1196   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
   1197   Dir->setCounters(Exprs.Counters);
   1198   Dir->setPrivateCounters(Exprs.PrivateCounters);
   1199   Dir->setInits(Exprs.Inits);
   1200   Dir->setUpdates(Exprs.Updates);
   1201   Dir->setFinals(Exprs.Finals);
   1202   Dir->setPreInits(Exprs.PreInits);
   1203   return Dir;
   1204 }
   1205 
   1206 OMPDistributeSimdDirective *
   1207 OMPDistributeSimdDirective::CreateEmpty(const ASTContext &C,
   1208                                         unsigned NumClauses,
   1209                                         unsigned CollapsedNum, EmptyShell) {
   1210   unsigned Size = llvm::alignTo(sizeof(OMPDistributeSimdDirective),
   1211                                 llvm::alignOf<OMPClause *>());
   1212   void *Mem = C.Allocate(
   1213       Size + sizeof(OMPClause *) * NumClauses +
   1214       sizeof(Stmt *) *
   1215           numLoopChildren(CollapsedNum, OMPD_distribute_simd));
   1216   return new (Mem) OMPDistributeSimdDirective(CollapsedNum, NumClauses);
   1217 }
   1218 
   1219 OMPTargetParallelForSimdDirective *OMPTargetParallelForSimdDirective::Create(
   1220     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
   1221     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
   1222     const HelperExprs &Exprs) {
   1223   unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForSimdDirective),
   1224                                 llvm::alignOf<OMPClause *>());
   1225   void *Mem = C.Allocate(
   1226       Size + sizeof(OMPClause *) * Clauses.size() +
   1227       sizeof(Stmt *) *
   1228           numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd));
   1229   OMPTargetParallelForSimdDirective *Dir =
   1230       new (Mem) OMPTargetParallelForSimdDirective(StartLoc, EndLoc,
   1231                                                   CollapsedNum, Clauses.size());
   1232   Dir->setClauses(Clauses);
   1233   Dir->setAssociatedStmt(AssociatedStmt);
   1234   Dir->setIterationVariable(Exprs.IterationVarRef);
   1235   Dir->setLastIteration(Exprs.LastIteration);
   1236   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
   1237   Dir->setPreCond(Exprs.PreCond);
   1238   Dir->setCond(Exprs.Cond);
   1239   Dir->setInit(Exprs.Init);
   1240   Dir->setInc(Exprs.Inc);
   1241   Dir->setIsLastIterVariable(Exprs.IL);
   1242   Dir->setLowerBoundVariable(Exprs.LB);
   1243   Dir->setUpperBoundVariable(Exprs.UB);
   1244   Dir->setStrideVariable(Exprs.ST);
   1245   Dir->setEnsureUpperBound(Exprs.EUB);
   1246   Dir->setNextLowerBound(Exprs.NLB);
   1247   Dir->setNextUpperBound(Exprs.NUB);
   1248   Dir->setNumIterations(Exprs.NumIterations);
   1249   Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
   1250   Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
   1251   Dir->setCounters(Exprs.Counters);
   1252   Dir->setPrivateCounters(Exprs.PrivateCounters);
   1253   Dir->setInits(Exprs.Inits);
   1254   Dir->setUpdates(Exprs.Updates);
   1255   Dir->setFinals(Exprs.Finals);
   1256   Dir->setPreInits(Exprs.PreInits);
   1257   return Dir;
   1258 }
   1259 
   1260 OMPTargetParallelForSimdDirective *
   1261 OMPTargetParallelForSimdDirective::CreateEmpty(const ASTContext &C,
   1262                                                unsigned NumClauses,
   1263                                                unsigned CollapsedNum,
   1264                                                EmptyShell) {
   1265   unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForSimdDirective),
   1266                                 llvm::alignOf<OMPClause *>());
   1267   void *Mem = C.Allocate(
   1268       Size + sizeof(OMPClause *) * NumClauses +
   1269       sizeof(Stmt *) *
   1270           numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd));
   1271   return new (Mem) OMPTargetParallelForSimdDirective(CollapsedNum, NumClauses);
   1272 }
   1273