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