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