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

   1 //===--- StmtOpenMP.cpp - Classes for OpenMP directives -------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the subclesses of Stmt class declared in StmtOpenMP.h
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/AST/StmtOpenMP.h"
  15
  16 #include "clang/AST/ASTContext.h"
  17
  18 using namespace clang;
  19
  20 void OMPExecutableDirective::setClauses(ArrayRef<OMPClause *> Clauses) {
  21   assert(Clauses.size() == getNumClauses() &&
  22          "Number of clauses is not the same as the preallocated buffer");
  23   std::copy(Clauses.begin(), Clauses.end(), getClauses().begin());
  24 }
  25
  26 void OMPLoopDirective::setCounters(ArrayRef<Expr *> A) {
  27   assert(A.size() == getCollapsedNumber() &&
  28          "Number of loop counters is not the same as the collapsed number");
  29   std::copy(A.begin(), A.end(), getCounters().begin());
  30 }
  31
  32 void OMPLoopDirective::setPrivateCounters(ArrayRef<Expr *> A) {
  33   assert(A.size() == getCollapsedNumber() && "Number of loop private counters "
  34                                              "is not the same as the collapsed "
  35                                              "number");
  36   std::copy(A.begin(), A.end(), getPrivateCounters().begin());
  37 }
  38
  39 void OMPLoopDirective::setInits(ArrayRef<Expr *> A) {
  40   assert(A.size() == getCollapsedNumber() &&
  41          "Number of counter inits is not the same as the collapsed number");
  42   std::copy(A.begin(), A.end(), getInits().begin());
  43 }
  44
  45 void OMPLoopDirective::setUpdates(ArrayRef<Expr *> A) {
  46   assert(A.size() == getCollapsedNumber() &&
  47          "Number of counter updates is not the same as the collapsed number");
  48   std::copy(A.begin(), A.end(), getUpdates().begin());
  49 }
  50
  51 void OMPLoopDirective::setFinals(ArrayRef<Expr *> A) {
  52   assert(A.size() == getCollapsedNumber() &&
  53          "Number of counter finals is not the same as the collapsed number");
  54   std::copy(A.begin(), A.end(), getFinals().begin());
  55 }
  56
  57 OMPParallelDirective *OMPParallelDirective::Create(
  58     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
  59     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
  60   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelDirective),
  61                                            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 = llvm::RoundUpToAlignment(sizeof(OMPParallelDirective),
  76                                            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 = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective),
  88                                            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   return Dir;
 109 }
 110
 111 OMPSimdDirective *OMPSimdDirective::CreateEmpty(const ASTContext &C,
 112                                                 unsigned NumClauses,
 113                                                 unsigned CollapsedNum,
 114                                                 EmptyShell) {
 115   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective),
 116                                            llvm::alignOf<OMPClause *>());
 117   void *Mem =
 118       C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
 119                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
 120   return new (Mem) OMPSimdDirective(CollapsedNum, NumClauses);
 121 }
 122
 123 OMPForDirective *
 124 OMPForDirective::Create(const ASTContext &C, SourceLocation StartLoc,
 125                         SourceLocation EndLoc, unsigned CollapsedNum,
 126                         ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
 127                         const HelperExprs &Exprs, bool HasCancel) {
 128   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForDirective),
 129                                            llvm::alignOf<OMPClause *>());
 130   void *Mem =
 131       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
 132                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
 133   OMPForDirective *Dir =
 134       new (Mem) OMPForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
 135   Dir->setClauses(Clauses);
 136   Dir->setAssociatedStmt(AssociatedStmt);
 137   Dir->setIterationVariable(Exprs.IterationVarRef);
 138   Dir->setLastIteration(Exprs.LastIteration);
 139   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
 140   Dir->setPreCond(Exprs.PreCond);
 141   Dir->setCond(Exprs.Cond);
 142   Dir->setInit(Exprs.Init);
 143   Dir->setInc(Exprs.Inc);
 144   Dir->setIsLastIterVariable(Exprs.IL);
 145   Dir->setLowerBoundVariable(Exprs.LB);
 146   Dir->setUpperBoundVariable(Exprs.UB);
 147   Dir->setStrideVariable(Exprs.ST);
 148   Dir->setEnsureUpperBound(Exprs.EUB);
 149   Dir->setNextLowerBound(Exprs.NLB);
 150   Dir->setNextUpperBound(Exprs.NUB);
 151   Dir->setCounters(Exprs.Counters);
 152   Dir->setPrivateCounters(Exprs.PrivateCounters);
 153   Dir->setInits(Exprs.Inits);
 154   Dir->setUpdates(Exprs.Updates);
 155   Dir->setFinals(Exprs.Finals);
 156   Dir->setHasCancel(HasCancel);
 157   return Dir;
 158 }
 159
 160 OMPForDirective *OMPForDirective::CreateEmpty(const ASTContext &C,
 161                                               unsigned NumClauses,
 162                                               unsigned CollapsedNum,
 163                                               EmptyShell) {
 164   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForDirective),
 165                                            llvm::alignOf<OMPClause *>());
 166   void *Mem =
 167       C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
 168                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
 169   return new (Mem) OMPForDirective(CollapsedNum, NumClauses);
 170 }
 171
 172 OMPForSimdDirective *
 173 OMPForSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
 174                             SourceLocation EndLoc, unsigned CollapsedNum,
 175                             ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
 176                             const HelperExprs &Exprs) {
 177   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForSimdDirective),
 178                                            llvm::alignOf<OMPClause *>());
 179   void *Mem =
 180       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
 181                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
 182   OMPForSimdDirective *Dir = new (Mem)
 183       OMPForSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
 184   Dir->setClauses(Clauses);
 185   Dir->setAssociatedStmt(AssociatedStmt);
 186   Dir->setIterationVariable(Exprs.IterationVarRef);
 187   Dir->setLastIteration(Exprs.LastIteration);
 188   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
 189   Dir->setPreCond(Exprs.PreCond);
 190   Dir->setCond(Exprs.Cond);
 191   Dir->setInit(Exprs.Init);
 192   Dir->setInc(Exprs.Inc);
 193   Dir->setIsLastIterVariable(Exprs.IL);
 194   Dir->setLowerBoundVariable(Exprs.LB);
 195   Dir->setUpperBoundVariable(Exprs.UB);
 196   Dir->setStrideVariable(Exprs.ST);
 197   Dir->setEnsureUpperBound(Exprs.EUB);
 198   Dir->setNextLowerBound(Exprs.NLB);
 199   Dir->setNextUpperBound(Exprs.NUB);
 200   Dir->setCounters(Exprs.Counters);
 201   Dir->setPrivateCounters(Exprs.PrivateCounters);
 202   Dir->setInits(Exprs.Inits);
 203   Dir->setUpdates(Exprs.Updates);
 204   Dir->setFinals(Exprs.Finals);
 205   return Dir;
 206 }
 207
 208 OMPForSimdDirective *OMPForSimdDirective::CreateEmpty(const ASTContext &C,
 209                                                       unsigned NumClauses,
 210                                                       unsigned CollapsedNum,
 211                                                       EmptyShell) {
 212   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForSimdDirective),
 213                                            llvm::alignOf<OMPClause *>());
 214   void *Mem =
 215       C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
 216                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
 217   return new (Mem) OMPForSimdDirective(CollapsedNum, NumClauses);
 218 }
 219
 220 OMPSectionsDirective *OMPSectionsDirective::Create(
 221     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
 222     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
 223   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective),
 224                                            llvm::alignOf<OMPClause *>());
 225   void *Mem =
 226       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
 227   OMPSectionsDirective *Dir =
 228       new (Mem) OMPSectionsDirective(StartLoc, EndLoc, Clauses.size());
 229   Dir->setClauses(Clauses);
 230   Dir->setAssociatedStmt(AssociatedStmt);
 231   Dir->setHasCancel(HasCancel);
 232   return Dir;
 233 }
 234
 235 OMPSectionsDirective *OMPSectionsDirective::CreateEmpty(const ASTContext &C,
 236                                                         unsigned NumClauses,
 237                                                         EmptyShell) {
 238   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective),
 239                                            llvm::alignOf<OMPClause *>());
 240   void *Mem =
 241       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
 242   return new (Mem) OMPSectionsDirective(NumClauses);
 243 }
 244
 245 OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C,
 246                                                  SourceLocation StartLoc,
 247                                                  SourceLocation EndLoc,
 248                                                  Stmt *AssociatedStmt,
 249                                                  bool HasCancel) {
 250   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionDirective),
 251                                            llvm::alignOf<Stmt *>());
 252   void *Mem = C.Allocate(Size + sizeof(Stmt *));
 253   OMPSectionDirective *Dir = new (Mem) OMPSectionDirective(StartLoc, EndLoc);
 254   Dir->setAssociatedStmt(AssociatedStmt);
 255   Dir->setHasCancel(HasCancel);
 256   return Dir;
 257 }
 258
 259 OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C,
 260                                                       EmptyShell) {
 261   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionDirective),
 262                                            llvm::alignOf<Stmt *>());
 263   void *Mem = C.Allocate(Size + sizeof(Stmt *));
 264   return new (Mem) OMPSectionDirective();
 265 }
 266
 267 OMPSingleDirective *OMPSingleDirective::Create(const ASTContext &C,
 268                                                SourceLocation StartLoc,
 269                                                SourceLocation EndLoc,
 270                                                ArrayRef<OMPClause *> Clauses,
 271                                                Stmt *AssociatedStmt) {
 272   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSingleDirective),
 273                                            llvm::alignOf<OMPClause *>());
 274   void *Mem =
 275       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
 276   OMPSingleDirective *Dir =
 277       new (Mem) OMPSingleDirective(StartLoc, EndLoc, Clauses.size());
 278   Dir->setClauses(Clauses);
 279   Dir->setAssociatedStmt(AssociatedStmt);
 280   return Dir;
 281 }
 282
 283 OMPSingleDirective *OMPSingleDirective::CreateEmpty(const ASTContext &C,
 284                                                     unsigned NumClauses,
 285                                                     EmptyShell) {
 286   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSingleDirective),
 287                                            llvm::alignOf<OMPClause *>());
 288   void *Mem =
 289       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
 290   return new (Mem) OMPSingleDirective(NumClauses);
 291 }
 292
 293 OMPMasterDirective *OMPMasterDirective::Create(const ASTContext &C,
 294                                                SourceLocation StartLoc,
 295                                                SourceLocation EndLoc,
 296                                                Stmt *AssociatedStmt) {
 297   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPMasterDirective),
 298                                            llvm::alignOf<Stmt *>());
 299   void *Mem = C.Allocate(Size + sizeof(Stmt *));
 300   OMPMasterDirective *Dir = new (Mem) OMPMasterDirective(StartLoc, EndLoc);
 301   Dir->setAssociatedStmt(AssociatedStmt);
 302   return Dir;
 303 }
 304
 305 OMPMasterDirective *OMPMasterDirective::CreateEmpty(const ASTContext &C,
 306                                                     EmptyShell) {
 307   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPMasterDirective),
 308                                            llvm::alignOf<Stmt *>());
 309   void *Mem = C.Allocate(Size + sizeof(Stmt *));
 310   return new (Mem) OMPMasterDirective();
 311 }
 312
 313 OMPCriticalDirective *OMPCriticalDirective::Create(
 314     const ASTContext &C, const DeclarationNameInfo &Name,
 315     SourceLocation StartLoc, SourceLocation EndLoc,
 316     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
 317   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective),
 318                                            llvm::alignOf<OMPClause *>());
 319   void *Mem =
 320       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
 321   OMPCriticalDirective *Dir =
 322       new (Mem) OMPCriticalDirective(Name, StartLoc, EndLoc, Clauses.size());
 323   Dir->setClauses(Clauses);
 324   Dir->setAssociatedStmt(AssociatedStmt);
 325   return Dir;
 326 }
 327
 328 OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C,
 329                                                         unsigned NumClauses,
 330                                                         EmptyShell) {
 331   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective),
 332                                            llvm::alignOf<OMPClause *>());
 333   void *Mem =
 334       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
 335   return new (Mem) OMPCriticalDirective(NumClauses);
 336 }
 337
 338 OMPParallelForDirective *OMPParallelForDirective::Create(
 339     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
 340     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
 341     const HelperExprs &Exprs, bool HasCancel) {
 342   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective),
 343                                            llvm::alignOf<OMPClause *>());
 344   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
 345                          sizeof(Stmt *) *
 346                              numLoopChildren(CollapsedNum, OMPD_parallel_for));
 347   OMPParallelForDirective *Dir = new (Mem)
 348       OMPParallelForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
 349   Dir->setClauses(Clauses);
 350   Dir->setAssociatedStmt(AssociatedStmt);
 351   Dir->setIterationVariable(Exprs.IterationVarRef);
 352   Dir->setLastIteration(Exprs.LastIteration);
 353   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
 354   Dir->setPreCond(Exprs.PreCond);
 355   Dir->setCond(Exprs.Cond);
 356   Dir->setInit(Exprs.Init);
 357   Dir->setInc(Exprs.Inc);
 358   Dir->setIsLastIterVariable(Exprs.IL);
 359   Dir->setLowerBoundVariable(Exprs.LB);
 360   Dir->setUpperBoundVariable(Exprs.UB);
 361   Dir->setStrideVariable(Exprs.ST);
 362   Dir->setEnsureUpperBound(Exprs.EUB);
 363   Dir->setNextLowerBound(Exprs.NLB);
 364   Dir->setNextUpperBound(Exprs.NUB);
 365   Dir->setCounters(Exprs.Counters);
 366   Dir->setPrivateCounters(Exprs.PrivateCounters);
 367   Dir->setInits(Exprs.Inits);
 368   Dir->setUpdates(Exprs.Updates);
 369   Dir->setFinals(Exprs.Finals);
 370   Dir->setHasCancel(HasCancel);
 371   return Dir;
 372 }
 373
 374 OMPParallelForDirective *
 375 OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
 376                                      unsigned CollapsedNum, EmptyShell) {
 377   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective),
 378                                            llvm::alignOf<OMPClause *>());
 379   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
 380                          sizeof(Stmt *) *
 381                              numLoopChildren(CollapsedNum, OMPD_parallel_for));
 382   return new (Mem) OMPParallelForDirective(CollapsedNum, NumClauses);
 383 }
 384
 385 OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create(
 386     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
 387     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
 388     const HelperExprs &Exprs) {
 389   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective),
 390                                            llvm::alignOf<OMPClause *>());
 391   void *Mem = C.Allocate(
 392       Size + sizeof(OMPClause *) * Clauses.size() +
 393       sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
 394   OMPParallelForSimdDirective *Dir = new (Mem) OMPParallelForSimdDirective(
 395       StartLoc, EndLoc, CollapsedNum, Clauses.size());
 396   Dir->setClauses(Clauses);
 397   Dir->setAssociatedStmt(AssociatedStmt);
 398   Dir->setIterationVariable(Exprs.IterationVarRef);
 399   Dir->setLastIteration(Exprs.LastIteration);
 400   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
 401   Dir->setPreCond(Exprs.PreCond);
 402   Dir->setCond(Exprs.Cond);
 403   Dir->setInit(Exprs.Init);
 404   Dir->setInc(Exprs.Inc);
 405   Dir->setIsLastIterVariable(Exprs.IL);
 406   Dir->setLowerBoundVariable(Exprs.LB);
 407   Dir->setUpperBoundVariable(Exprs.UB);
 408   Dir->setStrideVariable(Exprs.ST);
 409   Dir->setEnsureUpperBound(Exprs.EUB);
 410   Dir->setNextLowerBound(Exprs.NLB);
 411   Dir->setNextUpperBound(Exprs.NUB);
 412   Dir->setCounters(Exprs.Counters);
 413   Dir->setPrivateCounters(Exprs.PrivateCounters);
 414   Dir->setInits(Exprs.Inits);
 415   Dir->setUpdates(Exprs.Updates);
 416   Dir->setFinals(Exprs.Finals);
 417   return Dir;
 418 }
 419
 420 OMPParallelForSimdDirective *
 421 OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C,
 422                                          unsigned NumClauses,
 423                                          unsigned CollapsedNum, EmptyShell) {
 424   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective),
 425                                            llvm::alignOf<OMPClause *>());
 426   void *Mem = C.Allocate(
 427       Size + sizeof(OMPClause *) * NumClauses +
 428       sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
 429   return new (Mem) OMPParallelForSimdDirective(CollapsedNum, NumClauses);
 430 }
 431
 432 OMPParallelSectionsDirective *OMPParallelSectionsDirective::Create(
 433     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
 434     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
 435   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective),
 436                                            llvm::alignOf<OMPClause *>());
 437   void *Mem =
 438       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
 439   OMPParallelSectionsDirective *Dir =
 440       new (Mem) OMPParallelSectionsDirective(StartLoc, EndLoc, Clauses.size());
 441   Dir->setClauses(Clauses);
 442   Dir->setAssociatedStmt(AssociatedStmt);
 443   Dir->setHasCancel(HasCancel);
 444   return Dir;
 445 }
 446
 447 OMPParallelSectionsDirective *
 448 OMPParallelSectionsDirective::CreateEmpty(const ASTContext &C,
 449                                           unsigned NumClauses, EmptyShell) {
 450   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective),
 451                                            llvm::alignOf<OMPClause *>());
 452   void *Mem =
 453       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
 454   return new (Mem) OMPParallelSectionsDirective(NumClauses);
 455 }
 456
 457 OMPTaskDirective *
 458 OMPTaskDirective::Create(const ASTContext &C, SourceLocation StartLoc,
 459                          SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
 460                          Stmt *AssociatedStmt, bool HasCancel) {
 461   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective),
 462                                            llvm::alignOf<OMPClause *>());
 463   void *Mem =
 464       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
 465   OMPTaskDirective *Dir =
 466       new (Mem) OMPTaskDirective(StartLoc, EndLoc, Clauses.size());
 467   Dir->setClauses(Clauses);
 468   Dir->setAssociatedStmt(AssociatedStmt);
 469   Dir->setHasCancel(HasCancel);
 470   return Dir;
 471 }
 472
 473 OMPTaskDirective *OMPTaskDirective::CreateEmpty(const ASTContext &C,
 474                                                 unsigned NumClauses,
 475                                                 EmptyShell) {
 476   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective),
 477                                            llvm::alignOf<OMPClause *>());
 478   void *Mem =
 479       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
 480   return new (Mem) OMPTaskDirective(NumClauses);
 481 }
 482
 483 OMPTaskyieldDirective *OMPTaskyieldDirective::Create(const ASTContext &C,
 484                                                      SourceLocation StartLoc,
 485                                                      SourceLocation EndLoc) {
 486   void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
 487   OMPTaskyieldDirective *Dir =
 488       new (Mem) OMPTaskyieldDirective(StartLoc, EndLoc);
 489   return Dir;
 490 }
 491
 492 OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C,
 493                                                           EmptyShell) {
 494   void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
 495   return new (Mem) OMPTaskyieldDirective();
 496 }
 497
 498 OMPBarrierDirective *OMPBarrierDirective::Create(const ASTContext &C,
 499                                                  SourceLocation StartLoc,
 500                                                  SourceLocation EndLoc) {
 501   void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
 502   OMPBarrierDirective *Dir = new (Mem) OMPBarrierDirective(StartLoc, EndLoc);
 503   return Dir;
 504 }
 505
 506 OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C,
 507                                                       EmptyShell) {
 508   void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
 509   return new (Mem) OMPBarrierDirective();
 510 }
 511
 512 OMPTaskwaitDirective *OMPTaskwaitDirective::Create(const ASTContext &C,
 513                                                    SourceLocation StartLoc,
 514                                                    SourceLocation EndLoc) {
 515   void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
 516   OMPTaskwaitDirective *Dir = new (Mem) OMPTaskwaitDirective(StartLoc, EndLoc);
 517   return Dir;
 518 }
 519
 520 OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C,
 521                                                         EmptyShell) {
 522   void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
 523   return new (Mem) OMPTaskwaitDirective();
 524 }
 525
 526 OMPTaskgroupDirective *OMPTaskgroupDirective::Create(const ASTContext &C,
 527                                                      SourceLocation StartLoc,
 528                                                      SourceLocation EndLoc,
 529                                                      Stmt *AssociatedStmt) {
 530   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskgroupDirective),
 531                                            llvm::alignOf<Stmt *>());
 532   void *Mem = C.Allocate(Size + sizeof(Stmt *));
 533   OMPTaskgroupDirective *Dir =
 534       new (Mem) OMPTaskgroupDirective(StartLoc, EndLoc);
 535   Dir->setAssociatedStmt(AssociatedStmt);
 536   return Dir;
 537 }
 538
 539 OMPTaskgroupDirective *OMPTaskgroupDirective::CreateEmpty(const ASTContext &C,
 540                                                           EmptyShell) {
 541   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskgroupDirective),
 542                                            llvm::alignOf<Stmt *>());
 543   void *Mem = C.Allocate(Size + sizeof(Stmt *));
 544   return new (Mem) OMPTaskgroupDirective();
 545 }
 546
 547 OMPCancellationPointDirective *OMPCancellationPointDirective::Create(
 548     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
 549     OpenMPDirectiveKind CancelRegion) {
 550   unsigned Size = llvm::RoundUpToAlignment(
 551       sizeof(OMPCancellationPointDirective), llvm::alignOf<Stmt *>());
 552   void *Mem = C.Allocate(Size);
 553   OMPCancellationPointDirective *Dir =
 554       new (Mem) OMPCancellationPointDirective(StartLoc, EndLoc);
 555   Dir->setCancelRegion(CancelRegion);
 556   return Dir;
 557 }
 558
 559 OMPCancellationPointDirective *
 560 OMPCancellationPointDirective::CreateEmpty(const ASTContext &C, EmptyShell) {
 561   unsigned Size = llvm::RoundUpToAlignment(
 562       sizeof(OMPCancellationPointDirective), llvm::alignOf<Stmt *>());
 563   void *Mem = C.Allocate(Size);
 564   return new (Mem) OMPCancellationPointDirective();
 565 }
 566
 567 OMPCancelDirective *
 568 OMPCancelDirective::Create(const ASTContext &C, SourceLocation StartLoc,
 569                            SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
 570                            OpenMPDirectiveKind CancelRegion) {
 571   unsigned Size = llvm::RoundUpToAlignment(
 572       sizeof(OMPCancelDirective) + sizeof(OMPClause *) * Clauses.size(),
 573       llvm::alignOf<Stmt *>());
 574   void *Mem = C.Allocate(Size);
 575   OMPCancelDirective *Dir =
 576       new (Mem) OMPCancelDirective(StartLoc, EndLoc, Clauses.size());
 577   Dir->setClauses(Clauses);
 578   Dir->setCancelRegion(CancelRegion);
 579   return Dir;
 580 }
 581
 582 OMPCancelDirective *OMPCancelDirective::CreateEmpty(const ASTContext &C,
 583                                                     unsigned NumClauses,
 584                                                     EmptyShell) {
 585   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCancelDirective) +
 586                                                sizeof(OMPClause *) * NumClauses,
 587                                            llvm::alignOf<Stmt *>());
 588   void *Mem = C.Allocate(Size);
 589   return new (Mem) OMPCancelDirective(NumClauses);
 590 }
 591
 592 OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C,
 593                                              SourceLocation StartLoc,
 594                                              SourceLocation EndLoc,
 595                                              ArrayRef<OMPClause *> Clauses) {
 596   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPFlushDirective),
 597                                            llvm::alignOf<OMPClause *>());
 598   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size());
 599   OMPFlushDirective *Dir =
 600       new (Mem) OMPFlushDirective(StartLoc, EndLoc, Clauses.size());
 601   Dir->setClauses(Clauses);
 602   return Dir;
 603 }
 604
 605 OMPFlushDirective *OMPFlushDirective::CreateEmpty(const ASTContext &C,
 606                                                   unsigned NumClauses,
 607                                                   EmptyShell) {
 608   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPFlushDirective),
 609                                            llvm::alignOf<OMPClause *>());
 610   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses);
 611   return new (Mem) OMPFlushDirective(NumClauses);
 612 }
 613
 614 OMPOrderedDirective *OMPOrderedDirective::Create(const ASTContext &C,
 615                                                  SourceLocation StartLoc,
 616                                                  SourceLocation EndLoc,
 617                                                  ArrayRef<OMPClause *> Clauses,
 618                                                  Stmt *AssociatedStmt) {
 619   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective),
 620                                            llvm::alignOf<OMPClause *>());
 621   void *Mem =
 622       C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * Clauses.size());
 623   OMPOrderedDirective *Dir =
 624       new (Mem) OMPOrderedDirective(StartLoc, EndLoc, Clauses.size());
 625   Dir->setClauses(Clauses);
 626   Dir->setAssociatedStmt(AssociatedStmt);
 627   return Dir;
 628 }
 629
 630 OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(const ASTContext &C,
 631                                                       unsigned NumClauses,
 632                                                       EmptyShell) {
 633   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective),
 634                                            llvm::alignOf<OMPClause *>());
 635   void *Mem =
 636       C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * NumClauses);
 637   return new (Mem) OMPOrderedDirective(NumClauses);
 638 }
 639
 640 OMPAtomicDirective *OMPAtomicDirective::Create(
 641     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
 642     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
 643     Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {
 644   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective),
 645                                            llvm::alignOf<OMPClause *>());
 646   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
 647                          5 * sizeof(Stmt *));
 648   OMPAtomicDirective *Dir =
 649       new (Mem) OMPAtomicDirective(StartLoc, EndLoc, Clauses.size());
 650   Dir->setClauses(Clauses);
 651   Dir->setAssociatedStmt(AssociatedStmt);
 652   Dir->setX(X);
 653   Dir->setV(V);
 654   Dir->setExpr(E);
 655   Dir->setUpdateExpr(UE);
 656   Dir->IsXLHSInRHSPart = IsXLHSInRHSPart;
 657   Dir->IsPostfixUpdate = IsPostfixUpdate;
 658   return Dir;
 659 }
 660
 661 OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C,
 662                                                     unsigned NumClauses,
 663                                                     EmptyShell) {
 664   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective),
 665                                            llvm::alignOf<OMPClause *>());
 666   void *Mem =
 667       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 5 * sizeof(Stmt *));
 668   return new (Mem) OMPAtomicDirective(NumClauses);
 669 }
 670
 671 OMPTargetDirective *OMPTargetDirective::Create(const ASTContext &C,
 672                                                SourceLocation StartLoc,
 673                                                SourceLocation EndLoc,
 674                                                ArrayRef<OMPClause *> Clauses,
 675                                                Stmt *AssociatedStmt) {
 676   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective),
 677                                            llvm::alignOf<OMPClause *>());
 678   void *Mem =
 679       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
 680   OMPTargetDirective *Dir =
 681       new (Mem) OMPTargetDirective(StartLoc, EndLoc, Clauses.size());
 682   Dir->setClauses(Clauses);
 683   Dir->setAssociatedStmt(AssociatedStmt);
 684   return Dir;
 685 }
 686
 687 OMPTargetDirective *OMPTargetDirective::CreateEmpty(const ASTContext &C,
 688                                                     unsigned NumClauses,
 689                                                     EmptyShell) {
 690   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective),
 691                                            llvm::alignOf<OMPClause *>());
 692   void *Mem =
 693       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
 694   return new (Mem) OMPTargetDirective(NumClauses);
 695 }
 696
 697 OMPTargetDataDirective *OMPTargetDataDirective::Create(
 698     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
 699     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
 700   void *Mem =
 701       C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPTargetDataDirective),
 702                                           llvm::alignOf<OMPClause *>()) +
 703                  sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
 704   OMPTargetDataDirective *Dir =
 705       new (Mem) OMPTargetDataDirective(StartLoc, EndLoc, Clauses.size());
 706   Dir->setClauses(Clauses);
 707   Dir->setAssociatedStmt(AssociatedStmt);
 708   return Dir;
 709 }
 710
 711 OMPTargetDataDirective *OMPTargetDataDirective::CreateEmpty(const ASTContext &C,
 712                                                             unsigned N,
 713                                                             EmptyShell) {
 714   void *Mem =
 715       C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPTargetDataDirective),
 716                                           llvm::alignOf<OMPClause *>()) +
 717                  sizeof(OMPClause *) * N + sizeof(Stmt *));
 718   return new (Mem) OMPTargetDataDirective(N);
 719 }
 720
 721 OMPTeamsDirective *OMPTeamsDirective::Create(const ASTContext &C,
 722                                              SourceLocation StartLoc,
 723                                              SourceLocation EndLoc,
 724                                              ArrayRef<OMPClause *> Clauses,
 725                                              Stmt *AssociatedStmt) {
 726   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective),
 727                                            llvm::alignOf<OMPClause *>());
 728   void *Mem =
 729       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
 730   OMPTeamsDirective *Dir =
 731       new (Mem) OMPTeamsDirective(StartLoc, EndLoc, Clauses.size());
 732   Dir->setClauses(Clauses);
 733   Dir->setAssociatedStmt(AssociatedStmt);
 734   return Dir;
 735 }
 736
 737 OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C,
 738                                                   unsigned NumClauses,
 739                                                   EmptyShell) {
 740   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective),
 741                                            llvm::alignOf<OMPClause *>());
 742   void *Mem =
 743       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
 744   return new (Mem) OMPTeamsDirective(NumClauses);
 745 }
 746
 747 OMPTaskLoopDirective *OMPTaskLoopDirective::Create(
 748     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
 749     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
 750     const HelperExprs &Exprs) {
 751   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskLoopDirective),
 752                                            llvm::alignOf<OMPClause *>());
 753   void *Mem =
 754       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
 755                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
 756   OMPTaskLoopDirective *Dir = new (Mem)
 757       OMPTaskLoopDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
 758   Dir->setClauses(Clauses);
 759   Dir->setAssociatedStmt(AssociatedStmt);
 760   Dir->setIterationVariable(Exprs.IterationVarRef);
 761   Dir->setLastIteration(Exprs.LastIteration);
 762   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
 763   Dir->setPreCond(Exprs.PreCond);
 764   Dir->setCond(Exprs.Cond);
 765   Dir->setInit(Exprs.Init);
 766   Dir->setInc(Exprs.Inc);
 767   Dir->setIsLastIterVariable(Exprs.IL);
 768   Dir->setLowerBoundVariable(Exprs.LB);
 769   Dir->setUpperBoundVariable(Exprs.UB);
 770   Dir->setStrideVariable(Exprs.ST);
 771   Dir->setEnsureUpperBound(Exprs.EUB);
 772   Dir->setNextLowerBound(Exprs.NLB);
 773   Dir->setNextUpperBound(Exprs.NUB);
 774   Dir->setCounters(Exprs.Counters);
 775   Dir->setPrivateCounters(Exprs.PrivateCounters);
 776   Dir->setInits(Exprs.Inits);
 777   Dir->setUpdates(Exprs.Updates);
 778   Dir->setFinals(Exprs.Finals);
 779   return Dir;
 780 }
 781
 782 OMPTaskLoopDirective *OMPTaskLoopDirective::CreateEmpty(const ASTContext &C,
 783                                                         unsigned NumClauses,
 784                                                         unsigned CollapsedNum,
 785                                                         EmptyShell) {
 786   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskLoopDirective),
 787                                            llvm::alignOf<OMPClause *>());
 788   void *Mem =
 789       C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
 790                  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
 791   return new (Mem) OMPTaskLoopDirective(CollapsedNum, NumClauses);
 792 }
 793
 794 OMPTaskLoopSimdDirective *OMPTaskLoopSimdDirective::Create(
 795     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
 796     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
 797     const HelperExprs &Exprs) {
 798   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskLoopSimdDirective),
 799                                            llvm::alignOf<OMPClause *>());
 800   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
 801                          sizeof(Stmt *) *
 802                              numLoopChildren(CollapsedNum, OMPD_taskloop_simd));
 803   OMPTaskLoopSimdDirective *Dir = new (Mem)
 804       OMPTaskLoopSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
 805   Dir->setClauses(Clauses);
 806   Dir->setAssociatedStmt(AssociatedStmt);
 807   Dir->setIterationVariable(Exprs.IterationVarRef);
 808   Dir->setLastIteration(Exprs.LastIteration);
 809   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
 810   Dir->setPreCond(Exprs.PreCond);
 811   Dir->setCond(Exprs.Cond);
 812   Dir->setInit(Exprs.Init);
 813   Dir->setInc(Exprs.Inc);
 814   Dir->setIsLastIterVariable(Exprs.IL);
 815   Dir->setLowerBoundVariable(Exprs.LB);
 816   Dir->setUpperBoundVariable(Exprs.UB);
 817   Dir->setStrideVariable(Exprs.ST);
 818   Dir->setEnsureUpperBound(Exprs.EUB);
 819   Dir->setNextLowerBound(Exprs.NLB);
 820   Dir->setNextUpperBound(Exprs.NUB);
 821   Dir->setCounters(Exprs.Counters);
 822   Dir->setPrivateCounters(Exprs.PrivateCounters);
 823   Dir->setInits(Exprs.Inits);
 824   Dir->setUpdates(Exprs.Updates);
 825   Dir->setFinals(Exprs.Finals);
 826   return Dir;
 827 }
 828
 829 OMPTaskLoopSimdDirective *
 830 OMPTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
 831                                       unsigned CollapsedNum, EmptyShell) {
 832   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskLoopSimdDirective),
 833                                            llvm::alignOf<OMPClause *>());
 834   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
 835                          sizeof(Stmt *) *
 836                              numLoopChildren(CollapsedNum, OMPD_taskloop_simd));
 837   return new (Mem) OMPTaskLoopSimdDirective(CollapsedNum, NumClauses);
 838 }
 839
 840 OMPDistributeDirective *OMPDistributeDirective::Create(
 841     const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
 842     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
 843     const HelperExprs &Exprs) {
 844   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPDistributeDirective),
 845                                            llvm::alignOf<OMPClause *>());
 846   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
 847                          sizeof(Stmt *) *
 848                              numLoopChildren(CollapsedNum, OMPD_distribute));
 849   OMPDistributeDirective *Dir = new (Mem)
 850       OMPDistributeDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
 851   Dir->setClauses(Clauses);
 852   Dir->setAssociatedStmt(AssociatedStmt);
 853   Dir->setIterationVariable(Exprs.IterationVarRef);
 854   Dir->setLastIteration(Exprs.LastIteration);
 855   Dir->setCalcLastIteration(Exprs.CalcLastIteration);
 856   Dir->setPreCond(Exprs.PreCond);
 857   Dir->setCond(Exprs.Cond);
 858   Dir->setInit(Exprs.Init);
 859   Dir->setInc(Exprs.Inc);
 860   Dir->setIsLastIterVariable(Exprs.IL);
 861   Dir->setLowerBoundVariable(Exprs.LB);
 862   Dir->setUpperBoundVariable(Exprs.UB);
 863   Dir->setStrideVariable(Exprs.ST);
 864   Dir->setEnsureUpperBound(Exprs.EUB);
 865   Dir->setNextLowerBound(Exprs.NLB);
 866   Dir->setNextUpperBound(Exprs.NUB);
 867   Dir->setCounters(Exprs.Counters);
 868   Dir->setPrivateCounters(Exprs.PrivateCounters);
 869   Dir->setInits(Exprs.Inits);
 870   Dir->setUpdates(Exprs.Updates);
 871   Dir->setFinals(Exprs.Finals);
 872   return Dir;
 873 }
 874
 875 OMPDistributeDirective *
 876 OMPDistributeDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
 877                                     unsigned CollapsedNum, EmptyShell) {
 878   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPDistributeDirective),
 879                                            llvm::alignOf<OMPClause *>());
 880   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
 881                          sizeof(Stmt *) *
 882                              numLoopChildren(CollapsedNum, OMPD_distribute));
 883   return new (Mem) OMPDistributeDirective(CollapsedNum, NumClauses);
 884 }