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