xref: /freebsd/contrib/llvm-project/clang/lib/AST/OpenMPClause.cpp (revision 0fca6ea1d4eea4c934cfff25ac9ee8ad6fe95583)
1 //===- OpenMPClause.cpp - Classes for OpenMP clauses ----------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the subclesses of Stmt class declared in OpenMPClause.h
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/AST/OpenMPClause.h"
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/Attr.h"
16 #include "clang/AST/Decl.h"
17 #include "clang/AST/DeclOpenMP.h"
18 #include "clang/Basic/LLVM.h"
19 #include "clang/Basic/OpenMPKinds.h"
20 #include "clang/Basic/TargetInfo.h"
21 #include "llvm/ADT/SmallPtrSet.h"
22 #include "llvm/Support/Casting.h"
23 #include "llvm/Support/ErrorHandling.h"
24 #include <algorithm>
25 #include <cassert>
26 #include <optional>
27 
28 using namespace clang;
29 using namespace llvm;
30 using namespace omp;
31 
children()32 OMPClause::child_range OMPClause::children() {
33   switch (getClauseKind()) {
34   default:
35     break;
36 #define GEN_CLANG_CLAUSE_CLASS
37 #define CLAUSE_CLASS(Enum, Str, Class)                                         \
38   case Enum:                                                                   \
39     return static_cast<Class *>(this)->children();
40 #include "llvm/Frontend/OpenMP/OMP.inc"
41   }
42   llvm_unreachable("unknown OMPClause");
43 }
44 
used_children()45 OMPClause::child_range OMPClause::used_children() {
46   switch (getClauseKind()) {
47 #define GEN_CLANG_CLAUSE_CLASS
48 #define CLAUSE_CLASS(Enum, Str, Class)                                         \
49   case Enum:                                                                   \
50     return static_cast<Class *>(this)->used_children();
51 #define CLAUSE_NO_CLASS(Enum, Str)                                             \
52   case Enum:                                                                   \
53     break;
54 #include "llvm/Frontend/OpenMP/OMP.inc"
55   }
56   llvm_unreachable("unknown OMPClause");
57 }
58 
get(OMPClause * C)59 OMPClauseWithPreInit *OMPClauseWithPreInit::get(OMPClause *C) {
60   auto *Res = OMPClauseWithPreInit::get(const_cast<const OMPClause *>(C));
61   return Res ? const_cast<OMPClauseWithPreInit *>(Res) : nullptr;
62 }
63 
get(const OMPClause * C)64 const OMPClauseWithPreInit *OMPClauseWithPreInit::get(const OMPClause *C) {
65   switch (C->getClauseKind()) {
66   case OMPC_schedule:
67     return static_cast<const OMPScheduleClause *>(C);
68   case OMPC_dist_schedule:
69     return static_cast<const OMPDistScheduleClause *>(C);
70   case OMPC_firstprivate:
71     return static_cast<const OMPFirstprivateClause *>(C);
72   case OMPC_lastprivate:
73     return static_cast<const OMPLastprivateClause *>(C);
74   case OMPC_reduction:
75     return static_cast<const OMPReductionClause *>(C);
76   case OMPC_task_reduction:
77     return static_cast<const OMPTaskReductionClause *>(C);
78   case OMPC_in_reduction:
79     return static_cast<const OMPInReductionClause *>(C);
80   case OMPC_linear:
81     return static_cast<const OMPLinearClause *>(C);
82   case OMPC_if:
83     return static_cast<const OMPIfClause *>(C);
84   case OMPC_num_threads:
85     return static_cast<const OMPNumThreadsClause *>(C);
86   case OMPC_num_teams:
87     return static_cast<const OMPNumTeamsClause *>(C);
88   case OMPC_thread_limit:
89     return static_cast<const OMPThreadLimitClause *>(C);
90   case OMPC_device:
91     return static_cast<const OMPDeviceClause *>(C);
92   case OMPC_grainsize:
93     return static_cast<const OMPGrainsizeClause *>(C);
94   case OMPC_num_tasks:
95     return static_cast<const OMPNumTasksClause *>(C);
96   case OMPC_final:
97     return static_cast<const OMPFinalClause *>(C);
98   case OMPC_priority:
99     return static_cast<const OMPPriorityClause *>(C);
100   case OMPC_novariants:
101     return static_cast<const OMPNovariantsClause *>(C);
102   case OMPC_nocontext:
103     return static_cast<const OMPNocontextClause *>(C);
104   case OMPC_filter:
105     return static_cast<const OMPFilterClause *>(C);
106   case OMPC_ompx_dyn_cgroup_mem:
107     return static_cast<const OMPXDynCGroupMemClause *>(C);
108   case OMPC_default:
109   case OMPC_proc_bind:
110   case OMPC_safelen:
111   case OMPC_simdlen:
112   case OMPC_sizes:
113   case OMPC_allocator:
114   case OMPC_allocate:
115   case OMPC_collapse:
116   case OMPC_private:
117   case OMPC_shared:
118   case OMPC_aligned:
119   case OMPC_copyin:
120   case OMPC_copyprivate:
121   case OMPC_ordered:
122   case OMPC_nowait:
123   case OMPC_untied:
124   case OMPC_mergeable:
125   case OMPC_threadprivate:
126   case OMPC_flush:
127   case OMPC_depobj:
128   case OMPC_read:
129   case OMPC_write:
130   case OMPC_update:
131   case OMPC_capture:
132   case OMPC_compare:
133   case OMPC_fail:
134   case OMPC_seq_cst:
135   case OMPC_acq_rel:
136   case OMPC_acquire:
137   case OMPC_release:
138   case OMPC_relaxed:
139   case OMPC_depend:
140   case OMPC_threads:
141   case OMPC_simd:
142   case OMPC_map:
143   case OMPC_nogroup:
144   case OMPC_hint:
145   case OMPC_defaultmap:
146   case OMPC_unknown:
147   case OMPC_uniform:
148   case OMPC_to:
149   case OMPC_from:
150   case OMPC_use_device_ptr:
151   case OMPC_use_device_addr:
152   case OMPC_is_device_ptr:
153   case OMPC_has_device_addr:
154   case OMPC_unified_address:
155   case OMPC_unified_shared_memory:
156   case OMPC_reverse_offload:
157   case OMPC_dynamic_allocators:
158   case OMPC_atomic_default_mem_order:
159   case OMPC_at:
160   case OMPC_severity:
161   case OMPC_message:
162   case OMPC_device_type:
163   case OMPC_match:
164   case OMPC_nontemporal:
165   case OMPC_order:
166   case OMPC_destroy:
167   case OMPC_detach:
168   case OMPC_inclusive:
169   case OMPC_exclusive:
170   case OMPC_uses_allocators:
171   case OMPC_affinity:
172   case OMPC_when:
173   case OMPC_bind:
174   case OMPC_ompx_bare:
175     break;
176   default:
177     break;
178   }
179 
180   return nullptr;
181 }
182 
get(OMPClause * C)183 OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(OMPClause *C) {
184   auto *Res = OMPClauseWithPostUpdate::get(const_cast<const OMPClause *>(C));
185   return Res ? const_cast<OMPClauseWithPostUpdate *>(Res) : nullptr;
186 }
187 
get(const OMPClause * C)188 const OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(const OMPClause *C) {
189   switch (C->getClauseKind()) {
190   case OMPC_lastprivate:
191     return static_cast<const OMPLastprivateClause *>(C);
192   case OMPC_reduction:
193     return static_cast<const OMPReductionClause *>(C);
194   case OMPC_task_reduction:
195     return static_cast<const OMPTaskReductionClause *>(C);
196   case OMPC_in_reduction:
197     return static_cast<const OMPInReductionClause *>(C);
198   case OMPC_linear:
199     return static_cast<const OMPLinearClause *>(C);
200   case OMPC_schedule:
201   case OMPC_dist_schedule:
202   case OMPC_firstprivate:
203   case OMPC_default:
204   case OMPC_proc_bind:
205   case OMPC_if:
206   case OMPC_final:
207   case OMPC_num_threads:
208   case OMPC_safelen:
209   case OMPC_simdlen:
210   case OMPC_sizes:
211   case OMPC_allocator:
212   case OMPC_allocate:
213   case OMPC_collapse:
214   case OMPC_private:
215   case OMPC_shared:
216   case OMPC_aligned:
217   case OMPC_copyin:
218   case OMPC_copyprivate:
219   case OMPC_ordered:
220   case OMPC_nowait:
221   case OMPC_untied:
222   case OMPC_mergeable:
223   case OMPC_threadprivate:
224   case OMPC_flush:
225   case OMPC_depobj:
226   case OMPC_read:
227   case OMPC_write:
228   case OMPC_update:
229   case OMPC_capture:
230   case OMPC_compare:
231   case OMPC_fail:
232   case OMPC_seq_cst:
233   case OMPC_acq_rel:
234   case OMPC_acquire:
235   case OMPC_release:
236   case OMPC_relaxed:
237   case OMPC_depend:
238   case OMPC_device:
239   case OMPC_threads:
240   case OMPC_simd:
241   case OMPC_map:
242   case OMPC_num_teams:
243   case OMPC_thread_limit:
244   case OMPC_priority:
245   case OMPC_grainsize:
246   case OMPC_nogroup:
247   case OMPC_num_tasks:
248   case OMPC_hint:
249   case OMPC_defaultmap:
250   case OMPC_unknown:
251   case OMPC_uniform:
252   case OMPC_to:
253   case OMPC_from:
254   case OMPC_use_device_ptr:
255   case OMPC_use_device_addr:
256   case OMPC_is_device_ptr:
257   case OMPC_has_device_addr:
258   case OMPC_unified_address:
259   case OMPC_unified_shared_memory:
260   case OMPC_reverse_offload:
261   case OMPC_dynamic_allocators:
262   case OMPC_atomic_default_mem_order:
263   case OMPC_at:
264   case OMPC_severity:
265   case OMPC_message:
266   case OMPC_device_type:
267   case OMPC_match:
268   case OMPC_nontemporal:
269   case OMPC_order:
270   case OMPC_destroy:
271   case OMPC_novariants:
272   case OMPC_nocontext:
273   case OMPC_detach:
274   case OMPC_inclusive:
275   case OMPC_exclusive:
276   case OMPC_uses_allocators:
277   case OMPC_affinity:
278   case OMPC_when:
279   case OMPC_bind:
280     break;
281   default:
282     break;
283   }
284 
285   return nullptr;
286 }
287 
288 /// Gets the address of the original, non-captured, expression used in the
289 /// clause as the preinitializer.
getAddrOfExprAsWritten(Stmt * S)290 static Stmt **getAddrOfExprAsWritten(Stmt *S) {
291   if (!S)
292     return nullptr;
293   if (auto *DS = dyn_cast<DeclStmt>(S)) {
294     assert(DS->isSingleDecl() && "Only single expression must be captured.");
295     if (auto *OED = dyn_cast<OMPCapturedExprDecl>(DS->getSingleDecl()))
296       return OED->getInitAddress();
297   }
298   return nullptr;
299 }
300 
used_children()301 OMPClause::child_range OMPIfClause::used_children() {
302   if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
303     return child_range(C, C + 1);
304   return child_range(&Condition, &Condition + 1);
305 }
306 
used_children()307 OMPClause::child_range OMPGrainsizeClause::used_children() {
308   if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
309     return child_range(C, C + 1);
310   return child_range(&Grainsize, &Grainsize + 1);
311 }
312 
used_children()313 OMPClause::child_range OMPNumTasksClause::used_children() {
314   if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
315     return child_range(C, C + 1);
316   return child_range(&NumTasks, &NumTasks + 1);
317 }
318 
used_children()319 OMPClause::child_range OMPFinalClause::used_children() {
320   if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
321     return child_range(C, C + 1);
322   return children();
323 }
324 
used_children()325 OMPClause::child_range OMPPriorityClause::used_children() {
326   if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
327     return child_range(C, C + 1);
328   return child_range(&Priority, &Priority + 1);
329 }
330 
used_children()331 OMPClause::child_range OMPNovariantsClause::used_children() {
332   if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
333     return child_range(C, C + 1);
334   return children();
335 }
336 
used_children()337 OMPClause::child_range OMPNocontextClause::used_children() {
338   if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
339     return child_range(C, C + 1);
340   return children();
341 }
342 
Create(const ASTContext & C,Expr * Num,unsigned NumLoops,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)343 OMPOrderedClause *OMPOrderedClause::Create(const ASTContext &C, Expr *Num,
344                                            unsigned NumLoops,
345                                            SourceLocation StartLoc,
346                                            SourceLocation LParenLoc,
347                                            SourceLocation EndLoc) {
348   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * NumLoops));
349   auto *Clause =
350       new (Mem) OMPOrderedClause(Num, NumLoops, StartLoc, LParenLoc, EndLoc);
351   for (unsigned I = 0; I < NumLoops; ++I) {
352     Clause->setLoopNumIterations(I, nullptr);
353     Clause->setLoopCounter(I, nullptr);
354   }
355   return Clause;
356 }
357 
CreateEmpty(const ASTContext & C,unsigned NumLoops)358 OMPOrderedClause *OMPOrderedClause::CreateEmpty(const ASTContext &C,
359                                                 unsigned NumLoops) {
360   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * NumLoops));
361   auto *Clause = new (Mem) OMPOrderedClause(NumLoops);
362   for (unsigned I = 0; I < NumLoops; ++I) {
363     Clause->setLoopNumIterations(I, nullptr);
364     Clause->setLoopCounter(I, nullptr);
365   }
366   return Clause;
367 }
368 
setLoopNumIterations(unsigned NumLoop,Expr * NumIterations)369 void OMPOrderedClause::setLoopNumIterations(unsigned NumLoop,
370                                             Expr *NumIterations) {
371   assert(NumLoop < NumberOfLoops && "out of loops number.");
372   getTrailingObjects<Expr *>()[NumLoop] = NumIterations;
373 }
374 
getLoopNumIterations() const375 ArrayRef<Expr *> OMPOrderedClause::getLoopNumIterations() const {
376   return llvm::ArrayRef(getTrailingObjects<Expr *>(), NumberOfLoops);
377 }
378 
setLoopCounter(unsigned NumLoop,Expr * Counter)379 void OMPOrderedClause::setLoopCounter(unsigned NumLoop, Expr *Counter) {
380   assert(NumLoop < NumberOfLoops && "out of loops number.");
381   getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop] = Counter;
382 }
383 
getLoopCounter(unsigned NumLoop)384 Expr *OMPOrderedClause::getLoopCounter(unsigned NumLoop) {
385   assert(NumLoop < NumberOfLoops && "out of loops number.");
386   return getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop];
387 }
388 
getLoopCounter(unsigned NumLoop) const389 const Expr *OMPOrderedClause::getLoopCounter(unsigned NumLoop) const {
390   assert(NumLoop < NumberOfLoops && "out of loops number.");
391   return getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop];
392 }
393 
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc)394 OMPUpdateClause *OMPUpdateClause::Create(const ASTContext &C,
395                                          SourceLocation StartLoc,
396                                          SourceLocation EndLoc) {
397   return new (C) OMPUpdateClause(StartLoc, EndLoc, /*IsExtended=*/false);
398 }
399 
400 OMPUpdateClause *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation ArgumentLoc,OpenMPDependClauseKind DK,SourceLocation EndLoc)401 OMPUpdateClause::Create(const ASTContext &C, SourceLocation StartLoc,
402                         SourceLocation LParenLoc, SourceLocation ArgumentLoc,
403                         OpenMPDependClauseKind DK, SourceLocation EndLoc) {
404   void *Mem =
405       C.Allocate(totalSizeToAlloc<SourceLocation, OpenMPDependClauseKind>(2, 1),
406                  alignof(OMPUpdateClause));
407   auto *Clause =
408       new (Mem) OMPUpdateClause(StartLoc, EndLoc, /*IsExtended=*/true);
409   Clause->setLParenLoc(LParenLoc);
410   Clause->setArgumentLoc(ArgumentLoc);
411   Clause->setDependencyKind(DK);
412   return Clause;
413 }
414 
CreateEmpty(const ASTContext & C,bool IsExtended)415 OMPUpdateClause *OMPUpdateClause::CreateEmpty(const ASTContext &C,
416                                               bool IsExtended) {
417   if (!IsExtended)
418     return new (C) OMPUpdateClause(/*IsExtended=*/false);
419   void *Mem =
420       C.Allocate(totalSizeToAlloc<SourceLocation, OpenMPDependClauseKind>(2, 1),
421                  alignof(OMPUpdateClause));
422   auto *Clause = new (Mem) OMPUpdateClause(/*IsExtended=*/true);
423   Clause->IsExtended = true;
424   return Clause;
425 }
426 
setPrivateCopies(ArrayRef<Expr * > VL)427 void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
428   assert(VL.size() == varlist_size() &&
429          "Number of private copies is not the same as the preallocated buffer");
430   std::copy(VL.begin(), VL.end(), varlist_end());
431 }
432 
433 OMPPrivateClause *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > PrivateVL)434 OMPPrivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
435                          SourceLocation LParenLoc, SourceLocation EndLoc,
436                          ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) {
437   // Allocate space for private variables and initializer expressions.
438   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * VL.size()));
439   OMPPrivateClause *Clause =
440       new (Mem) OMPPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
441   Clause->setVarRefs(VL);
442   Clause->setPrivateCopies(PrivateVL);
443   return Clause;
444 }
445 
CreateEmpty(const ASTContext & C,unsigned N)446 OMPPrivateClause *OMPPrivateClause::CreateEmpty(const ASTContext &C,
447                                                 unsigned N) {
448   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * N));
449   return new (Mem) OMPPrivateClause(N);
450 }
451 
setPrivateCopies(ArrayRef<Expr * > VL)452 void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
453   assert(VL.size() == varlist_size() &&
454          "Number of private copies is not the same as the preallocated buffer");
455   std::copy(VL.begin(), VL.end(), varlist_end());
456 }
457 
setInits(ArrayRef<Expr * > VL)458 void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) {
459   assert(VL.size() == varlist_size() &&
460          "Number of inits is not the same as the preallocated buffer");
461   std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
462 }
463 
464 OMPFirstprivateClause *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > PrivateVL,ArrayRef<Expr * > InitVL,Stmt * PreInit)465 OMPFirstprivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
466                               SourceLocation LParenLoc, SourceLocation EndLoc,
467                               ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
468                               ArrayRef<Expr *> InitVL, Stmt *PreInit) {
469   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * VL.size()));
470   OMPFirstprivateClause *Clause =
471       new (Mem) OMPFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
472   Clause->setVarRefs(VL);
473   Clause->setPrivateCopies(PrivateVL);
474   Clause->setInits(InitVL);
475   Clause->setPreInitStmt(PreInit);
476   return Clause;
477 }
478 
CreateEmpty(const ASTContext & C,unsigned N)479 OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C,
480                                                           unsigned N) {
481   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * N));
482   return new (Mem) OMPFirstprivateClause(N);
483 }
484 
setPrivateCopies(ArrayRef<Expr * > PrivateCopies)485 void OMPLastprivateClause::setPrivateCopies(ArrayRef<Expr *> PrivateCopies) {
486   assert(PrivateCopies.size() == varlist_size() &&
487          "Number of private copies is not the same as the preallocated buffer");
488   std::copy(PrivateCopies.begin(), PrivateCopies.end(), varlist_end());
489 }
490 
setSourceExprs(ArrayRef<Expr * > SrcExprs)491 void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
492   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
493                                               "not the same as the "
494                                               "preallocated buffer");
495   std::copy(SrcExprs.begin(), SrcExprs.end(), getPrivateCopies().end());
496 }
497 
setDestinationExprs(ArrayRef<Expr * > DstExprs)498 void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
499   assert(DstExprs.size() == varlist_size() && "Number of destination "
500                                               "expressions is not the same as "
501                                               "the preallocated buffer");
502   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
503 }
504 
setAssignmentOps(ArrayRef<Expr * > AssignmentOps)505 void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
506   assert(AssignmentOps.size() == varlist_size() &&
507          "Number of assignment expressions is not the same as the preallocated "
508          "buffer");
509   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
510             getDestinationExprs().end());
511 }
512 
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > SrcExprs,ArrayRef<Expr * > DstExprs,ArrayRef<Expr * > AssignmentOps,OpenMPLastprivateModifier LPKind,SourceLocation LPKindLoc,SourceLocation ColonLoc,Stmt * PreInit,Expr * PostUpdate)513 OMPLastprivateClause *OMPLastprivateClause::Create(
514     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
515     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
516     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps,
517     OpenMPLastprivateModifier LPKind, SourceLocation LPKindLoc,
518     SourceLocation ColonLoc, Stmt *PreInit, Expr *PostUpdate) {
519   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
520   OMPLastprivateClause *Clause = new (Mem) OMPLastprivateClause(
521       StartLoc, LParenLoc, EndLoc, LPKind, LPKindLoc, ColonLoc, VL.size());
522   Clause->setVarRefs(VL);
523   Clause->setSourceExprs(SrcExprs);
524   Clause->setDestinationExprs(DstExprs);
525   Clause->setAssignmentOps(AssignmentOps);
526   Clause->setPreInitStmt(PreInit);
527   Clause->setPostUpdateExpr(PostUpdate);
528   return Clause;
529 }
530 
CreateEmpty(const ASTContext & C,unsigned N)531 OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C,
532                                                         unsigned N) {
533   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
534   return new (Mem) OMPLastprivateClause(N);
535 }
536 
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL)537 OMPSharedClause *OMPSharedClause::Create(const ASTContext &C,
538                                          SourceLocation StartLoc,
539                                          SourceLocation LParenLoc,
540                                          SourceLocation EndLoc,
541                                          ArrayRef<Expr *> VL) {
542   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
543   OMPSharedClause *Clause =
544       new (Mem) OMPSharedClause(StartLoc, LParenLoc, EndLoc, VL.size());
545   Clause->setVarRefs(VL);
546   return Clause;
547 }
548 
CreateEmpty(const ASTContext & C,unsigned N)549 OMPSharedClause *OMPSharedClause::CreateEmpty(const ASTContext &C, unsigned N) {
550   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
551   return new (Mem) OMPSharedClause(N);
552 }
553 
setPrivates(ArrayRef<Expr * > PL)554 void OMPLinearClause::setPrivates(ArrayRef<Expr *> PL) {
555   assert(PL.size() == varlist_size() &&
556          "Number of privates is not the same as the preallocated buffer");
557   std::copy(PL.begin(), PL.end(), varlist_end());
558 }
559 
setInits(ArrayRef<Expr * > IL)560 void OMPLinearClause::setInits(ArrayRef<Expr *> IL) {
561   assert(IL.size() == varlist_size() &&
562          "Number of inits is not the same as the preallocated buffer");
563   std::copy(IL.begin(), IL.end(), getPrivates().end());
564 }
565 
setUpdates(ArrayRef<Expr * > UL)566 void OMPLinearClause::setUpdates(ArrayRef<Expr *> UL) {
567   assert(UL.size() == varlist_size() &&
568          "Number of updates is not the same as the preallocated buffer");
569   std::copy(UL.begin(), UL.end(), getInits().end());
570 }
571 
setFinals(ArrayRef<Expr * > FL)572 void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) {
573   assert(FL.size() == varlist_size() &&
574          "Number of final updates is not the same as the preallocated buffer");
575   std::copy(FL.begin(), FL.end(), getUpdates().end());
576 }
577 
setUsedExprs(ArrayRef<Expr * > UE)578 void OMPLinearClause::setUsedExprs(ArrayRef<Expr *> UE) {
579   assert(
580       UE.size() == varlist_size() + 1 &&
581       "Number of used expressions is not the same as the preallocated buffer");
582   std::copy(UE.begin(), UE.end(), getFinals().end() + 2);
583 }
584 
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,OpenMPLinearClauseKind Modifier,SourceLocation ModifierLoc,SourceLocation ColonLoc,SourceLocation StepModifierLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > PL,ArrayRef<Expr * > IL,Expr * Step,Expr * CalcStep,Stmt * PreInit,Expr * PostUpdate)585 OMPLinearClause *OMPLinearClause::Create(
586     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
587     OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
588     SourceLocation ColonLoc, SourceLocation StepModifierLoc,
589     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> PL,
590     ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep, Stmt *PreInit,
591     Expr *PostUpdate) {
592   // Allocate space for 5 lists (Vars, Inits, Updates, Finals), 2 expressions
593   // (Step and CalcStep), list of used expression + step.
594   void *Mem =
595       C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2 + VL.size() + 1));
596   OMPLinearClause *Clause =
597       new (Mem) OMPLinearClause(StartLoc, LParenLoc, Modifier, ModifierLoc,
598                                 ColonLoc, StepModifierLoc, EndLoc, VL.size());
599   Clause->setVarRefs(VL);
600   Clause->setPrivates(PL);
601   Clause->setInits(IL);
602   // Fill update and final expressions with zeroes, they are provided later,
603   // after the directive construction.
604   std::fill(Clause->getInits().end(), Clause->getInits().end() + VL.size(),
605             nullptr);
606   std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(),
607             nullptr);
608   std::fill(Clause->getUsedExprs().begin(), Clause->getUsedExprs().end(),
609             nullptr);
610   Clause->setStep(Step);
611   Clause->setCalcStep(CalcStep);
612   Clause->setPreInitStmt(PreInit);
613   Clause->setPostUpdateExpr(PostUpdate);
614   return Clause;
615 }
616 
CreateEmpty(const ASTContext & C,unsigned NumVars)617 OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C,
618                                               unsigned NumVars) {
619   // Allocate space for 5 lists (Vars, Inits, Updates, Finals), 2 expressions
620   // (Step and CalcStep), list of used expression + step.
621   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2 + NumVars  +1));
622   return new (Mem) OMPLinearClause(NumVars);
623 }
624 
used_children()625 OMPClause::child_range OMPLinearClause::used_children() {
626   // Range includes only non-nullptr elements.
627   return child_range(
628       reinterpret_cast<Stmt **>(getUsedExprs().begin()),
629       reinterpret_cast<Stmt **>(llvm::find(getUsedExprs(), nullptr)));
630 }
631 
632 OMPAlignedClause *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation ColonLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,Expr * A)633 OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc,
634                          SourceLocation LParenLoc, SourceLocation ColonLoc,
635                          SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) {
636   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
637   OMPAlignedClause *Clause = new (Mem)
638       OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
639   Clause->setVarRefs(VL);
640   Clause->setAlignment(A);
641   return Clause;
642 }
643 
CreateEmpty(const ASTContext & C,unsigned NumVars)644 OMPAlignedClause *OMPAlignedClause::CreateEmpty(const ASTContext &C,
645                                                 unsigned NumVars) {
646   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumVars + 1));
647   return new (Mem) OMPAlignedClause(NumVars);
648 }
649 
Create(const ASTContext & C,Expr * A,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)650 OMPAlignClause *OMPAlignClause::Create(const ASTContext &C, Expr *A,
651                                        SourceLocation StartLoc,
652                                        SourceLocation LParenLoc,
653                                        SourceLocation EndLoc) {
654   return new (C) OMPAlignClause(A, StartLoc, LParenLoc, EndLoc);
655 }
656 
setSourceExprs(ArrayRef<Expr * > SrcExprs)657 void OMPCopyinClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
658   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
659                                               "not the same as the "
660                                               "preallocated buffer");
661   std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
662 }
663 
setDestinationExprs(ArrayRef<Expr * > DstExprs)664 void OMPCopyinClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
665   assert(DstExprs.size() == varlist_size() && "Number of destination "
666                                               "expressions is not the same as "
667                                               "the preallocated buffer");
668   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
669 }
670 
setAssignmentOps(ArrayRef<Expr * > AssignmentOps)671 void OMPCopyinClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
672   assert(AssignmentOps.size() == varlist_size() &&
673          "Number of assignment expressions is not the same as the preallocated "
674          "buffer");
675   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
676             getDestinationExprs().end());
677 }
678 
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > SrcExprs,ArrayRef<Expr * > DstExprs,ArrayRef<Expr * > AssignmentOps)679 OMPCopyinClause *OMPCopyinClause::Create(
680     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
681     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
682     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
683   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
684   OMPCopyinClause *Clause =
685       new (Mem) OMPCopyinClause(StartLoc, LParenLoc, EndLoc, VL.size());
686   Clause->setVarRefs(VL);
687   Clause->setSourceExprs(SrcExprs);
688   Clause->setDestinationExprs(DstExprs);
689   Clause->setAssignmentOps(AssignmentOps);
690   return Clause;
691 }
692 
CreateEmpty(const ASTContext & C,unsigned N)693 OMPCopyinClause *OMPCopyinClause::CreateEmpty(const ASTContext &C, unsigned N) {
694   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
695   return new (Mem) OMPCopyinClause(N);
696 }
697 
setSourceExprs(ArrayRef<Expr * > SrcExprs)698 void OMPCopyprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
699   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
700                                               "not the same as the "
701                                               "preallocated buffer");
702   std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
703 }
704 
setDestinationExprs(ArrayRef<Expr * > DstExprs)705 void OMPCopyprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
706   assert(DstExprs.size() == varlist_size() && "Number of destination "
707                                               "expressions is not the same as "
708                                               "the preallocated buffer");
709   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
710 }
711 
setAssignmentOps(ArrayRef<Expr * > AssignmentOps)712 void OMPCopyprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
713   assert(AssignmentOps.size() == varlist_size() &&
714          "Number of assignment expressions is not the same as the preallocated "
715          "buffer");
716   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
717             getDestinationExprs().end());
718 }
719 
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > SrcExprs,ArrayRef<Expr * > DstExprs,ArrayRef<Expr * > AssignmentOps)720 OMPCopyprivateClause *OMPCopyprivateClause::Create(
721     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
722     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
723     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
724   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
725   OMPCopyprivateClause *Clause =
726       new (Mem) OMPCopyprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
727   Clause->setVarRefs(VL);
728   Clause->setSourceExprs(SrcExprs);
729   Clause->setDestinationExprs(DstExprs);
730   Clause->setAssignmentOps(AssignmentOps);
731   return Clause;
732 }
733 
CreateEmpty(const ASTContext & C,unsigned N)734 OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(const ASTContext &C,
735                                                         unsigned N) {
736   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
737   return new (Mem) OMPCopyprivateClause(N);
738 }
739 
setPrivates(ArrayRef<Expr * > Privates)740 void OMPReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
741   assert(Privates.size() == varlist_size() &&
742          "Number of private copies is not the same as the preallocated buffer");
743   std::copy(Privates.begin(), Privates.end(), varlist_end());
744 }
745 
setLHSExprs(ArrayRef<Expr * > LHSExprs)746 void OMPReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
747   assert(
748       LHSExprs.size() == varlist_size() &&
749       "Number of LHS expressions is not the same as the preallocated buffer");
750   std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
751 }
752 
setRHSExprs(ArrayRef<Expr * > RHSExprs)753 void OMPReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
754   assert(
755       RHSExprs.size() == varlist_size() &&
756       "Number of RHS expressions is not the same as the preallocated buffer");
757   std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
758 }
759 
setReductionOps(ArrayRef<Expr * > ReductionOps)760 void OMPReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
761   assert(ReductionOps.size() == varlist_size() && "Number of reduction "
762                                                   "expressions is not the same "
763                                                   "as the preallocated buffer");
764   std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
765 }
766 
setInscanCopyOps(ArrayRef<Expr * > Ops)767 void OMPReductionClause::setInscanCopyOps(ArrayRef<Expr *> Ops) {
768   assert(Modifier == OMPC_REDUCTION_inscan && "Expected inscan reduction.");
769   assert(Ops.size() == varlist_size() && "Number of copy "
770                                          "expressions is not the same "
771                                          "as the preallocated buffer");
772   llvm::copy(Ops, getReductionOps().end());
773 }
774 
setInscanCopyArrayTemps(ArrayRef<Expr * > CopyArrayTemps)775 void OMPReductionClause::setInscanCopyArrayTemps(
776     ArrayRef<Expr *> CopyArrayTemps) {
777   assert(Modifier == OMPC_REDUCTION_inscan && "Expected inscan reduction.");
778   assert(CopyArrayTemps.size() == varlist_size() &&
779          "Number of copy temp expressions is not the same as the preallocated "
780          "buffer");
781   llvm::copy(CopyArrayTemps, getInscanCopyOps().end());
782 }
783 
setInscanCopyArrayElems(ArrayRef<Expr * > CopyArrayElems)784 void OMPReductionClause::setInscanCopyArrayElems(
785     ArrayRef<Expr *> CopyArrayElems) {
786   assert(Modifier == OMPC_REDUCTION_inscan && "Expected inscan reduction.");
787   assert(CopyArrayElems.size() == varlist_size() &&
788          "Number of copy temp expressions is not the same as the preallocated "
789          "buffer");
790   llvm::copy(CopyArrayElems, getInscanCopyArrayTemps().end());
791 }
792 
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation ModifierLoc,SourceLocation EndLoc,SourceLocation ColonLoc,OpenMPReductionClauseModifier Modifier,ArrayRef<Expr * > VL,NestedNameSpecifierLoc QualifierLoc,const DeclarationNameInfo & NameInfo,ArrayRef<Expr * > Privates,ArrayRef<Expr * > LHSExprs,ArrayRef<Expr * > RHSExprs,ArrayRef<Expr * > ReductionOps,ArrayRef<Expr * > CopyOps,ArrayRef<Expr * > CopyArrayTemps,ArrayRef<Expr * > CopyArrayElems,Stmt * PreInit,Expr * PostUpdate)793 OMPReductionClause *OMPReductionClause::Create(
794     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
795     SourceLocation ModifierLoc, SourceLocation EndLoc, SourceLocation ColonLoc,
796     OpenMPReductionClauseModifier Modifier, ArrayRef<Expr *> VL,
797     NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
798     ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
799     ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps,
800     ArrayRef<Expr *> CopyOps, ArrayRef<Expr *> CopyArrayTemps,
801     ArrayRef<Expr *> CopyArrayElems, Stmt *PreInit, Expr *PostUpdate) {
802   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(
803       (Modifier == OMPC_REDUCTION_inscan ? 8 : 5) * VL.size()));
804   auto *Clause = new (Mem)
805       OMPReductionClause(StartLoc, LParenLoc, ModifierLoc, EndLoc, ColonLoc,
806                          Modifier, VL.size(), QualifierLoc, NameInfo);
807   Clause->setVarRefs(VL);
808   Clause->setPrivates(Privates);
809   Clause->setLHSExprs(LHSExprs);
810   Clause->setRHSExprs(RHSExprs);
811   Clause->setReductionOps(ReductionOps);
812   Clause->setPreInitStmt(PreInit);
813   Clause->setPostUpdateExpr(PostUpdate);
814   if (Modifier == OMPC_REDUCTION_inscan) {
815     Clause->setInscanCopyOps(CopyOps);
816     Clause->setInscanCopyArrayTemps(CopyArrayTemps);
817     Clause->setInscanCopyArrayElems(CopyArrayElems);
818   } else {
819     assert(CopyOps.empty() &&
820            "copy operations are expected in inscan reductions only.");
821     assert(CopyArrayTemps.empty() &&
822            "copy array temps are expected in inscan reductions only.");
823     assert(CopyArrayElems.empty() &&
824            "copy array temps are expected in inscan reductions only.");
825   }
826   return Clause;
827 }
828 
829 OMPReductionClause *
CreateEmpty(const ASTContext & C,unsigned N,OpenMPReductionClauseModifier Modifier)830 OMPReductionClause::CreateEmpty(const ASTContext &C, unsigned N,
831                                 OpenMPReductionClauseModifier Modifier) {
832   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(
833       (Modifier == OMPC_REDUCTION_inscan ? 8 : 5) * N));
834   auto *Clause = new (Mem) OMPReductionClause(N);
835   Clause->setModifier(Modifier);
836   return Clause;
837 }
838 
setPrivates(ArrayRef<Expr * > Privates)839 void OMPTaskReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
840   assert(Privates.size() == varlist_size() &&
841          "Number of private copies is not the same as the preallocated buffer");
842   std::copy(Privates.begin(), Privates.end(), varlist_end());
843 }
844 
setLHSExprs(ArrayRef<Expr * > LHSExprs)845 void OMPTaskReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
846   assert(
847       LHSExprs.size() == varlist_size() &&
848       "Number of LHS expressions is not the same as the preallocated buffer");
849   std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
850 }
851 
setRHSExprs(ArrayRef<Expr * > RHSExprs)852 void OMPTaskReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
853   assert(
854       RHSExprs.size() == varlist_size() &&
855       "Number of RHS expressions is not the same as the preallocated buffer");
856   std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
857 }
858 
setReductionOps(ArrayRef<Expr * > ReductionOps)859 void OMPTaskReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
860   assert(ReductionOps.size() == varlist_size() && "Number of task reduction "
861                                                   "expressions is not the same "
862                                                   "as the preallocated buffer");
863   std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
864 }
865 
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,SourceLocation ColonLoc,ArrayRef<Expr * > VL,NestedNameSpecifierLoc QualifierLoc,const DeclarationNameInfo & NameInfo,ArrayRef<Expr * > Privates,ArrayRef<Expr * > LHSExprs,ArrayRef<Expr * > RHSExprs,ArrayRef<Expr * > ReductionOps,Stmt * PreInit,Expr * PostUpdate)866 OMPTaskReductionClause *OMPTaskReductionClause::Create(
867     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
868     SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
869     NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
870     ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
871     ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
872     Expr *PostUpdate) {
873   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
874   OMPTaskReductionClause *Clause = new (Mem) OMPTaskReductionClause(
875       StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
876   Clause->setVarRefs(VL);
877   Clause->setPrivates(Privates);
878   Clause->setLHSExprs(LHSExprs);
879   Clause->setRHSExprs(RHSExprs);
880   Clause->setReductionOps(ReductionOps);
881   Clause->setPreInitStmt(PreInit);
882   Clause->setPostUpdateExpr(PostUpdate);
883   return Clause;
884 }
885 
CreateEmpty(const ASTContext & C,unsigned N)886 OMPTaskReductionClause *OMPTaskReductionClause::CreateEmpty(const ASTContext &C,
887                                                             unsigned N) {
888   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
889   return new (Mem) OMPTaskReductionClause(N);
890 }
891 
setPrivates(ArrayRef<Expr * > Privates)892 void OMPInReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
893   assert(Privates.size() == varlist_size() &&
894          "Number of private copies is not the same as the preallocated buffer");
895   std::copy(Privates.begin(), Privates.end(), varlist_end());
896 }
897 
setLHSExprs(ArrayRef<Expr * > LHSExprs)898 void OMPInReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
899   assert(
900       LHSExprs.size() == varlist_size() &&
901       "Number of LHS expressions is not the same as the preallocated buffer");
902   std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
903 }
904 
setRHSExprs(ArrayRef<Expr * > RHSExprs)905 void OMPInReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
906   assert(
907       RHSExprs.size() == varlist_size() &&
908       "Number of RHS expressions is not the same as the preallocated buffer");
909   std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
910 }
911 
setReductionOps(ArrayRef<Expr * > ReductionOps)912 void OMPInReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
913   assert(ReductionOps.size() == varlist_size() && "Number of in reduction "
914                                                   "expressions is not the same "
915                                                   "as the preallocated buffer");
916   std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
917 }
918 
setTaskgroupDescriptors(ArrayRef<Expr * > TaskgroupDescriptors)919 void OMPInReductionClause::setTaskgroupDescriptors(
920     ArrayRef<Expr *> TaskgroupDescriptors) {
921   assert(TaskgroupDescriptors.size() == varlist_size() &&
922          "Number of in reduction descriptors is not the same as the "
923          "preallocated buffer");
924   std::copy(TaskgroupDescriptors.begin(), TaskgroupDescriptors.end(),
925             getReductionOps().end());
926 }
927 
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,SourceLocation ColonLoc,ArrayRef<Expr * > VL,NestedNameSpecifierLoc QualifierLoc,const DeclarationNameInfo & NameInfo,ArrayRef<Expr * > Privates,ArrayRef<Expr * > LHSExprs,ArrayRef<Expr * > RHSExprs,ArrayRef<Expr * > ReductionOps,ArrayRef<Expr * > TaskgroupDescriptors,Stmt * PreInit,Expr * PostUpdate)928 OMPInReductionClause *OMPInReductionClause::Create(
929     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
930     SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
931     NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
932     ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
933     ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps,
934     ArrayRef<Expr *> TaskgroupDescriptors, Stmt *PreInit, Expr *PostUpdate) {
935   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(6 * VL.size()));
936   OMPInReductionClause *Clause = new (Mem) OMPInReductionClause(
937       StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
938   Clause->setVarRefs(VL);
939   Clause->setPrivates(Privates);
940   Clause->setLHSExprs(LHSExprs);
941   Clause->setRHSExprs(RHSExprs);
942   Clause->setReductionOps(ReductionOps);
943   Clause->setTaskgroupDescriptors(TaskgroupDescriptors);
944   Clause->setPreInitStmt(PreInit);
945   Clause->setPostUpdateExpr(PostUpdate);
946   return Clause;
947 }
948 
CreateEmpty(const ASTContext & C,unsigned N)949 OMPInReductionClause *OMPInReductionClause::CreateEmpty(const ASTContext &C,
950                                                         unsigned N) {
951   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(6 * N));
952   return new (Mem) OMPInReductionClause(N);
953 }
954 
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > Sizes)955 OMPSizesClause *OMPSizesClause::Create(const ASTContext &C,
956                                        SourceLocation StartLoc,
957                                        SourceLocation LParenLoc,
958                                        SourceLocation EndLoc,
959                                        ArrayRef<Expr *> Sizes) {
960   OMPSizesClause *Clause = CreateEmpty(C, Sizes.size());
961   Clause->setLocStart(StartLoc);
962   Clause->setLParenLoc(LParenLoc);
963   Clause->setLocEnd(EndLoc);
964   Clause->setSizesRefs(Sizes);
965   return Clause;
966 }
967 
CreateEmpty(const ASTContext & C,unsigned NumSizes)968 OMPSizesClause *OMPSizesClause::CreateEmpty(const ASTContext &C,
969                                             unsigned NumSizes) {
970   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumSizes));
971   return new (Mem) OMPSizesClause(NumSizes);
972 }
973 
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation EndLoc)974 OMPFullClause *OMPFullClause::Create(const ASTContext &C,
975                                      SourceLocation StartLoc,
976                                      SourceLocation EndLoc) {
977   OMPFullClause *Clause = CreateEmpty(C);
978   Clause->setLocStart(StartLoc);
979   Clause->setLocEnd(EndLoc);
980   return Clause;
981 }
982 
CreateEmpty(const ASTContext & C)983 OMPFullClause *OMPFullClause::CreateEmpty(const ASTContext &C) {
984   return new (C) OMPFullClause();
985 }
986 
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,Expr * Factor)987 OMPPartialClause *OMPPartialClause::Create(const ASTContext &C,
988                                            SourceLocation StartLoc,
989                                            SourceLocation LParenLoc,
990                                            SourceLocation EndLoc,
991                                            Expr *Factor) {
992   OMPPartialClause *Clause = CreateEmpty(C);
993   Clause->setLocStart(StartLoc);
994   Clause->setLParenLoc(LParenLoc);
995   Clause->setLocEnd(EndLoc);
996   Clause->setFactor(Factor);
997   return Clause;
998 }
999 
CreateEmpty(const ASTContext & C)1000 OMPPartialClause *OMPPartialClause::CreateEmpty(const ASTContext &C) {
1001   return new (C) OMPPartialClause();
1002 }
1003 
1004 OMPAllocateClause *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,Expr * Allocator,SourceLocation ColonLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL)1005 OMPAllocateClause::Create(const ASTContext &C, SourceLocation StartLoc,
1006                           SourceLocation LParenLoc, Expr *Allocator,
1007                           SourceLocation ColonLoc, SourceLocation EndLoc,
1008                           ArrayRef<Expr *> VL) {
1009   // Allocate space for private variables and initializer expressions.
1010   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
1011   auto *Clause = new (Mem) OMPAllocateClause(StartLoc, LParenLoc, Allocator,
1012                                              ColonLoc, EndLoc, VL.size());
1013   Clause->setVarRefs(VL);
1014   return Clause;
1015 }
1016 
CreateEmpty(const ASTContext & C,unsigned N)1017 OMPAllocateClause *OMPAllocateClause::CreateEmpty(const ASTContext &C,
1018                                                   unsigned N) {
1019   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
1020   return new (Mem) OMPAllocateClause(N);
1021 }
1022 
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL)1023 OMPFlushClause *OMPFlushClause::Create(const ASTContext &C,
1024                                        SourceLocation StartLoc,
1025                                        SourceLocation LParenLoc,
1026                                        SourceLocation EndLoc,
1027                                        ArrayRef<Expr *> VL) {
1028   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
1029   OMPFlushClause *Clause =
1030       new (Mem) OMPFlushClause(StartLoc, LParenLoc, EndLoc, VL.size());
1031   Clause->setVarRefs(VL);
1032   return Clause;
1033 }
1034 
CreateEmpty(const ASTContext & C,unsigned N)1035 OMPFlushClause *OMPFlushClause::CreateEmpty(const ASTContext &C, unsigned N) {
1036   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
1037   return new (Mem) OMPFlushClause(N);
1038 }
1039 
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation RParenLoc,Expr * Depobj)1040 OMPDepobjClause *OMPDepobjClause::Create(const ASTContext &C,
1041                                          SourceLocation StartLoc,
1042                                          SourceLocation LParenLoc,
1043                                          SourceLocation RParenLoc,
1044                                          Expr *Depobj) {
1045   auto *Clause = new (C) OMPDepobjClause(StartLoc, LParenLoc, RParenLoc);
1046   Clause->setDepobj(Depobj);
1047   return Clause;
1048 }
1049 
CreateEmpty(const ASTContext & C)1050 OMPDepobjClause *OMPDepobjClause::CreateEmpty(const ASTContext &C) {
1051   return new (C) OMPDepobjClause();
1052 }
1053 
1054 OMPDependClause *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,DependDataTy Data,Expr * DepModifier,ArrayRef<Expr * > VL,unsigned NumLoops)1055 OMPDependClause::Create(const ASTContext &C, SourceLocation StartLoc,
1056                         SourceLocation LParenLoc, SourceLocation EndLoc,
1057                         DependDataTy Data, Expr *DepModifier,
1058                         ArrayRef<Expr *> VL, unsigned NumLoops) {
1059   void *Mem = C.Allocate(
1060       totalSizeToAlloc<Expr *>(VL.size() + /*depend-modifier*/ 1 + NumLoops),
1061       alignof(OMPDependClause));
1062   OMPDependClause *Clause = new (Mem)
1063       OMPDependClause(StartLoc, LParenLoc, EndLoc, VL.size(), NumLoops);
1064   Clause->setDependencyKind(Data.DepKind);
1065   Clause->setDependencyLoc(Data.DepLoc);
1066   Clause->setColonLoc(Data.ColonLoc);
1067   Clause->setOmpAllMemoryLoc(Data.OmpAllMemoryLoc);
1068   Clause->setModifier(DepModifier);
1069   Clause->setVarRefs(VL);
1070   for (unsigned I = 0 ; I < NumLoops; ++I)
1071     Clause->setLoopData(I, nullptr);
1072   return Clause;
1073 }
1074 
CreateEmpty(const ASTContext & C,unsigned N,unsigned NumLoops)1075 OMPDependClause *OMPDependClause::CreateEmpty(const ASTContext &C, unsigned N,
1076                                               unsigned NumLoops) {
1077   void *Mem =
1078       C.Allocate(totalSizeToAlloc<Expr *>(N + /*depend-modifier*/ 1 + NumLoops),
1079                  alignof(OMPDependClause));
1080   return new (Mem) OMPDependClause(N, NumLoops);
1081 }
1082 
setLoopData(unsigned NumLoop,Expr * Cnt)1083 void OMPDependClause::setLoopData(unsigned NumLoop, Expr *Cnt) {
1084   assert((getDependencyKind() == OMPC_DEPEND_sink ||
1085           getDependencyKind() == OMPC_DEPEND_source) &&
1086          NumLoop < NumLoops &&
1087          "Expected sink or source depend + loop index must be less number of "
1088          "loops.");
1089   auto *It = std::next(getVarRefs().end(), NumLoop + 1);
1090   *It = Cnt;
1091 }
1092 
getLoopData(unsigned NumLoop)1093 Expr *OMPDependClause::getLoopData(unsigned NumLoop) {
1094   assert((getDependencyKind() == OMPC_DEPEND_sink ||
1095           getDependencyKind() == OMPC_DEPEND_source) &&
1096          NumLoop < NumLoops &&
1097          "Expected sink or source depend + loop index must be less number of "
1098          "loops.");
1099   auto *It = std::next(getVarRefs().end(), NumLoop + 1);
1100   return *It;
1101 }
1102 
getLoopData(unsigned NumLoop) const1103 const Expr *OMPDependClause::getLoopData(unsigned NumLoop) const {
1104   assert((getDependencyKind() == OMPC_DEPEND_sink ||
1105           getDependencyKind() == OMPC_DEPEND_source) &&
1106          NumLoop < NumLoops &&
1107          "Expected sink or source depend + loop index must be less number of "
1108          "loops.");
1109   const auto *It = std::next(getVarRefs().end(), NumLoop + 1);
1110   return *It;
1111 }
1112 
setModifier(Expr * DepModifier)1113 void OMPDependClause::setModifier(Expr *DepModifier) {
1114   *getVarRefs().end() = DepModifier;
1115 }
getModifier()1116 Expr *OMPDependClause::getModifier() { return *getVarRefs().end(); }
1117 
getComponentsTotalNumber(MappableExprComponentListsRef ComponentLists)1118 unsigned OMPClauseMappableExprCommon::getComponentsTotalNumber(
1119     MappableExprComponentListsRef ComponentLists) {
1120   unsigned TotalNum = 0u;
1121   for (auto &C : ComponentLists)
1122     TotalNum += C.size();
1123   return TotalNum;
1124 }
1125 
getUniqueDeclarationsTotalNumber(ArrayRef<const ValueDecl * > Declarations)1126 unsigned OMPClauseMappableExprCommon::getUniqueDeclarationsTotalNumber(
1127     ArrayRef<const ValueDecl *> Declarations) {
1128   unsigned TotalNum = 0u;
1129   llvm::SmallPtrSet<const ValueDecl *, 8> Cache;
1130   for (const ValueDecl *D : Declarations) {
1131     const ValueDecl *VD = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr;
1132     if (Cache.count(VD))
1133       continue;
1134     ++TotalNum;
1135     Cache.insert(VD);
1136   }
1137   return TotalNum;
1138 }
1139 
Create(const ASTContext & C,const OMPVarListLocTy & Locs,ArrayRef<Expr * > Vars,ArrayRef<ValueDecl * > Declarations,MappableExprComponentListsRef ComponentLists,ArrayRef<Expr * > UDMapperRefs,Expr * IteratorModifier,ArrayRef<OpenMPMapModifierKind> MapModifiers,ArrayRef<SourceLocation> MapModifiersLoc,NestedNameSpecifierLoc UDMQualifierLoc,DeclarationNameInfo MapperId,OpenMPMapClauseKind Type,bool TypeIsImplicit,SourceLocation TypeLoc)1140 OMPMapClause *OMPMapClause::Create(
1141     const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
1142     ArrayRef<ValueDecl *> Declarations,
1143     MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
1144     Expr *IteratorModifier, ArrayRef<OpenMPMapModifierKind> MapModifiers,
1145     ArrayRef<SourceLocation> MapModifiersLoc,
1146     NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId,
1147     OpenMPMapClauseKind Type, bool TypeIsImplicit, SourceLocation TypeLoc) {
1148   OMPMappableExprListSizeTy Sizes;
1149   Sizes.NumVars = Vars.size();
1150   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1151   Sizes.NumComponentLists = ComponentLists.size();
1152   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1153 
1154   // We need to allocate:
1155   // 2 x NumVars x Expr* - we have an original list expression and an associated
1156   // user-defined mapper for each clause list entry.
1157   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1158   // with each component list.
1159   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1160   // number of lists for each unique declaration and the size of each component
1161   // list.
1162   // NumComponents x MappableComponent - the total of all the components in all
1163   // the lists.
1164   void *Mem = C.Allocate(
1165       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1166                        OMPClauseMappableExprCommon::MappableComponent>(
1167           2 * Sizes.NumVars + 1, Sizes.NumUniqueDeclarations,
1168           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1169           Sizes.NumComponents));
1170   OMPMapClause *Clause = new (Mem)
1171       OMPMapClause(MapModifiers, MapModifiersLoc, UDMQualifierLoc, MapperId,
1172                    Type, TypeIsImplicit, TypeLoc, Locs, Sizes);
1173 
1174   Clause->setVarRefs(Vars);
1175   Clause->setUDMapperRefs(UDMapperRefs);
1176   Clause->setIteratorModifier(IteratorModifier);
1177   Clause->setClauseInfo(Declarations, ComponentLists);
1178   Clause->setMapType(Type);
1179   Clause->setMapLoc(TypeLoc);
1180   return Clause;
1181 }
1182 
1183 OMPMapClause *
CreateEmpty(const ASTContext & C,const OMPMappableExprListSizeTy & Sizes)1184 OMPMapClause::CreateEmpty(const ASTContext &C,
1185                           const OMPMappableExprListSizeTy &Sizes) {
1186   void *Mem = C.Allocate(
1187       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1188                        OMPClauseMappableExprCommon::MappableComponent>(
1189           2 * Sizes.NumVars + 1, Sizes.NumUniqueDeclarations,
1190           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1191           Sizes.NumComponents));
1192   OMPMapClause *Clause = new (Mem) OMPMapClause(Sizes);
1193   Clause->setIteratorModifier(nullptr);
1194   return Clause;
1195 }
1196 
Create(const ASTContext & C,const OMPVarListLocTy & Locs,ArrayRef<Expr * > Vars,ArrayRef<ValueDecl * > Declarations,MappableExprComponentListsRef ComponentLists,ArrayRef<Expr * > UDMapperRefs,ArrayRef<OpenMPMotionModifierKind> MotionModifiers,ArrayRef<SourceLocation> MotionModifiersLoc,NestedNameSpecifierLoc UDMQualifierLoc,DeclarationNameInfo MapperId)1197 OMPToClause *OMPToClause::Create(
1198     const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
1199     ArrayRef<ValueDecl *> Declarations,
1200     MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
1201     ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
1202     ArrayRef<SourceLocation> MotionModifiersLoc,
1203     NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId) {
1204   OMPMappableExprListSizeTy Sizes;
1205   Sizes.NumVars = Vars.size();
1206   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1207   Sizes.NumComponentLists = ComponentLists.size();
1208   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1209 
1210   // We need to allocate:
1211   // 2 x NumVars x Expr* - we have an original list expression and an associated
1212   // user-defined mapper for each clause list entry.
1213   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1214   // with each component list.
1215   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1216   // number of lists for each unique declaration and the size of each component
1217   // list.
1218   // NumComponents x MappableComponent - the total of all the components in all
1219   // the lists.
1220   void *Mem = C.Allocate(
1221       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1222                        OMPClauseMappableExprCommon::MappableComponent>(
1223           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1224           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1225           Sizes.NumComponents));
1226 
1227   auto *Clause = new (Mem) OMPToClause(MotionModifiers, MotionModifiersLoc,
1228                                        UDMQualifierLoc, MapperId, Locs, Sizes);
1229 
1230   Clause->setVarRefs(Vars);
1231   Clause->setUDMapperRefs(UDMapperRefs);
1232   Clause->setClauseInfo(Declarations, ComponentLists);
1233   return Clause;
1234 }
1235 
CreateEmpty(const ASTContext & C,const OMPMappableExprListSizeTy & Sizes)1236 OMPToClause *OMPToClause::CreateEmpty(const ASTContext &C,
1237                                       const OMPMappableExprListSizeTy &Sizes) {
1238   void *Mem = C.Allocate(
1239       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1240                        OMPClauseMappableExprCommon::MappableComponent>(
1241           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1242           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1243           Sizes.NumComponents));
1244   return new (Mem) OMPToClause(Sizes);
1245 }
1246 
Create(const ASTContext & C,const OMPVarListLocTy & Locs,ArrayRef<Expr * > Vars,ArrayRef<ValueDecl * > Declarations,MappableExprComponentListsRef ComponentLists,ArrayRef<Expr * > UDMapperRefs,ArrayRef<OpenMPMotionModifierKind> MotionModifiers,ArrayRef<SourceLocation> MotionModifiersLoc,NestedNameSpecifierLoc UDMQualifierLoc,DeclarationNameInfo MapperId)1247 OMPFromClause *OMPFromClause::Create(
1248     const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
1249     ArrayRef<ValueDecl *> Declarations,
1250     MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
1251     ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
1252     ArrayRef<SourceLocation> MotionModifiersLoc,
1253     NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId) {
1254   OMPMappableExprListSizeTy Sizes;
1255   Sizes.NumVars = Vars.size();
1256   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1257   Sizes.NumComponentLists = ComponentLists.size();
1258   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1259 
1260   // We need to allocate:
1261   // 2 x NumVars x Expr* - we have an original list expression and an associated
1262   // user-defined mapper for each clause list entry.
1263   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1264   // with each component list.
1265   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1266   // number of lists for each unique declaration and the size of each component
1267   // list.
1268   // NumComponents x MappableComponent - the total of all the components in all
1269   // the lists.
1270   void *Mem = C.Allocate(
1271       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1272                        OMPClauseMappableExprCommon::MappableComponent>(
1273           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1274           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1275           Sizes.NumComponents));
1276 
1277   auto *Clause =
1278       new (Mem) OMPFromClause(MotionModifiers, MotionModifiersLoc,
1279                               UDMQualifierLoc, MapperId, Locs, Sizes);
1280 
1281   Clause->setVarRefs(Vars);
1282   Clause->setUDMapperRefs(UDMapperRefs);
1283   Clause->setClauseInfo(Declarations, ComponentLists);
1284   return Clause;
1285 }
1286 
1287 OMPFromClause *
CreateEmpty(const ASTContext & C,const OMPMappableExprListSizeTy & Sizes)1288 OMPFromClause::CreateEmpty(const ASTContext &C,
1289                            const OMPMappableExprListSizeTy &Sizes) {
1290   void *Mem = C.Allocate(
1291       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1292                        OMPClauseMappableExprCommon::MappableComponent>(
1293           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1294           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1295           Sizes.NumComponents));
1296   return new (Mem) OMPFromClause(Sizes);
1297 }
1298 
setPrivateCopies(ArrayRef<Expr * > VL)1299 void OMPUseDevicePtrClause::setPrivateCopies(ArrayRef<Expr *> VL) {
1300   assert(VL.size() == varlist_size() &&
1301          "Number of private copies is not the same as the preallocated buffer");
1302   std::copy(VL.begin(), VL.end(), varlist_end());
1303 }
1304 
setInits(ArrayRef<Expr * > VL)1305 void OMPUseDevicePtrClause::setInits(ArrayRef<Expr *> VL) {
1306   assert(VL.size() == varlist_size() &&
1307          "Number of inits is not the same as the preallocated buffer");
1308   std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
1309 }
1310 
Create(const ASTContext & C,const OMPVarListLocTy & Locs,ArrayRef<Expr * > Vars,ArrayRef<Expr * > PrivateVars,ArrayRef<Expr * > Inits,ArrayRef<ValueDecl * > Declarations,MappableExprComponentListsRef ComponentLists)1311 OMPUseDevicePtrClause *OMPUseDevicePtrClause::Create(
1312     const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
1313     ArrayRef<Expr *> PrivateVars, ArrayRef<Expr *> Inits,
1314     ArrayRef<ValueDecl *> Declarations,
1315     MappableExprComponentListsRef ComponentLists) {
1316   OMPMappableExprListSizeTy Sizes;
1317   Sizes.NumVars = Vars.size();
1318   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1319   Sizes.NumComponentLists = ComponentLists.size();
1320   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1321 
1322   // We need to allocate:
1323   // NumVars x Expr* - we have an original list expression for each clause
1324   // list entry.
1325   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1326   // with each component list.
1327   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1328   // number of lists for each unique declaration and the size of each component
1329   // list.
1330   // NumComponents x MappableComponent - the total of all the components in all
1331   // the lists.
1332   void *Mem = C.Allocate(
1333       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1334                        OMPClauseMappableExprCommon::MappableComponent>(
1335           3 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1336           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1337           Sizes.NumComponents));
1338 
1339   OMPUseDevicePtrClause *Clause = new (Mem) OMPUseDevicePtrClause(Locs, Sizes);
1340 
1341   Clause->setVarRefs(Vars);
1342   Clause->setPrivateCopies(PrivateVars);
1343   Clause->setInits(Inits);
1344   Clause->setClauseInfo(Declarations, ComponentLists);
1345   return Clause;
1346 }
1347 
1348 OMPUseDevicePtrClause *
CreateEmpty(const ASTContext & C,const OMPMappableExprListSizeTy & Sizes)1349 OMPUseDevicePtrClause::CreateEmpty(const ASTContext &C,
1350                                    const OMPMappableExprListSizeTy &Sizes) {
1351   void *Mem = C.Allocate(
1352       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1353                        OMPClauseMappableExprCommon::MappableComponent>(
1354           3 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1355           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1356           Sizes.NumComponents));
1357   return new (Mem) OMPUseDevicePtrClause(Sizes);
1358 }
1359 
1360 OMPUseDeviceAddrClause *
Create(const ASTContext & C,const OMPVarListLocTy & Locs,ArrayRef<Expr * > Vars,ArrayRef<ValueDecl * > Declarations,MappableExprComponentListsRef ComponentLists)1361 OMPUseDeviceAddrClause::Create(const ASTContext &C, const OMPVarListLocTy &Locs,
1362                                ArrayRef<Expr *> Vars,
1363                                ArrayRef<ValueDecl *> Declarations,
1364                                MappableExprComponentListsRef ComponentLists) {
1365   OMPMappableExprListSizeTy Sizes;
1366   Sizes.NumVars = Vars.size();
1367   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1368   Sizes.NumComponentLists = ComponentLists.size();
1369   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1370 
1371   // We need to allocate:
1372   // 3 x NumVars x Expr* - we have an original list expression for each clause
1373   // list entry and an equal number of private copies and inits.
1374   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1375   // with each component list.
1376   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1377   // number of lists for each unique declaration and the size of each component
1378   // list.
1379   // NumComponents x MappableComponent - the total of all the components in all
1380   // the lists.
1381   void *Mem = C.Allocate(
1382       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1383                        OMPClauseMappableExprCommon::MappableComponent>(
1384           Sizes.NumVars, Sizes.NumUniqueDeclarations,
1385           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1386           Sizes.NumComponents));
1387 
1388   auto *Clause = new (Mem) OMPUseDeviceAddrClause(Locs, Sizes);
1389 
1390   Clause->setVarRefs(Vars);
1391   Clause->setClauseInfo(Declarations, ComponentLists);
1392   return Clause;
1393 }
1394 
1395 OMPUseDeviceAddrClause *
CreateEmpty(const ASTContext & C,const OMPMappableExprListSizeTy & Sizes)1396 OMPUseDeviceAddrClause::CreateEmpty(const ASTContext &C,
1397                                     const OMPMappableExprListSizeTy &Sizes) {
1398   void *Mem = C.Allocate(
1399       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1400                        OMPClauseMappableExprCommon::MappableComponent>(
1401           Sizes.NumVars, Sizes.NumUniqueDeclarations,
1402           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1403           Sizes.NumComponents));
1404   return new (Mem) OMPUseDeviceAddrClause(Sizes);
1405 }
1406 
1407 OMPIsDevicePtrClause *
Create(const ASTContext & C,const OMPVarListLocTy & Locs,ArrayRef<Expr * > Vars,ArrayRef<ValueDecl * > Declarations,MappableExprComponentListsRef ComponentLists)1408 OMPIsDevicePtrClause::Create(const ASTContext &C, const OMPVarListLocTy &Locs,
1409                              ArrayRef<Expr *> Vars,
1410                              ArrayRef<ValueDecl *> Declarations,
1411                              MappableExprComponentListsRef ComponentLists) {
1412   OMPMappableExprListSizeTy Sizes;
1413   Sizes.NumVars = Vars.size();
1414   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1415   Sizes.NumComponentLists = ComponentLists.size();
1416   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1417 
1418   // We need to allocate:
1419   // NumVars x Expr* - we have an original list expression for each clause list
1420   // entry.
1421   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1422   // with each component list.
1423   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1424   // number of lists for each unique declaration and the size of each component
1425   // list.
1426   // NumComponents x MappableComponent - the total of all the components in all
1427   // the lists.
1428   void *Mem = C.Allocate(
1429       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1430                        OMPClauseMappableExprCommon::MappableComponent>(
1431           Sizes.NumVars, Sizes.NumUniqueDeclarations,
1432           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1433           Sizes.NumComponents));
1434 
1435   OMPIsDevicePtrClause *Clause = new (Mem) OMPIsDevicePtrClause(Locs, Sizes);
1436 
1437   Clause->setVarRefs(Vars);
1438   Clause->setClauseInfo(Declarations, ComponentLists);
1439   return Clause;
1440 }
1441 
1442 OMPIsDevicePtrClause *
CreateEmpty(const ASTContext & C,const OMPMappableExprListSizeTy & Sizes)1443 OMPIsDevicePtrClause::CreateEmpty(const ASTContext &C,
1444                                   const OMPMappableExprListSizeTy &Sizes) {
1445   void *Mem = C.Allocate(
1446       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1447                        OMPClauseMappableExprCommon::MappableComponent>(
1448           Sizes.NumVars, Sizes.NumUniqueDeclarations,
1449           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1450           Sizes.NumComponents));
1451   return new (Mem) OMPIsDevicePtrClause(Sizes);
1452 }
1453 
1454 OMPHasDeviceAddrClause *
Create(const ASTContext & C,const OMPVarListLocTy & Locs,ArrayRef<Expr * > Vars,ArrayRef<ValueDecl * > Declarations,MappableExprComponentListsRef ComponentLists)1455 OMPHasDeviceAddrClause::Create(const ASTContext &C, const OMPVarListLocTy &Locs,
1456                                ArrayRef<Expr *> Vars,
1457                                ArrayRef<ValueDecl *> Declarations,
1458                                MappableExprComponentListsRef ComponentLists) {
1459   OMPMappableExprListSizeTy Sizes;
1460   Sizes.NumVars = Vars.size();
1461   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1462   Sizes.NumComponentLists = ComponentLists.size();
1463   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1464 
1465   // We need to allocate:
1466   // NumVars x Expr* - we have an original list expression for each clause list
1467   // entry.
1468   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1469   // with each component list.
1470   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1471   // number of lists for each unique declaration and the size of each component
1472   // list.
1473   // NumComponents x MappableComponent - the total of all the components in all
1474   // the lists.
1475   void *Mem = C.Allocate(
1476       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1477                        OMPClauseMappableExprCommon::MappableComponent>(
1478           Sizes.NumVars, Sizes.NumUniqueDeclarations,
1479           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1480           Sizes.NumComponents));
1481 
1482   auto *Clause = new (Mem) OMPHasDeviceAddrClause(Locs, Sizes);
1483 
1484   Clause->setVarRefs(Vars);
1485   Clause->setClauseInfo(Declarations, ComponentLists);
1486   return Clause;
1487 }
1488 
1489 OMPHasDeviceAddrClause *
CreateEmpty(const ASTContext & C,const OMPMappableExprListSizeTy & Sizes)1490 OMPHasDeviceAddrClause::CreateEmpty(const ASTContext &C,
1491                                     const OMPMappableExprListSizeTy &Sizes) {
1492   void *Mem = C.Allocate(
1493       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1494                        OMPClauseMappableExprCommon::MappableComponent>(
1495           Sizes.NumVars, Sizes.NumUniqueDeclarations,
1496           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1497           Sizes.NumComponents));
1498   return new (Mem) OMPHasDeviceAddrClause(Sizes);
1499 }
1500 
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL)1501 OMPNontemporalClause *OMPNontemporalClause::Create(const ASTContext &C,
1502                                                    SourceLocation StartLoc,
1503                                                    SourceLocation LParenLoc,
1504                                                    SourceLocation EndLoc,
1505                                                    ArrayRef<Expr *> VL) {
1506   // Allocate space for nontemporal variables + private references.
1507   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * VL.size()));
1508   auto *Clause =
1509       new (Mem) OMPNontemporalClause(StartLoc, LParenLoc, EndLoc, VL.size());
1510   Clause->setVarRefs(VL);
1511   return Clause;
1512 }
1513 
CreateEmpty(const ASTContext & C,unsigned N)1514 OMPNontemporalClause *OMPNontemporalClause::CreateEmpty(const ASTContext &C,
1515                                                         unsigned N) {
1516   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * N));
1517   return new (Mem) OMPNontemporalClause(N);
1518 }
1519 
setPrivateRefs(ArrayRef<Expr * > VL)1520 void OMPNontemporalClause::setPrivateRefs(ArrayRef<Expr *> VL) {
1521   assert(VL.size() == varlist_size() && "Number of private references is not "
1522                                         "the same as the preallocated buffer");
1523   std::copy(VL.begin(), VL.end(), varlist_end());
1524 }
1525 
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL)1526 OMPInclusiveClause *OMPInclusiveClause::Create(const ASTContext &C,
1527                                                SourceLocation StartLoc,
1528                                                SourceLocation LParenLoc,
1529                                                SourceLocation EndLoc,
1530                                                ArrayRef<Expr *> VL) {
1531   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
1532   auto *Clause =
1533       new (Mem) OMPInclusiveClause(StartLoc, LParenLoc, EndLoc, VL.size());
1534   Clause->setVarRefs(VL);
1535   return Clause;
1536 }
1537 
CreateEmpty(const ASTContext & C,unsigned N)1538 OMPInclusiveClause *OMPInclusiveClause::CreateEmpty(const ASTContext &C,
1539                                                     unsigned N) {
1540   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
1541   return new (Mem) OMPInclusiveClause(N);
1542 }
1543 
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL)1544 OMPExclusiveClause *OMPExclusiveClause::Create(const ASTContext &C,
1545                                                SourceLocation StartLoc,
1546                                                SourceLocation LParenLoc,
1547                                                SourceLocation EndLoc,
1548                                                ArrayRef<Expr *> VL) {
1549   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
1550   auto *Clause =
1551       new (Mem) OMPExclusiveClause(StartLoc, LParenLoc, EndLoc, VL.size());
1552   Clause->setVarRefs(VL);
1553   return Clause;
1554 }
1555 
CreateEmpty(const ASTContext & C,unsigned N)1556 OMPExclusiveClause *OMPExclusiveClause::CreateEmpty(const ASTContext &C,
1557                                                     unsigned N) {
1558   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
1559   return new (Mem) OMPExclusiveClause(N);
1560 }
1561 
setAllocatorsData(ArrayRef<OMPUsesAllocatorsClause::Data> Data)1562 void OMPUsesAllocatorsClause::setAllocatorsData(
1563     ArrayRef<OMPUsesAllocatorsClause::Data> Data) {
1564   assert(Data.size() == NumOfAllocators &&
1565          "Size of allocators data is not the same as the preallocated buffer.");
1566   for (unsigned I = 0, E = Data.size(); I < E; ++I) {
1567     const OMPUsesAllocatorsClause::Data &D = Data[I];
1568     getTrailingObjects<Expr *>()[I * static_cast<int>(ExprOffsets::Total) +
1569                                  static_cast<int>(ExprOffsets::Allocator)] =
1570         D.Allocator;
1571     getTrailingObjects<Expr *>()[I * static_cast<int>(ExprOffsets::Total) +
1572                                  static_cast<int>(
1573                                      ExprOffsets::AllocatorTraits)] =
1574         D.AllocatorTraits;
1575     getTrailingObjects<
1576         SourceLocation>()[I * static_cast<int>(ParenLocsOffsets::Total) +
1577                           static_cast<int>(ParenLocsOffsets::LParen)] =
1578         D.LParenLoc;
1579     getTrailingObjects<
1580         SourceLocation>()[I * static_cast<int>(ParenLocsOffsets::Total) +
1581                           static_cast<int>(ParenLocsOffsets::RParen)] =
1582         D.RParenLoc;
1583   }
1584 }
1585 
1586 OMPUsesAllocatorsClause::Data
getAllocatorData(unsigned I) const1587 OMPUsesAllocatorsClause::getAllocatorData(unsigned I) const {
1588   OMPUsesAllocatorsClause::Data Data;
1589   Data.Allocator =
1590       getTrailingObjects<Expr *>()[I * static_cast<int>(ExprOffsets::Total) +
1591                                    static_cast<int>(ExprOffsets::Allocator)];
1592   Data.AllocatorTraits =
1593       getTrailingObjects<Expr *>()[I * static_cast<int>(ExprOffsets::Total) +
1594                                    static_cast<int>(
1595                                        ExprOffsets::AllocatorTraits)];
1596   Data.LParenLoc = getTrailingObjects<
1597       SourceLocation>()[I * static_cast<int>(ParenLocsOffsets::Total) +
1598                         static_cast<int>(ParenLocsOffsets::LParen)];
1599   Data.RParenLoc = getTrailingObjects<
1600       SourceLocation>()[I * static_cast<int>(ParenLocsOffsets::Total) +
1601                         static_cast<int>(ParenLocsOffsets::RParen)];
1602   return Data;
1603 }
1604 
1605 OMPUsesAllocatorsClause *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<OMPUsesAllocatorsClause::Data> Data)1606 OMPUsesAllocatorsClause::Create(const ASTContext &C, SourceLocation StartLoc,
1607                                 SourceLocation LParenLoc, SourceLocation EndLoc,
1608                                 ArrayRef<OMPUsesAllocatorsClause::Data> Data) {
1609   void *Mem = C.Allocate(totalSizeToAlloc<Expr *, SourceLocation>(
1610       static_cast<int>(ExprOffsets::Total) * Data.size(),
1611       static_cast<int>(ParenLocsOffsets::Total) * Data.size()));
1612   auto *Clause = new (Mem)
1613       OMPUsesAllocatorsClause(StartLoc, LParenLoc, EndLoc, Data.size());
1614   Clause->setAllocatorsData(Data);
1615   return Clause;
1616 }
1617 
1618 OMPUsesAllocatorsClause *
CreateEmpty(const ASTContext & C,unsigned N)1619 OMPUsesAllocatorsClause::CreateEmpty(const ASTContext &C, unsigned N) {
1620   void *Mem = C.Allocate(totalSizeToAlloc<Expr *, SourceLocation>(
1621       static_cast<int>(ExprOffsets::Total) * N,
1622       static_cast<int>(ParenLocsOffsets::Total) * N));
1623   return new (Mem) OMPUsesAllocatorsClause(N);
1624 }
1625 
1626 OMPAffinityClause *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation ColonLoc,SourceLocation EndLoc,Expr * Modifier,ArrayRef<Expr * > Locators)1627 OMPAffinityClause::Create(const ASTContext &C, SourceLocation StartLoc,
1628                           SourceLocation LParenLoc, SourceLocation ColonLoc,
1629                           SourceLocation EndLoc, Expr *Modifier,
1630                           ArrayRef<Expr *> Locators) {
1631   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(Locators.size() + 1));
1632   auto *Clause = new (Mem)
1633       OMPAffinityClause(StartLoc, LParenLoc, ColonLoc, EndLoc, Locators.size());
1634   Clause->setModifier(Modifier);
1635   Clause->setVarRefs(Locators);
1636   return Clause;
1637 }
1638 
CreateEmpty(const ASTContext & C,unsigned N)1639 OMPAffinityClause *OMPAffinityClause::CreateEmpty(const ASTContext &C,
1640                                                   unsigned N) {
1641   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N + 1));
1642   return new (Mem) OMPAffinityClause(N);
1643 }
1644 
Create(const ASTContext & C,Expr * InteropVar,OMPInteropInfo & InteropInfo,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation VarLoc,SourceLocation EndLoc)1645 OMPInitClause *OMPInitClause::Create(const ASTContext &C, Expr *InteropVar,
1646                                      OMPInteropInfo &InteropInfo,
1647                                      SourceLocation StartLoc,
1648                                      SourceLocation LParenLoc,
1649                                      SourceLocation VarLoc,
1650                                      SourceLocation EndLoc) {
1651 
1652   void *Mem =
1653       C.Allocate(totalSizeToAlloc<Expr *>(InteropInfo.PreferTypes.size() + 1));
1654   auto *Clause = new (Mem) OMPInitClause(
1655       InteropInfo.IsTarget, InteropInfo.IsTargetSync, StartLoc, LParenLoc,
1656       VarLoc, EndLoc, InteropInfo.PreferTypes.size() + 1);
1657   Clause->setInteropVar(InteropVar);
1658   llvm::copy(InteropInfo.PreferTypes, Clause->getTrailingObjects<Expr *>() + 1);
1659   return Clause;
1660 }
1661 
CreateEmpty(const ASTContext & C,unsigned N)1662 OMPInitClause *OMPInitClause::CreateEmpty(const ASTContext &C, unsigned N) {
1663   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
1664   return new (Mem) OMPInitClause(N);
1665 }
1666 
1667 OMPBindClause *
Create(const ASTContext & C,OpenMPBindClauseKind K,SourceLocation KLoc,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc)1668 OMPBindClause::Create(const ASTContext &C, OpenMPBindClauseKind K,
1669                       SourceLocation KLoc, SourceLocation StartLoc,
1670                       SourceLocation LParenLoc, SourceLocation EndLoc) {
1671   return new (C) OMPBindClause(K, KLoc, StartLoc, LParenLoc, EndLoc);
1672 }
1673 
CreateEmpty(const ASTContext & C)1674 OMPBindClause *OMPBindClause::CreateEmpty(const ASTContext &C) {
1675   return new (C) OMPBindClause();
1676 }
1677 
1678 OMPDoacrossClause *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,OpenMPDoacrossClauseModifier DepType,SourceLocation DepLoc,SourceLocation ColonLoc,ArrayRef<Expr * > VL,unsigned NumLoops)1679 OMPDoacrossClause::Create(const ASTContext &C, SourceLocation StartLoc,
1680                           SourceLocation LParenLoc, SourceLocation EndLoc,
1681                           OpenMPDoacrossClauseModifier DepType,
1682                           SourceLocation DepLoc, SourceLocation ColonLoc,
1683                           ArrayRef<Expr *> VL, unsigned NumLoops) {
1684   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + NumLoops),
1685                          alignof(OMPDoacrossClause));
1686   OMPDoacrossClause *Clause = new (Mem)
1687       OMPDoacrossClause(StartLoc, LParenLoc, EndLoc, VL.size(), NumLoops);
1688   Clause->setDependenceType(DepType);
1689   Clause->setDependenceLoc(DepLoc);
1690   Clause->setColonLoc(ColonLoc);
1691   Clause->setVarRefs(VL);
1692   for (unsigned I = 0; I < NumLoops; ++I)
1693     Clause->setLoopData(I, nullptr);
1694   return Clause;
1695 }
1696 
CreateEmpty(const ASTContext & C,unsigned N,unsigned NumLoops)1697 OMPDoacrossClause *OMPDoacrossClause::CreateEmpty(const ASTContext &C,
1698                                                   unsigned N,
1699                                                   unsigned NumLoops) {
1700   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N + NumLoops),
1701                          alignof(OMPDoacrossClause));
1702   return new (Mem) OMPDoacrossClause(N, NumLoops);
1703 }
1704 
setLoopData(unsigned NumLoop,Expr * Cnt)1705 void OMPDoacrossClause::setLoopData(unsigned NumLoop, Expr *Cnt) {
1706   assert(NumLoop < NumLoops && "Loop index must be less number of loops.");
1707   auto *It = std::next(getVarRefs().end(), NumLoop);
1708   *It = Cnt;
1709 }
1710 
getLoopData(unsigned NumLoop)1711 Expr *OMPDoacrossClause::getLoopData(unsigned NumLoop) {
1712   assert(NumLoop < NumLoops && "Loop index must be less number of loops.");
1713   auto *It = std::next(getVarRefs().end(), NumLoop);
1714   return *It;
1715 }
1716 
getLoopData(unsigned NumLoop) const1717 const Expr *OMPDoacrossClause::getLoopData(unsigned NumLoop) const {
1718   assert(NumLoop < NumLoops && "Loop index must be less number of loops.");
1719   const auto *It = std::next(getVarRefs().end(), NumLoop);
1720   return *It;
1721 }
1722 
1723 //===----------------------------------------------------------------------===//
1724 //  OpenMP clauses printing methods
1725 //===----------------------------------------------------------------------===//
1726 
VisitOMPIfClause(OMPIfClause * Node)1727 void OMPClausePrinter::VisitOMPIfClause(OMPIfClause *Node) {
1728   OS << "if(";
1729   if (Node->getNameModifier() != OMPD_unknown)
1730     OS << getOpenMPDirectiveName(Node->getNameModifier()) << ": ";
1731   Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
1732   OS << ")";
1733 }
1734 
VisitOMPFinalClause(OMPFinalClause * Node)1735 void OMPClausePrinter::VisitOMPFinalClause(OMPFinalClause *Node) {
1736   OS << "final(";
1737   Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
1738   OS << ")";
1739 }
1740 
VisitOMPNumThreadsClause(OMPNumThreadsClause * Node)1741 void OMPClausePrinter::VisitOMPNumThreadsClause(OMPNumThreadsClause *Node) {
1742   OS << "num_threads(";
1743   Node->getNumThreads()->printPretty(OS, nullptr, Policy, 0);
1744   OS << ")";
1745 }
1746 
VisitOMPAlignClause(OMPAlignClause * Node)1747 void OMPClausePrinter::VisitOMPAlignClause(OMPAlignClause *Node) {
1748   OS << "align(";
1749   Node->getAlignment()->printPretty(OS, nullptr, Policy, 0);
1750   OS << ")";
1751 }
1752 
VisitOMPSafelenClause(OMPSafelenClause * Node)1753 void OMPClausePrinter::VisitOMPSafelenClause(OMPSafelenClause *Node) {
1754   OS << "safelen(";
1755   Node->getSafelen()->printPretty(OS, nullptr, Policy, 0);
1756   OS << ")";
1757 }
1758 
VisitOMPSimdlenClause(OMPSimdlenClause * Node)1759 void OMPClausePrinter::VisitOMPSimdlenClause(OMPSimdlenClause *Node) {
1760   OS << "simdlen(";
1761   Node->getSimdlen()->printPretty(OS, nullptr, Policy, 0);
1762   OS << ")";
1763 }
1764 
VisitOMPSizesClause(OMPSizesClause * Node)1765 void OMPClausePrinter::VisitOMPSizesClause(OMPSizesClause *Node) {
1766   OS << "sizes(";
1767   bool First = true;
1768   for (auto *Size : Node->getSizesRefs()) {
1769     if (!First)
1770       OS << ", ";
1771     Size->printPretty(OS, nullptr, Policy, 0);
1772     First = false;
1773   }
1774   OS << ")";
1775 }
1776 
VisitOMPFullClause(OMPFullClause * Node)1777 void OMPClausePrinter::VisitOMPFullClause(OMPFullClause *Node) { OS << "full"; }
1778 
VisitOMPPartialClause(OMPPartialClause * Node)1779 void OMPClausePrinter::VisitOMPPartialClause(OMPPartialClause *Node) {
1780   OS << "partial";
1781 
1782   if (Expr *Factor = Node->getFactor()) {
1783     OS << '(';
1784     Factor->printPretty(OS, nullptr, Policy, 0);
1785     OS << ')';
1786   }
1787 }
1788 
VisitOMPAllocatorClause(OMPAllocatorClause * Node)1789 void OMPClausePrinter::VisitOMPAllocatorClause(OMPAllocatorClause *Node) {
1790   OS << "allocator(";
1791   Node->getAllocator()->printPretty(OS, nullptr, Policy, 0);
1792   OS << ")";
1793 }
1794 
VisitOMPCollapseClause(OMPCollapseClause * Node)1795 void OMPClausePrinter::VisitOMPCollapseClause(OMPCollapseClause *Node) {
1796   OS << "collapse(";
1797   Node->getNumForLoops()->printPretty(OS, nullptr, Policy, 0);
1798   OS << ")";
1799 }
1800 
VisitOMPDetachClause(OMPDetachClause * Node)1801 void OMPClausePrinter::VisitOMPDetachClause(OMPDetachClause *Node) {
1802   OS << "detach(";
1803   Node->getEventHandler()->printPretty(OS, nullptr, Policy, 0);
1804   OS << ")";
1805 }
1806 
VisitOMPDefaultClause(OMPDefaultClause * Node)1807 void OMPClausePrinter::VisitOMPDefaultClause(OMPDefaultClause *Node) {
1808   OS << "default("
1809      << getOpenMPSimpleClauseTypeName(OMPC_default,
1810                                       unsigned(Node->getDefaultKind()))
1811      << ")";
1812 }
1813 
VisitOMPProcBindClause(OMPProcBindClause * Node)1814 void OMPClausePrinter::VisitOMPProcBindClause(OMPProcBindClause *Node) {
1815   OS << "proc_bind("
1816      << getOpenMPSimpleClauseTypeName(OMPC_proc_bind,
1817                                       unsigned(Node->getProcBindKind()))
1818      << ")";
1819 }
1820 
VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *)1821 void OMPClausePrinter::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) {
1822   OS << "unified_address";
1823 }
1824 
VisitOMPUnifiedSharedMemoryClause(OMPUnifiedSharedMemoryClause *)1825 void OMPClausePrinter::VisitOMPUnifiedSharedMemoryClause(
1826     OMPUnifiedSharedMemoryClause *) {
1827   OS << "unified_shared_memory";
1828 }
1829 
VisitOMPReverseOffloadClause(OMPReverseOffloadClause *)1830 void OMPClausePrinter::VisitOMPReverseOffloadClause(OMPReverseOffloadClause *) {
1831   OS << "reverse_offload";
1832 }
1833 
VisitOMPDynamicAllocatorsClause(OMPDynamicAllocatorsClause *)1834 void OMPClausePrinter::VisitOMPDynamicAllocatorsClause(
1835     OMPDynamicAllocatorsClause *) {
1836   OS << "dynamic_allocators";
1837 }
1838 
VisitOMPAtomicDefaultMemOrderClause(OMPAtomicDefaultMemOrderClause * Node)1839 void OMPClausePrinter::VisitOMPAtomicDefaultMemOrderClause(
1840     OMPAtomicDefaultMemOrderClause *Node) {
1841   OS << "atomic_default_mem_order("
1842      << getOpenMPSimpleClauseTypeName(OMPC_atomic_default_mem_order,
1843                                       Node->getAtomicDefaultMemOrderKind())
1844      << ")";
1845 }
1846 
VisitOMPAtClause(OMPAtClause * Node)1847 void OMPClausePrinter::VisitOMPAtClause(OMPAtClause *Node) {
1848   OS << "at(" << getOpenMPSimpleClauseTypeName(OMPC_at, Node->getAtKind())
1849      << ")";
1850 }
1851 
VisitOMPSeverityClause(OMPSeverityClause * Node)1852 void OMPClausePrinter::VisitOMPSeverityClause(OMPSeverityClause *Node) {
1853   OS << "severity("
1854      << getOpenMPSimpleClauseTypeName(OMPC_severity, Node->getSeverityKind())
1855      << ")";
1856 }
1857 
VisitOMPMessageClause(OMPMessageClause * Node)1858 void OMPClausePrinter::VisitOMPMessageClause(OMPMessageClause *Node) {
1859   OS << "message(\""
1860      << cast<StringLiteral>(Node->getMessageString())->getString() << "\")";
1861 }
1862 
VisitOMPScheduleClause(OMPScheduleClause * Node)1863 void OMPClausePrinter::VisitOMPScheduleClause(OMPScheduleClause *Node) {
1864   OS << "schedule(";
1865   if (Node->getFirstScheduleModifier() != OMPC_SCHEDULE_MODIFIER_unknown) {
1866     OS << getOpenMPSimpleClauseTypeName(OMPC_schedule,
1867                                         Node->getFirstScheduleModifier());
1868     if (Node->getSecondScheduleModifier() != OMPC_SCHEDULE_MODIFIER_unknown) {
1869       OS << ", ";
1870       OS << getOpenMPSimpleClauseTypeName(OMPC_schedule,
1871                                           Node->getSecondScheduleModifier());
1872     }
1873     OS << ": ";
1874   }
1875   OS << getOpenMPSimpleClauseTypeName(OMPC_schedule, Node->getScheduleKind());
1876   if (auto *E = Node->getChunkSize()) {
1877     OS << ", ";
1878     E->printPretty(OS, nullptr, Policy);
1879   }
1880   OS << ")";
1881 }
1882 
VisitOMPOrderedClause(OMPOrderedClause * Node)1883 void OMPClausePrinter::VisitOMPOrderedClause(OMPOrderedClause *Node) {
1884   OS << "ordered";
1885   if (auto *Num = Node->getNumForLoops()) {
1886     OS << "(";
1887     Num->printPretty(OS, nullptr, Policy, 0);
1888     OS << ")";
1889   }
1890 }
1891 
VisitOMPNowaitClause(OMPNowaitClause *)1892 void OMPClausePrinter::VisitOMPNowaitClause(OMPNowaitClause *) {
1893   OS << "nowait";
1894 }
1895 
VisitOMPUntiedClause(OMPUntiedClause *)1896 void OMPClausePrinter::VisitOMPUntiedClause(OMPUntiedClause *) {
1897   OS << "untied";
1898 }
1899 
VisitOMPNogroupClause(OMPNogroupClause *)1900 void OMPClausePrinter::VisitOMPNogroupClause(OMPNogroupClause *) {
1901   OS << "nogroup";
1902 }
1903 
VisitOMPMergeableClause(OMPMergeableClause *)1904 void OMPClausePrinter::VisitOMPMergeableClause(OMPMergeableClause *) {
1905   OS << "mergeable";
1906 }
1907 
VisitOMPReadClause(OMPReadClause *)1908 void OMPClausePrinter::VisitOMPReadClause(OMPReadClause *) { OS << "read"; }
1909 
VisitOMPWriteClause(OMPWriteClause *)1910 void OMPClausePrinter::VisitOMPWriteClause(OMPWriteClause *) { OS << "write"; }
1911 
VisitOMPUpdateClause(OMPUpdateClause * Node)1912 void OMPClausePrinter::VisitOMPUpdateClause(OMPUpdateClause *Node) {
1913   OS << "update";
1914   if (Node->isExtended()) {
1915     OS << "(";
1916     OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(),
1917                                         Node->getDependencyKind());
1918     OS << ")";
1919   }
1920 }
1921 
VisitOMPCaptureClause(OMPCaptureClause *)1922 void OMPClausePrinter::VisitOMPCaptureClause(OMPCaptureClause *) {
1923   OS << "capture";
1924 }
1925 
VisitOMPCompareClause(OMPCompareClause *)1926 void OMPClausePrinter::VisitOMPCompareClause(OMPCompareClause *) {
1927   OS << "compare";
1928 }
1929 
VisitOMPFailClause(OMPFailClause * Node)1930 void OMPClausePrinter::VisitOMPFailClause(OMPFailClause *Node) {
1931   OS << "fail";
1932   if (Node) {
1933     OS << "(";
1934     OS << getOpenMPSimpleClauseTypeName(
1935         Node->getClauseKind(), static_cast<int>(Node->getFailParameter()));
1936     OS << ")";
1937   }
1938 }
1939 
VisitOMPSeqCstClause(OMPSeqCstClause *)1940 void OMPClausePrinter::VisitOMPSeqCstClause(OMPSeqCstClause *) {
1941   OS << "seq_cst";
1942 }
1943 
VisitOMPAcqRelClause(OMPAcqRelClause *)1944 void OMPClausePrinter::VisitOMPAcqRelClause(OMPAcqRelClause *) {
1945   OS << "acq_rel";
1946 }
1947 
VisitOMPAcquireClause(OMPAcquireClause *)1948 void OMPClausePrinter::VisitOMPAcquireClause(OMPAcquireClause *) {
1949   OS << "acquire";
1950 }
1951 
VisitOMPReleaseClause(OMPReleaseClause *)1952 void OMPClausePrinter::VisitOMPReleaseClause(OMPReleaseClause *) {
1953   OS << "release";
1954 }
1955 
VisitOMPRelaxedClause(OMPRelaxedClause *)1956 void OMPClausePrinter::VisitOMPRelaxedClause(OMPRelaxedClause *) {
1957   OS << "relaxed";
1958 }
1959 
VisitOMPWeakClause(OMPWeakClause *)1960 void OMPClausePrinter::VisitOMPWeakClause(OMPWeakClause *) { OS << "weak"; }
1961 
VisitOMPThreadsClause(OMPThreadsClause *)1962 void OMPClausePrinter::VisitOMPThreadsClause(OMPThreadsClause *) {
1963   OS << "threads";
1964 }
1965 
VisitOMPSIMDClause(OMPSIMDClause *)1966 void OMPClausePrinter::VisitOMPSIMDClause(OMPSIMDClause *) { OS << "simd"; }
1967 
VisitOMPDeviceClause(OMPDeviceClause * Node)1968 void OMPClausePrinter::VisitOMPDeviceClause(OMPDeviceClause *Node) {
1969   OS << "device(";
1970   OpenMPDeviceClauseModifier Modifier = Node->getModifier();
1971   if (Modifier != OMPC_DEVICE_unknown) {
1972     OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(), Modifier)
1973        << ": ";
1974   }
1975   Node->getDevice()->printPretty(OS, nullptr, Policy, 0);
1976   OS << ")";
1977 }
1978 
VisitOMPNumTeamsClause(OMPNumTeamsClause * Node)1979 void OMPClausePrinter::VisitOMPNumTeamsClause(OMPNumTeamsClause *Node) {
1980   OS << "num_teams(";
1981   Node->getNumTeams()->printPretty(OS, nullptr, Policy, 0);
1982   OS << ")";
1983 }
1984 
VisitOMPThreadLimitClause(OMPThreadLimitClause * Node)1985 void OMPClausePrinter::VisitOMPThreadLimitClause(OMPThreadLimitClause *Node) {
1986   OS << "thread_limit(";
1987   Node->getThreadLimit()->printPretty(OS, nullptr, Policy, 0);
1988   OS << ")";
1989 }
1990 
VisitOMPPriorityClause(OMPPriorityClause * Node)1991 void OMPClausePrinter::VisitOMPPriorityClause(OMPPriorityClause *Node) {
1992   OS << "priority(";
1993   Node->getPriority()->printPretty(OS, nullptr, Policy, 0);
1994   OS << ")";
1995 }
1996 
VisitOMPGrainsizeClause(OMPGrainsizeClause * Node)1997 void OMPClausePrinter::VisitOMPGrainsizeClause(OMPGrainsizeClause *Node) {
1998   OS << "grainsize(";
1999   OpenMPGrainsizeClauseModifier Modifier = Node->getModifier();
2000   if (Modifier != OMPC_GRAINSIZE_unknown) {
2001     OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(), Modifier)
2002        << ": ";
2003   }
2004   Node->getGrainsize()->printPretty(OS, nullptr, Policy, 0);
2005   OS << ")";
2006 }
2007 
VisitOMPNumTasksClause(OMPNumTasksClause * Node)2008 void OMPClausePrinter::VisitOMPNumTasksClause(OMPNumTasksClause *Node) {
2009   OS << "num_tasks(";
2010   OpenMPNumTasksClauseModifier Modifier = Node->getModifier();
2011   if (Modifier != OMPC_NUMTASKS_unknown) {
2012     OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(), Modifier)
2013        << ": ";
2014   }
2015   Node->getNumTasks()->printPretty(OS, nullptr, Policy, 0);
2016   OS << ")";
2017 }
2018 
VisitOMPHintClause(OMPHintClause * Node)2019 void OMPClausePrinter::VisitOMPHintClause(OMPHintClause *Node) {
2020   OS << "hint(";
2021   Node->getHint()->printPretty(OS, nullptr, Policy, 0);
2022   OS << ")";
2023 }
2024 
VisitOMPInitClause(OMPInitClause * Node)2025 void OMPClausePrinter::VisitOMPInitClause(OMPInitClause *Node) {
2026   OS << "init(";
2027   bool First = true;
2028   for (const Expr *E : Node->prefs()) {
2029     if (First)
2030       OS << "prefer_type(";
2031     else
2032       OS << ",";
2033     E->printPretty(OS, nullptr, Policy);
2034     First = false;
2035   }
2036   if (!First)
2037     OS << "), ";
2038   if (Node->getIsTarget())
2039     OS << "target";
2040   if (Node->getIsTargetSync()) {
2041     if (Node->getIsTarget())
2042       OS << ", ";
2043     OS << "targetsync";
2044   }
2045   OS << " : ";
2046   Node->getInteropVar()->printPretty(OS, nullptr, Policy);
2047   OS << ")";
2048 }
2049 
VisitOMPUseClause(OMPUseClause * Node)2050 void OMPClausePrinter::VisitOMPUseClause(OMPUseClause *Node) {
2051   OS << "use(";
2052   Node->getInteropVar()->printPretty(OS, nullptr, Policy);
2053   OS << ")";
2054 }
2055 
VisitOMPDestroyClause(OMPDestroyClause * Node)2056 void OMPClausePrinter::VisitOMPDestroyClause(OMPDestroyClause *Node) {
2057   OS << "destroy";
2058   if (Expr *E = Node->getInteropVar()) {
2059     OS << "(";
2060     E->printPretty(OS, nullptr, Policy);
2061     OS << ")";
2062   }
2063 }
2064 
VisitOMPNovariantsClause(OMPNovariantsClause * Node)2065 void OMPClausePrinter::VisitOMPNovariantsClause(OMPNovariantsClause *Node) {
2066   OS << "novariants";
2067   if (Expr *E = Node->getCondition()) {
2068     OS << "(";
2069     E->printPretty(OS, nullptr, Policy, 0);
2070     OS << ")";
2071   }
2072 }
2073 
VisitOMPNocontextClause(OMPNocontextClause * Node)2074 void OMPClausePrinter::VisitOMPNocontextClause(OMPNocontextClause *Node) {
2075   OS << "nocontext";
2076   if (Expr *E = Node->getCondition()) {
2077     OS << "(";
2078     E->printPretty(OS, nullptr, Policy, 0);
2079     OS << ")";
2080   }
2081 }
2082 
2083 template<typename T>
VisitOMPClauseList(T * Node,char StartSym)2084 void OMPClausePrinter::VisitOMPClauseList(T *Node, char StartSym) {
2085   for (typename T::varlist_iterator I = Node->varlist_begin(),
2086                                     E = Node->varlist_end();
2087        I != E; ++I) {
2088     assert(*I && "Expected non-null Stmt");
2089     OS << (I == Node->varlist_begin() ? StartSym : ',');
2090     if (auto *DRE = dyn_cast<DeclRefExpr>(*I)) {
2091       if (isa<OMPCapturedExprDecl>(DRE->getDecl()))
2092         DRE->printPretty(OS, nullptr, Policy, 0);
2093       else
2094         DRE->getDecl()->printQualifiedName(OS);
2095     } else
2096       (*I)->printPretty(OS, nullptr, Policy, 0);
2097   }
2098 }
2099 
VisitOMPAllocateClause(OMPAllocateClause * Node)2100 void OMPClausePrinter::VisitOMPAllocateClause(OMPAllocateClause *Node) {
2101   if (Node->varlist_empty())
2102     return;
2103   OS << "allocate";
2104   if (Expr *Allocator = Node->getAllocator()) {
2105     OS << "(";
2106     Allocator->printPretty(OS, nullptr, Policy, 0);
2107     OS << ":";
2108     VisitOMPClauseList(Node, ' ');
2109   } else {
2110     VisitOMPClauseList(Node, '(');
2111   }
2112   OS << ")";
2113 }
2114 
VisitOMPPrivateClause(OMPPrivateClause * Node)2115 void OMPClausePrinter::VisitOMPPrivateClause(OMPPrivateClause *Node) {
2116   if (!Node->varlist_empty()) {
2117     OS << "private";
2118     VisitOMPClauseList(Node, '(');
2119     OS << ")";
2120   }
2121 }
2122 
VisitOMPFirstprivateClause(OMPFirstprivateClause * Node)2123 void OMPClausePrinter::VisitOMPFirstprivateClause(OMPFirstprivateClause *Node) {
2124   if (!Node->varlist_empty()) {
2125     OS << "firstprivate";
2126     VisitOMPClauseList(Node, '(');
2127     OS << ")";
2128   }
2129 }
2130 
VisitOMPLastprivateClause(OMPLastprivateClause * Node)2131 void OMPClausePrinter::VisitOMPLastprivateClause(OMPLastprivateClause *Node) {
2132   if (!Node->varlist_empty()) {
2133     OS << "lastprivate";
2134     OpenMPLastprivateModifier LPKind = Node->getKind();
2135     if (LPKind != OMPC_LASTPRIVATE_unknown) {
2136       OS << "("
2137          << getOpenMPSimpleClauseTypeName(OMPC_lastprivate, Node->getKind())
2138          << ":";
2139     }
2140     VisitOMPClauseList(Node, LPKind == OMPC_LASTPRIVATE_unknown ? '(' : ' ');
2141     OS << ")";
2142   }
2143 }
2144 
VisitOMPSharedClause(OMPSharedClause * Node)2145 void OMPClausePrinter::VisitOMPSharedClause(OMPSharedClause *Node) {
2146   if (!Node->varlist_empty()) {
2147     OS << "shared";
2148     VisitOMPClauseList(Node, '(');
2149     OS << ")";
2150   }
2151 }
2152 
VisitOMPReductionClause(OMPReductionClause * Node)2153 void OMPClausePrinter::VisitOMPReductionClause(OMPReductionClause *Node) {
2154   if (!Node->varlist_empty()) {
2155     OS << "reduction(";
2156     if (Node->getModifierLoc().isValid())
2157       OS << getOpenMPSimpleClauseTypeName(OMPC_reduction, Node->getModifier())
2158          << ", ";
2159     NestedNameSpecifier *QualifierLoc =
2160         Node->getQualifierLoc().getNestedNameSpecifier();
2161     OverloadedOperatorKind OOK =
2162         Node->getNameInfo().getName().getCXXOverloadedOperator();
2163     if (QualifierLoc == nullptr && OOK != OO_None) {
2164       // Print reduction identifier in C format
2165       OS << getOperatorSpelling(OOK);
2166     } else {
2167       // Use C++ format
2168       if (QualifierLoc != nullptr)
2169         QualifierLoc->print(OS, Policy);
2170       OS << Node->getNameInfo();
2171     }
2172     OS << ":";
2173     VisitOMPClauseList(Node, ' ');
2174     OS << ")";
2175   }
2176 }
2177 
VisitOMPTaskReductionClause(OMPTaskReductionClause * Node)2178 void OMPClausePrinter::VisitOMPTaskReductionClause(
2179     OMPTaskReductionClause *Node) {
2180   if (!Node->varlist_empty()) {
2181     OS << "task_reduction(";
2182     NestedNameSpecifier *QualifierLoc =
2183         Node->getQualifierLoc().getNestedNameSpecifier();
2184     OverloadedOperatorKind OOK =
2185         Node->getNameInfo().getName().getCXXOverloadedOperator();
2186     if (QualifierLoc == nullptr && OOK != OO_None) {
2187       // Print reduction identifier in C format
2188       OS << getOperatorSpelling(OOK);
2189     } else {
2190       // Use C++ format
2191       if (QualifierLoc != nullptr)
2192         QualifierLoc->print(OS, Policy);
2193       OS << Node->getNameInfo();
2194     }
2195     OS << ":";
2196     VisitOMPClauseList(Node, ' ');
2197     OS << ")";
2198   }
2199 }
2200 
VisitOMPInReductionClause(OMPInReductionClause * Node)2201 void OMPClausePrinter::VisitOMPInReductionClause(OMPInReductionClause *Node) {
2202   if (!Node->varlist_empty()) {
2203     OS << "in_reduction(";
2204     NestedNameSpecifier *QualifierLoc =
2205         Node->getQualifierLoc().getNestedNameSpecifier();
2206     OverloadedOperatorKind OOK =
2207         Node->getNameInfo().getName().getCXXOverloadedOperator();
2208     if (QualifierLoc == nullptr && OOK != OO_None) {
2209       // Print reduction identifier in C format
2210       OS << getOperatorSpelling(OOK);
2211     } else {
2212       // Use C++ format
2213       if (QualifierLoc != nullptr)
2214         QualifierLoc->print(OS, Policy);
2215       OS << Node->getNameInfo();
2216     }
2217     OS << ":";
2218     VisitOMPClauseList(Node, ' ');
2219     OS << ")";
2220   }
2221 }
2222 
VisitOMPLinearClause(OMPLinearClause * Node)2223 void OMPClausePrinter::VisitOMPLinearClause(OMPLinearClause *Node) {
2224   if (!Node->varlist_empty()) {
2225     OS << "linear";
2226     VisitOMPClauseList(Node, '(');
2227     if (Node->getModifierLoc().isValid() || Node->getStep() != nullptr) {
2228       OS << ": ";
2229     }
2230     if (Node->getModifierLoc().isValid()) {
2231       OS << getOpenMPSimpleClauseTypeName(OMPC_linear, Node->getModifier());
2232     }
2233     if (Node->getStep() != nullptr) {
2234       if (Node->getModifierLoc().isValid()) {
2235         OS << ", ";
2236       }
2237       OS << "step(";
2238       Node->getStep()->printPretty(OS, nullptr, Policy, 0);
2239       OS << ")";
2240     }
2241     OS << ")";
2242   }
2243 }
2244 
VisitOMPAlignedClause(OMPAlignedClause * Node)2245 void OMPClausePrinter::VisitOMPAlignedClause(OMPAlignedClause *Node) {
2246   if (!Node->varlist_empty()) {
2247     OS << "aligned";
2248     VisitOMPClauseList(Node, '(');
2249     if (Node->getAlignment() != nullptr) {
2250       OS << ": ";
2251       Node->getAlignment()->printPretty(OS, nullptr, Policy, 0);
2252     }
2253     OS << ")";
2254   }
2255 }
2256 
VisitOMPCopyinClause(OMPCopyinClause * Node)2257 void OMPClausePrinter::VisitOMPCopyinClause(OMPCopyinClause *Node) {
2258   if (!Node->varlist_empty()) {
2259     OS << "copyin";
2260     VisitOMPClauseList(Node, '(');
2261     OS << ")";
2262   }
2263 }
2264 
VisitOMPCopyprivateClause(OMPCopyprivateClause * Node)2265 void OMPClausePrinter::VisitOMPCopyprivateClause(OMPCopyprivateClause *Node) {
2266   if (!Node->varlist_empty()) {
2267     OS << "copyprivate";
2268     VisitOMPClauseList(Node, '(');
2269     OS << ")";
2270   }
2271 }
2272 
VisitOMPFlushClause(OMPFlushClause * Node)2273 void OMPClausePrinter::VisitOMPFlushClause(OMPFlushClause *Node) {
2274   if (!Node->varlist_empty()) {
2275     VisitOMPClauseList(Node, '(');
2276     OS << ")";
2277   }
2278 }
2279 
VisitOMPDepobjClause(OMPDepobjClause * Node)2280 void OMPClausePrinter::VisitOMPDepobjClause(OMPDepobjClause *Node) {
2281   OS << "(";
2282   Node->getDepobj()->printPretty(OS, nullptr, Policy, 0);
2283   OS << ")";
2284 }
2285 
VisitOMPDependClause(OMPDependClause * Node)2286 void OMPClausePrinter::VisitOMPDependClause(OMPDependClause *Node) {
2287   OS << "depend(";
2288   if (Expr *DepModifier = Node->getModifier()) {
2289     DepModifier->printPretty(OS, nullptr, Policy);
2290     OS << ", ";
2291   }
2292   OpenMPDependClauseKind DepKind = Node->getDependencyKind();
2293   OpenMPDependClauseKind PrintKind = DepKind;
2294   bool IsOmpAllMemory = false;
2295   if (PrintKind == OMPC_DEPEND_outallmemory) {
2296     PrintKind = OMPC_DEPEND_out;
2297     IsOmpAllMemory = true;
2298   } else if (PrintKind == OMPC_DEPEND_inoutallmemory) {
2299     PrintKind = OMPC_DEPEND_inout;
2300     IsOmpAllMemory = true;
2301   }
2302   OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(), PrintKind);
2303   if (!Node->varlist_empty() || IsOmpAllMemory)
2304     OS << " :";
2305   VisitOMPClauseList(Node, ' ');
2306   if (IsOmpAllMemory) {
2307     OS << (Node->varlist_empty() ? " " : ",");
2308     OS << "omp_all_memory";
2309   }
2310   OS << ")";
2311 }
2312 
2313 template <typename T>
PrintMapper(raw_ostream & OS,T * Node,const PrintingPolicy & Policy)2314 static void PrintMapper(raw_ostream &OS, T *Node,
2315                         const PrintingPolicy &Policy) {
2316   OS << '(';
2317   NestedNameSpecifier *MapperNNS =
2318       Node->getMapperQualifierLoc().getNestedNameSpecifier();
2319   if (MapperNNS)
2320     MapperNNS->print(OS, Policy);
2321   OS << Node->getMapperIdInfo() << ')';
2322 }
2323 
2324 template <typename T>
PrintIterator(raw_ostream & OS,T * Node,const PrintingPolicy & Policy)2325 static void PrintIterator(raw_ostream &OS, T *Node,
2326                           const PrintingPolicy &Policy) {
2327   if (Expr *IteratorModifier = Node->getIteratorModifier())
2328     IteratorModifier->printPretty(OS, nullptr, Policy);
2329 }
2330 
VisitOMPMapClause(OMPMapClause * Node)2331 void OMPClausePrinter::VisitOMPMapClause(OMPMapClause *Node) {
2332   if (!Node->varlist_empty()) {
2333     OS << "map(";
2334     if (Node->getMapType() != OMPC_MAP_unknown) {
2335       for (unsigned I = 0; I < NumberOfOMPMapClauseModifiers; ++I) {
2336         if (Node->getMapTypeModifier(I) != OMPC_MAP_MODIFIER_unknown) {
2337           if (Node->getMapTypeModifier(I) == OMPC_MAP_MODIFIER_iterator) {
2338             PrintIterator(OS, Node, Policy);
2339           } else {
2340             OS << getOpenMPSimpleClauseTypeName(OMPC_map,
2341                                                 Node->getMapTypeModifier(I));
2342             if (Node->getMapTypeModifier(I) == OMPC_MAP_MODIFIER_mapper)
2343               PrintMapper(OS, Node, Policy);
2344           }
2345           OS << ',';
2346         }
2347       }
2348       OS << getOpenMPSimpleClauseTypeName(OMPC_map, Node->getMapType());
2349       OS << ':';
2350     }
2351     VisitOMPClauseList(Node, ' ');
2352     OS << ")";
2353   }
2354 }
2355 
VisitOMPMotionClause(T * Node)2356 template <typename T> void OMPClausePrinter::VisitOMPMotionClause(T *Node) {
2357   if (Node->varlist_empty())
2358     return;
2359   OS << getOpenMPClauseName(Node->getClauseKind());
2360   unsigned ModifierCount = 0;
2361   for (unsigned I = 0; I < NumberOfOMPMotionModifiers; ++I) {
2362     if (Node->getMotionModifier(I) != OMPC_MOTION_MODIFIER_unknown)
2363       ++ModifierCount;
2364   }
2365   if (ModifierCount) {
2366     OS << '(';
2367     for (unsigned I = 0; I < NumberOfOMPMotionModifiers; ++I) {
2368       if (Node->getMotionModifier(I) != OMPC_MOTION_MODIFIER_unknown) {
2369         OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(),
2370                                             Node->getMotionModifier(I));
2371         if (Node->getMotionModifier(I) == OMPC_MOTION_MODIFIER_mapper)
2372           PrintMapper(OS, Node, Policy);
2373         if (I < ModifierCount - 1)
2374           OS << ", ";
2375       }
2376     }
2377     OS << ':';
2378     VisitOMPClauseList(Node, ' ');
2379   } else {
2380     VisitOMPClauseList(Node, '(');
2381   }
2382   OS << ")";
2383 }
2384 
VisitOMPToClause(OMPToClause * Node)2385 void OMPClausePrinter::VisitOMPToClause(OMPToClause *Node) {
2386   VisitOMPMotionClause(Node);
2387 }
2388 
VisitOMPFromClause(OMPFromClause * Node)2389 void OMPClausePrinter::VisitOMPFromClause(OMPFromClause *Node) {
2390   VisitOMPMotionClause(Node);
2391 }
2392 
VisitOMPDistScheduleClause(OMPDistScheduleClause * Node)2393 void OMPClausePrinter::VisitOMPDistScheduleClause(OMPDistScheduleClause *Node) {
2394   OS << "dist_schedule(" << getOpenMPSimpleClauseTypeName(
2395                            OMPC_dist_schedule, Node->getDistScheduleKind());
2396   if (auto *E = Node->getChunkSize()) {
2397     OS << ", ";
2398     E->printPretty(OS, nullptr, Policy);
2399   }
2400   OS << ")";
2401 }
2402 
VisitOMPDefaultmapClause(OMPDefaultmapClause * Node)2403 void OMPClausePrinter::VisitOMPDefaultmapClause(OMPDefaultmapClause *Node) {
2404   OS << "defaultmap(";
2405   OS << getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
2406                                       Node->getDefaultmapModifier());
2407   if (Node->getDefaultmapKind() != OMPC_DEFAULTMAP_unknown) {
2408     OS << ": ";
2409     OS << getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
2410                                         Node->getDefaultmapKind());
2411   }
2412   OS << ")";
2413 }
2414 
VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause * Node)2415 void OMPClausePrinter::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *Node) {
2416   if (!Node->varlist_empty()) {
2417     OS << "use_device_ptr";
2418     VisitOMPClauseList(Node, '(');
2419     OS << ")";
2420   }
2421 }
2422 
VisitOMPUseDeviceAddrClause(OMPUseDeviceAddrClause * Node)2423 void OMPClausePrinter::VisitOMPUseDeviceAddrClause(
2424     OMPUseDeviceAddrClause *Node) {
2425   if (!Node->varlist_empty()) {
2426     OS << "use_device_addr";
2427     VisitOMPClauseList(Node, '(');
2428     OS << ")";
2429   }
2430 }
2431 
VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause * Node)2432 void OMPClausePrinter::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *Node) {
2433   if (!Node->varlist_empty()) {
2434     OS << "is_device_ptr";
2435     VisitOMPClauseList(Node, '(');
2436     OS << ")";
2437   }
2438 }
2439 
VisitOMPHasDeviceAddrClause(OMPHasDeviceAddrClause * Node)2440 void OMPClausePrinter::VisitOMPHasDeviceAddrClause(OMPHasDeviceAddrClause *Node) {
2441   if (!Node->varlist_empty()) {
2442     OS << "has_device_addr";
2443     VisitOMPClauseList(Node, '(');
2444     OS << ")";
2445   }
2446 }
2447 
VisitOMPNontemporalClause(OMPNontemporalClause * Node)2448 void OMPClausePrinter::VisitOMPNontemporalClause(OMPNontemporalClause *Node) {
2449   if (!Node->varlist_empty()) {
2450     OS << "nontemporal";
2451     VisitOMPClauseList(Node, '(');
2452     OS << ")";
2453   }
2454 }
2455 
VisitOMPOrderClause(OMPOrderClause * Node)2456 void OMPClausePrinter::VisitOMPOrderClause(OMPOrderClause *Node) {
2457   OS << "order(";
2458   if (Node->getModifier() != OMPC_ORDER_MODIFIER_unknown) {
2459     OS << getOpenMPSimpleClauseTypeName(OMPC_order, Node->getModifier());
2460     OS << ": ";
2461   }
2462   OS << getOpenMPSimpleClauseTypeName(OMPC_order, Node->getKind()) << ")";
2463 }
2464 
VisitOMPInclusiveClause(OMPInclusiveClause * Node)2465 void OMPClausePrinter::VisitOMPInclusiveClause(OMPInclusiveClause *Node) {
2466   if (!Node->varlist_empty()) {
2467     OS << "inclusive";
2468     VisitOMPClauseList(Node, '(');
2469     OS << ")";
2470   }
2471 }
2472 
VisitOMPExclusiveClause(OMPExclusiveClause * Node)2473 void OMPClausePrinter::VisitOMPExclusiveClause(OMPExclusiveClause *Node) {
2474   if (!Node->varlist_empty()) {
2475     OS << "exclusive";
2476     VisitOMPClauseList(Node, '(');
2477     OS << ")";
2478   }
2479 }
2480 
VisitOMPUsesAllocatorsClause(OMPUsesAllocatorsClause * Node)2481 void OMPClausePrinter::VisitOMPUsesAllocatorsClause(
2482     OMPUsesAllocatorsClause *Node) {
2483   if (Node->getNumberOfAllocators() == 0)
2484     return;
2485   OS << "uses_allocators(";
2486   for (unsigned I = 0, E = Node->getNumberOfAllocators(); I < E; ++I) {
2487     OMPUsesAllocatorsClause::Data Data = Node->getAllocatorData(I);
2488     Data.Allocator->printPretty(OS, nullptr, Policy);
2489     if (Data.AllocatorTraits) {
2490       OS << "(";
2491       Data.AllocatorTraits->printPretty(OS, nullptr, Policy);
2492       OS << ")";
2493     }
2494     if (I < E - 1)
2495       OS << ",";
2496   }
2497   OS << ")";
2498 }
2499 
VisitOMPAffinityClause(OMPAffinityClause * Node)2500 void OMPClausePrinter::VisitOMPAffinityClause(OMPAffinityClause *Node) {
2501   if (Node->varlist_empty())
2502     return;
2503   OS << "affinity";
2504   char StartSym = '(';
2505   if (Expr *Modifier = Node->getModifier()) {
2506     OS << "(";
2507     Modifier->printPretty(OS, nullptr, Policy);
2508     OS << " :";
2509     StartSym = ' ';
2510   }
2511   VisitOMPClauseList(Node, StartSym);
2512   OS << ")";
2513 }
2514 
VisitOMPFilterClause(OMPFilterClause * Node)2515 void OMPClausePrinter::VisitOMPFilterClause(OMPFilterClause *Node) {
2516   OS << "filter(";
2517   Node->getThreadID()->printPretty(OS, nullptr, Policy, 0);
2518   OS << ")";
2519 }
2520 
VisitOMPBindClause(OMPBindClause * Node)2521 void OMPClausePrinter::VisitOMPBindClause(OMPBindClause *Node) {
2522   OS << "bind("
2523      << getOpenMPSimpleClauseTypeName(OMPC_bind, unsigned(Node->getBindKind()))
2524      << ")";
2525 }
2526 
VisitOMPXDynCGroupMemClause(OMPXDynCGroupMemClause * Node)2527 void OMPClausePrinter::VisitOMPXDynCGroupMemClause(
2528     OMPXDynCGroupMemClause *Node) {
2529   OS << "ompx_dyn_cgroup_mem(";
2530   Node->getSize()->printPretty(OS, nullptr, Policy, 0);
2531   OS << ")";
2532 }
2533 
VisitOMPDoacrossClause(OMPDoacrossClause * Node)2534 void OMPClausePrinter::VisitOMPDoacrossClause(OMPDoacrossClause *Node) {
2535   OS << "doacross(";
2536   OpenMPDoacrossClauseModifier DepType = Node->getDependenceType();
2537 
2538   switch (DepType) {
2539   case OMPC_DOACROSS_source:
2540     OS << "source:";
2541     break;
2542   case OMPC_DOACROSS_sink:
2543     OS << "sink:";
2544     break;
2545   case OMPC_DOACROSS_source_omp_cur_iteration:
2546     OS << "source: omp_cur_iteration";
2547     break;
2548   case OMPC_DOACROSS_sink_omp_cur_iteration:
2549     OS << "sink: omp_cur_iteration - 1";
2550     break;
2551   default:
2552     llvm_unreachable("unknown docaross modifier");
2553   }
2554   VisitOMPClauseList(Node, ' ');
2555   OS << ")";
2556 }
2557 
VisitOMPXAttributeClause(OMPXAttributeClause * Node)2558 void OMPClausePrinter::VisitOMPXAttributeClause(OMPXAttributeClause *Node) {
2559   OS << "ompx_attribute(";
2560   bool IsFirst = true;
2561   for (auto &Attr : Node->getAttrs()) {
2562     if (!IsFirst)
2563       OS << ", ";
2564     Attr->printPretty(OS, Policy);
2565     IsFirst = false;
2566   }
2567   OS << ")";
2568 }
2569 
VisitOMPXBareClause(OMPXBareClause * Node)2570 void OMPClausePrinter::VisitOMPXBareClause(OMPXBareClause *Node) {
2571   OS << "ompx_bare";
2572 }
2573 
getAsVariantMatchInfo(ASTContext & ASTCtx,VariantMatchInfo & VMI) const2574 void OMPTraitInfo::getAsVariantMatchInfo(ASTContext &ASTCtx,
2575                                          VariantMatchInfo &VMI) const {
2576   for (const OMPTraitSet &Set : Sets) {
2577     for (const OMPTraitSelector &Selector : Set.Selectors) {
2578 
2579       // User conditions are special as we evaluate the condition here.
2580       if (Selector.Kind == TraitSelector::user_condition) {
2581         assert(Selector.ScoreOrCondition &&
2582                "Ill-formed user condition, expected condition expression!");
2583         assert(Selector.Properties.size() == 1 &&
2584                Selector.Properties.front().Kind ==
2585                    TraitProperty::user_condition_unknown &&
2586                "Ill-formed user condition, expected unknown trait property!");
2587 
2588         if (std::optional<APSInt> CondVal =
2589                 Selector.ScoreOrCondition->getIntegerConstantExpr(ASTCtx))
2590           VMI.addTrait(CondVal->isZero() ? TraitProperty::user_condition_false
2591                                          : TraitProperty::user_condition_true,
2592                        "<condition>");
2593         else
2594           VMI.addTrait(TraitProperty::user_condition_false, "<condition>");
2595         continue;
2596       }
2597 
2598       std::optional<llvm::APSInt> Score;
2599       llvm::APInt *ScorePtr = nullptr;
2600       if (Selector.ScoreOrCondition) {
2601         if ((Score = Selector.ScoreOrCondition->getIntegerConstantExpr(ASTCtx)))
2602           ScorePtr = &*Score;
2603         else
2604           VMI.addTrait(TraitProperty::user_condition_false,
2605                        "<non-constant-score>");
2606       }
2607 
2608       for (const OMPTraitProperty &Property : Selector.Properties)
2609         VMI.addTrait(Set.Kind, Property.Kind, Property.RawString, ScorePtr);
2610 
2611       if (Set.Kind != TraitSet::construct)
2612         continue;
2613 
2614       // TODO: This might not hold once we implement SIMD properly.
2615       assert(Selector.Properties.size() == 1 &&
2616              Selector.Properties.front().Kind ==
2617                  getOpenMPContextTraitPropertyForSelector(
2618                      Selector.Kind) &&
2619              "Ill-formed construct selector!");
2620     }
2621   }
2622 }
2623 
print(llvm::raw_ostream & OS,const PrintingPolicy & Policy) const2624 void OMPTraitInfo::print(llvm::raw_ostream &OS,
2625                          const PrintingPolicy &Policy) const {
2626   bool FirstSet = true;
2627   for (const OMPTraitSet &Set : Sets) {
2628     if (!FirstSet)
2629       OS << ", ";
2630     FirstSet = false;
2631     OS << getOpenMPContextTraitSetName(Set.Kind) << "={";
2632 
2633     bool FirstSelector = true;
2634     for (const OMPTraitSelector &Selector : Set.Selectors) {
2635       if (!FirstSelector)
2636         OS << ", ";
2637       FirstSelector = false;
2638       OS << getOpenMPContextTraitSelectorName(Selector.Kind);
2639 
2640       bool AllowsTraitScore = false;
2641       bool RequiresProperty = false;
2642       isValidTraitSelectorForTraitSet(
2643           Selector.Kind, Set.Kind, AllowsTraitScore, RequiresProperty);
2644 
2645       if (!RequiresProperty)
2646         continue;
2647 
2648       OS << "(";
2649       if (Selector.Kind == TraitSelector::user_condition) {
2650         if (Selector.ScoreOrCondition)
2651           Selector.ScoreOrCondition->printPretty(OS, nullptr, Policy);
2652         else
2653           OS << "...";
2654       } else {
2655 
2656         if (Selector.ScoreOrCondition) {
2657           OS << "score(";
2658           Selector.ScoreOrCondition->printPretty(OS, nullptr, Policy);
2659           OS << "): ";
2660         }
2661 
2662         bool FirstProperty = true;
2663         for (const OMPTraitProperty &Property : Selector.Properties) {
2664           if (!FirstProperty)
2665             OS << ", ";
2666           FirstProperty = false;
2667           OS << getOpenMPContextTraitPropertyName(Property.Kind,
2668                                                   Property.RawString);
2669         }
2670       }
2671       OS << ")";
2672     }
2673     OS << "}";
2674   }
2675 }
2676 
getMangledName() const2677 std::string OMPTraitInfo::getMangledName() const {
2678   std::string MangledName;
2679   llvm::raw_string_ostream OS(MangledName);
2680   for (const OMPTraitSet &Set : Sets) {
2681     OS << '$' << 'S' << unsigned(Set.Kind);
2682     for (const OMPTraitSelector &Selector : Set.Selectors) {
2683 
2684       bool AllowsTraitScore = false;
2685       bool RequiresProperty = false;
2686       isValidTraitSelectorForTraitSet(
2687           Selector.Kind, Set.Kind, AllowsTraitScore, RequiresProperty);
2688       OS << '$' << 's' << unsigned(Selector.Kind);
2689 
2690       if (!RequiresProperty ||
2691           Selector.Kind == TraitSelector::user_condition)
2692         continue;
2693 
2694       for (const OMPTraitProperty &Property : Selector.Properties)
2695         OS << '$' << 'P'
2696            << getOpenMPContextTraitPropertyName(Property.Kind,
2697                                                 Property.RawString);
2698     }
2699   }
2700   return MangledName;
2701 }
2702 
OMPTraitInfo(StringRef MangledName)2703 OMPTraitInfo::OMPTraitInfo(StringRef MangledName) {
2704   unsigned long U;
2705   do {
2706     if (!MangledName.consume_front("$S"))
2707       break;
2708     if (MangledName.consumeInteger(10, U))
2709       break;
2710     Sets.push_back(OMPTraitSet());
2711     OMPTraitSet &Set = Sets.back();
2712     Set.Kind = TraitSet(U);
2713     do {
2714       if (!MangledName.consume_front("$s"))
2715         break;
2716       if (MangledName.consumeInteger(10, U))
2717         break;
2718       Set.Selectors.push_back(OMPTraitSelector());
2719       OMPTraitSelector &Selector = Set.Selectors.back();
2720       Selector.Kind = TraitSelector(U);
2721       do {
2722         if (!MangledName.consume_front("$P"))
2723           break;
2724         Selector.Properties.push_back(OMPTraitProperty());
2725         OMPTraitProperty &Property = Selector.Properties.back();
2726         std::pair<StringRef, StringRef> PropRestPair = MangledName.split('$');
2727         Property.RawString = PropRestPair.first;
2728         Property.Kind = getOpenMPContextTraitPropertyKind(
2729             Set.Kind, Selector.Kind, PropRestPair.first);
2730         MangledName = MangledName.drop_front(PropRestPair.first.size());
2731       } while (true);
2732     } while (true);
2733   } while (true);
2734 }
2735 
operator <<(llvm::raw_ostream & OS,const OMPTraitInfo & TI)2736 llvm::raw_ostream &clang::operator<<(llvm::raw_ostream &OS,
2737                                      const OMPTraitInfo &TI) {
2738   LangOptions LO;
2739   PrintingPolicy Policy(LO);
2740   TI.print(OS, Policy);
2741   return OS;
2742 }
operator <<(llvm::raw_ostream & OS,const OMPTraitInfo * TI)2743 llvm::raw_ostream &clang::operator<<(llvm::raw_ostream &OS,
2744                                      const OMPTraitInfo *TI) {
2745   return TI ? OS << *TI : OS;
2746 }
2747 
TargetOMPContext(ASTContext & ASTCtx,std::function<void (StringRef)> && DiagUnknownTrait,const FunctionDecl * CurrentFunctionDecl,ArrayRef<llvm::omp::TraitProperty> ConstructTraits)2748 TargetOMPContext::TargetOMPContext(
2749     ASTContext &ASTCtx, std::function<void(StringRef)> &&DiagUnknownTrait,
2750     const FunctionDecl *CurrentFunctionDecl,
2751     ArrayRef<llvm::omp::TraitProperty> ConstructTraits)
2752     : OMPContext(ASTCtx.getLangOpts().OpenMPIsTargetDevice,
2753                  ASTCtx.getTargetInfo().getTriple()),
2754       FeatureValidityCheck([&](StringRef FeatureName) {
2755         return ASTCtx.getTargetInfo().isValidFeatureName(FeatureName);
2756       }),
2757       DiagUnknownTrait(std::move(DiagUnknownTrait)) {
2758   ASTCtx.getFunctionFeatureMap(FeatureMap, CurrentFunctionDecl);
2759 
2760   for (llvm::omp::TraitProperty Property : ConstructTraits)
2761     addTrait(Property);
2762 }
2763 
matchesISATrait(StringRef RawString) const2764 bool TargetOMPContext::matchesISATrait(StringRef RawString) const {
2765   auto It = FeatureMap.find(RawString);
2766   if (It != FeatureMap.end())
2767     return It->second;
2768   if (!FeatureValidityCheck(RawString))
2769     DiagUnknownTrait(RawString);
2770   return false;
2771 }
2772