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

   1 //===- OpenMPClause.cpp - Classes for OpenMP clauses ----------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements the subclesses of Stmt class declared in OpenMPClause.h
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "clang/AST/OpenMPClause.h"
  14 #include "clang/AST/ASTContext.h"
  15 #include "clang/AST/Decl.h"
  16 #include "clang/AST/DeclOpenMP.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 OMPClause::child_range OMPClause::used_children() {
  39   switch (getClauseKind()) {
  40 #define OPENMP_CLAUSE(Name, Class)                                             \
  41   case OMPC_##Name:                                                            \
  42     return static_cast<Class *>(this)->used_children();
  43 #include "clang/Basic/OpenMPKinds.def"
  44   case OMPC_threadprivate:
  45   case OMPC_uniform:
  46   case OMPC_device_type:
  47   case OMPC_match:
  48   case OMPC_unknown:
  49     break;
  50   }
  51   llvm_unreachable("unknown OMPClause");
  52 }
  53
  54 OMPClauseWithPreInit *OMPClauseWithPreInit::get(OMPClause *C) {
  55   auto *Res = OMPClauseWithPreInit::get(const_cast<const OMPClause *>(C));
  56   return Res ? const_cast<OMPClauseWithPreInit *>(Res) : nullptr;
  57 }
  58
  59 const OMPClauseWithPreInit *OMPClauseWithPreInit::get(const OMPClause *C) {
  60   switch (C->getClauseKind()) {
  61   case OMPC_schedule:
  62     return static_cast<const OMPScheduleClause *>(C);
  63   case OMPC_dist_schedule:
  64     return static_cast<const OMPDistScheduleClause *>(C);
  65   case OMPC_firstprivate:
  66     return static_cast<const OMPFirstprivateClause *>(C);
  67   case OMPC_lastprivate:
  68     return static_cast<const OMPLastprivateClause *>(C);
  69   case OMPC_reduction:
  70     return static_cast<const OMPReductionClause *>(C);
  71   case OMPC_task_reduction:
  72     return static_cast<const OMPTaskReductionClause *>(C);
  73   case OMPC_in_reduction:
  74     return static_cast<const OMPInReductionClause *>(C);
  75   case OMPC_linear:
  76     return static_cast<const OMPLinearClause *>(C);
  77   case OMPC_if:
  78     return static_cast<const OMPIfClause *>(C);
  79   case OMPC_num_threads:
  80     return static_cast<const OMPNumThreadsClause *>(C);
  81   case OMPC_num_teams:
  82     return static_cast<const OMPNumTeamsClause *>(C);
  83   case OMPC_thread_limit:
  84     return static_cast<const OMPThreadLimitClause *>(C);
  85   case OMPC_device:
  86     return static_cast<const OMPDeviceClause *>(C);
  87   case OMPC_grainsize:
  88     return static_cast<const OMPGrainsizeClause *>(C);
  89   case OMPC_num_tasks:
  90     return static_cast<const OMPNumTasksClause *>(C);
  91   case OMPC_final:
  92     return static_cast<const OMPFinalClause *>(C);
  93   case OMPC_priority:
  94     return static_cast<const OMPPriorityClause *>(C);
  95   case OMPC_default:
  96   case OMPC_proc_bind:
  97   case OMPC_safelen:
  98   case OMPC_simdlen:
  99   case OMPC_allocator:
 100   case OMPC_allocate:
 101   case OMPC_collapse:
 102   case OMPC_private:
 103   case OMPC_shared:
 104   case OMPC_aligned:
 105   case OMPC_copyin:
 106   case OMPC_copyprivate:
 107   case OMPC_ordered:
 108   case OMPC_nowait:
 109   case OMPC_untied:
 110   case OMPC_mergeable:
 111   case OMPC_threadprivate:
 112   case OMPC_flush:
 113   case OMPC_read:
 114   case OMPC_write:
 115   case OMPC_update:
 116   case OMPC_capture:
 117   case OMPC_seq_cst:
 118   case OMPC_depend:
 119   case OMPC_threads:
 120   case OMPC_simd:
 121   case OMPC_map:
 122   case OMPC_nogroup:
 123   case OMPC_hint:
 124   case OMPC_defaultmap:
 125   case OMPC_unknown:
 126   case OMPC_uniform:
 127   case OMPC_to:
 128   case OMPC_from:
 129   case OMPC_use_device_ptr:
 130   case OMPC_is_device_ptr:
 131   case OMPC_unified_address:
 132   case OMPC_unified_shared_memory:
 133   case OMPC_reverse_offload:
 134   case OMPC_dynamic_allocators:
 135   case OMPC_atomic_default_mem_order:
 136   case OMPC_device_type:
 137   case OMPC_match:
 138     break;
 139   }
 140
 141   return nullptr;
 142 }
 143
 144 OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(OMPClause *C) {
 145   auto *Res = OMPClauseWithPostUpdate::get(const_cast<const OMPClause *>(C));
 146   return Res ? const_cast<OMPClauseWithPostUpdate *>(Res) : nullptr;
 147 }
 148
 149 const OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(const OMPClause *C) {
 150   switch (C->getClauseKind()) {
 151   case OMPC_lastprivate:
 152     return static_cast<const OMPLastprivateClause *>(C);
 153   case OMPC_reduction:
 154     return static_cast<const OMPReductionClause *>(C);
 155   case OMPC_task_reduction:
 156     return static_cast<const OMPTaskReductionClause *>(C);
 157   case OMPC_in_reduction:
 158     return static_cast<const OMPInReductionClause *>(C);
 159   case OMPC_linear:
 160     return static_cast<const OMPLinearClause *>(C);
 161   case OMPC_schedule:
 162   case OMPC_dist_schedule:
 163   case OMPC_firstprivate:
 164   case OMPC_default:
 165   case OMPC_proc_bind:
 166   case OMPC_if:
 167   case OMPC_final:
 168   case OMPC_num_threads:
 169   case OMPC_safelen:
 170   case OMPC_simdlen:
 171   case OMPC_allocator:
 172   case OMPC_allocate:
 173   case OMPC_collapse:
 174   case OMPC_private:
 175   case OMPC_shared:
 176   case OMPC_aligned:
 177   case OMPC_copyin:
 178   case OMPC_copyprivate:
 179   case OMPC_ordered:
 180   case OMPC_nowait:
 181   case OMPC_untied:
 182   case OMPC_mergeable:
 183   case OMPC_threadprivate:
 184   case OMPC_flush:
 185   case OMPC_read:
 186   case OMPC_write:
 187   case OMPC_update:
 188   case OMPC_capture:
 189   case OMPC_seq_cst:
 190   case OMPC_depend:
 191   case OMPC_device:
 192   case OMPC_threads:
 193   case OMPC_simd:
 194   case OMPC_map:
 195   case OMPC_num_teams:
 196   case OMPC_thread_limit:
 197   case OMPC_priority:
 198   case OMPC_grainsize:
 199   case OMPC_nogroup:
 200   case OMPC_num_tasks:
 201   case OMPC_hint:
 202   case OMPC_defaultmap:
 203   case OMPC_unknown:
 204   case OMPC_uniform:
 205   case OMPC_to:
 206   case OMPC_from:
 207   case OMPC_use_device_ptr:
 208   case OMPC_is_device_ptr:
 209   case OMPC_unified_address:
 210   case OMPC_unified_shared_memory:
 211   case OMPC_reverse_offload:
 212   case OMPC_dynamic_allocators:
 213   case OMPC_atomic_default_mem_order:
 214   case OMPC_device_type:
 215   case OMPC_match:
 216     break;
 217   }
 218
 219   return nullptr;
 220 }
 221
 222 /// Gets the address of the original, non-captured, expression used in the
 223 /// clause as the preinitializer.
 224 static Stmt **getAddrOfExprAsWritten(Stmt *S) {
 225   if (!S)
 226     return nullptr;
 227   if (auto *DS = dyn_cast<DeclStmt>(S)) {
 228     assert(DS->isSingleDecl() && "Only single expression must be captured.");
 229     if (auto *OED = dyn_cast<OMPCapturedExprDecl>(DS->getSingleDecl()))
 230       return OED->getInitAddress();
 231   }
 232   return nullptr;
 233 }
 234
 235 OMPClause::child_range OMPIfClause::used_children() {
 236   if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
 237     return child_range(C, C + 1);
 238   return child_range(&Condition, &Condition + 1);
 239 }
 240
 241 OMPClause::child_range OMPGrainsizeClause::used_children() {
 242   if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
 243     return child_range(C, C + 1);
 244   return child_range(&Grainsize, &Grainsize + 1);
 245 }
 246
 247 OMPClause::child_range OMPNumTasksClause::used_children() {
 248   if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
 249     return child_range(C, C + 1);
 250   return child_range(&NumTasks, &NumTasks + 1);
 251 }
 252
 253 OMPClause::child_range OMPFinalClause::used_children() {
 254   if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
 255     return child_range(C, C + 1);
 256   return child_range(&Condition, &Condition + 1);
 257 }
 258
 259 OMPClause::child_range OMPPriorityClause::used_children() {
 260   if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
 261     return child_range(C, C + 1);
 262   return child_range(&Priority, &Priority + 1);
 263 }
 264
 265 OMPOrderedClause *OMPOrderedClause::Create(const ASTContext &C, Expr *Num,
 266                                            unsigned NumLoops,
 267                                            SourceLocation StartLoc,
 268                                            SourceLocation LParenLoc,
 269                                            SourceLocation EndLoc) {
 270   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * NumLoops));
 271   auto *Clause =
 272       new (Mem) OMPOrderedClause(Num, NumLoops, StartLoc, LParenLoc, EndLoc);
 273   for (unsigned I = 0; I < NumLoops; ++I) {
 274     Clause->setLoopNumIterations(I, nullptr);
 275     Clause->setLoopCounter(I, nullptr);
 276   }
 277   return Clause;
 278 }
 279
 280 OMPOrderedClause *OMPOrderedClause::CreateEmpty(const ASTContext &C,
 281                                                 unsigned NumLoops) {
 282   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * NumLoops));
 283   auto *Clause = new (Mem) OMPOrderedClause(NumLoops);
 284   for (unsigned I = 0; I < NumLoops; ++I) {
 285     Clause->setLoopNumIterations(I, nullptr);
 286     Clause->setLoopCounter(I, nullptr);
 287   }
 288   return Clause;
 289 }
 290
 291 void OMPOrderedClause::setLoopNumIterations(unsigned NumLoop,
 292                                             Expr *NumIterations) {
 293   assert(NumLoop < NumberOfLoops && "out of loops number.");
 294   getTrailingObjects<Expr *>()[NumLoop] = NumIterations;
 295 }
 296
 297 ArrayRef<Expr *> OMPOrderedClause::getLoopNumIterations() const {
 298   return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumberOfLoops);
 299 }
 300
 301 void OMPOrderedClause::setLoopCounter(unsigned NumLoop, Expr *Counter) {
 302   assert(NumLoop < NumberOfLoops && "out of loops number.");
 303   getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop] = Counter;
 304 }
 305
 306 Expr *OMPOrderedClause::getLoopCounter(unsigned NumLoop) {
 307   assert(NumLoop < NumberOfLoops && "out of loops number.");
 308   return getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop];
 309 }
 310
 311 const Expr *OMPOrderedClause::getLoopCounter(unsigned NumLoop) const {
 312   assert(NumLoop < NumberOfLoops && "out of loops number.");
 313   return getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop];
 314 }
 315
 316 void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
 317   assert(VL.size() == varlist_size() &&
 318          "Number of private copies is not the same as the preallocated buffer");
 319   std::copy(VL.begin(), VL.end(), varlist_end());
 320 }
 321
 322 OMPPrivateClause *
 323 OMPPrivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
 324                          SourceLocation LParenLoc, SourceLocation EndLoc,
 325                          ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) {
 326   // Allocate space for private variables and initializer expressions.
 327   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * VL.size()));
 328   OMPPrivateClause *Clause =
 329       new (Mem) OMPPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
 330   Clause->setVarRefs(VL);
 331   Clause->setPrivateCopies(PrivateVL);
 332   return Clause;
 333 }
 334
 335 OMPPrivateClause *OMPPrivateClause::CreateEmpty(const ASTContext &C,
 336                                                 unsigned N) {
 337   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * N));
 338   return new (Mem) OMPPrivateClause(N);
 339 }
 340
 341 void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
 342   assert(VL.size() == varlist_size() &&
 343          "Number of private copies is not the same as the preallocated buffer");
 344   std::copy(VL.begin(), VL.end(), varlist_end());
 345 }
 346
 347 void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) {
 348   assert(VL.size() == varlist_size() &&
 349          "Number of inits is not the same as the preallocated buffer");
 350   std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
 351 }
 352
 353 OMPFirstprivateClause *
 354 OMPFirstprivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
 355                               SourceLocation LParenLoc, SourceLocation EndLoc,
 356                               ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
 357                               ArrayRef<Expr *> InitVL, Stmt *PreInit) {
 358   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * VL.size()));
 359   OMPFirstprivateClause *Clause =
 360       new (Mem) OMPFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
 361   Clause->setVarRefs(VL);
 362   Clause->setPrivateCopies(PrivateVL);
 363   Clause->setInits(InitVL);
 364   Clause->setPreInitStmt(PreInit);
 365   return Clause;
 366 }
 367
 368 OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C,
 369                                                           unsigned N) {
 370   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * N));
 371   return new (Mem) OMPFirstprivateClause(N);
 372 }
 373
 374 void OMPLastprivateClause::setPrivateCopies(ArrayRef<Expr *> PrivateCopies) {
 375   assert(PrivateCopies.size() == varlist_size() &&
 376          "Number of private copies is not the same as the preallocated buffer");
 377   std::copy(PrivateCopies.begin(), PrivateCopies.end(), varlist_end());
 378 }
 379
 380 void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
 381   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
 382                                               "not the same as the "
 383                                               "preallocated buffer");
 384   std::copy(SrcExprs.begin(), SrcExprs.end(), getPrivateCopies().end());
 385 }
 386
 387 void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
 388   assert(DstExprs.size() == varlist_size() && "Number of destination "
 389                                               "expressions is not the same as "
 390                                               "the preallocated buffer");
 391   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
 392 }
 393
 394 void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
 395   assert(AssignmentOps.size() == varlist_size() &&
 396          "Number of assignment expressions is not the same as the preallocated "
 397          "buffer");
 398   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
 399             getDestinationExprs().end());
 400 }
 401
 402 OMPLastprivateClause *OMPLastprivateClause::Create(
 403     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
 404     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
 405     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps, Stmt *PreInit,
 406     Expr *PostUpdate) {
 407   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
 408   OMPLastprivateClause *Clause =
 409       new (Mem) OMPLastprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
 410   Clause->setVarRefs(VL);
 411   Clause->setSourceExprs(SrcExprs);
 412   Clause->setDestinationExprs(DstExprs);
 413   Clause->setAssignmentOps(AssignmentOps);
 414   Clause->setPreInitStmt(PreInit);
 415   Clause->setPostUpdateExpr(PostUpdate);
 416   return Clause;
 417 }
 418
 419 OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C,
 420                                                         unsigned N) {
 421   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
 422   return new (Mem) OMPLastprivateClause(N);
 423 }
 424
 425 OMPSharedClause *OMPSharedClause::Create(const ASTContext &C,
 426                                          SourceLocation StartLoc,
 427                                          SourceLocation LParenLoc,
 428                                          SourceLocation EndLoc,
 429                                          ArrayRef<Expr *> VL) {
 430   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
 431   OMPSharedClause *Clause =
 432       new (Mem) OMPSharedClause(StartLoc, LParenLoc, EndLoc, VL.size());
 433   Clause->setVarRefs(VL);
 434   return Clause;
 435 }
 436
 437 OMPSharedClause *OMPSharedClause::CreateEmpty(const ASTContext &C, unsigned N) {
 438   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
 439   return new (Mem) OMPSharedClause(N);
 440 }
 441
 442 void OMPLinearClause::setPrivates(ArrayRef<Expr *> PL) {
 443   assert(PL.size() == varlist_size() &&
 444          "Number of privates is not the same as the preallocated buffer");
 445   std::copy(PL.begin(), PL.end(), varlist_end());
 446 }
 447
 448 void OMPLinearClause::setInits(ArrayRef<Expr *> IL) {
 449   assert(IL.size() == varlist_size() &&
 450          "Number of inits is not the same as the preallocated buffer");
 451   std::copy(IL.begin(), IL.end(), getPrivates().end());
 452 }
 453
 454 void OMPLinearClause::setUpdates(ArrayRef<Expr *> UL) {
 455   assert(UL.size() == varlist_size() &&
 456          "Number of updates is not the same as the preallocated buffer");
 457   std::copy(UL.begin(), UL.end(), getInits().end());
 458 }
 459
 460 void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) {
 461   assert(FL.size() == varlist_size() &&
 462          "Number of final updates is not the same as the preallocated buffer");
 463   std::copy(FL.begin(), FL.end(), getUpdates().end());
 464 }
 465
 466 void OMPLinearClause::setUsedExprs(ArrayRef<Expr *> UE) {
 467   assert(
 468       UE.size() == varlist_size() + 1 &&
 469       "Number of used expressions is not the same as the preallocated buffer");
 470   std::copy(UE.begin(), UE.end(), getFinals().end() + 2);
 471 }
 472
 473 OMPLinearClause *OMPLinearClause::Create(
 474     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
 475     OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
 476     SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
 477     ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
 478     Stmt *PreInit, Expr *PostUpdate) {
 479   // Allocate space for 5 lists (Vars, Inits, Updates, Finals), 2 expressions
 480   // (Step and CalcStep), list of used expression + step.
 481   void *Mem =
 482       C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2 + VL.size() + 1));
 483   OMPLinearClause *Clause = new (Mem) OMPLinearClause(
 484       StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc, EndLoc, VL.size());
 485   Clause->setVarRefs(VL);
 486   Clause->setPrivates(PL);
 487   Clause->setInits(IL);
 488   // Fill update and final expressions with zeroes, they are provided later,
 489   // after the directive construction.
 490   std::fill(Clause->getInits().end(), Clause->getInits().end() + VL.size(),
 491             nullptr);
 492   std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(),
 493             nullptr);
 494   std::fill(Clause->getUsedExprs().begin(), Clause->getUsedExprs().end(),
 495             nullptr);
 496   Clause->setStep(Step);
 497   Clause->setCalcStep(CalcStep);
 498   Clause->setPreInitStmt(PreInit);
 499   Clause->setPostUpdateExpr(PostUpdate);
 500   return Clause;
 501 }
 502
 503 OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C,
 504                                               unsigned NumVars) {
 505   // Allocate space for 5 lists (Vars, Inits, Updates, Finals), 2 expressions
 506   // (Step and CalcStep), list of used expression + step.
 507   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2 + NumVars  +1));
 508   return new (Mem) OMPLinearClause(NumVars);
 509 }
 510
 511 OMPClause::child_range OMPLinearClause::used_children() {
 512   // Range includes only non-nullptr elements.
 513   return child_range(
 514       reinterpret_cast<Stmt **>(getUsedExprs().begin()),
 515       reinterpret_cast<Stmt **>(llvm::find(getUsedExprs(), nullptr)));
 516 }
 517
 518 OMPAlignedClause *
 519 OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc,
 520                          SourceLocation LParenLoc, SourceLocation ColonLoc,
 521                          SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) {
 522   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
 523   OMPAlignedClause *Clause = new (Mem)
 524       OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
 525   Clause->setVarRefs(VL);
 526   Clause->setAlignment(A);
 527   return Clause;
 528 }
 529
 530 OMPAlignedClause *OMPAlignedClause::CreateEmpty(const ASTContext &C,
 531                                                 unsigned NumVars) {
 532   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumVars + 1));
 533   return new (Mem) OMPAlignedClause(NumVars);
 534 }
 535
 536 void OMPCopyinClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
 537   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
 538                                               "not the same as the "
 539                                               "preallocated buffer");
 540   std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
 541 }
 542
 543 void OMPCopyinClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
 544   assert(DstExprs.size() == varlist_size() && "Number of destination "
 545                                               "expressions is not the same as "
 546                                               "the preallocated buffer");
 547   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
 548 }
 549
 550 void OMPCopyinClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
 551   assert(AssignmentOps.size() == varlist_size() &&
 552          "Number of assignment expressions is not the same as the preallocated "
 553          "buffer");
 554   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
 555             getDestinationExprs().end());
 556 }
 557
 558 OMPCopyinClause *OMPCopyinClause::Create(
 559     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
 560     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
 561     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
 562   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
 563   OMPCopyinClause *Clause =
 564       new (Mem) OMPCopyinClause(StartLoc, LParenLoc, EndLoc, VL.size());
 565   Clause->setVarRefs(VL);
 566   Clause->setSourceExprs(SrcExprs);
 567   Clause->setDestinationExprs(DstExprs);
 568   Clause->setAssignmentOps(AssignmentOps);
 569   return Clause;
 570 }
 571
 572 OMPCopyinClause *OMPCopyinClause::CreateEmpty(const ASTContext &C, unsigned N) {
 573   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
 574   return new (Mem) OMPCopyinClause(N);
 575 }
 576
 577 void OMPCopyprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
 578   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
 579                                               "not the same as the "
 580                                               "preallocated buffer");
 581   std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
 582 }
 583
 584 void OMPCopyprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
 585   assert(DstExprs.size() == varlist_size() && "Number of destination "
 586                                               "expressions is not the same as "
 587                                               "the preallocated buffer");
 588   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
 589 }
 590
 591 void OMPCopyprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
 592   assert(AssignmentOps.size() == varlist_size() &&
 593          "Number of assignment expressions is not the same as the preallocated "
 594          "buffer");
 595   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
 596             getDestinationExprs().end());
 597 }
 598
 599 OMPCopyprivateClause *OMPCopyprivateClause::Create(
 600     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
 601     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
 602     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
 603   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
 604   OMPCopyprivateClause *Clause =
 605       new (Mem) OMPCopyprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
 606   Clause->setVarRefs(VL);
 607   Clause->setSourceExprs(SrcExprs);
 608   Clause->setDestinationExprs(DstExprs);
 609   Clause->setAssignmentOps(AssignmentOps);
 610   return Clause;
 611 }
 612
 613 OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(const ASTContext &C,
 614                                                         unsigned N) {
 615   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
 616   return new (Mem) OMPCopyprivateClause(N);
 617 }
 618
 619 void OMPReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
 620   assert(Privates.size() == varlist_size() &&
 621          "Number of private copies is not the same as the preallocated buffer");
 622   std::copy(Privates.begin(), Privates.end(), varlist_end());
 623 }
 624
 625 void OMPReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
 626   assert(
 627       LHSExprs.size() == varlist_size() &&
 628       "Number of LHS expressions is not the same as the preallocated buffer");
 629   std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
 630 }
 631
 632 void OMPReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
 633   assert(
 634       RHSExprs.size() == varlist_size() &&
 635       "Number of RHS expressions is not the same as the preallocated buffer");
 636   std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
 637 }
 638
 639 void OMPReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
 640   assert(ReductionOps.size() == varlist_size() && "Number of reduction "
 641                                                   "expressions is not the same "
 642                                                   "as the preallocated buffer");
 643   std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
 644 }
 645
 646 OMPReductionClause *OMPReductionClause::Create(
 647     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
 648     SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
 649     NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
 650     ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
 651     ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
 652     Expr *PostUpdate) {
 653   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
 654   OMPReductionClause *Clause = new (Mem) OMPReductionClause(
 655       StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
 656   Clause->setVarRefs(VL);
 657   Clause->setPrivates(Privates);
 658   Clause->setLHSExprs(LHSExprs);
 659   Clause->setRHSExprs(RHSExprs);
 660   Clause->setReductionOps(ReductionOps);
 661   Clause->setPreInitStmt(PreInit);
 662   Clause->setPostUpdateExpr(PostUpdate);
 663   return Clause;
 664 }
 665
 666 OMPReductionClause *OMPReductionClause::CreateEmpty(const ASTContext &C,
 667                                                     unsigned N) {
 668   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
 669   return new (Mem) OMPReductionClause(N);
 670 }
 671
 672 void OMPTaskReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
 673   assert(Privates.size() == varlist_size() &&
 674          "Number of private copies is not the same as the preallocated buffer");
 675   std::copy(Privates.begin(), Privates.end(), varlist_end());
 676 }
 677
 678 void OMPTaskReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
 679   assert(
 680       LHSExprs.size() == varlist_size() &&
 681       "Number of LHS expressions is not the same as the preallocated buffer");
 682   std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
 683 }
 684
 685 void OMPTaskReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
 686   assert(
 687       RHSExprs.size() == varlist_size() &&
 688       "Number of RHS expressions is not the same as the preallocated buffer");
 689   std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
 690 }
 691
 692 void OMPTaskReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
 693   assert(ReductionOps.size() == varlist_size() && "Number of task reduction "
 694                                                   "expressions is not the same "
 695                                                   "as the preallocated buffer");
 696   std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
 697 }
 698
 699 OMPTaskReductionClause *OMPTaskReductionClause::Create(
 700     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
 701     SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
 702     NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
 703     ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
 704     ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
 705     Expr *PostUpdate) {
 706   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
 707   OMPTaskReductionClause *Clause = new (Mem) OMPTaskReductionClause(
 708       StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
 709   Clause->setVarRefs(VL);
 710   Clause->setPrivates(Privates);
 711   Clause->setLHSExprs(LHSExprs);
 712   Clause->setRHSExprs(RHSExprs);
 713   Clause->setReductionOps(ReductionOps);
 714   Clause->setPreInitStmt(PreInit);
 715   Clause->setPostUpdateExpr(PostUpdate);
 716   return Clause;
 717 }
 718
 719 OMPTaskReductionClause *OMPTaskReductionClause::CreateEmpty(const ASTContext &C,
 720                                                             unsigned N) {
 721   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
 722   return new (Mem) OMPTaskReductionClause(N);
 723 }
 724
 725 void OMPInReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
 726   assert(Privates.size() == varlist_size() &&
 727          "Number of private copies is not the same as the preallocated buffer");
 728   std::copy(Privates.begin(), Privates.end(), varlist_end());
 729 }
 730
 731 void OMPInReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
 732   assert(
 733       LHSExprs.size() == varlist_size() &&
 734       "Number of LHS expressions is not the same as the preallocated buffer");
 735   std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
 736 }
 737
 738 void OMPInReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
 739   assert(
 740       RHSExprs.size() == varlist_size() &&
 741       "Number of RHS expressions is not the same as the preallocated buffer");
 742   std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
 743 }
 744
 745 void OMPInReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
 746   assert(ReductionOps.size() == varlist_size() && "Number of in reduction "
 747                                                   "expressions is not the same "
 748                                                   "as the preallocated buffer");
 749   std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
 750 }
 751
 752 void OMPInReductionClause::setTaskgroupDescriptors(
 753     ArrayRef<Expr *> TaskgroupDescriptors) {
 754   assert(TaskgroupDescriptors.size() == varlist_size() &&
 755          "Number of in reduction descriptors is not the same as the "
 756          "preallocated buffer");
 757   std::copy(TaskgroupDescriptors.begin(), TaskgroupDescriptors.end(),
 758             getReductionOps().end());
 759 }
 760
 761 OMPInReductionClause *OMPInReductionClause::Create(
 762     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
 763     SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
 764     NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
 765     ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
 766     ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps,
 767     ArrayRef<Expr *> TaskgroupDescriptors, Stmt *PreInit, Expr *PostUpdate) {
 768   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(6 * VL.size()));
 769   OMPInReductionClause *Clause = new (Mem) OMPInReductionClause(
 770       StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
 771   Clause->setVarRefs(VL);
 772   Clause->setPrivates(Privates);
 773   Clause->setLHSExprs(LHSExprs);
 774   Clause->setRHSExprs(RHSExprs);
 775   Clause->setReductionOps(ReductionOps);
 776   Clause->setTaskgroupDescriptors(TaskgroupDescriptors);
 777   Clause->setPreInitStmt(PreInit);
 778   Clause->setPostUpdateExpr(PostUpdate);
 779   return Clause;
 780 }
 781
 782 OMPInReductionClause *OMPInReductionClause::CreateEmpty(const ASTContext &C,
 783                                                         unsigned N) {
 784   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(6 * N));
 785   return new (Mem) OMPInReductionClause(N);
 786 }
 787
 788 OMPAllocateClause *
 789 OMPAllocateClause::Create(const ASTContext &C, SourceLocation StartLoc,
 790                           SourceLocation LParenLoc, Expr *Allocator,
 791                           SourceLocation ColonLoc, SourceLocation EndLoc,
 792                           ArrayRef<Expr *> VL) {
 793   // Allocate space for private variables and initializer expressions.
 794   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
 795   auto *Clause = new (Mem) OMPAllocateClause(StartLoc, LParenLoc, Allocator,
 796                                              ColonLoc, EndLoc, VL.size());
 797   Clause->setVarRefs(VL);
 798   return Clause;
 799 }
 800
 801 OMPAllocateClause *OMPAllocateClause::CreateEmpty(const ASTContext &C,
 802                                                   unsigned N) {
 803   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
 804   return new (Mem) OMPAllocateClause(N);
 805 }
 806
 807 OMPFlushClause *OMPFlushClause::Create(const ASTContext &C,
 808                                        SourceLocation StartLoc,
 809                                        SourceLocation LParenLoc,
 810                                        SourceLocation EndLoc,
 811                                        ArrayRef<Expr *> VL) {
 812   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
 813   OMPFlushClause *Clause =
 814       new (Mem) OMPFlushClause(StartLoc, LParenLoc, EndLoc, VL.size());
 815   Clause->setVarRefs(VL);
 816   return Clause;
 817 }
 818
 819 OMPFlushClause *OMPFlushClause::CreateEmpty(const ASTContext &C, unsigned N) {
 820   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
 821   return new (Mem) OMPFlushClause(N);
 822 }
 823
 824 OMPDependClause *
 825 OMPDependClause::Create(const ASTContext &C, SourceLocation StartLoc,
 826                         SourceLocation LParenLoc, SourceLocation EndLoc,
 827                         OpenMPDependClauseKind DepKind, SourceLocation DepLoc,
 828                         SourceLocation ColonLoc, ArrayRef<Expr *> VL,
 829                         unsigned NumLoops) {
 830   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + NumLoops));
 831   OMPDependClause *Clause = new (Mem)
 832       OMPDependClause(StartLoc, LParenLoc, EndLoc, VL.size(), NumLoops);
 833   Clause->setVarRefs(VL);
 834   Clause->setDependencyKind(DepKind);
 835   Clause->setDependencyLoc(DepLoc);
 836   Clause->setColonLoc(ColonLoc);
 837   for (unsigned I = 0 ; I < NumLoops; ++I)
 838     Clause->setLoopData(I, nullptr);
 839   return Clause;
 840 }
 841
 842 OMPDependClause *OMPDependClause::CreateEmpty(const ASTContext &C, unsigned N,
 843                                               unsigned NumLoops) {
 844   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N + NumLoops));
 845   return new (Mem) OMPDependClause(N, NumLoops);
 846 }
 847
 848 void OMPDependClause::setLoopData(unsigned NumLoop, Expr *Cnt) {
 849   assert((getDependencyKind() == OMPC_DEPEND_sink ||
 850           getDependencyKind() == OMPC_DEPEND_source) &&
 851          NumLoop < NumLoops &&
 852          "Expected sink or source depend + loop index must be less number of "
 853          "loops.");
 854   auto It = std::next(getVarRefs().end(), NumLoop);
 855   *It = Cnt;
 856 }
 857
 858 Expr *OMPDependClause::getLoopData(unsigned NumLoop) {
 859   assert((getDependencyKind() == OMPC_DEPEND_sink ||
 860           getDependencyKind() == OMPC_DEPEND_source) &&
 861          NumLoop < NumLoops &&
 862          "Expected sink or source depend + loop index must be less number of "
 863          "loops.");
 864   auto It = std::next(getVarRefs().end(), NumLoop);
 865   return *It;
 866 }
 867
 868 const Expr *OMPDependClause::getLoopData(unsigned NumLoop) const {
 869   assert((getDependencyKind() == OMPC_DEPEND_sink ||
 870           getDependencyKind() == OMPC_DEPEND_source) &&
 871          NumLoop < NumLoops &&
 872          "Expected sink or source depend + loop index must be less number of "
 873          "loops.");
 874   auto It = std::next(getVarRefs().end(), NumLoop);
 875   return *It;
 876 }
 877
 878 unsigned OMPClauseMappableExprCommon::getComponentsTotalNumber(
 879     MappableExprComponentListsRef ComponentLists) {
 880   unsigned TotalNum = 0u;
 881   for (auto &C : ComponentLists)
 882     TotalNum += C.size();
 883   return TotalNum;
 884 }
 885
 886 unsigned OMPClauseMappableExprCommon::getUniqueDeclarationsTotalNumber(
 887     ArrayRef<const ValueDecl *> Declarations) {
 888   unsigned TotalNum = 0u;
 889   llvm::SmallPtrSet<const ValueDecl *, 8> Cache;
 890   for (const ValueDecl *D : Declarations) {
 891     const ValueDecl *VD = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr;
 892     if (Cache.count(VD))
 893       continue;
 894     ++TotalNum;
 895     Cache.insert(VD);
 896   }
 897   return TotalNum;
 898 }
 899
 900 OMPMapClause *OMPMapClause::Create(
 901     const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
 902     ArrayRef<ValueDecl *> Declarations,
 903     MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
 904     ArrayRef<OpenMPMapModifierKind> MapModifiers,
 905     ArrayRef<SourceLocation> MapModifiersLoc,
 906     NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId,
 907     OpenMPMapClauseKind Type, bool TypeIsImplicit, SourceLocation TypeLoc) {
 908   OMPMappableExprListSizeTy Sizes;
 909   Sizes.NumVars = Vars.size();
 910   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
 911   Sizes.NumComponentLists = ComponentLists.size();
 912   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
 913
 914   // We need to allocate:
 915   // 2 x NumVars x Expr* - we have an original list expression and an associated
 916   // user-defined mapper for each clause list entry.
 917   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
 918   // with each component list.
 919   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
 920   // number of lists for each unique declaration and the size of each component
 921   // list.
 922   // NumComponents x MappableComponent - the total of all the components in all
 923   // the lists.
 924   void *Mem = C.Allocate(
 925       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
 926                        OMPClauseMappableExprCommon::MappableComponent>(
 927           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
 928           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
 929           Sizes.NumComponents));
 930   OMPMapClause *Clause = new (Mem)
 931       OMPMapClause(MapModifiers, MapModifiersLoc, UDMQualifierLoc, MapperId,
 932                    Type, TypeIsImplicit, TypeLoc, Locs, Sizes);
 933
 934   Clause->setVarRefs(Vars);
 935   Clause->setUDMapperRefs(UDMapperRefs);
 936   Clause->setClauseInfo(Declarations, ComponentLists);
 937   Clause->setMapType(Type);
 938   Clause->setMapLoc(TypeLoc);
 939   return Clause;
 940 }
 941
 942 OMPMapClause *
 943 OMPMapClause::CreateEmpty(const ASTContext &C,
 944                           const OMPMappableExprListSizeTy &Sizes) {
 945   void *Mem = C.Allocate(
 946       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
 947                        OMPClauseMappableExprCommon::MappableComponent>(
 948           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
 949           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
 950           Sizes.NumComponents));
 951   return new (Mem) OMPMapClause(Sizes);
 952 }
 953
 954 OMPToClause *OMPToClause::Create(
 955     const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
 956     ArrayRef<ValueDecl *> Declarations,
 957     MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
 958     NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId) {
 959   OMPMappableExprListSizeTy Sizes;
 960   Sizes.NumVars = Vars.size();
 961   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
 962   Sizes.NumComponentLists = ComponentLists.size();
 963   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
 964
 965   // We need to allocate:
 966   // 2 x NumVars x Expr* - we have an original list expression and an associated
 967   // user-defined mapper for each clause list entry.
 968   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
 969   // with each component list.
 970   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
 971   // number of lists for each unique declaration and the size of each component
 972   // list.
 973   // NumComponents x MappableComponent - the total of all the components in all
 974   // the lists.
 975   void *Mem = C.Allocate(
 976       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
 977                        OMPClauseMappableExprCommon::MappableComponent>(
 978           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
 979           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
 980           Sizes.NumComponents));
 981
 982   auto *Clause = new (Mem) OMPToClause(UDMQualifierLoc, MapperId, Locs, Sizes);
 983
 984   Clause->setVarRefs(Vars);
 985   Clause->setUDMapperRefs(UDMapperRefs);
 986   Clause->setClauseInfo(Declarations, ComponentLists);
 987   return Clause;
 988 }
 989
 990 OMPToClause *OMPToClause::CreateEmpty(const ASTContext &C,
 991                                       const OMPMappableExprListSizeTy &Sizes) {
 992   void *Mem = C.Allocate(
 993       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
 994                        OMPClauseMappableExprCommon::MappableComponent>(
 995           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
 996           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
 997           Sizes.NumComponents));
 998   return new (Mem) OMPToClause(Sizes);
 999 }
1000
1001 OMPFromClause *OMPFromClause::Create(
1002     const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
1003     ArrayRef<ValueDecl *> Declarations,
1004     MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
1005     NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId) {
1006   OMPMappableExprListSizeTy Sizes;
1007   Sizes.NumVars = Vars.size();
1008   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1009   Sizes.NumComponentLists = ComponentLists.size();
1010   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1011
1012   // We need to allocate:
1013   // 2 x NumVars x Expr* - we have an original list expression and an associated
1014   // user-defined mapper for each clause list entry.
1015   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1016   // with each component list.
1017   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1018   // number of lists for each unique declaration and the size of each component
1019   // list.
1020   // NumComponents x MappableComponent - the total of all the components in all
1021   // the lists.
1022   void *Mem = C.Allocate(
1023       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1024                        OMPClauseMappableExprCommon::MappableComponent>(
1025           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1026           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1027           Sizes.NumComponents));
1028
1029   auto *Clause =
1030       new (Mem) OMPFromClause(UDMQualifierLoc, MapperId, Locs, Sizes);
1031
1032   Clause->setVarRefs(Vars);
1033   Clause->setUDMapperRefs(UDMapperRefs);
1034   Clause->setClauseInfo(Declarations, ComponentLists);
1035   return Clause;
1036 }
1037
1038 OMPFromClause *
1039 OMPFromClause::CreateEmpty(const ASTContext &C,
1040                            const OMPMappableExprListSizeTy &Sizes) {
1041   void *Mem = C.Allocate(
1042       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1043                        OMPClauseMappableExprCommon::MappableComponent>(
1044           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1045           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1046           Sizes.NumComponents));
1047   return new (Mem) OMPFromClause(Sizes);
1048 }
1049
1050 void OMPUseDevicePtrClause::setPrivateCopies(ArrayRef<Expr *> VL) {
1051   assert(VL.size() == varlist_size() &&
1052          "Number of private copies is not the same as the preallocated buffer");
1053   std::copy(VL.begin(), VL.end(), varlist_end());
1054 }
1055
1056 void OMPUseDevicePtrClause::setInits(ArrayRef<Expr *> VL) {
1057   assert(VL.size() == varlist_size() &&
1058          "Number of inits is not the same as the preallocated buffer");
1059   std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
1060 }
1061
1062 OMPUseDevicePtrClause *OMPUseDevicePtrClause::Create(
1063     const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
1064     ArrayRef<Expr *> PrivateVars, ArrayRef<Expr *> Inits,
1065     ArrayRef<ValueDecl *> Declarations,
1066     MappableExprComponentListsRef ComponentLists) {
1067   OMPMappableExprListSizeTy Sizes;
1068   Sizes.NumVars = Vars.size();
1069   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1070   Sizes.NumComponentLists = ComponentLists.size();
1071   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1072
1073   // We need to allocate:
1074   // 3 x NumVars x Expr* - we have an original list expression for each clause
1075   // list entry and an equal number of private copies and inits.
1076   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1077   // with each component list.
1078   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1079   // number of lists for each unique declaration and the size of each component
1080   // list.
1081   // NumComponents x MappableComponent - the total of all the components in all
1082   // the lists.
1083   void *Mem = C.Allocate(
1084       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1085                        OMPClauseMappableExprCommon::MappableComponent>(
1086           3 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1087           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1088           Sizes.NumComponents));
1089
1090   OMPUseDevicePtrClause *Clause = new (Mem) OMPUseDevicePtrClause(Locs, Sizes);
1091
1092   Clause->setVarRefs(Vars);
1093   Clause->setPrivateCopies(PrivateVars);
1094   Clause->setInits(Inits);
1095   Clause->setClauseInfo(Declarations, ComponentLists);
1096   return Clause;
1097 }
1098
1099 OMPUseDevicePtrClause *
1100 OMPUseDevicePtrClause::CreateEmpty(const ASTContext &C,
1101                                    const OMPMappableExprListSizeTy &Sizes) {
1102   void *Mem = C.Allocate(
1103       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1104                        OMPClauseMappableExprCommon::MappableComponent>(
1105           3 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1106           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1107           Sizes.NumComponents));
1108   return new (Mem) OMPUseDevicePtrClause(Sizes);
1109 }
1110
1111 OMPIsDevicePtrClause *
1112 OMPIsDevicePtrClause::Create(const ASTContext &C, const OMPVarListLocTy &Locs,
1113                              ArrayRef<Expr *> Vars,
1114                              ArrayRef<ValueDecl *> Declarations,
1115                              MappableExprComponentListsRef ComponentLists) {
1116   OMPMappableExprListSizeTy Sizes;
1117   Sizes.NumVars = Vars.size();
1118   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1119   Sizes.NumComponentLists = ComponentLists.size();
1120   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1121
1122   // We need to allocate:
1123   // NumVars x Expr* - we have an original list expression for each clause list
1124   // entry.
1125   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1126   // with each component list.
1127   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1128   // number of lists for each unique declaration and the size of each component
1129   // list.
1130   // NumComponents x MappableComponent - the total of all the components in all
1131   // the lists.
1132   void *Mem = C.Allocate(
1133       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1134                        OMPClauseMappableExprCommon::MappableComponent>(
1135           Sizes.NumVars, Sizes.NumUniqueDeclarations,
1136           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1137           Sizes.NumComponents));
1138
1139   OMPIsDevicePtrClause *Clause = new (Mem) OMPIsDevicePtrClause(Locs, Sizes);
1140
1141   Clause->setVarRefs(Vars);
1142   Clause->setClauseInfo(Declarations, ComponentLists);
1143   return Clause;
1144 }
1145
1146 OMPIsDevicePtrClause *
1147 OMPIsDevicePtrClause::CreateEmpty(const ASTContext &C,
1148                                   const OMPMappableExprListSizeTy &Sizes) {
1149   void *Mem = C.Allocate(
1150       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1151                        OMPClauseMappableExprCommon::MappableComponent>(
1152           Sizes.NumVars, Sizes.NumUniqueDeclarations,
1153           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1154           Sizes.NumComponents));
1155   return new (Mem) OMPIsDevicePtrClause(Sizes);
1156 }
1157
1158 //===----------------------------------------------------------------------===//
1159 //  OpenMP clauses printing methods
1160 //===----------------------------------------------------------------------===//
1161
1162 void OMPClausePrinter::VisitOMPIfClause(OMPIfClause *Node) {
1163   OS << "if(";
1164   if (Node->getNameModifier() != OMPD_unknown)
1165     OS << getOpenMPDirectiveName(Node->getNameModifier()) << ": ";
1166   Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
1167   OS << ")";
1168 }
1169
1170 void OMPClausePrinter::VisitOMPFinalClause(OMPFinalClause *Node) {
1171   OS << "final(";
1172   Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
1173   OS << ")";
1174 }
1175
1176 void OMPClausePrinter::VisitOMPNumThreadsClause(OMPNumThreadsClause *Node) {
1177   OS << "num_threads(";
1178   Node->getNumThreads()->printPretty(OS, nullptr, Policy, 0);
1179   OS << ")";
1180 }
1181
1182 void OMPClausePrinter::VisitOMPSafelenClause(OMPSafelenClause *Node) {
1183   OS << "safelen(";
1184   Node->getSafelen()->printPretty(OS, nullptr, Policy, 0);
1185   OS << ")";
1186 }
1187
1188 void OMPClausePrinter::VisitOMPSimdlenClause(OMPSimdlenClause *Node) {
1189   OS << "simdlen(";
1190   Node->getSimdlen()->printPretty(OS, nullptr, Policy, 0);
1191   OS << ")";
1192 }
1193
1194 void OMPClausePrinter::VisitOMPAllocatorClause(OMPAllocatorClause *Node) {
1195   OS << "allocator(";
1196   Node->getAllocator()->printPretty(OS, nullptr, Policy, 0);
1197   OS << ")";
1198 }
1199
1200 void OMPClausePrinter::VisitOMPCollapseClause(OMPCollapseClause *Node) {
1201   OS << "collapse(";
1202   Node->getNumForLoops()->printPretty(OS, nullptr, Policy, 0);
1203   OS << ")";
1204 }
1205
1206 void OMPClausePrinter::VisitOMPDefaultClause(OMPDefaultClause *Node) {
1207   OS << "default("
1208      << getOpenMPSimpleClauseTypeName(OMPC_default, Node->getDefaultKind())
1209      << ")";
1210 }
1211
1212 void OMPClausePrinter::VisitOMPProcBindClause(OMPProcBindClause *Node) {
1213   OS << "proc_bind("
1214      << getOpenMPSimpleClauseTypeName(OMPC_proc_bind, Node->getProcBindKind())
1215      << ")";
1216 }
1217
1218 void OMPClausePrinter::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) {
1219   OS << "unified_address";
1220 }
1221
1222 void OMPClausePrinter::VisitOMPUnifiedSharedMemoryClause(
1223     OMPUnifiedSharedMemoryClause *) {
1224   OS << "unified_shared_memory";
1225 }
1226
1227 void OMPClausePrinter::VisitOMPReverseOffloadClause(OMPReverseOffloadClause *) {
1228   OS << "reverse_offload";
1229 }
1230
1231 void OMPClausePrinter::VisitOMPDynamicAllocatorsClause(
1232     OMPDynamicAllocatorsClause *) {
1233   OS << "dynamic_allocators";
1234 }
1235
1236 void OMPClausePrinter::VisitOMPAtomicDefaultMemOrderClause(
1237     OMPAtomicDefaultMemOrderClause *Node) {
1238   OS << "atomic_default_mem_order("
1239      << getOpenMPSimpleClauseTypeName(OMPC_atomic_default_mem_order,
1240                                       Node->getAtomicDefaultMemOrderKind())
1241      << ")";
1242 }
1243
1244 void OMPClausePrinter::VisitOMPScheduleClause(OMPScheduleClause *Node) {
1245   OS << "schedule(";
1246   if (Node->getFirstScheduleModifier() != OMPC_SCHEDULE_MODIFIER_unknown) {
1247     OS << getOpenMPSimpleClauseTypeName(OMPC_schedule,
1248                                         Node->getFirstScheduleModifier());
1249     if (Node->getSecondScheduleModifier() != OMPC_SCHEDULE_MODIFIER_unknown) {
1250       OS << ", ";
1251       OS << getOpenMPSimpleClauseTypeName(OMPC_schedule,
1252                                           Node->getSecondScheduleModifier());
1253     }
1254     OS << ": ";
1255   }
1256   OS << getOpenMPSimpleClauseTypeName(OMPC_schedule, Node->getScheduleKind());
1257   if (auto *E = Node->getChunkSize()) {
1258     OS << ", ";
1259     E->printPretty(OS, nullptr, Policy);
1260   }
1261   OS << ")";
1262 }
1263
1264 void OMPClausePrinter::VisitOMPOrderedClause(OMPOrderedClause *Node) {
1265   OS << "ordered";
1266   if (auto *Num = Node->getNumForLoops()) {
1267     OS << "(";
1268     Num->printPretty(OS, nullptr, Policy, 0);
1269     OS << ")";
1270   }
1271 }
1272
1273 void OMPClausePrinter::VisitOMPNowaitClause(OMPNowaitClause *) {
1274   OS << "nowait";
1275 }
1276
1277 void OMPClausePrinter::VisitOMPUntiedClause(OMPUntiedClause *) {
1278   OS << "untied";
1279 }
1280
1281 void OMPClausePrinter::VisitOMPNogroupClause(OMPNogroupClause *) {
1282   OS << "nogroup";
1283 }
1284
1285 void OMPClausePrinter::VisitOMPMergeableClause(OMPMergeableClause *) {
1286   OS << "mergeable";
1287 }
1288
1289 void OMPClausePrinter::VisitOMPReadClause(OMPReadClause *) { OS << "read"; }
1290
1291 void OMPClausePrinter::VisitOMPWriteClause(OMPWriteClause *) { OS << "write"; }
1292
1293 void OMPClausePrinter::VisitOMPUpdateClause(OMPUpdateClause *) {
1294   OS << "update";
1295 }
1296
1297 void OMPClausePrinter::VisitOMPCaptureClause(OMPCaptureClause *) {
1298   OS << "capture";
1299 }
1300
1301 void OMPClausePrinter::VisitOMPSeqCstClause(OMPSeqCstClause *) {
1302   OS << "seq_cst";
1303 }
1304
1305 void OMPClausePrinter::VisitOMPThreadsClause(OMPThreadsClause *) {
1306   OS << "threads";
1307 }
1308
1309 void OMPClausePrinter::VisitOMPSIMDClause(OMPSIMDClause *) { OS << "simd"; }
1310
1311 void OMPClausePrinter::VisitOMPDeviceClause(OMPDeviceClause *Node) {
1312   OS << "device(";
1313   Node->getDevice()->printPretty(OS, nullptr, Policy, 0);
1314   OS << ")";
1315 }
1316
1317 void OMPClausePrinter::VisitOMPNumTeamsClause(OMPNumTeamsClause *Node) {
1318   OS << "num_teams(";
1319   Node->getNumTeams()->printPretty(OS, nullptr, Policy, 0);
1320   OS << ")";
1321 }
1322
1323 void OMPClausePrinter::VisitOMPThreadLimitClause(OMPThreadLimitClause *Node) {
1324   OS << "thread_limit(";
1325   Node->getThreadLimit()->printPretty(OS, nullptr, Policy, 0);
1326   OS << ")";
1327 }
1328
1329 void OMPClausePrinter::VisitOMPPriorityClause(OMPPriorityClause *Node) {
1330   OS << "priority(";
1331   Node->getPriority()->printPretty(OS, nullptr, Policy, 0);
1332   OS << ")";
1333 }
1334
1335 void OMPClausePrinter::VisitOMPGrainsizeClause(OMPGrainsizeClause *Node) {
1336   OS << "grainsize(";
1337   Node->getGrainsize()->printPretty(OS, nullptr, Policy, 0);
1338   OS << ")";
1339 }
1340
1341 void OMPClausePrinter::VisitOMPNumTasksClause(OMPNumTasksClause *Node) {
1342   OS << "num_tasks(";
1343   Node->getNumTasks()->printPretty(OS, nullptr, Policy, 0);
1344   OS << ")";
1345 }
1346
1347 void OMPClausePrinter::VisitOMPHintClause(OMPHintClause *Node) {
1348   OS << "hint(";
1349   Node->getHint()->printPretty(OS, nullptr, Policy, 0);
1350   OS << ")";
1351 }
1352
1353 template<typename T>
1354 void OMPClausePrinter::VisitOMPClauseList(T *Node, char StartSym) {
1355   for (typename T::varlist_iterator I = Node->varlist_begin(),
1356                                     E = Node->varlist_end();
1357        I != E; ++I) {
1358     assert(*I && "Expected non-null Stmt");
1359     OS << (I == Node->varlist_begin() ? StartSym : ',');
1360     if (auto *DRE = dyn_cast<DeclRefExpr>(*I)) {
1361       if (isa<OMPCapturedExprDecl>(DRE->getDecl()))
1362         DRE->printPretty(OS, nullptr, Policy, 0);
1363       else
1364         DRE->getDecl()->printQualifiedName(OS);
1365     } else
1366       (*I)->printPretty(OS, nullptr, Policy, 0);
1367   }
1368 }
1369
1370 void OMPClausePrinter::VisitOMPAllocateClause(OMPAllocateClause *Node) {
1371   if (Node->varlist_empty())
1372     return;
1373   OS << "allocate";
1374   if (Expr *Allocator = Node->getAllocator()) {
1375     OS << "(";
1376     Allocator->printPretty(OS, nullptr, Policy, 0);
1377     OS << ":";
1378     VisitOMPClauseList(Node, ' ');
1379   } else {
1380     VisitOMPClauseList(Node, '(');
1381   }
1382   OS << ")";
1383 }
1384
1385 void OMPClausePrinter::VisitOMPPrivateClause(OMPPrivateClause *Node) {
1386   if (!Node->varlist_empty()) {
1387     OS << "private";
1388     VisitOMPClauseList(Node, '(');
1389     OS << ")";
1390   }
1391 }
1392
1393 void OMPClausePrinter::VisitOMPFirstprivateClause(OMPFirstprivateClause *Node) {
1394   if (!Node->varlist_empty()) {
1395     OS << "firstprivate";
1396     VisitOMPClauseList(Node, '(');
1397     OS << ")";
1398   }
1399 }
1400
1401 void OMPClausePrinter::VisitOMPLastprivateClause(OMPLastprivateClause *Node) {
1402   if (!Node->varlist_empty()) {
1403     OS << "lastprivate";
1404     VisitOMPClauseList(Node, '(');
1405     OS << ")";
1406   }
1407 }
1408
1409 void OMPClausePrinter::VisitOMPSharedClause(OMPSharedClause *Node) {
1410   if (!Node->varlist_empty()) {
1411     OS << "shared";
1412     VisitOMPClauseList(Node, '(');
1413     OS << ")";
1414   }
1415 }
1416
1417 void OMPClausePrinter::VisitOMPReductionClause(OMPReductionClause *Node) {
1418   if (!Node->varlist_empty()) {
1419     OS << "reduction(";
1420     NestedNameSpecifier *QualifierLoc =
1421         Node->getQualifierLoc().getNestedNameSpecifier();
1422     OverloadedOperatorKind OOK =
1423         Node->getNameInfo().getName().getCXXOverloadedOperator();
1424     if (QualifierLoc == nullptr && OOK != OO_None) {
1425       // Print reduction identifier in C format
1426       OS << getOperatorSpelling(OOK);
1427     } else {
1428       // Use C++ format
1429       if (QualifierLoc != nullptr)
1430         QualifierLoc->print(OS, Policy);
1431       OS << Node->getNameInfo();
1432     }
1433     OS << ":";
1434     VisitOMPClauseList(Node, ' ');
1435     OS << ")";
1436   }
1437 }
1438
1439 void OMPClausePrinter::VisitOMPTaskReductionClause(
1440     OMPTaskReductionClause *Node) {
1441   if (!Node->varlist_empty()) {
1442     OS << "task_reduction(";
1443     NestedNameSpecifier *QualifierLoc =
1444         Node->getQualifierLoc().getNestedNameSpecifier();
1445     OverloadedOperatorKind OOK =
1446         Node->getNameInfo().getName().getCXXOverloadedOperator();
1447     if (QualifierLoc == nullptr && OOK != OO_None) {
1448       // Print reduction identifier in C format
1449       OS << getOperatorSpelling(OOK);
1450     } else {
1451       // Use C++ format
1452       if (QualifierLoc != nullptr)
1453         QualifierLoc->print(OS, Policy);
1454       OS << Node->getNameInfo();
1455     }
1456     OS << ":";
1457     VisitOMPClauseList(Node, ' ');
1458     OS << ")";
1459   }
1460 }
1461
1462 void OMPClausePrinter::VisitOMPInReductionClause(OMPInReductionClause *Node) {
1463   if (!Node->varlist_empty()) {
1464     OS << "in_reduction(";
1465     NestedNameSpecifier *QualifierLoc =
1466         Node->getQualifierLoc().getNestedNameSpecifier();
1467     OverloadedOperatorKind OOK =
1468         Node->getNameInfo().getName().getCXXOverloadedOperator();
1469     if (QualifierLoc == nullptr && OOK != OO_None) {
1470       // Print reduction identifier in C format
1471       OS << getOperatorSpelling(OOK);
1472     } else {
1473       // Use C++ format
1474       if (QualifierLoc != nullptr)
1475         QualifierLoc->print(OS, Policy);
1476       OS << Node->getNameInfo();
1477     }
1478     OS << ":";
1479     VisitOMPClauseList(Node, ' ');
1480     OS << ")";
1481   }
1482 }
1483
1484 void OMPClausePrinter::VisitOMPLinearClause(OMPLinearClause *Node) {
1485   if (!Node->varlist_empty()) {
1486     OS << "linear";
1487     if (Node->getModifierLoc().isValid()) {
1488       OS << '('
1489          << getOpenMPSimpleClauseTypeName(OMPC_linear, Node->getModifier());
1490     }
1491     VisitOMPClauseList(Node, '(');
1492     if (Node->getModifierLoc().isValid())
1493       OS << ')';
1494     if (Node->getStep() != nullptr) {
1495       OS << ": ";
1496       Node->getStep()->printPretty(OS, nullptr, Policy, 0);
1497     }
1498     OS << ")";
1499   }
1500 }
1501
1502 void OMPClausePrinter::VisitOMPAlignedClause(OMPAlignedClause *Node) {
1503   if (!Node->varlist_empty()) {
1504     OS << "aligned";
1505     VisitOMPClauseList(Node, '(');
1506     if (Node->getAlignment() != nullptr) {
1507       OS << ": ";
1508       Node->getAlignment()->printPretty(OS, nullptr, Policy, 0);
1509     }
1510     OS << ")";
1511   }
1512 }
1513
1514 void OMPClausePrinter::VisitOMPCopyinClause(OMPCopyinClause *Node) {
1515   if (!Node->varlist_empty()) {
1516     OS << "copyin";
1517     VisitOMPClauseList(Node, '(');
1518     OS << ")";
1519   }
1520 }
1521
1522 void OMPClausePrinter::VisitOMPCopyprivateClause(OMPCopyprivateClause *Node) {
1523   if (!Node->varlist_empty()) {
1524     OS << "copyprivate";
1525     VisitOMPClauseList(Node, '(');
1526     OS << ")";
1527   }
1528 }
1529
1530 void OMPClausePrinter::VisitOMPFlushClause(OMPFlushClause *Node) {
1531   if (!Node->varlist_empty()) {
1532     VisitOMPClauseList(Node, '(');
1533     OS << ")";
1534   }
1535 }
1536
1537 void OMPClausePrinter::VisitOMPDependClause(OMPDependClause *Node) {
1538   OS << "depend(";
1539   OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(),
1540                                       Node->getDependencyKind());
1541   if (!Node->varlist_empty()) {
1542     OS << " :";
1543     VisitOMPClauseList(Node, ' ');
1544   }
1545   OS << ")";
1546 }
1547
1548 void OMPClausePrinter::VisitOMPMapClause(OMPMapClause *Node) {
1549   if (!Node->varlist_empty()) {
1550     OS << "map(";
1551     if (Node->getMapType() != OMPC_MAP_unknown) {
1552       for (unsigned I = 0; I < OMPMapClause::NumberOfModifiers; ++I) {
1553         if (Node->getMapTypeModifier(I) != OMPC_MAP_MODIFIER_unknown) {
1554           OS << getOpenMPSimpleClauseTypeName(OMPC_map,
1555                                               Node->getMapTypeModifier(I));
1556           if (Node->getMapTypeModifier(I) == OMPC_MAP_MODIFIER_mapper) {
1557             OS << '(';
1558             NestedNameSpecifier *MapperNNS =
1559                 Node->getMapperQualifierLoc().getNestedNameSpecifier();
1560             if (MapperNNS)
1561               MapperNNS->print(OS, Policy);
1562             OS << Node->getMapperIdInfo() << ')';
1563           }
1564           OS << ',';
1565         }
1566       }
1567       OS << getOpenMPSimpleClauseTypeName(OMPC_map, Node->getMapType());
1568       OS << ':';
1569     }
1570     VisitOMPClauseList(Node, ' ');
1571     OS << ")";
1572   }
1573 }
1574
1575 void OMPClausePrinter::VisitOMPToClause(OMPToClause *Node) {
1576   if (!Node->varlist_empty()) {
1577     OS << "to";
1578     DeclarationNameInfo MapperId = Node->getMapperIdInfo();
1579     if (MapperId.getName() && !MapperId.getName().isEmpty()) {
1580       OS << '(';
1581       OS << "mapper(";
1582       NestedNameSpecifier *MapperNNS =
1583           Node->getMapperQualifierLoc().getNestedNameSpecifier();
1584       if (MapperNNS)
1585         MapperNNS->print(OS, Policy);
1586       OS << MapperId << "):";
1587       VisitOMPClauseList(Node, ' ');
1588     } else {
1589       VisitOMPClauseList(Node, '(');
1590     }
1591     OS << ")";
1592   }
1593 }
1594
1595 void OMPClausePrinter::VisitOMPFromClause(OMPFromClause *Node) {
1596   if (!Node->varlist_empty()) {
1597     OS << "from";
1598     DeclarationNameInfo MapperId = Node->getMapperIdInfo();
1599     if (MapperId.getName() && !MapperId.getName().isEmpty()) {
1600       OS << '(';
1601       OS << "mapper(";
1602       NestedNameSpecifier *MapperNNS =
1603           Node->getMapperQualifierLoc().getNestedNameSpecifier();
1604       if (MapperNNS)
1605         MapperNNS->print(OS, Policy);
1606       OS << MapperId << "):";
1607       VisitOMPClauseList(Node, ' ');
1608     } else {
1609       VisitOMPClauseList(Node, '(');
1610     }
1611     OS << ")";
1612   }
1613 }
1614
1615 void OMPClausePrinter::VisitOMPDistScheduleClause(OMPDistScheduleClause *Node) {
1616   OS << "dist_schedule(" << getOpenMPSimpleClauseTypeName(
1617                            OMPC_dist_schedule, Node->getDistScheduleKind());
1618   if (auto *E = Node->getChunkSize()) {
1619     OS << ", ";
1620     E->printPretty(OS, nullptr, Policy);
1621   }
1622   OS << ")";
1623 }
1624
1625 void OMPClausePrinter::VisitOMPDefaultmapClause(OMPDefaultmapClause *Node) {
1626   OS << "defaultmap(";
1627   OS << getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
1628                                       Node->getDefaultmapModifier());
1629   OS << ": ";
1630   OS << getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
1631     Node->getDefaultmapKind());
1632   OS << ")";
1633 }
1634
1635 void OMPClausePrinter::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *Node) {
1636   if (!Node->varlist_empty()) {
1637     OS << "use_device_ptr";
1638     VisitOMPClauseList(Node, '(');
1639     OS << ")";
1640   }
1641 }
1642
1643 void OMPClausePrinter::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *Node) {
1644   if (!Node->varlist_empty()) {
1645     OS << "is_device_ptr";
1646     VisitOMPClauseList(Node, '(');
1647     OS << ")";
1648   }
1649 }
1650