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                         OpenMPDependClauseKind DepKind, SourceLocation DepLoc,
904                         SourceLocation ColonLoc, ArrayRef<Expr *> VL,
905                         unsigned NumLoops) {
906   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + NumLoops));
907   OMPDependClause *Clause = new (Mem)
908       OMPDependClause(StartLoc, LParenLoc, EndLoc, VL.size(), NumLoops);
909   Clause->setVarRefs(VL);
910   Clause->setDependencyKind(DepKind);
911   Clause->setDependencyLoc(DepLoc);
912   Clause->setColonLoc(ColonLoc);
913   for (unsigned I = 0 ; I < NumLoops; ++I)
914     Clause->setLoopData(I, nullptr);
915   return Clause;
916 }
917 
918 OMPDependClause *OMPDependClause::CreateEmpty(const ASTContext &C, unsigned N,
919                                               unsigned NumLoops) {
920   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N + NumLoops));
921   return new (Mem) OMPDependClause(N, NumLoops);
922 }
923 
924 void OMPDependClause::setLoopData(unsigned NumLoop, Expr *Cnt) {
925   assert((getDependencyKind() == OMPC_DEPEND_sink ||
926           getDependencyKind() == OMPC_DEPEND_source) &&
927          NumLoop < NumLoops &&
928          "Expected sink or source depend + loop index must be less number of "
929          "loops.");
930   auto It = std::next(getVarRefs().end(), NumLoop);
931   *It = Cnt;
932 }
933 
934 Expr *OMPDependClause::getLoopData(unsigned NumLoop) {
935   assert((getDependencyKind() == OMPC_DEPEND_sink ||
936           getDependencyKind() == OMPC_DEPEND_source) &&
937          NumLoop < NumLoops &&
938          "Expected sink or source depend + loop index must be less number of "
939          "loops.");
940   auto It = std::next(getVarRefs().end(), NumLoop);
941   return *It;
942 }
943 
944 const Expr *OMPDependClause::getLoopData(unsigned NumLoop) const {
945   assert((getDependencyKind() == OMPC_DEPEND_sink ||
946           getDependencyKind() == OMPC_DEPEND_source) &&
947          NumLoop < NumLoops &&
948          "Expected sink or source depend + loop index must be less number of "
949          "loops.");
950   auto It = std::next(getVarRefs().end(), NumLoop);
951   return *It;
952 }
953 
954 unsigned OMPClauseMappableExprCommon::getComponentsTotalNumber(
955     MappableExprComponentListsRef ComponentLists) {
956   unsigned TotalNum = 0u;
957   for (auto &C : ComponentLists)
958     TotalNum += C.size();
959   return TotalNum;
960 }
961 
962 unsigned OMPClauseMappableExprCommon::getUniqueDeclarationsTotalNumber(
963     ArrayRef<const ValueDecl *> Declarations) {
964   unsigned TotalNum = 0u;
965   llvm::SmallPtrSet<const ValueDecl *, 8> Cache;
966   for (const ValueDecl *D : Declarations) {
967     const ValueDecl *VD = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr;
968     if (Cache.count(VD))
969       continue;
970     ++TotalNum;
971     Cache.insert(VD);
972   }
973   return TotalNum;
974 }
975 
976 OMPMapClause *OMPMapClause::Create(
977     const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
978     ArrayRef<ValueDecl *> Declarations,
979     MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
980     ArrayRef<OpenMPMapModifierKind> MapModifiers,
981     ArrayRef<SourceLocation> MapModifiersLoc,
982     NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId,
983     OpenMPMapClauseKind Type, bool TypeIsImplicit, SourceLocation TypeLoc) {
984   OMPMappableExprListSizeTy Sizes;
985   Sizes.NumVars = Vars.size();
986   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
987   Sizes.NumComponentLists = ComponentLists.size();
988   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
989 
990   // We need to allocate:
991   // 2 x NumVars x Expr* - we have an original list expression and an associated
992   // user-defined mapper for each clause list entry.
993   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
994   // with each component list.
995   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
996   // number of lists for each unique declaration and the size of each component
997   // list.
998   // NumComponents x MappableComponent - the total of all the components in all
999   // the lists.
1000   void *Mem = C.Allocate(
1001       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1002                        OMPClauseMappableExprCommon::MappableComponent>(
1003           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1004           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1005           Sizes.NumComponents));
1006   OMPMapClause *Clause = new (Mem)
1007       OMPMapClause(MapModifiers, MapModifiersLoc, UDMQualifierLoc, MapperId,
1008                    Type, TypeIsImplicit, TypeLoc, Locs, Sizes);
1009 
1010   Clause->setVarRefs(Vars);
1011   Clause->setUDMapperRefs(UDMapperRefs);
1012   Clause->setClauseInfo(Declarations, ComponentLists);
1013   Clause->setMapType(Type);
1014   Clause->setMapLoc(TypeLoc);
1015   return Clause;
1016 }
1017 
1018 OMPMapClause *
1019 OMPMapClause::CreateEmpty(const ASTContext &C,
1020                           const OMPMappableExprListSizeTy &Sizes) {
1021   void *Mem = C.Allocate(
1022       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1023                        OMPClauseMappableExprCommon::MappableComponent>(
1024           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1025           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1026           Sizes.NumComponents));
1027   return new (Mem) OMPMapClause(Sizes);
1028 }
1029 
1030 OMPToClause *OMPToClause::Create(
1031     const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
1032     ArrayRef<ValueDecl *> Declarations,
1033     MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
1034     NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId) {
1035   OMPMappableExprListSizeTy Sizes;
1036   Sizes.NumVars = Vars.size();
1037   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1038   Sizes.NumComponentLists = ComponentLists.size();
1039   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1040 
1041   // We need to allocate:
1042   // 2 x NumVars x Expr* - we have an original list expression and an associated
1043   // user-defined mapper for each clause list entry.
1044   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1045   // with each component list.
1046   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1047   // number of lists for each unique declaration and the size of each component
1048   // list.
1049   // NumComponents x MappableComponent - the total of all the components in all
1050   // the lists.
1051   void *Mem = C.Allocate(
1052       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1053                        OMPClauseMappableExprCommon::MappableComponent>(
1054           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1055           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1056           Sizes.NumComponents));
1057 
1058   auto *Clause = new (Mem) OMPToClause(UDMQualifierLoc, MapperId, Locs, Sizes);
1059 
1060   Clause->setVarRefs(Vars);
1061   Clause->setUDMapperRefs(UDMapperRefs);
1062   Clause->setClauseInfo(Declarations, ComponentLists);
1063   return Clause;
1064 }
1065 
1066 OMPToClause *OMPToClause::CreateEmpty(const ASTContext &C,
1067                                       const OMPMappableExprListSizeTy &Sizes) {
1068   void *Mem = C.Allocate(
1069       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1070                        OMPClauseMappableExprCommon::MappableComponent>(
1071           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1072           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1073           Sizes.NumComponents));
1074   return new (Mem) OMPToClause(Sizes);
1075 }
1076 
1077 OMPFromClause *OMPFromClause::Create(
1078     const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
1079     ArrayRef<ValueDecl *> Declarations,
1080     MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
1081     NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId) {
1082   OMPMappableExprListSizeTy Sizes;
1083   Sizes.NumVars = Vars.size();
1084   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1085   Sizes.NumComponentLists = ComponentLists.size();
1086   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1087 
1088   // We need to allocate:
1089   // 2 x NumVars x Expr* - we have an original list expression and an associated
1090   // user-defined mapper for each clause list entry.
1091   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1092   // with each component list.
1093   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1094   // number of lists for each unique declaration and the size of each component
1095   // list.
1096   // NumComponents x MappableComponent - the total of all the components in all
1097   // the lists.
1098   void *Mem = C.Allocate(
1099       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1100                        OMPClauseMappableExprCommon::MappableComponent>(
1101           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1102           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1103           Sizes.NumComponents));
1104 
1105   auto *Clause =
1106       new (Mem) OMPFromClause(UDMQualifierLoc, MapperId, Locs, Sizes);
1107 
1108   Clause->setVarRefs(Vars);
1109   Clause->setUDMapperRefs(UDMapperRefs);
1110   Clause->setClauseInfo(Declarations, ComponentLists);
1111   return Clause;
1112 }
1113 
1114 OMPFromClause *
1115 OMPFromClause::CreateEmpty(const ASTContext &C,
1116                            const OMPMappableExprListSizeTy &Sizes) {
1117   void *Mem = C.Allocate(
1118       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1119                        OMPClauseMappableExprCommon::MappableComponent>(
1120           2 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1121           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1122           Sizes.NumComponents));
1123   return new (Mem) OMPFromClause(Sizes);
1124 }
1125 
1126 void OMPUseDevicePtrClause::setPrivateCopies(ArrayRef<Expr *> VL) {
1127   assert(VL.size() == varlist_size() &&
1128          "Number of private copies is not the same as the preallocated buffer");
1129   std::copy(VL.begin(), VL.end(), varlist_end());
1130 }
1131 
1132 void OMPUseDevicePtrClause::setInits(ArrayRef<Expr *> VL) {
1133   assert(VL.size() == varlist_size() &&
1134          "Number of inits is not the same as the preallocated buffer");
1135   std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
1136 }
1137 
1138 OMPUseDevicePtrClause *OMPUseDevicePtrClause::Create(
1139     const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
1140     ArrayRef<Expr *> PrivateVars, ArrayRef<Expr *> Inits,
1141     ArrayRef<ValueDecl *> Declarations,
1142     MappableExprComponentListsRef ComponentLists) {
1143   OMPMappableExprListSizeTy Sizes;
1144   Sizes.NumVars = Vars.size();
1145   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1146   Sizes.NumComponentLists = ComponentLists.size();
1147   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1148 
1149   // We need to allocate:
1150   // 3 x NumVars x Expr* - we have an original list expression for each clause
1151   // list entry and an equal number of private copies and inits.
1152   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1153   // with each component list.
1154   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1155   // number of lists for each unique declaration and the size of each component
1156   // list.
1157   // NumComponents x MappableComponent - the total of all the components in all
1158   // the lists.
1159   void *Mem = C.Allocate(
1160       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1161                        OMPClauseMappableExprCommon::MappableComponent>(
1162           3 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1163           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1164           Sizes.NumComponents));
1165 
1166   OMPUseDevicePtrClause *Clause = new (Mem) OMPUseDevicePtrClause(Locs, Sizes);
1167 
1168   Clause->setVarRefs(Vars);
1169   Clause->setPrivateCopies(PrivateVars);
1170   Clause->setInits(Inits);
1171   Clause->setClauseInfo(Declarations, ComponentLists);
1172   return Clause;
1173 }
1174 
1175 OMPUseDevicePtrClause *
1176 OMPUseDevicePtrClause::CreateEmpty(const ASTContext &C,
1177                                    const OMPMappableExprListSizeTy &Sizes) {
1178   void *Mem = C.Allocate(
1179       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1180                        OMPClauseMappableExprCommon::MappableComponent>(
1181           3 * Sizes.NumVars, Sizes.NumUniqueDeclarations,
1182           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1183           Sizes.NumComponents));
1184   return new (Mem) OMPUseDevicePtrClause(Sizes);
1185 }
1186 
1187 OMPIsDevicePtrClause *
1188 OMPIsDevicePtrClause::Create(const ASTContext &C, const OMPVarListLocTy &Locs,
1189                              ArrayRef<Expr *> Vars,
1190                              ArrayRef<ValueDecl *> Declarations,
1191                              MappableExprComponentListsRef ComponentLists) {
1192   OMPMappableExprListSizeTy Sizes;
1193   Sizes.NumVars = Vars.size();
1194   Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations);
1195   Sizes.NumComponentLists = ComponentLists.size();
1196   Sizes.NumComponents = getComponentsTotalNumber(ComponentLists);
1197 
1198   // We need to allocate:
1199   // NumVars x Expr* - we have an original list expression for each clause list
1200   // entry.
1201   // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1202   // with each component list.
1203   // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1204   // number of lists for each unique declaration and the size of each component
1205   // list.
1206   // NumComponents x MappableComponent - the total of all the components in all
1207   // the lists.
1208   void *Mem = C.Allocate(
1209       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1210                        OMPClauseMappableExprCommon::MappableComponent>(
1211           Sizes.NumVars, Sizes.NumUniqueDeclarations,
1212           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1213           Sizes.NumComponents));
1214 
1215   OMPIsDevicePtrClause *Clause = new (Mem) OMPIsDevicePtrClause(Locs, Sizes);
1216 
1217   Clause->setVarRefs(Vars);
1218   Clause->setClauseInfo(Declarations, ComponentLists);
1219   return Clause;
1220 }
1221 
1222 OMPIsDevicePtrClause *
1223 OMPIsDevicePtrClause::CreateEmpty(const ASTContext &C,
1224                                   const OMPMappableExprListSizeTy &Sizes) {
1225   void *Mem = C.Allocate(
1226       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1227                        OMPClauseMappableExprCommon::MappableComponent>(
1228           Sizes.NumVars, Sizes.NumUniqueDeclarations,
1229           Sizes.NumUniqueDeclarations + Sizes.NumComponentLists,
1230           Sizes.NumComponents));
1231   return new (Mem) OMPIsDevicePtrClause(Sizes);
1232 }
1233 
1234 OMPNontemporalClause *OMPNontemporalClause::Create(const ASTContext &C,
1235                                                    SourceLocation StartLoc,
1236                                                    SourceLocation LParenLoc,
1237                                                    SourceLocation EndLoc,
1238                                                    ArrayRef<Expr *> VL) {
1239   // Allocate space for nontemporal variables + private references.
1240   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * VL.size()));
1241   auto *Clause =
1242       new (Mem) OMPNontemporalClause(StartLoc, LParenLoc, EndLoc, VL.size());
1243   Clause->setVarRefs(VL);
1244   return Clause;
1245 }
1246 
1247 OMPNontemporalClause *OMPNontemporalClause::CreateEmpty(const ASTContext &C,
1248                                                         unsigned N) {
1249   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * N));
1250   return new (Mem) OMPNontemporalClause(N);
1251 }
1252 
1253 void OMPNontemporalClause::setPrivateRefs(ArrayRef<Expr *> VL) {
1254   assert(VL.size() == varlist_size() && "Number of private references is not "
1255                                         "the same as the preallocated buffer");
1256   std::copy(VL.begin(), VL.end(), varlist_end());
1257 }
1258 
1259 OMPInclusiveClause *OMPInclusiveClause::Create(const ASTContext &C,
1260                                                SourceLocation StartLoc,
1261                                                SourceLocation LParenLoc,
1262                                                SourceLocation EndLoc,
1263                                                ArrayRef<Expr *> VL) {
1264   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
1265   auto *Clause =
1266       new (Mem) OMPInclusiveClause(StartLoc, LParenLoc, EndLoc, VL.size());
1267   Clause->setVarRefs(VL);
1268   return Clause;
1269 }
1270 
1271 OMPInclusiveClause *OMPInclusiveClause::CreateEmpty(const ASTContext &C,
1272                                                     unsigned N) {
1273   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
1274   return new (Mem) OMPInclusiveClause(N);
1275 }
1276 
1277 OMPExclusiveClause *OMPExclusiveClause::Create(const ASTContext &C,
1278                                                SourceLocation StartLoc,
1279                                                SourceLocation LParenLoc,
1280                                                SourceLocation EndLoc,
1281                                                ArrayRef<Expr *> VL) {
1282   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
1283   auto *Clause =
1284       new (Mem) OMPExclusiveClause(StartLoc, LParenLoc, EndLoc, VL.size());
1285   Clause->setVarRefs(VL);
1286   return Clause;
1287 }
1288 
1289 OMPExclusiveClause *OMPExclusiveClause::CreateEmpty(const ASTContext &C,
1290                                                     unsigned N) {
1291   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
1292   return new (Mem) OMPExclusiveClause(N);
1293 }
1294 
1295 //===----------------------------------------------------------------------===//
1296 //  OpenMP clauses printing methods
1297 //===----------------------------------------------------------------------===//
1298 
1299 void OMPClausePrinter::VisitOMPIfClause(OMPIfClause *Node) {
1300   OS << "if(";
1301   if (Node->getNameModifier() != OMPD_unknown)
1302     OS << getOpenMPDirectiveName(Node->getNameModifier()) << ": ";
1303   Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
1304   OS << ")";
1305 }
1306 
1307 void OMPClausePrinter::VisitOMPFinalClause(OMPFinalClause *Node) {
1308   OS << "final(";
1309   Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
1310   OS << ")";
1311 }
1312 
1313 void OMPClausePrinter::VisitOMPNumThreadsClause(OMPNumThreadsClause *Node) {
1314   OS << "num_threads(";
1315   Node->getNumThreads()->printPretty(OS, nullptr, Policy, 0);
1316   OS << ")";
1317 }
1318 
1319 void OMPClausePrinter::VisitOMPSafelenClause(OMPSafelenClause *Node) {
1320   OS << "safelen(";
1321   Node->getSafelen()->printPretty(OS, nullptr, Policy, 0);
1322   OS << ")";
1323 }
1324 
1325 void OMPClausePrinter::VisitOMPSimdlenClause(OMPSimdlenClause *Node) {
1326   OS << "simdlen(";
1327   Node->getSimdlen()->printPretty(OS, nullptr, Policy, 0);
1328   OS << ")";
1329 }
1330 
1331 void OMPClausePrinter::VisitOMPAllocatorClause(OMPAllocatorClause *Node) {
1332   OS << "allocator(";
1333   Node->getAllocator()->printPretty(OS, nullptr, Policy, 0);
1334   OS << ")";
1335 }
1336 
1337 void OMPClausePrinter::VisitOMPCollapseClause(OMPCollapseClause *Node) {
1338   OS << "collapse(";
1339   Node->getNumForLoops()->printPretty(OS, nullptr, Policy, 0);
1340   OS << ")";
1341 }
1342 
1343 void OMPClausePrinter::VisitOMPDetachClause(OMPDetachClause *Node) {
1344   OS << "detach(";
1345   Node->getEventHandler()->printPretty(OS, nullptr, Policy, 0);
1346   OS << ")";
1347 }
1348 
1349 void OMPClausePrinter::VisitOMPDefaultClause(OMPDefaultClause *Node) {
1350   OS << "default("
1351      << getOpenMPSimpleClauseTypeName(OMPC_default,
1352                                       unsigned(Node->getDefaultKind()))
1353      << ")";
1354 }
1355 
1356 void OMPClausePrinter::VisitOMPProcBindClause(OMPProcBindClause *Node) {
1357   OS << "proc_bind("
1358      << getOpenMPSimpleClauseTypeName(OMPC_proc_bind,
1359                                       unsigned(Node->getProcBindKind()))
1360      << ")";
1361 }
1362 
1363 void OMPClausePrinter::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) {
1364   OS << "unified_address";
1365 }
1366 
1367 void OMPClausePrinter::VisitOMPUnifiedSharedMemoryClause(
1368     OMPUnifiedSharedMemoryClause *) {
1369   OS << "unified_shared_memory";
1370 }
1371 
1372 void OMPClausePrinter::VisitOMPReverseOffloadClause(OMPReverseOffloadClause *) {
1373   OS << "reverse_offload";
1374 }
1375 
1376 void OMPClausePrinter::VisitOMPDynamicAllocatorsClause(
1377     OMPDynamicAllocatorsClause *) {
1378   OS << "dynamic_allocators";
1379 }
1380 
1381 void OMPClausePrinter::VisitOMPAtomicDefaultMemOrderClause(
1382     OMPAtomicDefaultMemOrderClause *Node) {
1383   OS << "atomic_default_mem_order("
1384      << getOpenMPSimpleClauseTypeName(OMPC_atomic_default_mem_order,
1385                                       Node->getAtomicDefaultMemOrderKind())
1386      << ")";
1387 }
1388 
1389 void OMPClausePrinter::VisitOMPScheduleClause(OMPScheduleClause *Node) {
1390   OS << "schedule(";
1391   if (Node->getFirstScheduleModifier() != OMPC_SCHEDULE_MODIFIER_unknown) {
1392     OS << getOpenMPSimpleClauseTypeName(OMPC_schedule,
1393                                         Node->getFirstScheduleModifier());
1394     if (Node->getSecondScheduleModifier() != OMPC_SCHEDULE_MODIFIER_unknown) {
1395       OS << ", ";
1396       OS << getOpenMPSimpleClauseTypeName(OMPC_schedule,
1397                                           Node->getSecondScheduleModifier());
1398     }
1399     OS << ": ";
1400   }
1401   OS << getOpenMPSimpleClauseTypeName(OMPC_schedule, Node->getScheduleKind());
1402   if (auto *E = Node->getChunkSize()) {
1403     OS << ", ";
1404     E->printPretty(OS, nullptr, Policy);
1405   }
1406   OS << ")";
1407 }
1408 
1409 void OMPClausePrinter::VisitOMPOrderedClause(OMPOrderedClause *Node) {
1410   OS << "ordered";
1411   if (auto *Num = Node->getNumForLoops()) {
1412     OS << "(";
1413     Num->printPretty(OS, nullptr, Policy, 0);
1414     OS << ")";
1415   }
1416 }
1417 
1418 void OMPClausePrinter::VisitOMPNowaitClause(OMPNowaitClause *) {
1419   OS << "nowait";
1420 }
1421 
1422 void OMPClausePrinter::VisitOMPUntiedClause(OMPUntiedClause *) {
1423   OS << "untied";
1424 }
1425 
1426 void OMPClausePrinter::VisitOMPNogroupClause(OMPNogroupClause *) {
1427   OS << "nogroup";
1428 }
1429 
1430 void OMPClausePrinter::VisitOMPMergeableClause(OMPMergeableClause *) {
1431   OS << "mergeable";
1432 }
1433 
1434 void OMPClausePrinter::VisitOMPReadClause(OMPReadClause *) { OS << "read"; }
1435 
1436 void OMPClausePrinter::VisitOMPWriteClause(OMPWriteClause *) { OS << "write"; }
1437 
1438 void OMPClausePrinter::VisitOMPUpdateClause(OMPUpdateClause *Node) {
1439   OS << "update";
1440   if (Node->isExtended()) {
1441     OS << "(";
1442     OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(),
1443                                         Node->getDependencyKind());
1444     OS << ")";
1445   }
1446 }
1447 
1448 void OMPClausePrinter::VisitOMPCaptureClause(OMPCaptureClause *) {
1449   OS << "capture";
1450 }
1451 
1452 void OMPClausePrinter::VisitOMPSeqCstClause(OMPSeqCstClause *) {
1453   OS << "seq_cst";
1454 }
1455 
1456 void OMPClausePrinter::VisitOMPAcqRelClause(OMPAcqRelClause *) {
1457   OS << "acq_rel";
1458 }
1459 
1460 void OMPClausePrinter::VisitOMPAcquireClause(OMPAcquireClause *) {
1461   OS << "acquire";
1462 }
1463 
1464 void OMPClausePrinter::VisitOMPReleaseClause(OMPReleaseClause *) {
1465   OS << "release";
1466 }
1467 
1468 void OMPClausePrinter::VisitOMPRelaxedClause(OMPRelaxedClause *) {
1469   OS << "relaxed";
1470 }
1471 
1472 void OMPClausePrinter::VisitOMPThreadsClause(OMPThreadsClause *) {
1473   OS << "threads";
1474 }
1475 
1476 void OMPClausePrinter::VisitOMPSIMDClause(OMPSIMDClause *) { OS << "simd"; }
1477 
1478 void OMPClausePrinter::VisitOMPDeviceClause(OMPDeviceClause *Node) {
1479   OS << "device(";
1480   OpenMPDeviceClauseModifier Modifier = Node->getModifier();
1481   if (Modifier != OMPC_DEVICE_unknown) {
1482     OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(), Modifier)
1483        << ": ";
1484   }
1485   Node->getDevice()->printPretty(OS, nullptr, Policy, 0);
1486   OS << ")";
1487 }
1488 
1489 void OMPClausePrinter::VisitOMPNumTeamsClause(OMPNumTeamsClause *Node) {
1490   OS << "num_teams(";
1491   Node->getNumTeams()->printPretty(OS, nullptr, Policy, 0);
1492   OS << ")";
1493 }
1494 
1495 void OMPClausePrinter::VisitOMPThreadLimitClause(OMPThreadLimitClause *Node) {
1496   OS << "thread_limit(";
1497   Node->getThreadLimit()->printPretty(OS, nullptr, Policy, 0);
1498   OS << ")";
1499 }
1500 
1501 void OMPClausePrinter::VisitOMPPriorityClause(OMPPriorityClause *Node) {
1502   OS << "priority(";
1503   Node->getPriority()->printPretty(OS, nullptr, Policy, 0);
1504   OS << ")";
1505 }
1506 
1507 void OMPClausePrinter::VisitOMPGrainsizeClause(OMPGrainsizeClause *Node) {
1508   OS << "grainsize(";
1509   Node->getGrainsize()->printPretty(OS, nullptr, Policy, 0);
1510   OS << ")";
1511 }
1512 
1513 void OMPClausePrinter::VisitOMPNumTasksClause(OMPNumTasksClause *Node) {
1514   OS << "num_tasks(";
1515   Node->getNumTasks()->printPretty(OS, nullptr, Policy, 0);
1516   OS << ")";
1517 }
1518 
1519 void OMPClausePrinter::VisitOMPHintClause(OMPHintClause *Node) {
1520   OS << "hint(";
1521   Node->getHint()->printPretty(OS, nullptr, Policy, 0);
1522   OS << ")";
1523 }
1524 
1525 void OMPClausePrinter::VisitOMPDestroyClause(OMPDestroyClause *) {
1526   OS << "destroy";
1527 }
1528 
1529 template<typename T>
1530 void OMPClausePrinter::VisitOMPClauseList(T *Node, char StartSym) {
1531   for (typename T::varlist_iterator I = Node->varlist_begin(),
1532                                     E = Node->varlist_end();
1533        I != E; ++I) {
1534     assert(*I && "Expected non-null Stmt");
1535     OS << (I == Node->varlist_begin() ? StartSym : ',');
1536     if (auto *DRE = dyn_cast<DeclRefExpr>(*I)) {
1537       if (isa<OMPCapturedExprDecl>(DRE->getDecl()))
1538         DRE->printPretty(OS, nullptr, Policy, 0);
1539       else
1540         DRE->getDecl()->printQualifiedName(OS);
1541     } else
1542       (*I)->printPretty(OS, nullptr, Policy, 0);
1543   }
1544 }
1545 
1546 void OMPClausePrinter::VisitOMPAllocateClause(OMPAllocateClause *Node) {
1547   if (Node->varlist_empty())
1548     return;
1549   OS << "allocate";
1550   if (Expr *Allocator = Node->getAllocator()) {
1551     OS << "(";
1552     Allocator->printPretty(OS, nullptr, Policy, 0);
1553     OS << ":";
1554     VisitOMPClauseList(Node, ' ');
1555   } else {
1556     VisitOMPClauseList(Node, '(');
1557   }
1558   OS << ")";
1559 }
1560 
1561 void OMPClausePrinter::VisitOMPPrivateClause(OMPPrivateClause *Node) {
1562   if (!Node->varlist_empty()) {
1563     OS << "private";
1564     VisitOMPClauseList(Node, '(');
1565     OS << ")";
1566   }
1567 }
1568 
1569 void OMPClausePrinter::VisitOMPFirstprivateClause(OMPFirstprivateClause *Node) {
1570   if (!Node->varlist_empty()) {
1571     OS << "firstprivate";
1572     VisitOMPClauseList(Node, '(');
1573     OS << ")";
1574   }
1575 }
1576 
1577 void OMPClausePrinter::VisitOMPLastprivateClause(OMPLastprivateClause *Node) {
1578   if (!Node->varlist_empty()) {
1579     OS << "lastprivate";
1580     OpenMPLastprivateModifier LPKind = Node->getKind();
1581     if (LPKind != OMPC_LASTPRIVATE_unknown) {
1582       OS << "("
1583          << getOpenMPSimpleClauseTypeName(OMPC_lastprivate, Node->getKind())
1584          << ":";
1585     }
1586     VisitOMPClauseList(Node, LPKind == OMPC_LASTPRIVATE_unknown ? '(' : ' ');
1587     OS << ")";
1588   }
1589 }
1590 
1591 void OMPClausePrinter::VisitOMPSharedClause(OMPSharedClause *Node) {
1592   if (!Node->varlist_empty()) {
1593     OS << "shared";
1594     VisitOMPClauseList(Node, '(');
1595     OS << ")";
1596   }
1597 }
1598 
1599 void OMPClausePrinter::VisitOMPReductionClause(OMPReductionClause *Node) {
1600   if (!Node->varlist_empty()) {
1601     OS << "reduction(";
1602     if (Node->getModifierLoc().isValid())
1603       OS << getOpenMPSimpleClauseTypeName(OMPC_reduction, Node->getModifier())
1604          << ", ";
1605     NestedNameSpecifier *QualifierLoc =
1606         Node->getQualifierLoc().getNestedNameSpecifier();
1607     OverloadedOperatorKind OOK =
1608         Node->getNameInfo().getName().getCXXOverloadedOperator();
1609     if (QualifierLoc == nullptr && OOK != OO_None) {
1610       // Print reduction identifier in C format
1611       OS << getOperatorSpelling(OOK);
1612     } else {
1613       // Use C++ format
1614       if (QualifierLoc != nullptr)
1615         QualifierLoc->print(OS, Policy);
1616       OS << Node->getNameInfo();
1617     }
1618     OS << ":";
1619     VisitOMPClauseList(Node, ' ');
1620     OS << ")";
1621   }
1622 }
1623 
1624 void OMPClausePrinter::VisitOMPTaskReductionClause(
1625     OMPTaskReductionClause *Node) {
1626   if (!Node->varlist_empty()) {
1627     OS << "task_reduction(";
1628     NestedNameSpecifier *QualifierLoc =
1629         Node->getQualifierLoc().getNestedNameSpecifier();
1630     OverloadedOperatorKind OOK =
1631         Node->getNameInfo().getName().getCXXOverloadedOperator();
1632     if (QualifierLoc == nullptr && OOK != OO_None) {
1633       // Print reduction identifier in C format
1634       OS << getOperatorSpelling(OOK);
1635     } else {
1636       // Use C++ format
1637       if (QualifierLoc != nullptr)
1638         QualifierLoc->print(OS, Policy);
1639       OS << Node->getNameInfo();
1640     }
1641     OS << ":";
1642     VisitOMPClauseList(Node, ' ');
1643     OS << ")";
1644   }
1645 }
1646 
1647 void OMPClausePrinter::VisitOMPInReductionClause(OMPInReductionClause *Node) {
1648   if (!Node->varlist_empty()) {
1649     OS << "in_reduction(";
1650     NestedNameSpecifier *QualifierLoc =
1651         Node->getQualifierLoc().getNestedNameSpecifier();
1652     OverloadedOperatorKind OOK =
1653         Node->getNameInfo().getName().getCXXOverloadedOperator();
1654     if (QualifierLoc == nullptr && OOK != OO_None) {
1655       // Print reduction identifier in C format
1656       OS << getOperatorSpelling(OOK);
1657     } else {
1658       // Use C++ format
1659       if (QualifierLoc != nullptr)
1660         QualifierLoc->print(OS, Policy);
1661       OS << Node->getNameInfo();
1662     }
1663     OS << ":";
1664     VisitOMPClauseList(Node, ' ');
1665     OS << ")";
1666   }
1667 }
1668 
1669 void OMPClausePrinter::VisitOMPLinearClause(OMPLinearClause *Node) {
1670   if (!Node->varlist_empty()) {
1671     OS << "linear";
1672     if (Node->getModifierLoc().isValid()) {
1673       OS << '('
1674          << getOpenMPSimpleClauseTypeName(OMPC_linear, Node->getModifier());
1675     }
1676     VisitOMPClauseList(Node, '(');
1677     if (Node->getModifierLoc().isValid())
1678       OS << ')';
1679     if (Node->getStep() != nullptr) {
1680       OS << ": ";
1681       Node->getStep()->printPretty(OS, nullptr, Policy, 0);
1682     }
1683     OS << ")";
1684   }
1685 }
1686 
1687 void OMPClausePrinter::VisitOMPAlignedClause(OMPAlignedClause *Node) {
1688   if (!Node->varlist_empty()) {
1689     OS << "aligned";
1690     VisitOMPClauseList(Node, '(');
1691     if (Node->getAlignment() != nullptr) {
1692       OS << ": ";
1693       Node->getAlignment()->printPretty(OS, nullptr, Policy, 0);
1694     }
1695     OS << ")";
1696   }
1697 }
1698 
1699 void OMPClausePrinter::VisitOMPCopyinClause(OMPCopyinClause *Node) {
1700   if (!Node->varlist_empty()) {
1701     OS << "copyin";
1702     VisitOMPClauseList(Node, '(');
1703     OS << ")";
1704   }
1705 }
1706 
1707 void OMPClausePrinter::VisitOMPCopyprivateClause(OMPCopyprivateClause *Node) {
1708   if (!Node->varlist_empty()) {
1709     OS << "copyprivate";
1710     VisitOMPClauseList(Node, '(');
1711     OS << ")";
1712   }
1713 }
1714 
1715 void OMPClausePrinter::VisitOMPFlushClause(OMPFlushClause *Node) {
1716   if (!Node->varlist_empty()) {
1717     VisitOMPClauseList(Node, '(');
1718     OS << ")";
1719   }
1720 }
1721 
1722 void OMPClausePrinter::VisitOMPDepobjClause(OMPDepobjClause *Node) {
1723   OS << "(";
1724   Node->getDepobj()->printPretty(OS, nullptr, Policy, 0);
1725   OS << ")";
1726 }
1727 
1728 void OMPClausePrinter::VisitOMPDependClause(OMPDependClause *Node) {
1729   OS << "depend(";
1730   OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(),
1731                                       Node->getDependencyKind());
1732   if (!Node->varlist_empty()) {
1733     OS << " :";
1734     VisitOMPClauseList(Node, ' ');
1735   }
1736   OS << ")";
1737 }
1738 
1739 void OMPClausePrinter::VisitOMPMapClause(OMPMapClause *Node) {
1740   if (!Node->varlist_empty()) {
1741     OS << "map(";
1742     if (Node->getMapType() != OMPC_MAP_unknown) {
1743       for (unsigned I = 0; I < OMPMapClause::NumberOfModifiers; ++I) {
1744         if (Node->getMapTypeModifier(I) != OMPC_MAP_MODIFIER_unknown) {
1745           OS << getOpenMPSimpleClauseTypeName(OMPC_map,
1746                                               Node->getMapTypeModifier(I));
1747           if (Node->getMapTypeModifier(I) == OMPC_MAP_MODIFIER_mapper) {
1748             OS << '(';
1749             NestedNameSpecifier *MapperNNS =
1750                 Node->getMapperQualifierLoc().getNestedNameSpecifier();
1751             if (MapperNNS)
1752               MapperNNS->print(OS, Policy);
1753             OS << Node->getMapperIdInfo() << ')';
1754           }
1755           OS << ',';
1756         }
1757       }
1758       OS << getOpenMPSimpleClauseTypeName(OMPC_map, Node->getMapType());
1759       OS << ':';
1760     }
1761     VisitOMPClauseList(Node, ' ');
1762     OS << ")";
1763   }
1764 }
1765 
1766 void OMPClausePrinter::VisitOMPToClause(OMPToClause *Node) {
1767   if (!Node->varlist_empty()) {
1768     OS << "to";
1769     DeclarationNameInfo MapperId = Node->getMapperIdInfo();
1770     if (MapperId.getName() && !MapperId.getName().isEmpty()) {
1771       OS << '(';
1772       OS << "mapper(";
1773       NestedNameSpecifier *MapperNNS =
1774           Node->getMapperQualifierLoc().getNestedNameSpecifier();
1775       if (MapperNNS)
1776         MapperNNS->print(OS, Policy);
1777       OS << MapperId << "):";
1778       VisitOMPClauseList(Node, ' ');
1779     } else {
1780       VisitOMPClauseList(Node, '(');
1781     }
1782     OS << ")";
1783   }
1784 }
1785 
1786 void OMPClausePrinter::VisitOMPFromClause(OMPFromClause *Node) {
1787   if (!Node->varlist_empty()) {
1788     OS << "from";
1789     DeclarationNameInfo MapperId = Node->getMapperIdInfo();
1790     if (MapperId.getName() && !MapperId.getName().isEmpty()) {
1791       OS << '(';
1792       OS << "mapper(";
1793       NestedNameSpecifier *MapperNNS =
1794           Node->getMapperQualifierLoc().getNestedNameSpecifier();
1795       if (MapperNNS)
1796         MapperNNS->print(OS, Policy);
1797       OS << MapperId << "):";
1798       VisitOMPClauseList(Node, ' ');
1799     } else {
1800       VisitOMPClauseList(Node, '(');
1801     }
1802     OS << ")";
1803   }
1804 }
1805 
1806 void OMPClausePrinter::VisitOMPDistScheduleClause(OMPDistScheduleClause *Node) {
1807   OS << "dist_schedule(" << getOpenMPSimpleClauseTypeName(
1808                            OMPC_dist_schedule, Node->getDistScheduleKind());
1809   if (auto *E = Node->getChunkSize()) {
1810     OS << ", ";
1811     E->printPretty(OS, nullptr, Policy);
1812   }
1813   OS << ")";
1814 }
1815 
1816 void OMPClausePrinter::VisitOMPDefaultmapClause(OMPDefaultmapClause *Node) {
1817   OS << "defaultmap(";
1818   OS << getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
1819                                       Node->getDefaultmapModifier());
1820   OS << ": ";
1821   OS << getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
1822     Node->getDefaultmapKind());
1823   OS << ")";
1824 }
1825 
1826 void OMPClausePrinter::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *Node) {
1827   if (!Node->varlist_empty()) {
1828     OS << "use_device_ptr";
1829     VisitOMPClauseList(Node, '(');
1830     OS << ")";
1831   }
1832 }
1833 
1834 void OMPClausePrinter::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *Node) {
1835   if (!Node->varlist_empty()) {
1836     OS << "is_device_ptr";
1837     VisitOMPClauseList(Node, '(');
1838     OS << ")";
1839   }
1840 }
1841 
1842 void OMPClausePrinter::VisitOMPNontemporalClause(OMPNontemporalClause *Node) {
1843   if (!Node->varlist_empty()) {
1844     OS << "nontemporal";
1845     VisitOMPClauseList(Node, '(');
1846     OS << ")";
1847   }
1848 }
1849 
1850 void OMPClausePrinter::VisitOMPOrderClause(OMPOrderClause *Node) {
1851   OS << "order(" << getOpenMPSimpleClauseTypeName(OMPC_order, Node->getKind())
1852      << ")";
1853 }
1854 
1855 void OMPClausePrinter::VisitOMPInclusiveClause(OMPInclusiveClause *Node) {
1856   if (!Node->varlist_empty()) {
1857     OS << "inclusive";
1858     VisitOMPClauseList(Node, '(');
1859     OS << ")";
1860   }
1861 }
1862 
1863 void OMPClausePrinter::VisitOMPExclusiveClause(OMPExclusiveClause *Node) {
1864   if (!Node->varlist_empty()) {
1865     OS << "exclusive";
1866     VisitOMPClauseList(Node, '(');
1867     OS << ")";
1868   }
1869 }
1870 
1871 void OMPTraitInfo::getAsVariantMatchInfo(ASTContext &ASTCtx,
1872                                          VariantMatchInfo &VMI,
1873                                          bool DeviceSetOnly) const {
1874   for (const OMPTraitSet &Set : Sets) {
1875     if (DeviceSetOnly && Set.Kind != TraitSet::device)
1876       continue;
1877     for (const OMPTraitSelector &Selector : Set.Selectors) {
1878 
1879       // User conditions are special as we evaluate the condition here.
1880       if (Selector.Kind == TraitSelector::user_condition) {
1881         assert(Selector.ScoreOrCondition &&
1882                "Ill-formed user condition, expected condition expression!");
1883         assert(Selector.Properties.size() == 1 &&
1884                Selector.Properties.front().Kind ==
1885                    TraitProperty::user_condition_unknown &&
1886                "Ill-formed user condition, expected unknown trait property!");
1887 
1888         llvm::APInt CondVal =
1889             Selector.ScoreOrCondition->EvaluateKnownConstInt(ASTCtx);
1890         VMI.addTrait(CondVal.isNullValue()
1891                          ? TraitProperty::user_condition_false
1892                          : TraitProperty::user_condition_true);
1893         continue;
1894       }
1895 
1896       llvm::APInt Score;
1897       llvm::APInt *ScorePtr = nullptr;
1898       if (Selector.ScoreOrCondition) {
1899         Score = Selector.ScoreOrCondition->EvaluateKnownConstInt(ASTCtx);
1900         ScorePtr = &Score;
1901       }
1902       for (const OMPTraitProperty &Property : Selector.Properties)
1903         VMI.addTrait(Set.Kind, Property.Kind, ScorePtr);
1904 
1905       if (Set.Kind != TraitSet::construct)
1906         continue;
1907 
1908       // TODO: This might not hold once we implement SIMD properly.
1909       assert(Selector.Properties.size() == 1 &&
1910              Selector.Properties.front().Kind ==
1911                  getOpenMPContextTraitPropertyForSelector(
1912                      Selector.Kind) &&
1913              "Ill-formed construct selector!");
1914 
1915       VMI.ConstructTraits.push_back(Selector.Properties.front().Kind);
1916     }
1917   }
1918 }
1919 
1920 void OMPTraitInfo::print(llvm::raw_ostream &OS,
1921                          const PrintingPolicy &Policy) const {
1922   bool FirstSet = true;
1923   for (const OMPTraitInfo::OMPTraitSet &Set : Sets) {
1924     if (!FirstSet)
1925       OS << ", ";
1926     FirstSet = false;
1927     OS << getOpenMPContextTraitSetName(Set.Kind) << "={";
1928 
1929     bool FirstSelector = true;
1930     for (const OMPTraitInfo::OMPTraitSelector &Selector : Set.Selectors) {
1931       if (!FirstSelector)
1932         OS << ", ";
1933       FirstSelector = false;
1934       OS << getOpenMPContextTraitSelectorName(Selector.Kind);
1935 
1936       bool AllowsTraitScore = false;
1937       bool RequiresProperty = false;
1938       isValidTraitSelectorForTraitSet(
1939           Selector.Kind, Set.Kind, AllowsTraitScore, RequiresProperty);
1940 
1941       if (!RequiresProperty)
1942         continue;
1943 
1944       OS << "(";
1945       if (Selector.Kind == TraitSelector::user_condition) {
1946         Selector.ScoreOrCondition->printPretty(OS, nullptr, Policy);
1947       } else {
1948 
1949         if (Selector.ScoreOrCondition) {
1950           OS << "score(";
1951           Selector.ScoreOrCondition->printPretty(OS, nullptr, Policy);
1952           OS << "): ";
1953         }
1954 
1955         bool FirstProperty = true;
1956         for (const OMPTraitInfo::OMPTraitProperty &Property :
1957              Selector.Properties) {
1958           if (!FirstProperty)
1959             OS << ", ";
1960           FirstProperty = false;
1961           OS << getOpenMPContextTraitPropertyName(Property.Kind);
1962         }
1963       }
1964       OS << ")";
1965     }
1966     OS << "}";
1967   }
1968 }
1969 
1970 std::string OMPTraitInfo::getMangledName() const {
1971   std::string MangledName;
1972   llvm::raw_string_ostream OS(MangledName);
1973   for (const OMPTraitInfo::OMPTraitSet &Set : Sets) {
1974     OS << '.' << 'S' << unsigned(Set.Kind);
1975     for (const OMPTraitInfo::OMPTraitSelector &Selector : Set.Selectors) {
1976 
1977       bool AllowsTraitScore = false;
1978       bool RequiresProperty = false;
1979       isValidTraitSelectorForTraitSet(
1980           Selector.Kind, Set.Kind, AllowsTraitScore, RequiresProperty);
1981       OS << '.' << 's' << unsigned(Selector.Kind);
1982 
1983       if (!RequiresProperty ||
1984           Selector.Kind == TraitSelector::user_condition)
1985         continue;
1986 
1987       for (const OMPTraitInfo::OMPTraitProperty &Property : Selector.Properties)
1988         OS << '.' << 'P'
1989            << getOpenMPContextTraitPropertyName(Property.Kind);
1990     }
1991   }
1992   return OS.str();
1993 }
1994 
1995 OMPTraitInfo::OMPTraitInfo(StringRef MangledName) {
1996   unsigned long U;
1997   do {
1998     if (!MangledName.consume_front(".S"))
1999       break;
2000     if (MangledName.consumeInteger(10, U))
2001       break;
2002     Sets.push_back(OMPTraitSet());
2003     OMPTraitSet &Set = Sets.back();
2004     Set.Kind = TraitSet(U);
2005     do {
2006       if (!MangledName.consume_front(".s"))
2007         break;
2008       if (MangledName.consumeInteger(10, U))
2009         break;
2010       Set.Selectors.push_back(OMPTraitSelector());
2011       OMPTraitSelector &Selector = Set.Selectors.back();
2012       Selector.Kind = TraitSelector(U);
2013       do {
2014         if (!MangledName.consume_front(".P"))
2015           break;
2016         Selector.Properties.push_back(OMPTraitProperty());
2017         OMPTraitProperty &Property = Selector.Properties.back();
2018         std::pair<StringRef, StringRef> PropRestPair = MangledName.split('.');
2019         Property.Kind =
2020             getOpenMPContextTraitPropertyKind(Set.Kind, PropRestPair.first);
2021         MangledName = PropRestPair.second;
2022       } while (true);
2023     } while (true);
2024   } while (true);
2025 }
2026 
2027 llvm::raw_ostream &clang::operator<<(llvm::raw_ostream &OS,
2028                                      const OMPTraitInfo &TI) {
2029   LangOptions LO;
2030   PrintingPolicy Policy(LO);
2031   TI.print(OS, Policy);
2032   return OS;
2033 }
2034 llvm::raw_ostream &clang::operator<<(llvm::raw_ostream &OS,
2035                                      const OMPTraitInfo *TI) {
2036   return TI ? OS << *TI : OS;
2037 }
2038