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