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

   1 //===- OpenMPClause.cpp - Classes for OpenMP clauses ----------------------===//
   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 OpenMPClause.h
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/AST/OpenMPClause.h"
  15 #include "clang/AST/ASTContext.h"
  16 #include "clang/AST/Decl.h"
  17 #include "clang/Basic/LLVM.h"
  18 #include "llvm/ADT/SmallPtrSet.h"
  19 #include "llvm/Support/Casting.h"
  20 #include "llvm/Support/ErrorHandling.h"
  21 #include <algorithm>
  22 #include <cassert>
  23
  24 using namespace clang;
  25
  26 OMPClause::child_range OMPClause::children() {
  27   switch (getClauseKind()) {
  28   default:
  29     break;
  30 #define OPENMP_CLAUSE(Name, Class)                                             \
  31   case OMPC_##Name:                                                            \
  32     return static_cast<Class *>(this)->children();
  33 #include "clang/Basic/OpenMPKinds.def"
  34   }
  35   llvm_unreachable("unknown OMPClause");
  36 }
  37
  38 OMPClauseWithPreInit *OMPClauseWithPreInit::get(OMPClause *C) {
  39   auto *Res = OMPClauseWithPreInit::get(const_cast<const OMPClause *>(C));
  40   return Res ? const_cast<OMPClauseWithPreInit *>(Res) : nullptr;
  41 }
  42
  43 const OMPClauseWithPreInit *OMPClauseWithPreInit::get(const OMPClause *C) {
  44   switch (C->getClauseKind()) {
  45   case OMPC_schedule:
  46     return static_cast<const OMPScheduleClause *>(C);
  47   case OMPC_dist_schedule:
  48     return static_cast<const OMPDistScheduleClause *>(C);
  49   case OMPC_firstprivate:
  50     return static_cast<const OMPFirstprivateClause *>(C);
  51   case OMPC_lastprivate:
  52     return static_cast<const OMPLastprivateClause *>(C);
  53   case OMPC_reduction:
  54     return static_cast<const OMPReductionClause *>(C);
  55   case OMPC_task_reduction:
  56     return static_cast<const OMPTaskReductionClause *>(C);
  57   case OMPC_in_reduction:
  58     return static_cast<const OMPInReductionClause *>(C);
  59   case OMPC_linear:
  60     return static_cast<const OMPLinearClause *>(C);
  61   case OMPC_if:
  62     return static_cast<const OMPIfClause *>(C);
  63   case OMPC_num_threads:
  64     return static_cast<const OMPNumThreadsClause *>(C);
  65   case OMPC_num_teams:
  66     return static_cast<const OMPNumTeamsClause *>(C);
  67   case OMPC_thread_limit:
  68     return static_cast<const OMPThreadLimitClause *>(C);
  69   case OMPC_device:
  70     return static_cast<const OMPDeviceClause *>(C);
  71   case OMPC_default:
  72   case OMPC_proc_bind:
  73   case OMPC_final:
  74   case OMPC_safelen:
  75   case OMPC_simdlen:
  76   case OMPC_collapse:
  77   case OMPC_private:
  78   case OMPC_shared:
  79   case OMPC_aligned:
  80   case OMPC_copyin:
  81   case OMPC_copyprivate:
  82   case OMPC_ordered:
  83   case OMPC_nowait:
  84   case OMPC_untied:
  85   case OMPC_mergeable:
  86   case OMPC_threadprivate:
  87   case OMPC_flush:
  88   case OMPC_read:
  89   case OMPC_write:
  90   case OMPC_update:
  91   case OMPC_capture:
  92   case OMPC_seq_cst:
  93   case OMPC_depend:
  94   case OMPC_threads:
  95   case OMPC_simd:
  96   case OMPC_map:
  97   case OMPC_priority:
  98   case OMPC_grainsize:
  99   case OMPC_nogroup:
 100   case OMPC_num_tasks:
 101   case OMPC_hint:
 102   case OMPC_defaultmap:
 103   case OMPC_unknown:
 104   case OMPC_uniform:
 105   case OMPC_to:
 106   case OMPC_from:
 107   case OMPC_use_device_ptr:
 108   case OMPC_is_device_ptr:
 109     break;
 110   }
 111
 112   return nullptr;
 113 }
 114
 115 OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(OMPClause *C) {
 116   auto *Res = OMPClauseWithPostUpdate::get(const_cast<const OMPClause *>(C));
 117   return Res ? const_cast<OMPClauseWithPostUpdate *>(Res) : nullptr;
 118 }
 119
 120 const OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(const OMPClause *C) {
 121   switch (C->getClauseKind()) {
 122   case OMPC_lastprivate:
 123     return static_cast<const OMPLastprivateClause *>(C);
 124   case OMPC_reduction:
 125     return static_cast<const OMPReductionClause *>(C);
 126   case OMPC_task_reduction:
 127     return static_cast<const OMPTaskReductionClause *>(C);
 128   case OMPC_in_reduction:
 129     return static_cast<const OMPInReductionClause *>(C);
 130   case OMPC_linear:
 131     return static_cast<const OMPLinearClause *>(C);
 132   case OMPC_schedule:
 133   case OMPC_dist_schedule:
 134   case OMPC_firstprivate:
 135   case OMPC_default:
 136   case OMPC_proc_bind:
 137   case OMPC_if:
 138   case OMPC_final:
 139   case OMPC_num_threads:
 140   case OMPC_safelen:
 141   case OMPC_simdlen:
 142   case OMPC_collapse:
 143   case OMPC_private:
 144   case OMPC_shared:
 145   case OMPC_aligned:
 146   case OMPC_copyin:
 147   case OMPC_copyprivate:
 148   case OMPC_ordered:
 149   case OMPC_nowait:
 150   case OMPC_untied:
 151   case OMPC_mergeable:
 152   case OMPC_threadprivate:
 153   case OMPC_flush:
 154   case OMPC_read:
 155   case OMPC_write:
 156   case OMPC_update:
 157   case OMPC_capture:
 158   case OMPC_seq_cst:
 159   case OMPC_depend:
 160   case OMPC_device:
 161   case OMPC_threads:
 162   case OMPC_simd:
 163   case OMPC_map:
 164   case OMPC_num_teams:
 165   case OMPC_thread_limit:
 166   case OMPC_priority:
 167   case OMPC_grainsize:
 168   case OMPC_nogroup:
 169   case OMPC_num_tasks:
 170   case OMPC_hint:
 171   case OMPC_defaultmap:
 172   case OMPC_unknown:
 173   case OMPC_uniform:
 174   case OMPC_to:
 175   case OMPC_from:
 176   case OMPC_use_device_ptr:
 177   case OMPC_is_device_ptr:
 178     break;
 179   }
 180
 181   return nullptr;
 182 }
 183
 184 OMPOrderedClause *OMPOrderedClause::Create(const ASTContext &C, Expr *Num,
 185                                            unsigned NumLoops,
 186                                            SourceLocation StartLoc,
 187                                            SourceLocation LParenLoc,
 188                                            SourceLocation EndLoc) {
 189   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * NumLoops));
 190   auto *Clause =
 191       new (Mem) OMPOrderedClause(Num, NumLoops, StartLoc, LParenLoc, EndLoc);
 192   for (unsigned I = 0; I < NumLoops; ++I) {
 193     Clause->setLoopNumIterations(I, nullptr);
 194     Clause->setLoopCounter(I, nullptr);
 195   }
 196   return Clause;
 197 }
 198
 199 OMPOrderedClause *OMPOrderedClause::CreateEmpty(const ASTContext &C,
 200                                                 unsigned NumLoops) {
 201   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * NumLoops));
 202   auto *Clause = new (Mem) OMPOrderedClause(NumLoops);
 203   for (unsigned I = 0; I < NumLoops; ++I) {
 204     Clause->setLoopNumIterations(I, nullptr);
 205     Clause->setLoopCounter(I, nullptr);
 206   }
 207   return Clause;
 208 }
 209
 210 void OMPOrderedClause::setLoopNumIterations(unsigned NumLoop,
 211                                             Expr *NumIterations) {
 212   assert(NumLoop < NumberOfLoops && "out of loops number.");
 213   getTrailingObjects<Expr *>()[NumLoop] = NumIterations;
 214 }
 215
 216 ArrayRef<Expr *> OMPOrderedClause::getLoopNumIterations() const {
 217   return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumberOfLoops);
 218 }
 219
 220 void OMPOrderedClause::setLoopCounter(unsigned NumLoop, Expr *Counter) {
 221   assert(NumLoop < NumberOfLoops && "out of loops number.");
 222   getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop] = Counter;
 223 }
 224
 225 Expr *OMPOrderedClause::getLoopCunter(unsigned NumLoop) {
 226   assert(NumLoop < NumberOfLoops && "out of loops number.");
 227   return getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop];
 228 }
 229
 230 const Expr *OMPOrderedClause::getLoopCunter(unsigned NumLoop) const {
 231   assert(NumLoop < NumberOfLoops && "out of loops number.");
 232   return getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop];
 233 }
 234
 235 void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
 236   assert(VL.size() == varlist_size() &&
 237          "Number of private copies is not the same as the preallocated buffer");
 238   std::copy(VL.begin(), VL.end(), varlist_end());
 239 }
 240
 241 OMPPrivateClause *
 242 OMPPrivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
 243                          SourceLocation LParenLoc, SourceLocation EndLoc,
 244                          ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) {
 245   // Allocate space for private variables and initializer expressions.
 246   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * VL.size()));
 247   OMPPrivateClause *Clause =
 248       new (Mem) OMPPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
 249   Clause->setVarRefs(VL);
 250   Clause->setPrivateCopies(PrivateVL);
 251   return Clause;
 252 }
 253
 254 OMPPrivateClause *OMPPrivateClause::CreateEmpty(const ASTContext &C,
 255                                                 unsigned N) {
 256   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * N));
 257   return new (Mem) OMPPrivateClause(N);
 258 }
 259
 260 void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
 261   assert(VL.size() == varlist_size() &&
 262          "Number of private copies is not the same as the preallocated buffer");
 263   std::copy(VL.begin(), VL.end(), varlist_end());
 264 }
 265
 266 void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) {
 267   assert(VL.size() == varlist_size() &&
 268          "Number of inits is not the same as the preallocated buffer");
 269   std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
 270 }
 271
 272 OMPFirstprivateClause *
 273 OMPFirstprivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
 274                               SourceLocation LParenLoc, SourceLocation EndLoc,
 275                               ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
 276                               ArrayRef<Expr *> InitVL, Stmt *PreInit) {
 277   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * VL.size()));
 278   OMPFirstprivateClause *Clause =
 279       new (Mem) OMPFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
 280   Clause->setVarRefs(VL);
 281   Clause->setPrivateCopies(PrivateVL);
 282   Clause->setInits(InitVL);
 283   Clause->setPreInitStmt(PreInit);
 284   return Clause;
 285 }
 286
 287 OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C,
 288                                                           unsigned N) {
 289   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * N));
 290   return new (Mem) OMPFirstprivateClause(N);
 291 }
 292
 293 void OMPLastprivateClause::setPrivateCopies(ArrayRef<Expr *> PrivateCopies) {
 294   assert(PrivateCopies.size() == varlist_size() &&
 295          "Number of private copies is not the same as the preallocated buffer");
 296   std::copy(PrivateCopies.begin(), PrivateCopies.end(), varlist_end());
 297 }
 298
 299 void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
 300   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
 301                                               "not the same as the "
 302                                               "preallocated buffer");
 303   std::copy(SrcExprs.begin(), SrcExprs.end(), getPrivateCopies().end());
 304 }
 305
 306 void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
 307   assert(DstExprs.size() == varlist_size() && "Number of destination "
 308                                               "expressions is not the same as "
 309                                               "the preallocated buffer");
 310   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
 311 }
 312
 313 void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
 314   assert(AssignmentOps.size() == varlist_size() &&
 315          "Number of assignment expressions is not the same as the preallocated "
 316          "buffer");
 317   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
 318             getDestinationExprs().end());
 319 }
 320
 321 OMPLastprivateClause *OMPLastprivateClause::Create(
 322     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
 323     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
 324     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps, Stmt *PreInit,
 325     Expr *PostUpdate) {
 326   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
 327   OMPLastprivateClause *Clause =
 328       new (Mem) OMPLastprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
 329   Clause->setVarRefs(VL);
 330   Clause->setSourceExprs(SrcExprs);
 331   Clause->setDestinationExprs(DstExprs);
 332   Clause->setAssignmentOps(AssignmentOps);
 333   Clause->setPreInitStmt(PreInit);
 334   Clause->setPostUpdateExpr(PostUpdate);
 335   return Clause;
 336 }
 337
 338 OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C,
 339                                                         unsigned N) {
 340   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
 341   return new (Mem) OMPLastprivateClause(N);
 342 }
 343
 344 OMPSharedClause *OMPSharedClause::Create(const ASTContext &C,
 345                                          SourceLocation StartLoc,
 346                                          SourceLocation LParenLoc,
 347                                          SourceLocation EndLoc,
 348                                          ArrayRef<Expr *> VL) {
 349   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
 350   OMPSharedClause *Clause =
 351       new (Mem) OMPSharedClause(StartLoc, LParenLoc, EndLoc, VL.size());
 352   Clause->setVarRefs(VL);
 353   return Clause;
 354 }
 355
 356 OMPSharedClause *OMPSharedClause::CreateEmpty(const ASTContext &C, unsigned N) {
 357   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
 358   return new (Mem) OMPSharedClause(N);
 359 }
 360
 361 void OMPLinearClause::setPrivates(ArrayRef<Expr *> PL) {
 362   assert(PL.size() == varlist_size() &&
 363          "Number of privates is not the same as the preallocated buffer");
 364   std::copy(PL.begin(), PL.end(), varlist_end());
 365 }
 366
 367 void OMPLinearClause::setInits(ArrayRef<Expr *> IL) {
 368   assert(IL.size() == varlist_size() &&
 369          "Number of inits is not the same as the preallocated buffer");
 370   std::copy(IL.begin(), IL.end(), getPrivates().end());
 371 }
 372
 373 void OMPLinearClause::setUpdates(ArrayRef<Expr *> UL) {
 374   assert(UL.size() == varlist_size() &&
 375          "Number of updates is not the same as the preallocated buffer");
 376   std::copy(UL.begin(), UL.end(), getInits().end());
 377 }
 378
 379 void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) {
 380   assert(FL.size() == varlist_size() &&
 381          "Number of final updates is not the same as the preallocated buffer");
 382   std::copy(FL.begin(), FL.end(), getUpdates().end());
 383 }
 384
 385 OMPLinearClause *OMPLinearClause::Create(
 386     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
 387     OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
 388     SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
 389     ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
 390     Stmt *PreInit, Expr *PostUpdate) {
 391   // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
 392   // (Step and CalcStep).
 393   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2));
 394   OMPLinearClause *Clause = new (Mem) OMPLinearClause(
 395       StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc, EndLoc, VL.size());
 396   Clause->setVarRefs(VL);
 397   Clause->setPrivates(PL);
 398   Clause->setInits(IL);
 399   // Fill update and final expressions with zeroes, they are provided later,
 400   // after the directive construction.
 401   std::fill(Clause->getInits().end(), Clause->getInits().end() + VL.size(),
 402             nullptr);
 403   std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(),
 404             nullptr);
 405   Clause->setStep(Step);
 406   Clause->setCalcStep(CalcStep);
 407   Clause->setPreInitStmt(PreInit);
 408   Clause->setPostUpdateExpr(PostUpdate);
 409   return Clause;
 410 }
 411
 412 OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C,
 413                                               unsigned NumVars) {
 414   // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
 415   // (Step and CalcStep).
 416   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2));
 417   return new (Mem) OMPLinearClause(NumVars);
 418 }
 419
 420 OMPAlignedClause *
 421 OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc,
 422                          SourceLocation LParenLoc, SourceLocation ColonLoc,
 423                          SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) {
 424   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
 425   OMPAlignedClause *Clause = new (Mem)
 426       OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
 427   Clause->setVarRefs(VL);
 428   Clause->setAlignment(A);
 429   return Clause;
 430 }
 431
 432 OMPAlignedClause *OMPAlignedClause::CreateEmpty(const ASTContext &C,
 433                                                 unsigned NumVars) {
 434   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumVars + 1));
 435   return new (Mem) OMPAlignedClause(NumVars);
 436 }
 437
 438 void OMPCopyinClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
 439   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
 440                                               "not the same as the "
 441                                               "preallocated buffer");
 442   std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
 443 }
 444
 445 void OMPCopyinClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
 446   assert(DstExprs.size() == varlist_size() && "Number of destination "
 447                                               "expressions is not the same as "
 448                                               "the preallocated buffer");
 449   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
 450 }
 451
 452 void OMPCopyinClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
 453   assert(AssignmentOps.size() == varlist_size() &&
 454          "Number of assignment expressions is not the same as the preallocated "
 455          "buffer");
 456   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
 457             getDestinationExprs().end());
 458 }
 459
 460 OMPCopyinClause *OMPCopyinClause::Create(
 461     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
 462     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
 463     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
 464   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
 465   OMPCopyinClause *Clause =
 466       new (Mem) OMPCopyinClause(StartLoc, LParenLoc, EndLoc, VL.size());
 467   Clause->setVarRefs(VL);
 468   Clause->setSourceExprs(SrcExprs);
 469   Clause->setDestinationExprs(DstExprs);
 470   Clause->setAssignmentOps(AssignmentOps);
 471   return Clause;
 472 }
 473
 474 OMPCopyinClause *OMPCopyinClause::CreateEmpty(const ASTContext &C, unsigned N) {
 475   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
 476   return new (Mem) OMPCopyinClause(N);
 477 }
 478
 479 void OMPCopyprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
 480   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
 481                                               "not the same as the "
 482                                               "preallocated buffer");
 483   std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
 484 }
 485
 486 void OMPCopyprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
 487   assert(DstExprs.size() == varlist_size() && "Number of destination "
 488                                               "expressions is not the same as "
 489                                               "the preallocated buffer");
 490   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
 491 }
 492
 493 void OMPCopyprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
 494   assert(AssignmentOps.size() == varlist_size() &&
 495          "Number of assignment expressions is not the same as the preallocated "
 496          "buffer");
 497   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
 498             getDestinationExprs().end());
 499 }
 500
 501 OMPCopyprivateClause *OMPCopyprivateClause::Create(
 502     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
 503     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
 504     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
 505   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
 506   OMPCopyprivateClause *Clause =
 507       new (Mem) OMPCopyprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
 508   Clause->setVarRefs(VL);
 509   Clause->setSourceExprs(SrcExprs);
 510   Clause->setDestinationExprs(DstExprs);
 511   Clause->setAssignmentOps(AssignmentOps);
 512   return Clause;
 513 }
 514
 515 OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(const ASTContext &C,
 516                                                         unsigned N) {
 517   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
 518   return new (Mem) OMPCopyprivateClause(N);
 519 }
 520
 521 void OMPReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
 522   assert(Privates.size() == varlist_size() &&
 523          "Number of private copies is not the same as the preallocated buffer");
 524   std::copy(Privates.begin(), Privates.end(), varlist_end());
 525 }
 526
 527 void OMPReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
 528   assert(
 529       LHSExprs.size() == varlist_size() &&
 530       "Number of LHS expressions is not the same as the preallocated buffer");
 531   std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
 532 }
 533
 534 void OMPReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
 535   assert(
 536       RHSExprs.size() == varlist_size() &&
 537       "Number of RHS expressions is not the same as the preallocated buffer");
 538   std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
 539 }
 540
 541 void OMPReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
 542   assert(ReductionOps.size() == varlist_size() && "Number of reduction "
 543                                                   "expressions is not the same "
 544                                                   "as the preallocated buffer");
 545   std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
 546 }
 547
 548 OMPReductionClause *OMPReductionClause::Create(
 549     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
 550     SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
 551     NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
 552     ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
 553     ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
 554     Expr *PostUpdate) {
 555   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
 556   OMPReductionClause *Clause = new (Mem) OMPReductionClause(
 557       StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
 558   Clause->setVarRefs(VL);
 559   Clause->setPrivates(Privates);
 560   Clause->setLHSExprs(LHSExprs);
 561   Clause->setRHSExprs(RHSExprs);
 562   Clause->setReductionOps(ReductionOps);
 563   Clause->setPreInitStmt(PreInit);
 564   Clause->setPostUpdateExpr(PostUpdate);
 565   return Clause;
 566 }
 567
 568 OMPReductionClause *OMPReductionClause::CreateEmpty(const ASTContext &C,
 569                                                     unsigned N) {
 570   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
 571   return new (Mem) OMPReductionClause(N);
 572 }
 573
 574 void OMPTaskReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
 575   assert(Privates.size() == varlist_size() &&
 576          "Number of private copies is not the same as the preallocated buffer");
 577   std::copy(Privates.begin(), Privates.end(), varlist_end());
 578 }
 579
 580 void OMPTaskReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
 581   assert(
 582       LHSExprs.size() == varlist_size() &&
 583       "Number of LHS expressions is not the same as the preallocated buffer");
 584   std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
 585 }
 586
 587 void OMPTaskReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
 588   assert(
 589       RHSExprs.size() == varlist_size() &&
 590       "Number of RHS expressions is not the same as the preallocated buffer");
 591   std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
 592 }
 593
 594 void OMPTaskReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
 595   assert(ReductionOps.size() == varlist_size() && "Number of task reduction "
 596                                                   "expressions is not the same "
 597                                                   "as the preallocated buffer");
 598   std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
 599 }
 600
 601 OMPTaskReductionClause *OMPTaskReductionClause::Create(
 602     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
 603     SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
 604     NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
 605     ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
 606     ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
 607     Expr *PostUpdate) {
 608   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
 609   OMPTaskReductionClause *Clause = new (Mem) OMPTaskReductionClause(
 610       StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
 611   Clause->setVarRefs(VL);
 612   Clause->setPrivates(Privates);
 613   Clause->setLHSExprs(LHSExprs);
 614   Clause->setRHSExprs(RHSExprs);
 615   Clause->setReductionOps(ReductionOps);
 616   Clause->setPreInitStmt(PreInit);
 617   Clause->setPostUpdateExpr(PostUpdate);
 618   return Clause;
 619 }
 620
 621 OMPTaskReductionClause *OMPTaskReductionClause::CreateEmpty(const ASTContext &C,
 622                                                             unsigned N) {
 623   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
 624   return new (Mem) OMPTaskReductionClause(N);
 625 }
 626
 627 void OMPInReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
 628   assert(Privates.size() == varlist_size() &&
 629          "Number of private copies is not the same as the preallocated buffer");
 630   std::copy(Privates.begin(), Privates.end(), varlist_end());
 631 }
 632
 633 void OMPInReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
 634   assert(
 635       LHSExprs.size() == varlist_size() &&
 636       "Number of LHS expressions is not the same as the preallocated buffer");
 637   std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
 638 }
 639
 640 void OMPInReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
 641   assert(
 642       RHSExprs.size() == varlist_size() &&
 643       "Number of RHS expressions is not the same as the preallocated buffer");
 644   std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
 645 }
 646
 647 void OMPInReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
 648   assert(ReductionOps.size() == varlist_size() && "Number of in reduction "
 649                                                   "expressions is not the same "
 650                                                   "as the preallocated buffer");
 651   std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
 652 }
 653
 654 void OMPInReductionClause::setTaskgroupDescriptors(
 655     ArrayRef<Expr *> TaskgroupDescriptors) {
 656   assert(TaskgroupDescriptors.size() == varlist_size() &&
 657          "Number of in reduction descriptors is not the same as the "
 658          "preallocated buffer");
 659   std::copy(TaskgroupDescriptors.begin(), TaskgroupDescriptors.end(),
 660             getReductionOps().end());
 661 }
 662
 663 OMPInReductionClause *OMPInReductionClause::Create(
 664     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
 665     SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
 666     NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
 667     ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
 668     ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps,
 669     ArrayRef<Expr *> TaskgroupDescriptors, Stmt *PreInit, Expr *PostUpdate) {
 670   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(6 * VL.size()));
 671   OMPInReductionClause *Clause = new (Mem) OMPInReductionClause(
 672       StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
 673   Clause->setVarRefs(VL);
 674   Clause->setPrivates(Privates);
 675   Clause->setLHSExprs(LHSExprs);
 676   Clause->setRHSExprs(RHSExprs);
 677   Clause->setReductionOps(ReductionOps);
 678   Clause->setTaskgroupDescriptors(TaskgroupDescriptors);
 679   Clause->setPreInitStmt(PreInit);
 680   Clause->setPostUpdateExpr(PostUpdate);
 681   return Clause;
 682 }
 683
 684 OMPInReductionClause *OMPInReductionClause::CreateEmpty(const ASTContext &C,
 685                                                         unsigned N) {
 686   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(6 * N));
 687   return new (Mem) OMPInReductionClause(N);
 688 }
 689
 690 OMPFlushClause *OMPFlushClause::Create(const ASTContext &C,
 691                                        SourceLocation StartLoc,
 692                                        SourceLocation LParenLoc,
 693                                        SourceLocation EndLoc,
 694                                        ArrayRef<Expr *> VL) {
 695   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
 696   OMPFlushClause *Clause =
 697       new (Mem) OMPFlushClause(StartLoc, LParenLoc, EndLoc, VL.size());
 698   Clause->setVarRefs(VL);
 699   return Clause;
 700 }
 701
 702 OMPFlushClause *OMPFlushClause::CreateEmpty(const ASTContext &C, unsigned N) {
 703   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
 704   return new (Mem) OMPFlushClause(N);
 705 }
 706
 707 OMPDependClause *
 708 OMPDependClause::Create(const ASTContext &C, SourceLocation StartLoc,
 709                         SourceLocation LParenLoc, SourceLocation EndLoc,
 710                         OpenMPDependClauseKind DepKind, SourceLocation DepLoc,
 711                         SourceLocation ColonLoc, ArrayRef<Expr *> VL,
 712                         unsigned NumLoops) {
 713   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + NumLoops));
 714   OMPDependClause *Clause = new (Mem)
 715       OMPDependClause(StartLoc, LParenLoc, EndLoc, VL.size(), NumLoops);
 716   Clause->setVarRefs(VL);
 717   Clause->setDependencyKind(DepKind);
 718   Clause->setDependencyLoc(DepLoc);
 719   Clause->setColonLoc(ColonLoc);
 720   for (unsigned I = 0 ; I < NumLoops; ++I)
 721     Clause->setLoopData(I, nullptr);
 722   return Clause;
 723 }
 724
 725 OMPDependClause *OMPDependClause::CreateEmpty(const ASTContext &C, unsigned N,
 726                                               unsigned NumLoops) {
 727   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N + NumLoops));
 728   return new (Mem) OMPDependClause(N, NumLoops);
 729 }
 730
 731 void OMPDependClause::setLoopData(unsigned NumLoop, Expr *Cnt) {
 732   assert((getDependencyKind() == OMPC_DEPEND_sink ||
 733           getDependencyKind() == OMPC_DEPEND_source) &&
 734          NumLoop < NumLoops &&
 735          "Expected sink or source depend + loop index must be less number of "
 736          "loops.");
 737   auto It = std::next(getVarRefs().end(), NumLoop);
 738   *It = Cnt;
 739 }
 740
 741 Expr *OMPDependClause::getLoopData(unsigned NumLoop) {
 742   assert((getDependencyKind() == OMPC_DEPEND_sink ||
 743           getDependencyKind() == OMPC_DEPEND_source) &&
 744          NumLoop < NumLoops &&
 745          "Expected sink or source depend + loop index must be less number of "
 746          "loops.");
 747   auto It = std::next(getVarRefs().end(), NumLoop);
 748   return *It;
 749 }
 750
 751 const Expr *OMPDependClause::getLoopData(unsigned NumLoop) const {
 752   assert((getDependencyKind() == OMPC_DEPEND_sink ||
 753           getDependencyKind() == OMPC_DEPEND_source) &&
 754          NumLoop < NumLoops &&
 755          "Expected sink or source depend + loop index must be less number of "
 756          "loops.");
 757   auto It = std::next(getVarRefs().end(), NumLoop);
 758   return *It;
 759 }
 760
 761 unsigned OMPClauseMappableExprCommon::getComponentsTotalNumber(
 762     MappableExprComponentListsRef ComponentLists) {
 763   unsigned TotalNum = 0u;
 764   for (auto &C : ComponentLists)
 765     TotalNum += C.size();
 766   return TotalNum;
 767 }
 768
 769 unsigned OMPClauseMappableExprCommon::getUniqueDeclarationsTotalNumber(
 770     ArrayRef<const ValueDecl *> Declarations) {
 771   unsigned TotalNum = 0u;
 772   llvm::SmallPtrSet<const ValueDecl *, 8> Cache;
 773   for (const ValueDecl *D : Declarations) {
 774     const ValueDecl *VD = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr;
 775     if (Cache.count(VD))
 776       continue;
 777     ++TotalNum;
 778     Cache.insert(VD);
 779   }
 780   return TotalNum;
 781 }
 782
 783 OMPMapClause *
 784 OMPMapClause::Create(const ASTContext &C, SourceLocation StartLoc,
 785                      SourceLocation LParenLoc, SourceLocation EndLoc,
 786                      ArrayRef<Expr *> Vars, ArrayRef<ValueDecl *> Declarations,
 787                      MappableExprComponentListsRef ComponentLists,
 788                      OpenMPMapClauseKind TypeModifier, OpenMPMapClauseKind Type,
 789                      bool TypeIsImplicit, SourceLocation TypeLoc) {
 790   unsigned NumVars = Vars.size();
 791   unsigned NumUniqueDeclarations =
 792       getUniqueDeclarationsTotalNumber(Declarations);
 793   unsigned NumComponentLists = ComponentLists.size();
 794   unsigned NumComponents = getComponentsTotalNumber(ComponentLists);
 795
 796   // We need to allocate:
 797   // NumVars x Expr* - we have an original list expression for each clause list
 798   // entry.
 799   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
 800   // with each component list.
 801   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
 802   // number of lists for each unique declaration and the size of each component
 803   // list.
 804   // NumComponents x MappableComponent - the total of all the components in all
 805   // the lists.
 806   void *Mem = C.Allocate(
 807       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
 808                        OMPClauseMappableExprCommon::MappableComponent>(
 809           NumVars, NumUniqueDeclarations,
 810           NumUniqueDeclarations + NumComponentLists, NumComponents));
 811   OMPMapClause *Clause = new (Mem) OMPMapClause(
 812       TypeModifier, Type, TypeIsImplicit, TypeLoc, StartLoc, LParenLoc, EndLoc,
 813       NumVars, NumUniqueDeclarations, NumComponentLists, NumComponents);
 814
 815   Clause->setVarRefs(Vars);
 816   Clause->setClauseInfo(Declarations, ComponentLists);
 817   Clause->setMapTypeModifier(TypeModifier);
 818   Clause->setMapType(Type);
 819   Clause->setMapLoc(TypeLoc);
 820   return Clause;
 821 }
 822
 823 OMPMapClause *OMPMapClause::CreateEmpty(const ASTContext &C, unsigned NumVars,
 824                                         unsigned NumUniqueDeclarations,
 825                                         unsigned NumComponentLists,
 826                                         unsigned NumComponents) {
 827   void *Mem = C.Allocate(
 828       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
 829                        OMPClauseMappableExprCommon::MappableComponent>(
 830           NumVars, NumUniqueDeclarations,
 831           NumUniqueDeclarations + NumComponentLists, NumComponents));
 832   return new (Mem) OMPMapClause(NumVars, NumUniqueDeclarations,
 833                                 NumComponentLists, NumComponents);
 834 }
 835
 836 OMPToClause *OMPToClause::Create(const ASTContext &C, SourceLocation StartLoc,
 837                                  SourceLocation LParenLoc,
 838                                  SourceLocation EndLoc, ArrayRef<Expr *> Vars,
 839                                  ArrayRef<ValueDecl *> Declarations,
 840                                  MappableExprComponentListsRef ComponentLists) {
 841   unsigned NumVars = Vars.size();
 842   unsigned NumUniqueDeclarations =
 843       getUniqueDeclarationsTotalNumber(Declarations);
 844   unsigned NumComponentLists = ComponentLists.size();
 845   unsigned NumComponents = getComponentsTotalNumber(ComponentLists);
 846
 847   // We need to allocate:
 848   // NumVars x Expr* - we have an original list expression for each clause list
 849   // entry.
 850   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
 851   // with each component list.
 852   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
 853   // number of lists for each unique declaration and the size of each component
 854   // list.
 855   // NumComponents x MappableComponent - the total of all the components in all
 856   // the lists.
 857   void *Mem = C.Allocate(
 858       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
 859                        OMPClauseMappableExprCommon::MappableComponent>(
 860           NumVars, NumUniqueDeclarations,
 861           NumUniqueDeclarations + NumComponentLists, NumComponents));
 862
 863   OMPToClause *Clause = new (Mem)
 864       OMPToClause(StartLoc, LParenLoc, EndLoc, NumVars, NumUniqueDeclarations,
 865                   NumComponentLists, NumComponents);
 866
 867   Clause->setVarRefs(Vars);
 868   Clause->setClauseInfo(Declarations, ComponentLists);
 869   return Clause;
 870 }
 871
 872 OMPToClause *OMPToClause::CreateEmpty(const ASTContext &C, unsigned NumVars,
 873                                       unsigned NumUniqueDeclarations,
 874                                       unsigned NumComponentLists,
 875                                       unsigned NumComponents) {
 876   void *Mem = C.Allocate(
 877       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
 878                        OMPClauseMappableExprCommon::MappableComponent>(
 879           NumVars, NumUniqueDeclarations,
 880           NumUniqueDeclarations + NumComponentLists, NumComponents));
 881   return new (Mem) OMPToClause(NumVars, NumUniqueDeclarations,
 882                                NumComponentLists, NumComponents);
 883 }
 884
 885 OMPFromClause *
 886 OMPFromClause::Create(const ASTContext &C, SourceLocation StartLoc,
 887                       SourceLocation LParenLoc, SourceLocation EndLoc,
 888                       ArrayRef<Expr *> Vars, ArrayRef<ValueDecl *> Declarations,
 889                       MappableExprComponentListsRef ComponentLists) {
 890   unsigned NumVars = Vars.size();
 891   unsigned NumUniqueDeclarations =
 892       getUniqueDeclarationsTotalNumber(Declarations);
 893   unsigned NumComponentLists = ComponentLists.size();
 894   unsigned NumComponents = getComponentsTotalNumber(ComponentLists);
 895
 896   // We need to allocate:
 897   // NumVars x Expr* - we have an original list expression for each clause list
 898   // entry.
 899   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
 900   // with each component list.
 901   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
 902   // number of lists for each unique declaration and the size of each component
 903   // list.
 904   // NumComponents x MappableComponent - the total of all the components in all
 905   // the lists.
 906   void *Mem = C.Allocate(
 907       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
 908                        OMPClauseMappableExprCommon::MappableComponent>(
 909           NumVars, NumUniqueDeclarations,
 910           NumUniqueDeclarations + NumComponentLists, NumComponents));
 911
 912   OMPFromClause *Clause = new (Mem)
 913       OMPFromClause(StartLoc, LParenLoc, EndLoc, NumVars, NumUniqueDeclarations,
 914                     NumComponentLists, NumComponents);
 915
 916   Clause->setVarRefs(Vars);
 917   Clause->setClauseInfo(Declarations, ComponentLists);
 918   return Clause;
 919 }
 920
 921 OMPFromClause *OMPFromClause::CreateEmpty(const ASTContext &C, unsigned NumVars,
 922                                           unsigned NumUniqueDeclarations,
 923                                           unsigned NumComponentLists,
 924                                           unsigned NumComponents) {
 925   void *Mem = C.Allocate(
 926       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
 927                        OMPClauseMappableExprCommon::MappableComponent>(
 928           NumVars, NumUniqueDeclarations,
 929           NumUniqueDeclarations + NumComponentLists, NumComponents));
 930   return new (Mem) OMPFromClause(NumVars, NumUniqueDeclarations,
 931                                  NumComponentLists, NumComponents);
 932 }
 933
 934 void OMPUseDevicePtrClause::setPrivateCopies(ArrayRef<Expr *> VL) {
 935   assert(VL.size() == varlist_size() &&
 936          "Number of private copies is not the same as the preallocated buffer");
 937   std::copy(VL.begin(), VL.end(), varlist_end());
 938 }
 939
 940 void OMPUseDevicePtrClause::setInits(ArrayRef<Expr *> VL) {
 941   assert(VL.size() == varlist_size() &&
 942          "Number of inits is not the same as the preallocated buffer");
 943   std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
 944 }
 945
 946 OMPUseDevicePtrClause *OMPUseDevicePtrClause::Create(
 947     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
 948     SourceLocation EndLoc, ArrayRef<Expr *> Vars, ArrayRef<Expr *> PrivateVars,
 949     ArrayRef<Expr *> Inits, ArrayRef<ValueDecl *> Declarations,
 950     MappableExprComponentListsRef ComponentLists) {
 951   unsigned NumVars = Vars.size();
 952   unsigned NumUniqueDeclarations =
 953       getUniqueDeclarationsTotalNumber(Declarations);
 954   unsigned NumComponentLists = ComponentLists.size();
 955   unsigned NumComponents = getComponentsTotalNumber(ComponentLists);
 956
 957   // We need to allocate:
 958   // 3 x NumVars x Expr* - we have an original list expression for each clause
 959   // list entry and an equal number of private copies and inits.
 960   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
 961   // with each component list.
 962   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
 963   // number of lists for each unique declaration and the size of each component
 964   // list.
 965   // NumComponents x MappableComponent - the total of all the components in all
 966   // the lists.
 967   void *Mem = C.Allocate(
 968       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
 969                        OMPClauseMappableExprCommon::MappableComponent>(
 970           3 * NumVars, NumUniqueDeclarations,
 971           NumUniqueDeclarations + NumComponentLists, NumComponents));
 972
 973   OMPUseDevicePtrClause *Clause = new (Mem) OMPUseDevicePtrClause(
 974       StartLoc, LParenLoc, EndLoc, NumVars, NumUniqueDeclarations,
 975       NumComponentLists, NumComponents);
 976
 977   Clause->setVarRefs(Vars);
 978   Clause->setPrivateCopies(PrivateVars);
 979   Clause->setInits(Inits);
 980   Clause->setClauseInfo(Declarations, ComponentLists);
 981   return Clause;
 982 }
 983
 984 OMPUseDevicePtrClause *OMPUseDevicePtrClause::CreateEmpty(
 985     const ASTContext &C, unsigned NumVars, unsigned NumUniqueDeclarations,
 986     unsigned NumComponentLists, unsigned NumComponents) {
 987   void *Mem = C.Allocate(
 988       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
 989                        OMPClauseMappableExprCommon::MappableComponent>(
 990           3 * NumVars, NumUniqueDeclarations,
 991           NumUniqueDeclarations + NumComponentLists, NumComponents));
 992   return new (Mem) OMPUseDevicePtrClause(NumVars, NumUniqueDeclarations,
 993                                          NumComponentLists, NumComponents);
 994 }
 995
 996 OMPIsDevicePtrClause *
 997 OMPIsDevicePtrClause::Create(const ASTContext &C, SourceLocation StartLoc,
 998                              SourceLocation LParenLoc, SourceLocation EndLoc,
 999                              ArrayRef<Expr *> Vars,
1000                              ArrayRef<ValueDecl *> Declarations,
1001                              MappableExprComponentListsRef ComponentLists) {
1002   unsigned NumVars = Vars.size();
1003   unsigned NumUniqueDeclarations =
1004       getUniqueDeclarationsTotalNumber(Declarations);
1005   unsigned NumComponentLists = ComponentLists.size();
1006   unsigned NumComponents = getComponentsTotalNumber(ComponentLists);
1007
1008   // We need to allocate:
1009   // NumVars x Expr* - we have an original list expression for each clause list
1010   // entry.
1011   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1012   // with each component list.
1013   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1014   // number of lists for each unique declaration and the size of each component
1015   // list.
1016   // NumComponents x MappableComponent - the total of all the components in all
1017   // the lists.
1018   void *Mem = C.Allocate(
1019       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1020                        OMPClauseMappableExprCommon::MappableComponent>(
1021           NumVars, NumUniqueDeclarations,
1022           NumUniqueDeclarations + NumComponentLists, NumComponents));
1023
1024   OMPIsDevicePtrClause *Clause = new (Mem) OMPIsDevicePtrClause(
1025       StartLoc, LParenLoc, EndLoc, NumVars, NumUniqueDeclarations,
1026       NumComponentLists, NumComponents);
1027
1028   Clause->setVarRefs(Vars);
1029   Clause->setClauseInfo(Declarations, ComponentLists);
1030   return Clause;
1031 }
1032
1033 OMPIsDevicePtrClause *OMPIsDevicePtrClause::CreateEmpty(
1034     const ASTContext &C, unsigned NumVars, unsigned NumUniqueDeclarations,
1035     unsigned NumComponentLists, unsigned NumComponents) {
1036   void *Mem = C.Allocate(
1037       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1038                        OMPClauseMappableExprCommon::MappableComponent>(
1039           NumVars, NumUniqueDeclarations,
1040           NumUniqueDeclarations + NumComponentLists, NumComponents));
1041   return new (Mem) OMPIsDevicePtrClause(NumVars, NumUniqueDeclarations,
1042                                         NumComponentLists, NumComponents);
1043 }