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