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