[OpenMP][NFC] Remove the need to include `OpenMPClause.h`
[lldb.git] / clang / lib / AST / OpenMPClause.cpp
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 "llvm/ADT/SmallPtrSet.h"
21 #include "llvm/Support/Casting.h"
22 #include "llvm/Support/ErrorHandling.h"
23 #include <algorithm>
24 #include <cassert>
25
26 using namespace clang;
27 using namespace llvm;
28 using namespace omp;
29
30 OMPClause::child_range OMPClause::children() {
31   switch (getClauseKind()) {
32   default:
33     break;
34 #define OPENMP_CLAUSE(Name, Class)                                             \
35   case OMPC_##Name:                                                            \
36     return static_cast<Class *>(this)->children();
37 #include "clang/Basic/OpenMPKinds.def"
38   }
39   llvm_unreachable("unknown OMPClause");
40 }
41
42 OMPClause::child_range OMPClause::used_children() {
43   switch (getClauseKind()) {
44 #define OPENMP_CLAUSE(Name, Class)                                             \
45   case OMPC_##Name:                                                            \
46     return static_cast<Class *>(this)->used_children();
47 #include "clang/Basic/OpenMPKinds.def"
48   case OMPC_threadprivate:
49   case OMPC_uniform:
50   case OMPC_device_type:
51   case OMPC_match:
52   case OMPC_unknown:
53     break;
54   }
55   llvm_unreachable("unknown OMPClause");
56 }
57
58 OMPClauseWithPreInit *OMPClauseWithPreInit::get(OMPClause *C) {
59   auto *Res = OMPClauseWithPreInit::get(const_cast<const OMPClause *>(C));
60   return Res ? const_cast<OMPClauseWithPreInit *>(Res) : nullptr;
61 }
62
63 const OMPClauseWithPreInit *OMPClauseWithPreInit::get(const OMPClause *C) {
64   switch (C->getClauseKind()) {
65   case OMPC_schedule:
66     return static_cast<const OMPScheduleClause *>(C);
67   case OMPC_dist_schedule:
68     return static_cast<const OMPDistScheduleClause *>(C);
69   case OMPC_firstprivate:
70     return static_cast<const OMPFirstprivateClause *>(C);
71   case OMPC_lastprivate:
72     return static_cast<const OMPLastprivateClause *>(C);
73   case OMPC_reduction:
74     return static_cast<const OMPReductionClause *>(C);
75   case OMPC_task_reduction:
76     return static_cast<const OMPTaskReductionClause *>(C);
77   case OMPC_in_reduction:
78     return static_cast<const OMPInReductionClause *>(C);
79   case OMPC_linear:
80     return static_cast<const OMPLinearClause *>(C);
81   case OMPC_if:
82     return static_cast<const OMPIfClause *>(C);
83   case OMPC_num_threads:
84     return static_cast<const OMPNumThreadsClause *>(C);
85   case OMPC_num_teams:
86     return static_cast<const OMPNumTeamsClause *>(C);
87   case OMPC_thread_limit:
88     return static_cast<const OMPThreadLimitClause *>(C);
89   case OMPC_device:
90     return static_cast<const OMPDeviceClause *>(C);
91   case OMPC_grainsize:
92     return static_cast<const OMPGrainsizeClause *>(C);
93   case OMPC_num_tasks:
94     return static_cast<const OMPNumTasksClause *>(C);
95   case OMPC_final:
96     return static_cast<const OMPFinalClause *>(C);
97   case OMPC_priority:
98     return static_cast<const OMPPriorityClause *>(C);
99   case OMPC_default:
100   case OMPC_proc_bind:
101   case OMPC_safelen:
102   case OMPC_simdlen:
103   case OMPC_allocator:
104   case OMPC_allocate:
105   case OMPC_collapse:
106   case OMPC_private:
107   case OMPC_shared:
108   case OMPC_aligned:
109   case OMPC_copyin:
110   case OMPC_copyprivate:
111   case OMPC_ordered:
112   case OMPC_nowait:
113   case OMPC_untied:
114   case OMPC_mergeable:
115   case OMPC_threadprivate:
116   case OMPC_flush:
117   case OMPC_depobj:
118   case OMPC_read:
119   case OMPC_write:
120   case OMPC_update:
121   case OMPC_capture:
122   case OMPC_seq_cst:
123   case OMPC_acq_rel:
124   case OMPC_acquire:
125   case OMPC_release:
126   case OMPC_relaxed:
127   case OMPC_depend:
128   case OMPC_threads:
129   case OMPC_simd:
130   case OMPC_map:
131   case OMPC_nogroup:
132   case OMPC_hint:
133   case OMPC_defaultmap:
134   case OMPC_unknown:
135   case OMPC_uniform:
136   case OMPC_to:
137   case OMPC_from:
138   case OMPC_use_device_ptr:
139   case OMPC_is_device_ptr:
140   case OMPC_unified_address:
141   case OMPC_unified_shared_memory:
142   case OMPC_reverse_offload:
143   case OMPC_dynamic_allocators:
144   case OMPC_atomic_default_mem_order:
145   case OMPC_device_type:
146   case OMPC_match:
147   case OMPC_nontemporal:
148   case OMPC_order:
149   case OMPC_destroy:
150   case OMPC_detach:
151   case OMPC_inclusive:
152   case OMPC_exclusive:
153     break;
154   }
155
156   return nullptr;
157 }
158
159 OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(OMPClause *C) {
160   auto *Res = OMPClauseWithPostUpdate::get(const_cast<const OMPClause *>(C));
161   return Res ? const_cast<OMPClauseWithPostUpdate *>(Res) : nullptr;
162 }
163
164 const OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(const OMPClause *C) {
165   switch (C->getClauseKind()) {
166   case OMPC_lastprivate:
167     return static_cast<const OMPLastprivateClause *>(C);
168   case OMPC_reduction:
169     return static_cast<const OMPReductionClause *>(C);
170   case OMPC_task_reduction:
171     return static_cast<const OMPTaskReductionClause *>(C);
172   case OMPC_in_reduction:
173     return static_cast<const OMPInReductionClause *>(C);
174   case OMPC_linear:
175     return static_cast<const OMPLinearClause *>(C);
176   case OMPC_schedule:
177   case OMPC_dist_schedule:
178   case OMPC_firstprivate:
179   case OMPC_default:
180   case OMPC_proc_bind:
181   case OMPC_if:
182   case OMPC_final:
183   case OMPC_num_threads:
184   case OMPC_safelen:
185   case OMPC_simdlen:
186   case OMPC_allocator:
187   case OMPC_allocate:
188   case OMPC_collapse:
189   case OMPC_private:
190   case OMPC_shared:
191   case OMPC_aligned:
192   case OMPC_copyin:
193   case OMPC_copyprivate:
194   case OMPC_ordered:
195   case OMPC_nowait:
196   case OMPC_untied:
197   case OMPC_mergeable:
198   case OMPC_threadprivate:
199   case OMPC_flush:
200   case OMPC_depobj:
201   case OMPC_read:
202   case OMPC_write:
203   case OMPC_update:
204   case OMPC_capture:
205   case OMPC_seq_cst:
206   case OMPC_acq_rel:
207   case OMPC_acquire:
208   case OMPC_release:
209   case OMPC_relaxed:
210   case OMPC_depend:
211   case OMPC_device:
212   case OMPC_threads:
213   case OMPC_simd:
214   case OMPC_map:
215   case OMPC_num_teams:
216   case OMPC_thread_limit:
217   case OMPC_priority:
218   case OMPC_grainsize:
219   case OMPC_nogroup:
220   case OMPC_num_tasks:
221   case OMPC_hint:
222   case OMPC_defaultmap:
223   case OMPC_unknown:
224   case OMPC_uniform:
225   case OMPC_to:
226   case OMPC_from:
227   case OMPC_use_device_ptr:
228   case OMPC_is_device_ptr:
229   case OMPC_unified_address:
230   case OMPC_unified_shared_memory:
231   case OMPC_reverse_offload:
232   case OMPC_dynamic_allocators:
233   case OMPC_atomic_default_mem_order:
234   case OMPC_device_type:
235   case OMPC_match:
236   case OMPC_nontemporal:
237   case OMPC_order:
238   case OMPC_destroy:
239   case OMPC_detach:
240   case OMPC_inclusive:
241   case OMPC_exclusive:
242     break;
243   }
244
245   return nullptr;
246 }
247
248 /// Gets the address of the original, non-captured, expression used in the
249 /// clause as the preinitializer.
250 static Stmt **getAddrOfExprAsWritten(Stmt *S) {
251   if (!S)
252     return nullptr;
253   if (auto *DS = dyn_cast<DeclStmt>(S)) {
254     assert(DS->isSingleDecl() && "Only single expression must be captured.");
255     if (auto *OED = dyn_cast<OMPCapturedExprDecl>(DS->getSingleDecl()))
256       return OED->getInitAddress();
257   }
258   return nullptr;
259 }
260
261 OMPClause::child_range OMPIfClause::used_children() {
262   if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
263     return child_range(C, C + 1);
264   return child_range(&Condition, &Condition + 1);
265 }
266
267 OMPClause::child_range OMPGrainsizeClause::used_children() {
268   if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
269     return child_range(C, C + 1);
270   return child_range(&Grainsize, &Grainsize + 1);
271 }
272
273 OMPClause::child_range OMPNumTasksClause::used_children() {
274   if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
275     return child_range(C, C + 1);
276   return child_range(&NumTasks, &NumTasks + 1);
277 }
278
279 OMPClause::child_range OMPFinalClause::used_children() {
280   if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
281     return child_range(C, C + 1);
282   return child_range(&Condition, &Condition + 1);
283 }
284
285 OMPClause::child_range OMPPriorityClause::used_children() {
286   if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
287     return child_range(C, C + 1);
288   return child_range(&Priority, &Priority + 1);
289 }
290
291 OMPOrderedClause *OMPOrderedClause::Create(const ASTContext &C, Expr *Num,
292                                            unsigned NumLoops,
293                                            SourceLocation StartLoc,
294                                            SourceLocation LParenLoc,
295                                            SourceLocation EndLoc) {
296   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * NumLoops));
297   auto *Clause =
298       new (Mem) OMPOrderedClause(Num, NumLoops, StartLoc, LParenLoc, EndLoc);
299   for (unsigned I = 0; I < NumLoops; ++I) {
300     Clause->setLoopNumIterations(I, nullptr);
301     Clause->setLoopCounter(I, nullptr);
302   }
303   return Clause;
304 }
305
306 OMPOrderedClause *OMPOrderedClause::CreateEmpty(const ASTContext &C,
307                                                 unsigned NumLoops) {
308   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * NumLoops));
309   auto *Clause = new (Mem) OMPOrderedClause(NumLoops);
310   for (unsigned I = 0; I < NumLoops; ++I) {
311     Clause->setLoopNumIterations(I, nullptr);
312     Clause->setLoopCounter(I, nullptr);
313   }
314   return Clause;
315 }
316
317 void OMPOrderedClause::setLoopNumIterations(unsigned NumLoop,
318                                             Expr *NumIterations) {
319   assert(NumLoop < NumberOfLoops && "out of loops number.");
320   getTrailingObjects<Expr *>()[NumLoop] = NumIterations;
321 }
322
323 ArrayRef<Expr *> OMPOrderedClause::getLoopNumIterations() const {
324   return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumberOfLoops);
325 }
326
327 void OMPOrderedClause::setLoopCounter(unsigned NumLoop, Expr *Counter) {
328   assert(NumLoop < NumberOfLoops && "out of loops number.");
329   getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop] = Counter;
330 }
331
332 Expr *OMPOrderedClause::getLoopCounter(unsigned NumLoop) {
333   assert(NumLoop < NumberOfLoops && "out of loops number.");
334   return getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop];
335 }
336
337 const Expr *OMPOrderedClause::getLoopCounter(unsigned NumLoop) const {
338   assert(NumLoop < NumberOfLoops && "out of loops number.");
339   return getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop];
340 }
341
342 OMPUpdateClause *OMPUpdateClause::Create(const ASTContext &C,
343                                          SourceLocation StartLoc,
344                                          SourceLocation EndLoc) {
345   return new (C) OMPUpdateClause(StartLoc, EndLoc, /*IsExtended=*/false);
346 }
347
348 OMPUpdateClause *
349 OMPUpdateClause::Create(const ASTContext &C, SourceLocation StartLoc,
350                         SourceLocation LParenLoc, SourceLocation ArgumentLoc,
351                         OpenMPDependClauseKind DK, SourceLocation EndLoc) {
352   void *Mem =
353       C.Allocate(totalSizeToAlloc<SourceLocation, OpenMPDependClauseKind>(2, 1),
354                  alignof(OMPUpdateClause));
355   auto *Clause =
356       new (Mem) OMPUpdateClause(StartLoc, EndLoc, /*IsExtended=*/true);
357   Clause->setLParenLoc(LParenLoc);
358   Clause->setArgumentLoc(ArgumentLoc);
359   Clause->setDependencyKind(DK);
360   return Clause;
361 }
362
363 OMPUpdateClause *OMPUpdateClause::CreateEmpty(const ASTContext &C,
364                                               bool IsExtended) {
365   if (!IsExtended)
366     return new (C) OMPUpdateClause(/*IsExtended=*/false);
367   void *Mem =
368       C.Allocate(totalSizeToAlloc<SourceLocation, OpenMPDependClauseKind>(2, 1),
369                  alignof(OMPUpdateClause));
370   auto *Clause = new (Mem) OMPUpdateClause(/*IsExtended=*/true);
371   Clause->IsExtended = true;
372   return Clause;
373 }
374
375 void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
376   assert(VL.size() == varlist_size() &&
377          "Number of private copies is not the same as the preallocated buffer");
378   std::copy(VL.begin(), VL.end(), varlist_end());
379 }
380
381 OMPPrivateClause *
382 OMPPrivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
383                          SourceLocation LParenLoc, SourceLocation EndLoc,
384                          ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) {
385   // Allocate space for private variables and initializer expressions.
386   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * VL.size()));
387   OMPPrivateClause *Clause =
388       new (Mem) OMPPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
389   Clause->setVarRefs(VL);
390   Clause->setPrivateCopies(PrivateVL);
391   return Clause;
392 }
393
394 OMPPrivateClause *OMPPrivateClause::CreateEmpty(const ASTContext &C,
395                                                 unsigned N) {
396   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * N));
397   return new (Mem) OMPPrivateClause(N);
398 }
399
400 void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
401   assert(VL.size() == varlist_size() &&
402          "Number of private copies is not the same as the preallocated buffer");
403   std::copy(VL.begin(), VL.end(), varlist_end());
404 }
405
406 void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) {
407   assert(VL.size() == varlist_size() &&
408          "Number of inits is not the same as the preallocated buffer");
409   std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
410 }
411
412 OMPFirstprivateClause *
413 OMPFirstprivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
414                               SourceLocation LParenLoc, SourceLocation EndLoc,
415                               ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
416                               ArrayRef<Expr *> InitVL, Stmt *PreInit) {
417   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * VL.size()));
418   OMPFirstprivateClause *Clause =
419       new (Mem) OMPFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
420   Clause->setVarRefs(VL);
421   Clause->setPrivateCopies(PrivateVL);
422   Clause->setInits(InitVL);
423   Clause->setPreInitStmt(PreInit);
424   return Clause;
425 }
426
427 OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C,
428                                                           unsigned N) {
429   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * N));
430   return new (Mem) OMPFirstprivateClause(N);
431 }
432
433 void OMPLastprivateClause::setPrivateCopies(ArrayRef<Expr *> PrivateCopies) {
434   assert(PrivateCopies.size() == varlist_size() &&
435          "Number of private copies is not the same as the preallocated buffer");
436   std::copy(PrivateCopies.begin(), PrivateCopies.end(), varlist_end());
437 }
438
439 void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
440   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
441                                               "not the same as the "
442                                               "preallocated buffer");
443   std::copy(SrcExprs.begin(), SrcExprs.end(), getPrivateCopies().end());
444 }
445
446 void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
447   assert(DstExprs.size() == varlist_size() && "Number of destination "
448                                               "expressions is not the same as "
449                                               "the preallocated buffer");
450   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
451 }
452
453 void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
454   assert(AssignmentOps.size() == varlist_size() &&
455          "Number of assignment expressions is not the same as the preallocated "
456          "buffer");
457   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
458             getDestinationExprs().end());
459 }
460
461 OMPLastprivateClause *OMPLastprivateClause::Create(
462     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
463     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
464     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps,
465     OpenMPLastprivateModifier LPKind, SourceLocation LPKindLoc,
466     SourceLocation ColonLoc, Stmt *PreInit, Expr *PostUpdate) {
467   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
468   OMPLastprivateClause *Clause = new (Mem) OMPLastprivateClause(
469       StartLoc, LParenLoc, EndLoc, LPKind, LPKindLoc, ColonLoc, VL.size());
470   Clause->setVarRefs(VL);
471   Clause->setSourceExprs(SrcExprs);
472   Clause->setDestinationExprs(DstExprs);
473   Clause->setAssignmentOps(AssignmentOps);
474   Clause->setPreInitStmt(PreInit);
475   Clause->setPostUpdateExpr(PostUpdate);
476   return Clause;
477 }
478
479 OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C,
480                                                         unsigned N) {
481   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
482   return new (Mem) OMPLastprivateClause(N);
483 }
484
485 OMPSharedClause *OMPSharedClause::Create(const ASTContext &C,
486                                          SourceLocation StartLoc,
487                                          SourceLocation LParenLoc,
488                                          SourceLocation EndLoc,
489                                          ArrayRef<Expr *> VL) {
490   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
491   OMPSharedClause *Clause =
492       new (Mem) OMPSharedClause(StartLoc, LParenLoc, EndLoc, VL.size());
493   Clause->setVarRefs(VL);
494   return Clause;
495 }
496
497 OMPSharedClause *OMPSharedClause::CreateEmpty(const ASTContext &C, unsigned N) {
498   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
499   return new (Mem) OMPSharedClause(N);
500 }
501
502 void OMPLinearClause::setPrivates(ArrayRef<Expr *> PL) {
503   assert(PL.size() == varlist_size() &&
504          "Number of privates is not the same as the preallocated buffer");
505   std::copy(PL.begin(), PL.end(), varlist_end());
506 }
507
508 void OMPLinearClause::setInits(ArrayRef<Expr *> IL) {
509   assert(IL.size() == varlist_size() &&
510          "Number of inits is not the same as the preallocated buffer");
511   std::copy(IL.begin(), IL.end(), getPrivates().end());
512 }
513
514 void OMPLinearClause::setUpdates(ArrayRef<Expr *> UL) {
515   assert(UL.size() == varlist_size() &&
516          "Number of updates is not the same as the preallocated buffer");
517   std::copy(UL.begin(), UL.end(), getInits().end());
518 }
519
520 void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) {
521   assert(FL.size() == varlist_size() &&
522          "Number of final updates is not the same as the preallocated buffer");
523   std::copy(FL.begin(), FL.end(), getUpdates().end());
524 }
525
526 void OMPLinearClause::setUsedExprs(ArrayRef<Expr *> UE) {
527   assert(
528       UE.size() == varlist_size() + 1 &&
529       "Number of used expressions is not the same as the preallocated buffer");
530   std::copy(UE.begin(), UE.end(), getFinals().end() + 2);
531 }
532
533 OMPLinearClause *OMPLinearClause::Create(
534     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
535     OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
536     SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
537     ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
538     Stmt *PreInit, Expr *PostUpdate) {
539   // Allocate space for 5 lists (Vars, Inits, Updates, Finals), 2 expressions
540   // (Step and CalcStep), list of used expression + step.
541   void *Mem =
542       C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2 + VL.size() + 1));
543   OMPLinearClause *Clause = new (Mem) OMPLinearClause(
544       StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc, EndLoc, VL.size());
545   Clause->setVarRefs(VL);
546   Clause->setPrivates(PL);
547   Clause->setInits(IL);
548   // Fill update and final expressions with zeroes, they are provided later,
549   // after the directive construction.
550   std::fill(Clause->getInits().end(), Clause->getInits().end() + VL.size(),
551             nullptr);
552   std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(),
553             nullptr);
554   std::fill(Clause->getUsedExprs().begin(), Clause->getUsedExprs().end(),
555             nullptr);
556   Clause->setStep(Step);
557   Clause->setCalcStep(CalcStep);
558   Clause->setPreInitStmt(PreInit);
559   Clause->setPostUpdateExpr(PostUpdate);
560   return Clause;
561 }
562
563 OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C,
564                                               unsigned NumVars) {
565   // Allocate space for 5 lists (Vars, Inits, Updates, Finals), 2 expressions
566   // (Step and CalcStep), list of used expression + step.
567   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2 + NumVars  +1));
568   return new (Mem) OMPLinearClause(NumVars);
569 }
570
571 OMPClause::child_range OMPLinearClause::used_children() {
572   // Range includes only non-nullptr elements.
573   return child_range(
574       reinterpret_cast<Stmt **>(getUsedExprs().begin()),
575       reinterpret_cast<Stmt **>(llvm::find(getUsedExprs(), nullptr)));
576 }
577
578 OMPAlignedClause *
579 OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc,
580                          SourceLocation LParenLoc, SourceLocation ColonLoc,
581                          SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) {
582   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
583   OMPAlignedClause *Clause = new (Mem)
584       OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
585   Clause->setVarRefs(VL);
586   Clause->setAlignment(A);
587   return Clause;
588 }
589
590 OMPAlignedClause *OMPAlignedClause::CreateEmpty(const ASTContext &C,
591                                                 unsigned NumVars) {
592   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumVars + 1));
593   return new (Mem) OMPAlignedClause(NumVars);
594 }
595
596 void OMPCopyinClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
597   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
598                                               "not the same as the "
599                                               "preallocated buffer");
600   std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
601 }
602
603 void OMPCopyinClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
604   assert(DstExprs.size() == varlist_size() && "Number of destination "
605                                               "expressions is not the same as "
606                                               "the preallocated buffer");
607   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
608 }
609
610 void OMPCopyinClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
611   assert(AssignmentOps.size() == varlist_size() &&
612          "Number of assignment expressions is not the same as the preallocated "
613          "buffer");
614   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
615             getDestinationExprs().end());
616 }
617
618 OMPCopyinClause *OMPCopyinClause::Create(
619     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
620     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
621     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
622   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
623   OMPCopyinClause *Clause =
624       new (Mem) OMPCopyinClause(StartLoc, LParenLoc, EndLoc, VL.size());
625   Clause->setVarRefs(VL);
626   Clause->setSourceExprs(SrcExprs);
627   Clause->setDestinationExprs(DstExprs);
628   Clause->setAssignmentOps(AssignmentOps);
629   return Clause;
630 }
631
632 OMPCopyinClause *OMPCopyinClause::CreateEmpty(const ASTContext &C, unsigned N) {
633   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
634   return new (Mem) OMPCopyinClause(N);
635 }
636
637 void OMPCopyprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
638   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
639                                               "not the same as the "
640                                               "preallocated buffer");
641   std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
642 }
643
644 void OMPCopyprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
645   assert(DstExprs.size() == varlist_size() && "Number of destination "
646                                               "expressions is not the same as "
647                                               "the preallocated buffer");
648   std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
649 }
650
651 void OMPCopyprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
652   assert(AssignmentOps.size() == varlist_size() &&
653          "Number of assignment expressions is not the same as the preallocated "
654          "buffer");
655   std::copy(AssignmentOps.begin(), AssignmentOps.end(),
656             getDestinationExprs().end());
657 }
658
659 OMPCopyprivateClause *OMPCopyprivateClause::Create(
660     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
661     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
662     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
663   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
664   OMPCopyprivateClause *Clause =
665       new (Mem) OMPCopyprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
666   Clause->setVarRefs(VL);
667   Clause->setSourceExprs(SrcExprs);
668   Clause->setDestinationExprs(DstExprs);
669   Clause->setAssignmentOps(AssignmentOps);
670   return Clause;
671 }
672
673 OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(const ASTContext &C,
674                                                         unsigned N) {
675   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
676   return new (Mem) OMPCopyprivateClause(N);
677 }
678
679 void OMPReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
680   assert(Privates.size() == varlist_size() &&
681          "Number of private copies is not the same as the preallocated buffer");
682   std::copy(Privates.begin(), Privates.end(), varlist_end());
683 }
684
685 void OMPReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
686   assert(
687       LHSExprs.size() == varlist_size() &&
688       "Number of LHS expressions is not the same as the preallocated buffer");
689   std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
690 }
691
692 void OMPReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
693   assert(
694       RHSExprs.size() == varlist_size() &&
695       "Number of RHS expressions is not the same as the preallocated buffer");
696   std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
697 }
698
699 void OMPReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
700   assert(ReductionOps.size() == varlist_size() && "Number of reduction "
701                                                   "expressions is not the same "
702                                                   "as the preallocated buffer");
703   std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
704 }
705
706 OMPReductionClause *OMPReductionClause::Create(
707     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
708     SourceLocation ModifierLoc, SourceLocation EndLoc, SourceLocation ColonLoc,
709     OpenMPReductionClauseModifier Modifier, ArrayRef<Expr *> VL,
710     NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
711     ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
712     ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
713     Expr *PostUpdate) {
714   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
715   auto *Clause = new (Mem)
716       OMPReductionClause(StartLoc, LParenLoc, ModifierLoc, EndLoc, ColonLoc,
717                          Modifier, VL.size(), QualifierLoc, NameInfo);
718   Clause->setVarRefs(VL);
719   Clause->setPrivates(Privates);
720   Clause->setLHSExprs(LHSExprs);
721   Clause->setRHSExprs(RHSExprs);
722   Clause->setReductionOps(ReductionOps);
723   Clause->setPreInitStmt(PreInit);
724   Clause->setPostUpdateExpr(PostUpdate);
725   return Clause;
726 }
727
728 OMPReductionClause *OMPReductionClause::CreateEmpty(const ASTContext &C,
729                                                     unsigned N) {
730   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
731   return new (Mem) OMPReductionClause(N);
732 }
733
734 void OMPTaskReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
735   assert(Privates.size() == varlist_size() &&
736          "Number of private copies is not the same as the preallocated buffer");
737   std::copy(Privates.begin(), Privates.end(), varlist_end());
738 }
739
740 void OMPTaskReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
741   assert(
742       LHSExprs.size() == varlist_size() &&
743       "Number of LHS expressions is not the same as the preallocated buffer");
744   std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
745 }
746
747 void OMPTaskReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
748   assert(
749       RHSExprs.size() == varlist_size() &&
750       "Number of RHS expressions is not the same as the preallocated buffer");
751   std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
752 }
753
754 void OMPTaskReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
755   assert(ReductionOps.size() == varlist_size() && "Number of task reduction "
756                                                   "expressions is not the same "
757                                                   "as the preallocated buffer");
758   std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
759 }
760
761 OMPTaskReductionClause *OMPTaskReductionClause::Create(
762     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
763     SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
764     NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
765     ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
766     ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
767     Expr *PostUpdate) {
768   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
769   OMPTaskReductionClause *Clause = new (Mem) OMPTaskReductionClause(
770       StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
771   Clause->setVarRefs(VL);
772   Clause->setPrivates(Privates);
773   Clause->setLHSExprs(LHSExprs);
774   Clause->setRHSExprs(RHSExprs);
775   Clause->setReductionOps(ReductionOps);
776   Clause->setPreInitStmt(PreInit);
777   Clause->setPostUpdateExpr(PostUpdate);
778   return Clause;
779 }
780
781 OMPTaskReductionClause *OMPTaskReductionClause::CreateEmpty(const ASTContext &C,
782                                                             unsigned N) {
783   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
784   return new (Mem) OMPTaskReductionClause(N);
785 }
786
787 void OMPInReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
788   assert(Privates.size() == varlist_size() &&
789          "Number of private copies is not the same as the preallocated buffer");
790   std::copy(Privates.begin(), Privates.end(), varlist_end());
791 }
792
793 void OMPInReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
794   assert(
795       LHSExprs.size() == varlist_size() &&
796       "Number of LHS expressions is not the same as the preallocated buffer");
797   std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
798 }
799
800 void OMPInReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
801   assert(
802       RHSExprs.size() == varlist_size() &&
803       "Number of RHS expressions is not the same as the preallocated buffer");
804   std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
805 }
806
807 void OMPInReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
808   assert(ReductionOps.size() == varlist_size() && "Number of in reduction "
809                                                   "expressions is not the same "
810                                                   "as the preallocated buffer");
811   std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
812 }
813
814 void OMPInReductionClause::setTaskgroupDescriptors(
815     ArrayRef<Expr *> TaskgroupDescriptors) {
816   assert(TaskgroupDescriptors.size() == varlist_size() &&
817          "Number of in reduction descriptors is not the same as the "
818          "preallocated buffer");
819   std::copy(TaskgroupDescriptors.begin(), TaskgroupDescriptors.end(),
820             getReductionOps().end());
821 }
822
823 OMPInReductionClause *OMPInReductionClause::Create(
824     const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
825     SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
826     NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
827     ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
828     ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps,
829     ArrayRef<Expr *> TaskgroupDescriptors, Stmt *PreInit, Expr *PostUpdate) {
830   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(6 * VL.size()));
831   OMPInReductionClause *Clause = new (Mem) OMPInReductionClause(
832       StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
833   Clause->setVarRefs(VL);
834   Clause->setPrivates(Privates);
835   Clause->setLHSExprs(LHSExprs);
836   Clause->setRHSExprs(RHSExprs);
837   Clause->setReductionOps(ReductionOps);
838   Clause->setTaskgroupDescriptors(TaskgroupDescriptors);
839   Clause->setPreInitStmt(PreInit);
840   Clause->setPostUpdateExpr(PostUpdate);
841   return Clause;
842 }
843
844 OMPInReductionClause *OMPInReductionClause::CreateEmpty(const ASTContext &C,
845                                                         unsigned N) {
846   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(6 * N));
847   return new (Mem) OMPInReductionClause(N);
848 }
849
850 OMPAllocateClause *
851 OMPAllocateClause::Create(const ASTContext &C, SourceLocation StartLoc,
852                           SourceLocation LParenLoc, Expr *Allocator,
853                           SourceLocation ColonLoc, SourceLocation EndLoc,
854                           ArrayRef<Expr *> VL) {
855   // Allocate space for private variables and initializer expressions.
856   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
857   auto *Clause = new (Mem) OMPAllocateClause(StartLoc, LParenLoc, Allocator,
858                                              ColonLoc, EndLoc, VL.size());
859   Clause->setVarRefs(VL);
860   return Clause;
861 }
862
863 OMPAllocateClause *OMPAllocateClause::CreateEmpty(const ASTContext &C,
864                                                   unsigned N) {
865   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
866   return new (Mem) OMPAllocateClause(N);
867 }
868
869 OMPFlushClause *OMPFlushClause::Create(const ASTContext &C,
870                                        SourceLocation StartLoc,
871                                        SourceLocation LParenLoc,
872                                        SourceLocation EndLoc,
873                                        ArrayRef<Expr *> VL) {
874   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
875   OMPFlushClause *Clause =
876       new (Mem) OMPFlushClause(StartLoc, LParenLoc, EndLoc, VL.size());
877   Clause->setVarRefs(VL);
878   return Clause;
879 }
880
881 OMPFlushClause *OMPFlushClause::CreateEmpty(const ASTContext &C, unsigned N) {
882   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
883   return new (Mem) OMPFlushClause(N);
884 }
885
886 OMPDepobjClause *OMPDepobjClause::Create(const ASTContext &C,
887                                          SourceLocation StartLoc,
888                                          SourceLocation LParenLoc,
889                                          SourceLocation RParenLoc,
890                                          Expr *Depobj) {
891   auto *Clause = new (C) OMPDepobjClause(StartLoc, LParenLoc, RParenLoc);
892   Clause->setDepobj(Depobj);
893   return Clause;
894 }
895
896 OMPDepobjClause *OMPDepobjClause::CreateEmpty(const ASTContext &C) {
897   return new (C) OMPDepobjClause();
898 }
899
900 OMPDependClause *
901 OMPDependClause::Create(const ASTContext &C, SourceLocation StartLoc,
902                         SourceLocation LParenLoc, SourceLocation EndLoc,
903                         Expr *DepModifier, OpenMPDependClauseKind DepKind,
904                         SourceLocation DepLoc, SourceLocation ColonLoc,
905                         ArrayRef<Expr *> VL, unsigned NumLoops) {
906   void *Mem = C.Allocate(
907       totalSizeToAlloc<Expr *>(VL.size() + /*depend-modifier*/ 1 + NumLoops),
908       alignof(OMPDependClause));
909   OMPDependClause *Clause = new (Mem)
910       OMPDependClause(StartLoc, LParenLoc, EndLoc, VL.size(), NumLoops);
911   Clause->setVarRefs(VL);
912   Clause->setDependencyKind(DepKind);
913   Clause->setDependencyLoc(DepLoc);
914   Clause->setColonLoc(ColonLoc);
915   Clause->setModifier(DepModifier);
916   for (unsigned I = 0 ; I < NumLoops; ++I)
917     Clause->setLoopData(I, nullptr);
918   return Clause;
919 }
920
921 OMPDependClause *OMPDependClause::CreateEmpty(const ASTContext &C, unsigned N,
922                                               unsigned NumLoops) {
923   void *Mem =
924       C.Allocate(totalSizeToAlloc<Expr *>(N + /*depend-modifier*/ 1 + NumLoops),
925                  alignof(OMPDependClause));
926   return new (Mem) OMPDependClause(N, NumLoops);
927 }
928
929 void OMPDependClause::setLoopData(unsigned NumLoop, Expr *Cnt) {
930   assert((getDependencyKind() == OMPC_DEPEND_sink ||
931           getDependencyKind() == OMPC_DEPEND_source) &&
932          NumLoop < NumLoops &&
933          "Expected sink or source depend + loop index must be less number of "
934          "loops.");
935   auto *It = std::next(getVarRefs().end(), NumLoop + 1);
936   *It = Cnt;
937 }
938
939 Expr *OMPDependClause::getLoopData(unsigned NumLoop) {
940   assert((getDependencyKind() == OMPC_DEPEND_sink ||
941           getDependencyKind() == OMPC_DEPEND_source) &&
942          NumLoop < NumLoops &&
943          "Expected sink or source depend + loop index must be less number of "
944          "loops.");
945   auto *It = std::next(getVarRefs().end(), NumLoop + 1);
946   return *It;
947 }
948
949 const Expr *OMPDependClause::getLoopData(unsigned NumLoop) const {
950   assert((getDependencyKind() == OMPC_DEPEND_sink ||
951           getDependencyKind() == OMPC_DEPEND_source) &&
952          NumLoop < NumLoops &&
953          "Expected sink or source depend + loop index must be less number of "
954          "loops.");
955   const auto *It = std::next(getVarRefs().end(), NumLoop + 1);
956   return *It;
957 }
958
959 void OMPDependClause::setModifier(Expr *DepModifier) {
960   *getVarRefs().end() = DepModifier;
961 }
962 Expr *OMPDependClause::getModifier() { return *getVarRefs().end(); }
963
964 unsigned OMPClauseMappableExprCommon::getComponentsTotalNumber(
965     MappableExprComponentListsRef ComponentLists) {
966   unsigned TotalNum = 0u;
967   for (auto &C : ComponentLists)
968     TotalNum += C.size();
969   return TotalNum;
970 }
971
972 unsigned OMPClauseMappableExprCommon::getUniqueDeclarationsTotalNumber(
973     ArrayRef<const ValueDecl *> Declarations) {
974   unsigned TotalNum = 0u;
975   llvm::SmallPtrSet<const ValueDecl *, 8> Cache;
976   for (const ValueDecl *D : Declarations) {
977     const ValueDecl *VD = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr;
978     if (Cache.count(VD))
979       continue;
980     ++TotalNum;
981     Cache.insert(VD);
982   }
983   return TotalNum;
984 }
985
986 OMPMapClause *OMPMapClause::Create(
987     const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
988     ArrayRef<ValueDecl *> Declarations,
989     MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
990     ArrayRef<OpenMPMapModifierKind> MapModifiers,
991     ArrayRef<SourceLocation> MapModifiersLoc,
992     NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId,
993     OpenMPMapClauseKind Type, bool TypeIsImplicit, SourceLocation TypeLoc) {
994   OMPMappableExprListSizeTy Sizes;
995   Sizes.NumVars = Vars.size();
996   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
997   Sizes.NumComponentLists = ComponentLists.size();
998   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
999
1000   // We need to allocate:
1001   // 2 x NumVars x Expr* - we have an original list expression and an associated
1002   // user-defined mapper for each clause list entry.
1003   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1004   // with each component list.
1005   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1006   // number of lists for each unique declaration and the size of each component
1007   // list.
1008   // NumComponents x MappableComponent - the total of all the components in all
1009   // the lists.
1010   void *Mem = C.Allocate(
1011       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1012                        OMPClauseMappableExprCommon::MappableComponent>(
1013           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1014           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1015           Sizes.NumComponents));
1016   OMPMapClause *Clause = new (Mem)
1017       OMPMapClause(MapModifiers, MapModifiersLoc, UDMQualifierLoc, MapperId,
1018                    Type, TypeIsImplicit, TypeLoc, Locs, Sizes);
1019
1020   Clause->setVarRefs(Vars);
1021   Clause->setUDMapperRefs(UDMapperRefs);
1022   Clause->setClauseInfo(Declarations, ComponentLists);
1023   Clause->setMapType(Type);
1024   Clause->setMapLoc(TypeLoc);
1025   return Clause;
1026 }
1027
1028 OMPMapClause *
1029 OMPMapClause::CreateEmpty(const ASTContext &C,
1030                           const OMPMappableExprListSizeTy &Sizes) {
1031   void *Mem = C.Allocate(
1032       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1033                        OMPClauseMappableExprCommon::MappableComponent>(
1034           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1035           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1036           Sizes.NumComponents));
1037   return new (Mem) OMPMapClause(Sizes);
1038 }
1039
1040 OMPToClause *OMPToClause::Create(
1041     const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
1042     ArrayRef<ValueDecl *> Declarations,
1043     MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
1044     NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId) {
1045   OMPMappableExprListSizeTy Sizes;
1046   Sizes.NumVars = Vars.size();
1047   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1048   Sizes.NumComponentLists = ComponentLists.size();
1049   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1050
1051   // We need to allocate:
1052   // 2 x NumVars x Expr* - we have an original list expression and an associated
1053   // user-defined mapper for each clause list entry.
1054   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1055   // with each component list.
1056   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1057   // number of lists for each unique declaration and the size of each component
1058   // list.
1059   // NumComponents x MappableComponent - the total of all the components in all
1060   // the lists.
1061   void *Mem = C.Allocate(
1062       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1063                        OMPClauseMappableExprCommon::MappableComponent>(
1064           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1065           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1066           Sizes.NumComponents));
1067
1068   auto *Clause = new (Mem) OMPToClause(UDMQualifierLoc, MapperId, Locs, Sizes);
1069
1070   Clause->setVarRefs(Vars);
1071   Clause->setUDMapperRefs(UDMapperRefs);
1072   Clause->setClauseInfo(Declarations, ComponentLists);
1073   return Clause;
1074 }
1075
1076 OMPToClause *OMPToClause::CreateEmpty(const ASTContext &C,
1077                                       const OMPMappableExprListSizeTy &Sizes) {
1078   void *Mem = C.Allocate(
1079       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1080                        OMPClauseMappableExprCommon::MappableComponent>(
1081           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1082           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1083           Sizes.NumComponents));
1084   return new (Mem) OMPToClause(Sizes);
1085 }
1086
1087 OMPFromClause *OMPFromClause::Create(
1088     const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
1089     ArrayRef<ValueDecl *> Declarations,
1090     MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
1091     NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId) {
1092   OMPMappableExprListSizeTy Sizes;
1093   Sizes.NumVars = Vars.size();
1094   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1095   Sizes.NumComponentLists = ComponentLists.size();
1096   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1097
1098   // We need to allocate:
1099   // 2 x NumVars x Expr* - we have an original list expression and an associated
1100   // user-defined mapper for each clause list entry.
1101   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1102   // with each component list.
1103   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1104   // number of lists for each unique declaration and the size of each component
1105   // list.
1106   // NumComponents x MappableComponent - the total of all the components in all
1107   // the lists.
1108   void *Mem = C.Allocate(
1109       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1110                        OMPClauseMappableExprCommon::MappableComponent>(
1111           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1112           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1113           Sizes.NumComponents));
1114
1115   auto *Clause =
1116       new (Mem) OMPFromClause(UDMQualifierLoc, MapperId, Locs, Sizes);
1117
1118   Clause->setVarRefs(Vars);
1119   Clause->setUDMapperRefs(UDMapperRefs);
1120   Clause->setClauseInfo(Declarations, ComponentLists);
1121   return Clause;
1122 }
1123
1124 OMPFromClause *
1125 OMPFromClause::CreateEmpty(const ASTContext &C,
1126                            const OMPMappableExprListSizeTy &Sizes) {
1127   void *Mem = C.Allocate(
1128       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1129                        OMPClauseMappableExprCommon::MappableComponent>(
1130           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1131           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1132           Sizes.NumComponents));
1133   return new (Mem) OMPFromClause(Sizes);
1134 }
1135
1136 void OMPUseDevicePtrClause::setPrivateCopies(ArrayRef<Expr *> VL) {
1137   assert(VL.size() == varlist_size() &&
1138          "Number of private copies is not the same as the preallocated buffer");
1139   std::copy(VL.begin(), VL.end(), varlist_end());
1140 }
1141
1142 void OMPUseDevicePtrClause::setInits(ArrayRef<Expr *> VL) {
1143   assert(VL.size() == varlist_size() &&
1144          "Number of inits is not the same as the preallocated buffer");
1145   std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
1146 }
1147
1148 OMPUseDevicePtrClause *OMPUseDevicePtrClause::Create(
1149     const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
1150     ArrayRef<Expr *> PrivateVars, ArrayRef<Expr *> Inits,
1151     ArrayRef<ValueDecl *> Declarations,
1152     MappableExprComponentListsRef ComponentLists) {
1153   OMPMappableExprListSizeTy Sizes;
1154   Sizes.NumVars = Vars.size();
1155   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1156   Sizes.NumComponentLists = ComponentLists.size();
1157   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1158
1159   // We need to allocate:
1160   // 3 x NumVars x Expr* - we have an original list expression for each clause
1161   // list entry and an equal number of private copies and inits.
1162   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1163   // with each component list.
1164   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1165   // number of lists for each unique declaration and the size of each component
1166   // list.
1167   // NumComponents x MappableComponent - the total of all the components in all
1168   // the lists.
1169   void *Mem = C.Allocate(
1170       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1171                        OMPClauseMappableExprCommon::MappableComponent>(
1172           3 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1173           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1174           Sizes.NumComponents));
1175
1176   OMPUseDevicePtrClause *Clause = new (Mem) OMPUseDevicePtrClause(Locs, Sizes);
1177
1178   Clause->setVarRefs(Vars);
1179   Clause->setPrivateCopies(PrivateVars);
1180   Clause->setInits(Inits);
1181   Clause->setClauseInfo(Declarations, ComponentLists);
1182   return Clause;
1183 }
1184
1185 OMPUseDevicePtrClause *
1186 OMPUseDevicePtrClause::CreateEmpty(const ASTContext &C,
1187                                    const OMPMappableExprListSizeTy &Sizes) {
1188   void *Mem = C.Allocate(
1189       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1190                        OMPClauseMappableExprCommon::MappableComponent>(
1191           3 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1192           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1193           Sizes.NumComponents));
1194   return new (Mem) OMPUseDevicePtrClause(Sizes);
1195 }
1196
1197 OMPIsDevicePtrClause *
1198 OMPIsDevicePtrClause::Create(const ASTContext &C, const OMPVarListLocTy &Locs,
1199                              ArrayRef<Expr *> Vars,
1200                              ArrayRef<ValueDecl *> Declarations,
1201                              MappableExprComponentListsRef ComponentLists) {
1202   OMPMappableExprListSizeTy Sizes;
1203   Sizes.NumVars = Vars.size();
1204   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1205   Sizes.NumComponentLists = ComponentLists.size();
1206   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1207
1208   // We need to allocate:
1209   // NumVars x Expr* - we have an original list expression for each clause list
1210   // entry.
1211   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1212   // with each component list.
1213   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1214   // number of lists for each unique declaration and the size of each component
1215   // list.
1216   // NumComponents x MappableComponent - the total of all the components in all
1217   // the lists.
1218   void *Mem = C.Allocate(
1219       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1220                        OMPClauseMappableExprCommon::MappableComponent>(
1221           Sizes.NumVars, Sizes.NumUniqueDeclarations,
1222           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1223           Sizes.NumComponents));
1224
1225   OMPIsDevicePtrClause *Clause = new (Mem) OMPIsDevicePtrClause(Locs, Sizes);
1226
1227   Clause->setVarRefs(Vars);
1228   Clause->setClauseInfo(Declarations, ComponentLists);
1229   return Clause;
1230 }
1231
1232 OMPIsDevicePtrClause *
1233 OMPIsDevicePtrClause::CreateEmpty(const ASTContext &C,
1234                                   const OMPMappableExprListSizeTy &Sizes) {
1235   void *Mem = C.Allocate(
1236       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1237                        OMPClauseMappableExprCommon::MappableComponent>(
1238           Sizes.NumVars, Sizes.NumUniqueDeclarations,
1239           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1240           Sizes.NumComponents));
1241   return new (Mem) OMPIsDevicePtrClause(Sizes);
1242 }
1243
1244 OMPNontemporalClause *OMPNontemporalClause::Create(const ASTContext &C,
1245                                                    SourceLocation StartLoc,
1246                                                    SourceLocation LParenLoc,
1247                                                    SourceLocation EndLoc,
1248                                                    ArrayRef<Expr *> VL) {
1249   // Allocate space for nontemporal variables + private references.
1250   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * VL.size()));
1251   auto *Clause =
1252       new (Mem) OMPNontemporalClause(StartLoc, LParenLoc, EndLoc, VL.size());
1253   Clause->setVarRefs(VL);
1254   return Clause;
1255 }
1256
1257 OMPNontemporalClause *OMPNontemporalClause::CreateEmpty(const ASTContext &C,
1258                                                         unsigned N) {
1259   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * N));
1260   return new (Mem) OMPNontemporalClause(N);
1261 }
1262
1263 void OMPNontemporalClause::setPrivateRefs(ArrayRef<Expr *> VL) {
1264   assert(VL.size() == varlist_size() && "Number of private references is not "
1265                                         "the same as the preallocated buffer");
1266   std::copy(VL.begin(), VL.end(), varlist_end());
1267 }
1268
1269 OMPInclusiveClause *OMPInclusiveClause::Create(const ASTContext &C,
1270                                                SourceLocation StartLoc,
1271                                                SourceLocation LParenLoc,
1272                                                SourceLocation EndLoc,
1273                                                ArrayRef<Expr *> VL) {
1274   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
1275   auto *Clause =
1276       new (Mem) OMPInclusiveClause(StartLoc, LParenLoc, EndLoc, VL.size());
1277   Clause->setVarRefs(VL);
1278   return Clause;
1279 }
1280
1281 OMPInclusiveClause *OMPInclusiveClause::CreateEmpty(const ASTContext &C,
1282                                                     unsigned N) {
1283   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
1284   return new (Mem) OMPInclusiveClause(N);
1285 }
1286
1287 OMPExclusiveClause *OMPExclusiveClause::Create(const ASTContext &C,
1288                                                SourceLocation StartLoc,
1289                                                SourceLocation LParenLoc,
1290                                                SourceLocation EndLoc,
1291                                                ArrayRef<Expr *> VL) {
1292   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
1293   auto *Clause =
1294       new (Mem) OMPExclusiveClause(StartLoc, LParenLoc, EndLoc, VL.size());
1295   Clause->setVarRefs(VL);
1296   return Clause;
1297 }
1298
1299 OMPExclusiveClause *OMPExclusiveClause::CreateEmpty(const ASTContext &C,
1300                                                     unsigned N) {
1301   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
1302   return new (Mem) OMPExclusiveClause(N);
1303 }
1304
1305 //===----------------------------------------------------------------------===//
1306 //  OpenMP clauses printing methods
1307 //===----------------------------------------------------------------------===//
1308
1309 void OMPClausePrinter::VisitOMPIfClause(OMPIfClause *Node) {
1310   OS << "if(";
1311   if (Node->getNameModifier() != OMPD_unknown)
1312     OS << getOpenMPDirectiveName(Node->getNameModifier()) << ": ";
1313   Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
1314   OS << ")";
1315 }
1316
1317 void OMPClausePrinter::VisitOMPFinalClause(OMPFinalClause *Node) {
1318   OS << "final(";
1319   Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
1320   OS << ")";
1321 }
1322
1323 void OMPClausePrinter::VisitOMPNumThreadsClause(OMPNumThreadsClause *Node) {
1324   OS << "num_threads(";
1325   Node->getNumThreads()->printPretty(OS, nullptr, Policy, 0);
1326   OS << ")";
1327 }
1328
1329 void OMPClausePrinter::VisitOMPSafelenClause(OMPSafelenClause *Node) {
1330   OS << "safelen(";
1331   Node->getSafelen()->printPretty(OS, nullptr, Policy, 0);
1332   OS << ")";
1333 }
1334
1335 void OMPClausePrinter::VisitOMPSimdlenClause(OMPSimdlenClause *Node) {
1336   OS << "simdlen(";
1337   Node->getSimdlen()->printPretty(OS, nullptr, Policy, 0);
1338   OS << ")";
1339 }
1340
1341 void OMPClausePrinter::VisitOMPAllocatorClause(OMPAllocatorClause *Node) {
1342   OS << "allocator(";
1343   Node->getAllocator()->printPretty(OS, nullptr, Policy, 0);
1344   OS << ")";
1345 }
1346
1347 void OMPClausePrinter::VisitOMPCollapseClause(OMPCollapseClause *Node) {
1348   OS << "collapse(";
1349   Node->getNumForLoops()->printPretty(OS, nullptr, Policy, 0);
1350   OS << ")";
1351 }
1352
1353 void OMPClausePrinter::VisitOMPDetachClause(OMPDetachClause *Node) {
1354   OS << "detach(";
1355   Node->getEventHandler()->printPretty(OS, nullptr, Policy, 0);
1356   OS << ")";
1357 }
1358
1359 void OMPClausePrinter::VisitOMPDefaultClause(OMPDefaultClause *Node) {
1360   OS << "default("
1361      << getOpenMPSimpleClauseTypeName(OMPC_default,
1362                                       unsigned(Node->getDefaultKind()))
1363      << ")";
1364 }
1365
1366 void OMPClausePrinter::VisitOMPProcBindClause(OMPProcBindClause *Node) {
1367   OS << "proc_bind("
1368      << getOpenMPSimpleClauseTypeName(OMPC_proc_bind,
1369                                       unsigned(Node->getProcBindKind()))
1370      << ")";
1371 }
1372
1373 void OMPClausePrinter::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) {
1374   OS << "unified_address";
1375 }
1376
1377 void OMPClausePrinter::VisitOMPUnifiedSharedMemoryClause(
1378     OMPUnifiedSharedMemoryClause *) {
1379   OS << "unified_shared_memory";
1380 }
1381
1382 void OMPClausePrinter::VisitOMPReverseOffloadClause(OMPReverseOffloadClause *) {
1383   OS << "reverse_offload";
1384 }
1385
1386 void OMPClausePrinter::VisitOMPDynamicAllocatorsClause(
1387     OMPDynamicAllocatorsClause *) {
1388   OS << "dynamic_allocators";
1389 }
1390
1391 void OMPClausePrinter::VisitOMPAtomicDefaultMemOrderClause(
1392     OMPAtomicDefaultMemOrderClause *Node) {
1393   OS << "atomic_default_mem_order("
1394      << getOpenMPSimpleClauseTypeName(OMPC_atomic_default_mem_order,
1395                                       Node->getAtomicDefaultMemOrderKind())
1396      << ")";
1397 }
1398
1399 void OMPClausePrinter::VisitOMPScheduleClause(OMPScheduleClause *Node) {
1400   OS << "schedule(";
1401   if (Node->getFirstScheduleModifier() != OMPC_SCHEDULE_MODIFIER_unknown) {
1402     OS << getOpenMPSimpleClauseTypeName(OMPC_schedule,
1403                                         Node->getFirstScheduleModifier());
1404     if (Node->getSecondScheduleModifier() != OMPC_SCHEDULE_MODIFIER_unknown) {
1405       OS << ", ";
1406       OS << getOpenMPSimpleClauseTypeName(OMPC_schedule,
1407                                           Node->getSecondScheduleModifier());
1408     }
1409     OS << ": ";
1410   }
1411   OS << getOpenMPSimpleClauseTypeName(OMPC_schedule, Node->getScheduleKind());
1412   if (auto *E = Node->getChunkSize()) {
1413     OS << ", ";
1414     E->printPretty(OS, nullptr, Policy);
1415   }
1416   OS << ")";
1417 }
1418
1419 void OMPClausePrinter::VisitOMPOrderedClause(OMPOrderedClause *Node) {
1420   OS << "ordered";
1421   if (auto *Num = Node->getNumForLoops()) {
1422     OS << "(";
1423     Num->printPretty(OS, nullptr, Policy, 0);
1424     OS << ")";
1425   }
1426 }
1427
1428 void OMPClausePrinter::VisitOMPNowaitClause(OMPNowaitClause *) {
1429   OS << "nowait";
1430 }
1431
1432 void OMPClausePrinter::VisitOMPUntiedClause(OMPUntiedClause *) {
1433   OS << "untied";
1434 }
1435
1436 void OMPClausePrinter::VisitOMPNogroupClause(OMPNogroupClause *) {
1437   OS << "nogroup";
1438 }
1439
1440 void OMPClausePrinter::VisitOMPMergeableClause(OMPMergeableClause *) {
1441   OS << "mergeable";
1442 }
1443
1444 void OMPClausePrinter::VisitOMPReadClause(OMPReadClause *) { OS << "read"; }
1445
1446 void OMPClausePrinter::VisitOMPWriteClause(OMPWriteClause *) { OS << "write"; }
1447
1448 void OMPClausePrinter::VisitOMPUpdateClause(OMPUpdateClause *Node) {
1449   OS << "update";
1450   if (Node->isExtended()) {
1451     OS << "(";
1452     OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(),
1453                                         Node->getDependencyKind());
1454     OS << ")";
1455   }
1456 }
1457
1458 void OMPClausePrinter::VisitOMPCaptureClause(OMPCaptureClause *) {
1459   OS << "capture";
1460 }
1461
1462 void OMPClausePrinter::VisitOMPSeqCstClause(OMPSeqCstClause *) {
1463   OS << "seq_cst";
1464 }
1465
1466 void OMPClausePrinter::VisitOMPAcqRelClause(OMPAcqRelClause *) {
1467   OS << "acq_rel";
1468 }
1469
1470 void OMPClausePrinter::VisitOMPAcquireClause(OMPAcquireClause *) {
1471   OS << "acquire";
1472 }
1473
1474 void OMPClausePrinter::VisitOMPReleaseClause(OMPReleaseClause *) {
1475   OS << "release";
1476 }
1477
1478 void OMPClausePrinter::VisitOMPRelaxedClause(OMPRelaxedClause *) {
1479   OS << "relaxed";
1480 }
1481
1482 void OMPClausePrinter::VisitOMPThreadsClause(OMPThreadsClause *) {
1483   OS << "threads";
1484 }
1485
1486 void OMPClausePrinter::VisitOMPSIMDClause(OMPSIMDClause *) { OS << "simd"; }
1487
1488 void OMPClausePrinter::VisitOMPDeviceClause(OMPDeviceClause *Node) {
1489   OS << "device(";
1490   OpenMPDeviceClauseModifier Modifier = Node->getModifier();
1491   if (Modifier != OMPC_DEVICE_unknown) {
1492     OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(), Modifier)
1493        << ": ";
1494   }
1495   Node->getDevice()->printPretty(OS, nullptr, Policy, 0);
1496   OS << ")";
1497 }
1498
1499 void OMPClausePrinter::VisitOMPNumTeamsClause(OMPNumTeamsClause *Node) {
1500   OS << "num_teams(";
1501   Node->getNumTeams()->printPretty(OS, nullptr, Policy, 0);
1502   OS << ")";
1503 }
1504
1505 void OMPClausePrinter::VisitOMPThreadLimitClause(OMPThreadLimitClause *Node) {
1506   OS << "thread_limit(";
1507   Node->getThreadLimit()->printPretty(OS, nullptr, Policy, 0);
1508   OS << ")";
1509 }
1510
1511 void OMPClausePrinter::VisitOMPPriorityClause(OMPPriorityClause *Node) {
1512   OS << "priority(";
1513   Node->getPriority()->printPretty(OS, nullptr, Policy, 0);
1514   OS << ")";
1515 }
1516
1517 void OMPClausePrinter::VisitOMPGrainsizeClause(OMPGrainsizeClause *Node) {
1518   OS << "grainsize(";
1519   Node->getGrainsize()->printPretty(OS, nullptr, Policy, 0);
1520   OS << ")";
1521 }
1522
1523 void OMPClausePrinter::VisitOMPNumTasksClause(OMPNumTasksClause *Node) {
1524   OS << "num_tasks(";
1525   Node->getNumTasks()->printPretty(OS, nullptr, Policy, 0);
1526   OS << ")";
1527 }
1528
1529 void OMPClausePrinter::VisitOMPHintClause(OMPHintClause *Node) {
1530   OS << "hint(";
1531   Node->getHint()->printPretty(OS, nullptr, Policy, 0);
1532   OS << ")";
1533 }
1534
1535 void OMPClausePrinter::VisitOMPDestroyClause(OMPDestroyClause *) {
1536   OS << "destroy";
1537 }
1538
1539 template<typename T>
1540 void OMPClausePrinter::VisitOMPClauseList(T *Node, char StartSym) {
1541   for (typename T::varlist_iterator I = Node->varlist_begin(),
1542                                     E = Node->varlist_end();
1543        I != E; ++I) {
1544     assert(*I && "Expected non-null Stmt");
1545     OS << (I == Node->varlist_begin() ? StartSym : ',');
1546     if (auto *DRE = dyn_cast<DeclRefExpr>(*I)) {
1547       if (isa<OMPCapturedExprDecl>(DRE->getDecl()))
1548         DRE->printPretty(OS, nullptr, Policy, 0);
1549       else
1550         DRE->getDecl()->printQualifiedName(OS);
1551     } else
1552       (*I)->printPretty(OS, nullptr, Policy, 0);
1553   }
1554 }
1555
1556 void OMPClausePrinter::VisitOMPAllocateClause(OMPAllocateClause *Node) {
1557   if (Node->varlist_empty())
1558     return;
1559   OS << "allocate";
1560   if (Expr *Allocator = Node->getAllocator()) {
1561     OS << "(";
1562     Allocator->printPretty(OS, nullptr, Policy, 0);
1563     OS << ":";
1564     VisitOMPClauseList(Node, ' ');
1565   } else {
1566     VisitOMPClauseList(Node, '(');
1567   }
1568   OS << ")";
1569 }
1570
1571 void OMPClausePrinter::VisitOMPPrivateClause(OMPPrivateClause *Node) {
1572   if (!Node->varlist_empty()) {
1573     OS << "private";
1574     VisitOMPClauseList(Node, '(');
1575     OS << ")";
1576   }
1577 }
1578
1579 void OMPClausePrinter::VisitOMPFirstprivateClause(OMPFirstprivateClause *Node) {
1580   if (!Node->varlist_empty()) {
1581     OS << "firstprivate";
1582     VisitOMPClauseList(Node, '(');
1583     OS << ")";
1584   }
1585 }
1586
1587 void OMPClausePrinter::VisitOMPLastprivateClause(OMPLastprivateClause *Node) {
1588   if (!Node->varlist_empty()) {
1589     OS << "lastprivate";
1590     OpenMPLastprivateModifier LPKind = Node->getKind();
1591     if (LPKind != OMPC_LASTPRIVATE_unknown) {
1592       OS << "("
1593          << getOpenMPSimpleClauseTypeName(OMPC_lastprivate, Node->getKind())
1594          << ":";
1595     }
1596     VisitOMPClauseList(Node, LPKind == OMPC_LASTPRIVATE_unknown ? '(' : ' ');
1597     OS << ")";
1598   }
1599 }
1600
1601 void OMPClausePrinter::VisitOMPSharedClause(OMPSharedClause *Node) {
1602   if (!Node->varlist_empty()) {
1603     OS << "shared";
1604     VisitOMPClauseList(Node, '(');
1605     OS << ")";
1606   }
1607 }
1608
1609 void OMPClausePrinter::VisitOMPReductionClause(OMPReductionClause *Node) {
1610   if (!Node->varlist_empty()) {
1611     OS << "reduction(";
1612     if (Node->getModifierLoc().isValid())
1613       OS << getOpenMPSimpleClauseTypeName(OMPC_reduction, Node->getModifier())
1614          << ", ";
1615     NestedNameSpecifier *QualifierLoc =
1616         Node->getQualifierLoc().getNestedNameSpecifier();
1617     OverloadedOperatorKind OOK =
1618         Node->getNameInfo().getName().getCXXOverloadedOperator();
1619     if (QualifierLoc == nullptr && OOK != OO_None) {
1620       // Print reduction identifier in C format
1621       OS << getOperatorSpelling(OOK);
1622     } else {
1623       // Use C++ format
1624       if (QualifierLoc != nullptr)
1625         QualifierLoc->print(OS, Policy);
1626       OS << Node->getNameInfo();
1627     }
1628     OS << ":";
1629     VisitOMPClauseList(Node, ' ');
1630     OS << ")";
1631   }
1632 }
1633
1634 void OMPClausePrinter::VisitOMPTaskReductionClause(
1635     OMPTaskReductionClause *Node) {
1636   if (!Node->varlist_empty()) {
1637     OS << "task_reduction(";
1638     NestedNameSpecifier *QualifierLoc =
1639         Node->getQualifierLoc().getNestedNameSpecifier();
1640     OverloadedOperatorKind OOK =
1641         Node->getNameInfo().getName().getCXXOverloadedOperator();
1642     if (QualifierLoc == nullptr && OOK != OO_None) {
1643       // Print reduction identifier in C format
1644       OS << getOperatorSpelling(OOK);
1645     } else {
1646       // Use C++ format
1647       if (QualifierLoc != nullptr)
1648         QualifierLoc->print(OS, Policy);
1649       OS << Node->getNameInfo();
1650     }
1651     OS << ":";
1652     VisitOMPClauseList(Node, ' ');
1653     OS << ")";
1654   }
1655 }
1656
1657 void OMPClausePrinter::VisitOMPInReductionClause(OMPInReductionClause *Node) {
1658   if (!Node->varlist_empty()) {
1659     OS << "in_reduction(";
1660     NestedNameSpecifier *QualifierLoc =
1661         Node->getQualifierLoc().getNestedNameSpecifier();
1662     OverloadedOperatorKind OOK =
1663         Node->getNameInfo().getName().getCXXOverloadedOperator();
1664     if (QualifierLoc == nullptr && OOK != OO_None) {
1665       // Print reduction identifier in C format
1666       OS << getOperatorSpelling(OOK);
1667     } else {
1668       // Use C++ format
1669       if (QualifierLoc != nullptr)
1670         QualifierLoc->print(OS, Policy);
1671       OS << Node->getNameInfo();
1672     }
1673     OS << ":";
1674     VisitOMPClauseList(Node, ' ');
1675     OS << ")";
1676   }
1677 }
1678
1679 void OMPClausePrinter::VisitOMPLinearClause(OMPLinearClause *Node) {
1680   if (!Node->varlist_empty()) {
1681     OS << "linear";
1682     if (Node->getModifierLoc().isValid()) {
1683       OS << '('
1684          << getOpenMPSimpleClauseTypeName(OMPC_linear, Node->getModifier());
1685     }
1686     VisitOMPClauseList(Node, '(');
1687     if (Node->getModifierLoc().isValid())
1688       OS << ')';
1689     if (Node->getStep() != nullptr) {
1690       OS << ": ";
1691       Node->getStep()->printPretty(OS, nullptr, Policy, 0);
1692     }
1693     OS << ")";
1694   }
1695 }
1696
1697 void OMPClausePrinter::VisitOMPAlignedClause(OMPAlignedClause *Node) {
1698   if (!Node->varlist_empty()) {
1699     OS << "aligned";
1700     VisitOMPClauseList(Node, '(');
1701     if (Node->getAlignment() != nullptr) {
1702       OS << ": ";
1703       Node->getAlignment()->printPretty(OS, nullptr, Policy, 0);
1704     }
1705     OS << ")";
1706   }
1707 }
1708
1709 void OMPClausePrinter::VisitOMPCopyinClause(OMPCopyinClause *Node) {
1710   if (!Node->varlist_empty()) {
1711     OS << "copyin";
1712     VisitOMPClauseList(Node, '(');
1713     OS << ")";
1714   }
1715 }
1716
1717 void OMPClausePrinter::VisitOMPCopyprivateClause(OMPCopyprivateClause *Node) {
1718   if (!Node->varlist_empty()) {
1719     OS << "copyprivate";
1720     VisitOMPClauseList(Node, '(');
1721     OS << ")";
1722   }
1723 }
1724
1725 void OMPClausePrinter::VisitOMPFlushClause(OMPFlushClause *Node) {
1726   if (!Node->varlist_empty()) {
1727     VisitOMPClauseList(Node, '(');
1728     OS << ")";
1729   }
1730 }
1731
1732 void OMPClausePrinter::VisitOMPDepobjClause(OMPDepobjClause *Node) {
1733   OS << "(";
1734   Node->getDepobj()->printPretty(OS, nullptr, Policy, 0);
1735   OS << ")";
1736 }
1737
1738 void OMPClausePrinter::VisitOMPDependClause(OMPDependClause *Node) {
1739   OS << "depend(";
1740   if (Expr *DepModifier = Node->getModifier()) {
1741     DepModifier->printPretty(OS, nullptr, Policy);
1742     OS << ", ";
1743   }
1744   OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(),
1745                                       Node->getDependencyKind());
1746   if (!Node->varlist_empty()) {
1747     OS << " :";
1748     VisitOMPClauseList(Node, ' ');
1749   }
1750   OS << ")";
1751 }
1752
1753 void OMPClausePrinter::VisitOMPMapClause(OMPMapClause *Node) {
1754   if (!Node->varlist_empty()) {
1755     OS << "map(";
1756     if (Node->getMapType() != OMPC_MAP_unknown) {
1757       for (unsigned I = 0; I < NumberOfOMPMapClauseModifiers; ++I) {
1758         if (Node->getMapTypeModifier(I) != OMPC_MAP_MODIFIER_unknown) {
1759           OS << getOpenMPSimpleClauseTypeName(OMPC_map,
1760                                               Node->getMapTypeModifier(I));
1761           if (Node->getMapTypeModifier(I) == OMPC_MAP_MODIFIER_mapper) {
1762             OS << '(';
1763             NestedNameSpecifier *MapperNNS =
1764                 Node->getMapperQualifierLoc().getNestedNameSpecifier();
1765             if (MapperNNS)
1766               MapperNNS->print(OS, Policy);
1767             OS << Node->getMapperIdInfo() << ')';
1768           }
1769           OS << ',';
1770         }
1771       }
1772       OS << getOpenMPSimpleClauseTypeName(OMPC_map, Node->getMapType());
1773       OS << ':';
1774     }
1775     VisitOMPClauseList(Node, ' ');
1776     OS << ")";
1777   }
1778 }
1779
1780 void OMPClausePrinter::VisitOMPToClause(OMPToClause *Node) {
1781   if (!Node->varlist_empty()) {
1782     OS << "to";
1783     DeclarationNameInfo MapperId = Node->getMapperIdInfo();
1784     if (MapperId.getName() && !MapperId.getName().isEmpty()) {
1785       OS << '(';
1786       OS << "mapper(";
1787       NestedNameSpecifier *MapperNNS =
1788           Node->getMapperQualifierLoc().getNestedNameSpecifier();
1789       if (MapperNNS)
1790         MapperNNS->print(OS, Policy);
1791       OS << MapperId << "):";
1792       VisitOMPClauseList(Node, ' ');
1793     } else {
1794       VisitOMPClauseList(Node, '(');
1795     }
1796     OS << ")";
1797   }
1798 }
1799
1800 void OMPClausePrinter::VisitOMPFromClause(OMPFromClause *Node) {
1801   if (!Node->varlist_empty()) {
1802     OS << "from";
1803     DeclarationNameInfo MapperId = Node->getMapperIdInfo();
1804     if (MapperId.getName() && !MapperId.getName().isEmpty()) {
1805       OS << '(';
1806       OS << "mapper(";
1807       NestedNameSpecifier *MapperNNS =
1808           Node->getMapperQualifierLoc().getNestedNameSpecifier();
1809       if (MapperNNS)
1810         MapperNNS->print(OS, Policy);
1811       OS << MapperId << "):";
1812       VisitOMPClauseList(Node, ' ');
1813     } else {
1814       VisitOMPClauseList(Node, '(');
1815     }
1816     OS << ")";
1817   }
1818 }
1819
1820 void OMPClausePrinter::VisitOMPDistScheduleClause(OMPDistScheduleClause *Node) {
1821   OS << "dist_schedule(" << getOpenMPSimpleClauseTypeName(
1822                            OMPC_dist_schedule, Node->getDistScheduleKind());
1823   if (auto *E = Node->getChunkSize()) {
1824     OS << ", ";
1825     E->printPretty(OS, nullptr, Policy);
1826   }
1827   OS << ")";
1828 }
1829
1830 void OMPClausePrinter::VisitOMPDefaultmapClause(OMPDefaultmapClause *Node) {
1831   OS << "defaultmap(";
1832   OS << getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
1833                                       Node->getDefaultmapModifier());
1834   OS << ": ";
1835   OS << getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
1836     Node->getDefaultmapKind());
1837   OS << ")";
1838 }
1839
1840 void OMPClausePrinter::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *Node) {
1841   if (!Node->varlist_empty()) {
1842     OS << "use_device_ptr";
1843     VisitOMPClauseList(Node, '(');
1844     OS << ")";
1845   }
1846 }
1847
1848 void OMPClausePrinter::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *Node) {
1849   if (!Node->varlist_empty()) {
1850     OS << "is_device_ptr";
1851     VisitOMPClauseList(Node, '(');
1852     OS << ")";
1853   }
1854 }
1855
1856 void OMPClausePrinter::VisitOMPNontemporalClause(OMPNontemporalClause *Node) {
1857   if (!Node->varlist_empty()) {
1858     OS << "nontemporal";
1859     VisitOMPClauseList(Node, '(');
1860     OS << ")";
1861   }
1862 }
1863
1864 void OMPClausePrinter::VisitOMPOrderClause(OMPOrderClause *Node) {
1865   OS << "order(" << getOpenMPSimpleClauseTypeName(OMPC_order, Node->getKind())
1866      << ")";
1867 }
1868
1869 void OMPClausePrinter::VisitOMPInclusiveClause(OMPInclusiveClause *Node) {
1870   if (!Node->varlist_empty()) {
1871     OS << "inclusive";
1872     VisitOMPClauseList(Node, '(');
1873     OS << ")";
1874   }
1875 }
1876
1877 void OMPClausePrinter::VisitOMPExclusiveClause(OMPExclusiveClause *Node) {
1878   if (!Node->varlist_empty()) {
1879     OS << "exclusive";
1880     VisitOMPClauseList(Node, '(');
1881     OS << ")";
1882   }
1883 }
1884
1885 void OMPTraitInfo::getAsVariantMatchInfo(ASTContext &ASTCtx,
1886                                          VariantMatchInfo &VMI,
1887                                          bool DeviceSetOnly) const {
1888   for (const OMPTraitSet &Set : Sets) {
1889     if (DeviceSetOnly && Set.Kind != TraitSet::device)
1890       continue;
1891     for (const OMPTraitSelector &Selector : Set.Selectors) {
1892
1893       // User conditions are special as we evaluate the condition here.
1894       if (Selector.Kind == TraitSelector::user_condition) {
1895         assert(Selector.ScoreOrCondition &&
1896                "Ill-formed user condition, expected condition expression!");
1897         assert(Selector.Properties.size() == 1 &&
1898                Selector.Properties.front().Kind ==
1899                    TraitProperty::user_condition_unknown &&
1900                "Ill-formed user condition, expected unknown trait property!");
1901
1902         llvm::APInt CondVal =
1903             Selector.ScoreOrCondition->EvaluateKnownConstInt(ASTCtx);
1904         VMI.addTrait(CondVal.isNullValue()
1905                          ? TraitProperty::user_condition_false
1906                          : TraitProperty::user_condition_true);
1907         continue;
1908       }
1909
1910       llvm::APInt Score;
1911       llvm::APInt *ScorePtr = nullptr;
1912       if (Selector.ScoreOrCondition) {
1913         Score = Selector.ScoreOrCondition->EvaluateKnownConstInt(ASTCtx);
1914         ScorePtr = &Score;
1915       }
1916       for (const OMPTraitProperty &Property : Selector.Properties)
1917         VMI.addTrait(Set.Kind, Property.Kind, ScorePtr);
1918
1919       if (Set.Kind != TraitSet::construct)
1920         continue;
1921
1922       // TODO: This might not hold once we implement SIMD properly.
1923       assert(Selector.Properties.size() == 1 &&
1924              Selector.Properties.front().Kind ==
1925                  getOpenMPContextTraitPropertyForSelector(
1926                      Selector.Kind) &&
1927              "Ill-formed construct selector!");
1928
1929       VMI.ConstructTraits.push_back(Selector.Properties.front().Kind);
1930     }
1931   }
1932 }
1933
1934 void OMPTraitInfo::print(llvm::raw_ostream &OS,
1935                          const PrintingPolicy &Policy) const {
1936   bool FirstSet = true;
1937   for (const OMPTraitSet &Set : Sets) {
1938     if (!FirstSet)
1939       OS << ", ";
1940     FirstSet = false;
1941     OS << getOpenMPContextTraitSetName(Set.Kind) << "={";
1942
1943     bool FirstSelector = true;
1944     for (const OMPTraitSelector &Selector : Set.Selectors) {
1945       if (!FirstSelector)
1946         OS << ", ";
1947       FirstSelector = false;
1948       OS << getOpenMPContextTraitSelectorName(Selector.Kind);
1949
1950       bool AllowsTraitScore = false;
1951       bool RequiresProperty = false;
1952       isValidTraitSelectorForTraitSet(
1953           Selector.Kind, Set.Kind, AllowsTraitScore, RequiresProperty);
1954
1955       if (!RequiresProperty)
1956         continue;
1957
1958       OS << "(";
1959       if (Selector.Kind == TraitSelector::user_condition) {
1960         Selector.ScoreOrCondition->printPretty(OS, nullptr, Policy);
1961       } else {
1962
1963         if (Selector.ScoreOrCondition) {
1964           OS << "score(";
1965           Selector.ScoreOrCondition->printPretty(OS, nullptr, Policy);
1966           OS << "): ";
1967         }
1968
1969         bool FirstProperty = true;
1970         for (const OMPTraitProperty &Property : Selector.Properties) {
1971           if (!FirstProperty)
1972             OS << ", ";
1973           FirstProperty = false;
1974           OS << getOpenMPContextTraitPropertyName(Property.Kind);
1975         }
1976       }
1977       OS << ")";
1978     }
1979     OS << "}";
1980   }
1981 }
1982
1983 std::string OMPTraitInfo::getMangledName() const {
1984   std::string MangledName;
1985   llvm::raw_string_ostream OS(MangledName);
1986   for (const OMPTraitSet &Set : Sets) {
1987     OS << '.' << 'S' << unsigned(Set.Kind);
1988     for (const OMPTraitSelector &Selector : Set.Selectors) {
1989
1990       bool AllowsTraitScore = false;
1991       bool RequiresProperty = false;
1992       isValidTraitSelectorForTraitSet(
1993           Selector.Kind, Set.Kind, AllowsTraitScore, RequiresProperty);
1994       OS << '.' << 's' << unsigned(Selector.Kind);
1995
1996       if (!RequiresProperty ||
1997           Selector.Kind == TraitSelector::user_condition)
1998         continue;
1999
2000       for (const OMPTraitProperty &Property : Selector.Properties)
2001         OS << '.' << 'P'
2002            << getOpenMPContextTraitPropertyName(Property.Kind);
2003     }
2004   }
2005   return OS.str();
2006 }
2007
2008 OMPTraitInfo::OMPTraitInfo(StringRef MangledName) {
2009   unsigned long U;
2010   do {
2011     if (!MangledName.consume_front(".S"))
2012       break;
2013     if (MangledName.consumeInteger(10, U))
2014       break;
2015     Sets.push_back(OMPTraitSet());
2016     OMPTraitSet &Set = Sets.back();
2017     Set.Kind = TraitSet(U);
2018     do {
2019       if (!MangledName.consume_front(".s"))
2020         break;
2021       if (MangledName.consumeInteger(10, U))
2022         break;
2023       Set.Selectors.push_back(OMPTraitSelector());
2024       OMPTraitSelector &Selector = Set.Selectors.back();
2025       Selector.Kind = TraitSelector(U);
2026       do {
2027         if (!MangledName.consume_front(".P"))
2028           break;
2029         Selector.Properties.push_back(OMPTraitProperty());
2030         OMPTraitProperty &Property = Selector.Properties.back();
2031         std::pair<StringRef, StringRef> PropRestPair = MangledName.split('.');
2032         Property.Kind =
2033             getOpenMPContextTraitPropertyKind(Set.Kind, PropRestPair.first);
2034         MangledName = PropRestPair.second;
2035       } while (true);
2036     } while (true);
2037   } while (true);
2038 }
2039
2040 llvm::raw_ostream &clang::operator<<(llvm::raw_ostream &OS,
2041                                      const OMPTraitInfo &TI) {
2042   LangOptions LO;
2043   PrintingPolicy Policy(LO);
2044   TI.print(OS, Policy);
2045   return OS;
2046 }
2047 llvm::raw_ostream &clang::operator<<(llvm::raw_ostream &OS,
2048                                      const OMPTraitInfo *TI) {
2049   return TI ? OS << *TI : OS;
2050 }