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