clang  9.0.0svn
OpenMPClause.cpp
Go to the documentation of this file.
1 //===- OpenMPClause.cpp - Classes for OpenMP clauses ----------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the subclesses of Stmt class declared in OpenMPClause.h
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/AST/OpenMPClause.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/Decl.h"
17 #include "clang/AST/DeclOpenMP.h"
18 #include "clang/Basic/LLVM.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 
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 
40  auto *Res = OMPClauseWithPreInit::get(const_cast<const OMPClause *>(C));
41  return Res ? const_cast<OMPClauseWithPreInit *>(Res) : nullptr;
42 }
43 
45  switch (C->getClauseKind()) {
46  case OMPC_schedule:
47  return static_cast<const OMPScheduleClause *>(C);
48  case OMPC_dist_schedule:
49  return static_cast<const OMPDistScheduleClause *>(C);
50  case OMPC_firstprivate:
51  return static_cast<const OMPFirstprivateClause *>(C);
52  case OMPC_lastprivate:
53  return static_cast<const OMPLastprivateClause *>(C);
54  case OMPC_reduction:
55  return static_cast<const OMPReductionClause *>(C);
56  case OMPC_task_reduction:
57  return static_cast<const OMPTaskReductionClause *>(C);
58  case OMPC_in_reduction:
59  return static_cast<const OMPInReductionClause *>(C);
60  case OMPC_linear:
61  return static_cast<const OMPLinearClause *>(C);
62  case OMPC_if:
63  return static_cast<const OMPIfClause *>(C);
64  case OMPC_num_threads:
65  return static_cast<const OMPNumThreadsClause *>(C);
66  case OMPC_num_teams:
67  return static_cast<const OMPNumTeamsClause *>(C);
68  case OMPC_thread_limit:
69  return static_cast<const OMPThreadLimitClause *>(C);
70  case OMPC_device:
71  return static_cast<const OMPDeviceClause *>(C);
72  case OMPC_default:
73  case OMPC_proc_bind:
74  case OMPC_final:
75  case OMPC_safelen:
76  case OMPC_simdlen:
77  case OMPC_collapse:
78  case OMPC_private:
79  case OMPC_shared:
80  case OMPC_aligned:
81  case OMPC_copyin:
82  case OMPC_copyprivate:
83  case OMPC_ordered:
84  case OMPC_nowait:
85  case OMPC_untied:
86  case OMPC_mergeable:
87  case OMPC_threadprivate:
88  case OMPC_flush:
89  case OMPC_read:
90  case OMPC_write:
91  case OMPC_update:
92  case OMPC_capture:
93  case OMPC_seq_cst:
94  case OMPC_depend:
95  case OMPC_threads:
96  case OMPC_simd:
97  case OMPC_map:
98  case OMPC_priority:
99  case OMPC_grainsize:
100  case OMPC_nogroup:
101  case OMPC_num_tasks:
102  case OMPC_hint:
103  case OMPC_defaultmap:
104  case OMPC_unknown:
105  case OMPC_uniform:
106  case OMPC_to:
107  case OMPC_from:
108  case OMPC_use_device_ptr:
109  case OMPC_is_device_ptr:
110  case OMPC_unified_address:
111  case OMPC_unified_shared_memory:
112  case OMPC_reverse_offload:
113  case OMPC_dynamic_allocators:
114  case OMPC_atomic_default_mem_order:
115  break;
116  }
117 
118  return nullptr;
119 }
120 
122  auto *Res = OMPClauseWithPostUpdate::get(const_cast<const OMPClause *>(C));
123  return Res ? const_cast<OMPClauseWithPostUpdate *>(Res) : nullptr;
124 }
125 
127  switch (C->getClauseKind()) {
128  case OMPC_lastprivate:
129  return static_cast<const OMPLastprivateClause *>(C);
130  case OMPC_reduction:
131  return static_cast<const OMPReductionClause *>(C);
132  case OMPC_task_reduction:
133  return static_cast<const OMPTaskReductionClause *>(C);
134  case OMPC_in_reduction:
135  return static_cast<const OMPInReductionClause *>(C);
136  case OMPC_linear:
137  return static_cast<const OMPLinearClause *>(C);
138  case OMPC_schedule:
139  case OMPC_dist_schedule:
140  case OMPC_firstprivate:
141  case OMPC_default:
142  case OMPC_proc_bind:
143  case OMPC_if:
144  case OMPC_final:
145  case OMPC_num_threads:
146  case OMPC_safelen:
147  case OMPC_simdlen:
148  case OMPC_collapse:
149  case OMPC_private:
150  case OMPC_shared:
151  case OMPC_aligned:
152  case OMPC_copyin:
153  case OMPC_copyprivate:
154  case OMPC_ordered:
155  case OMPC_nowait:
156  case OMPC_untied:
157  case OMPC_mergeable:
158  case OMPC_threadprivate:
159  case OMPC_flush:
160  case OMPC_read:
161  case OMPC_write:
162  case OMPC_update:
163  case OMPC_capture:
164  case OMPC_seq_cst:
165  case OMPC_depend:
166  case OMPC_device:
167  case OMPC_threads:
168  case OMPC_simd:
169  case OMPC_map:
170  case OMPC_num_teams:
171  case OMPC_thread_limit:
172  case OMPC_priority:
173  case OMPC_grainsize:
174  case OMPC_nogroup:
175  case OMPC_num_tasks:
176  case OMPC_hint:
177  case OMPC_defaultmap:
178  case OMPC_unknown:
179  case OMPC_uniform:
180  case OMPC_to:
181  case OMPC_from:
182  case OMPC_use_device_ptr:
183  case OMPC_is_device_ptr:
184  case OMPC_unified_address:
185  case OMPC_unified_shared_memory:
186  case OMPC_reverse_offload:
187  case OMPC_dynamic_allocators:
188  case OMPC_atomic_default_mem_order:
189  break;
190  }
191 
192  return nullptr;
193 }
194 
196  unsigned NumLoops,
197  SourceLocation StartLoc,
198  SourceLocation LParenLoc,
199  SourceLocation EndLoc) {
200  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * NumLoops));
201  auto *Clause =
202  new (Mem) OMPOrderedClause(Num, NumLoops, StartLoc, LParenLoc, EndLoc);
203  for (unsigned I = 0; I < NumLoops; ++I) {
204  Clause->setLoopNumIterations(I, nullptr);
205  Clause->setLoopCounter(I, nullptr);
206  }
207  return Clause;
208 }
209 
211  unsigned NumLoops) {
212  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * NumLoops));
213  auto *Clause = new (Mem) OMPOrderedClause(NumLoops);
214  for (unsigned I = 0; I < NumLoops; ++I) {
215  Clause->setLoopNumIterations(I, nullptr);
216  Clause->setLoopCounter(I, nullptr);
217  }
218  return Clause;
219 }
220 
222  Expr *NumIterations) {
223  assert(NumLoop < NumberOfLoops && "out of loops number.");
224  getTrailingObjects<Expr *>()[NumLoop] = NumIterations;
225 }
226 
228  return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumberOfLoops);
229 }
230 
231 void OMPOrderedClause::setLoopCounter(unsigned NumLoop, Expr *Counter) {
232  assert(NumLoop < NumberOfLoops && "out of loops number.");
233  getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop] = Counter;
234 }
235 
237  assert(NumLoop < NumberOfLoops && "out of loops number.");
238  return getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop];
239 }
240 
241 const Expr *OMPOrderedClause::getLoopCounter(unsigned NumLoop) const {
242  assert(NumLoop < NumberOfLoops && "out of loops number.");
243  return getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop];
244 }
245 
246 void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
247  assert(VL.size() == varlist_size() &&
248  "Number of private copies is not the same as the preallocated buffer");
249  std::copy(VL.begin(), VL.end(), varlist_end());
250 }
251 
254  SourceLocation LParenLoc, SourceLocation EndLoc,
255  ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) {
256  // Allocate space for private variables and initializer expressions.
257  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * VL.size()));
258  OMPPrivateClause *Clause =
259  new (Mem) OMPPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
260  Clause->setVarRefs(VL);
261  Clause->setPrivateCopies(PrivateVL);
262  return Clause;
263 }
264 
266  unsigned N) {
267  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * N));
268  return new (Mem) OMPPrivateClause(N);
269 }
270 
271 void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
272  assert(VL.size() == varlist_size() &&
273  "Number of private copies is not the same as the preallocated buffer");
274  std::copy(VL.begin(), VL.end(), varlist_end());
275 }
276 
277 void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) {
278  assert(VL.size() == varlist_size() &&
279  "Number of inits is not the same as the preallocated buffer");
280  std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
281 }
282 
285  SourceLocation LParenLoc, SourceLocation EndLoc,
286  ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
287  ArrayRef<Expr *> InitVL, Stmt *PreInit) {
288  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * VL.size()));
289  OMPFirstprivateClause *Clause =
290  new (Mem) OMPFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
291  Clause->setVarRefs(VL);
292  Clause->setPrivateCopies(PrivateVL);
293  Clause->setInits(InitVL);
294  Clause->setPreInitStmt(PreInit);
295  return Clause;
296 }
297 
299  unsigned N) {
300  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * N));
301  return new (Mem) OMPFirstprivateClause(N);
302 }
303 
305  assert(PrivateCopies.size() == varlist_size() &&
306  "Number of private copies is not the same as the preallocated buffer");
307  std::copy(PrivateCopies.begin(), PrivateCopies.end(), varlist_end());
308 }
309 
310 void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
311  assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
312  "not the same as the "
313  "preallocated buffer");
314  std::copy(SrcExprs.begin(), SrcExprs.end(), getPrivateCopies().end());
315 }
316 
317 void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
318  assert(DstExprs.size() == varlist_size() && "Number of destination "
319  "expressions is not the same as "
320  "the preallocated buffer");
321  std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
322 }
323 
324 void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
325  assert(AssignmentOps.size() == varlist_size() &&
326  "Number of assignment expressions is not the same as the preallocated "
327  "buffer");
328  std::copy(AssignmentOps.begin(), AssignmentOps.end(),
329  getDestinationExprs().end());
330 }
331 
333  const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
334  SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
335  ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps, Stmt *PreInit,
336  Expr *PostUpdate) {
337  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
338  OMPLastprivateClause *Clause =
339  new (Mem) OMPLastprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
340  Clause->setVarRefs(VL);
341  Clause->setSourceExprs(SrcExprs);
342  Clause->setDestinationExprs(DstExprs);
343  Clause->setAssignmentOps(AssignmentOps);
344  Clause->setPreInitStmt(PreInit);
345  Clause->setPostUpdateExpr(PostUpdate);
346  return Clause;
347 }
348 
350  unsigned N) {
351  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
352  return new (Mem) OMPLastprivateClause(N);
353 }
354 
356  SourceLocation StartLoc,
357  SourceLocation LParenLoc,
358  SourceLocation EndLoc,
359  ArrayRef<Expr *> VL) {
360  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
361  OMPSharedClause *Clause =
362  new (Mem) OMPSharedClause(StartLoc, LParenLoc, EndLoc, VL.size());
363  Clause->setVarRefs(VL);
364  return Clause;
365 }
366 
368  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
369  return new (Mem) OMPSharedClause(N);
370 }
371 
373  assert(PL.size() == varlist_size() &&
374  "Number of privates is not the same as the preallocated buffer");
375  std::copy(PL.begin(), PL.end(), varlist_end());
376 }
377 
379  assert(IL.size() == varlist_size() &&
380  "Number of inits is not the same as the preallocated buffer");
381  std::copy(IL.begin(), IL.end(), getPrivates().end());
382 }
383 
385  assert(UL.size() == varlist_size() &&
386  "Number of updates is not the same as the preallocated buffer");
387  std::copy(UL.begin(), UL.end(), getInits().end());
388 }
389 
391  assert(FL.size() == varlist_size() &&
392  "Number of final updates is not the same as the preallocated buffer");
393  std::copy(FL.begin(), FL.end(), getUpdates().end());
394 }
395 
397  const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
401  Stmt *PreInit, Expr *PostUpdate) {
402  // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
403  // (Step and CalcStep).
404  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2));
405  OMPLinearClause *Clause = new (Mem) OMPLinearClause(
406  StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc, EndLoc, VL.size());
407  Clause->setVarRefs(VL);
408  Clause->setPrivates(PL);
409  Clause->setInits(IL);
410  // Fill update and final expressions with zeroes, they are provided later,
411  // after the directive construction.
412  std::fill(Clause->getInits().end(), Clause->getInits().end() + VL.size(),
413  nullptr);
414  std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(),
415  nullptr);
416  Clause->setStep(Step);
417  Clause->setCalcStep(CalcStep);
418  Clause->setPreInitStmt(PreInit);
419  Clause->setPostUpdateExpr(PostUpdate);
420  return Clause;
421 }
422 
424  unsigned NumVars) {
425  // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
426  // (Step and CalcStep).
427  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2));
428  return new (Mem) OMPLinearClause(NumVars);
429 }
430 
433  SourceLocation LParenLoc, SourceLocation ColonLoc,
434  SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) {
435  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
436  OMPAlignedClause *Clause = new (Mem)
437  OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
438  Clause->setVarRefs(VL);
439  Clause->setAlignment(A);
440  return Clause;
441 }
442 
444  unsigned NumVars) {
445  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumVars + 1));
446  return new (Mem) OMPAlignedClause(NumVars);
447 }
448 
449 void OMPCopyinClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
450  assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
451  "not the same as the "
452  "preallocated buffer");
453  std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
454 }
455 
456 void OMPCopyinClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
457  assert(DstExprs.size() == varlist_size() && "Number of destination "
458  "expressions is not the same as "
459  "the preallocated buffer");
460  std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
461 }
462 
463 void OMPCopyinClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
464  assert(AssignmentOps.size() == varlist_size() &&
465  "Number of assignment expressions is not the same as the preallocated "
466  "buffer");
467  std::copy(AssignmentOps.begin(), AssignmentOps.end(),
468  getDestinationExprs().end());
469 }
470 
472  const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
473  SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
474  ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
475  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
476  OMPCopyinClause *Clause =
477  new (Mem) OMPCopyinClause(StartLoc, LParenLoc, EndLoc, VL.size());
478  Clause->setVarRefs(VL);
479  Clause->setSourceExprs(SrcExprs);
480  Clause->setDestinationExprs(DstExprs);
481  Clause->setAssignmentOps(AssignmentOps);
482  return Clause;
483 }
484 
486  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
487  return new (Mem) OMPCopyinClause(N);
488 }
489 
490 void OMPCopyprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
491  assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
492  "not the same as the "
493  "preallocated buffer");
494  std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
495 }
496 
497 void OMPCopyprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
498  assert(DstExprs.size() == varlist_size() && "Number of destination "
499  "expressions is not the same as "
500  "the preallocated buffer");
501  std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
502 }
503 
504 void OMPCopyprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
505  assert(AssignmentOps.size() == varlist_size() &&
506  "Number of assignment expressions is not the same as the preallocated "
507  "buffer");
508  std::copy(AssignmentOps.begin(), AssignmentOps.end(),
509  getDestinationExprs().end());
510 }
511 
513  const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
514  SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
515  ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
516  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
517  OMPCopyprivateClause *Clause =
518  new (Mem) OMPCopyprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
519  Clause->setVarRefs(VL);
520  Clause->setSourceExprs(SrcExprs);
521  Clause->setDestinationExprs(DstExprs);
522  Clause->setAssignmentOps(AssignmentOps);
523  return Clause;
524 }
525 
527  unsigned N) {
528  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
529  return new (Mem) OMPCopyprivateClause(N);
530 }
531 
532 void OMPReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
533  assert(Privates.size() == varlist_size() &&
534  "Number of private copies is not the same as the preallocated buffer");
535  std::copy(Privates.begin(), Privates.end(), varlist_end());
536 }
537 
538 void OMPReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
539  assert(
540  LHSExprs.size() == varlist_size() &&
541  "Number of LHS expressions is not the same as the preallocated buffer");
542  std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
543 }
544 
545 void OMPReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
546  assert(
547  RHSExprs.size() == varlist_size() &&
548  "Number of RHS expressions is not the same as the preallocated buffer");
549  std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
550 }
551 
552 void OMPReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
553  assert(ReductionOps.size() == varlist_size() && "Number of reduction "
554  "expressions is not the same "
555  "as the preallocated buffer");
556  std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
557 }
558 
560  const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
561  SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
562  NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
564  ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
565  Expr *PostUpdate) {
566  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
567  OMPReductionClause *Clause = new (Mem) OMPReductionClause(
568  StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
569  Clause->setVarRefs(VL);
570  Clause->setPrivates(Privates);
571  Clause->setLHSExprs(LHSExprs);
572  Clause->setRHSExprs(RHSExprs);
573  Clause->setReductionOps(ReductionOps);
574  Clause->setPreInitStmt(PreInit);
575  Clause->setPostUpdateExpr(PostUpdate);
576  return Clause;
577 }
578 
580  unsigned N) {
581  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
582  return new (Mem) OMPReductionClause(N);
583 }
584 
585 void OMPTaskReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
586  assert(Privates.size() == varlist_size() &&
587  "Number of private copies is not the same as the preallocated buffer");
588  std::copy(Privates.begin(), Privates.end(), varlist_end());
589 }
590 
591 void OMPTaskReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
592  assert(
593  LHSExprs.size() == varlist_size() &&
594  "Number of LHS expressions is not the same as the preallocated buffer");
595  std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
596 }
597 
598 void OMPTaskReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
599  assert(
600  RHSExprs.size() == varlist_size() &&
601  "Number of RHS expressions is not the same as the preallocated buffer");
602  std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
603 }
604 
605 void OMPTaskReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
606  assert(ReductionOps.size() == varlist_size() && "Number of task reduction "
607  "expressions is not the same "
608  "as the preallocated buffer");
609  std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
610 }
611 
613  const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
614  SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
615  NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
616  ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
617  ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
618  Expr *PostUpdate) {
619  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
621  StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
622  Clause->setVarRefs(VL);
623  Clause->setPrivates(Privates);
624  Clause->setLHSExprs(LHSExprs);
625  Clause->setRHSExprs(RHSExprs);
626  Clause->setReductionOps(ReductionOps);
627  Clause->setPreInitStmt(PreInit);
628  Clause->setPostUpdateExpr(PostUpdate);
629  return Clause;
630 }
631 
633  unsigned N) {
634  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
635  return new (Mem) OMPTaskReductionClause(N);
636 }
637 
638 void OMPInReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
639  assert(Privates.size() == varlist_size() &&
640  "Number of private copies is not the same as the preallocated buffer");
641  std::copy(Privates.begin(), Privates.end(), varlist_end());
642 }
643 
644 void OMPInReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
645  assert(
646  LHSExprs.size() == varlist_size() &&
647  "Number of LHS expressions is not the same as the preallocated buffer");
648  std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
649 }
650 
651 void OMPInReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
652  assert(
653  RHSExprs.size() == varlist_size() &&
654  "Number of RHS expressions is not the same as the preallocated buffer");
655  std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
656 }
657 
658 void OMPInReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
659  assert(ReductionOps.size() == varlist_size() && "Number of in reduction "
660  "expressions is not the same "
661  "as the preallocated buffer");
662  std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
663 }
664 
665 void OMPInReductionClause::setTaskgroupDescriptors(
666  ArrayRef<Expr *> TaskgroupDescriptors) {
667  assert(TaskgroupDescriptors.size() == varlist_size() &&
668  "Number of in reduction descriptors is not the same as the "
669  "preallocated buffer");
670  std::copy(TaskgroupDescriptors.begin(), TaskgroupDescriptors.end(),
671  getReductionOps().end());
672 }
673 
675  const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
676  SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
677  NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
678  ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
679  ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps,
680  ArrayRef<Expr *> TaskgroupDescriptors, Stmt *PreInit, Expr *PostUpdate) {
681  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(6 * VL.size()));
682  OMPInReductionClause *Clause = new (Mem) OMPInReductionClause(
683  StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
684  Clause->setVarRefs(VL);
685  Clause->setPrivates(Privates);
686  Clause->setLHSExprs(LHSExprs);
687  Clause->setRHSExprs(RHSExprs);
688  Clause->setReductionOps(ReductionOps);
689  Clause->setTaskgroupDescriptors(TaskgroupDescriptors);
690  Clause->setPreInitStmt(PreInit);
691  Clause->setPostUpdateExpr(PostUpdate);
692  return Clause;
693 }
694 
696  unsigned N) {
697  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(6 * N));
698  return new (Mem) OMPInReductionClause(N);
699 }
700 
702  SourceLocation StartLoc,
703  SourceLocation LParenLoc,
704  SourceLocation EndLoc,
705  ArrayRef<Expr *> VL) {
706  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
707  OMPFlushClause *Clause =
708  new (Mem) OMPFlushClause(StartLoc, LParenLoc, EndLoc, VL.size());
709  Clause->setVarRefs(VL);
710  return Clause;
711 }
712 
714  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
715  return new (Mem) OMPFlushClause(N);
716 }
717 
720  SourceLocation LParenLoc, SourceLocation EndLoc,
721  OpenMPDependClauseKind DepKind, SourceLocation DepLoc,
722  SourceLocation ColonLoc, ArrayRef<Expr *> VL,
723  unsigned NumLoops) {
724  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + NumLoops));
725  OMPDependClause *Clause = new (Mem)
726  OMPDependClause(StartLoc, LParenLoc, EndLoc, VL.size(), NumLoops);
727  Clause->setVarRefs(VL);
728  Clause->setDependencyKind(DepKind);
729  Clause->setDependencyLoc(DepLoc);
730  Clause->setColonLoc(ColonLoc);
731  for (unsigned I = 0 ; I < NumLoops; ++I)
732  Clause->setLoopData(I, nullptr);
733  return Clause;
734 }
735 
737  unsigned NumLoops) {
738  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N + NumLoops));
739  return new (Mem) OMPDependClause(N, NumLoops);
740 }
741 
742 void OMPDependClause::setLoopData(unsigned NumLoop, Expr *Cnt) {
743  assert((getDependencyKind() == OMPC_DEPEND_sink ||
744  getDependencyKind() == OMPC_DEPEND_source) &&
745  NumLoop < NumLoops &&
746  "Expected sink or source depend + loop index must be less number of "
747  "loops.");
748  auto It = std::next(getVarRefs().end(), NumLoop);
749  *It = Cnt;
750 }
751 
752 Expr *OMPDependClause::getLoopData(unsigned NumLoop) {
753  assert((getDependencyKind() == OMPC_DEPEND_sink ||
754  getDependencyKind() == OMPC_DEPEND_source) &&
755  NumLoop < NumLoops &&
756  "Expected sink or source depend + loop index must be less number of "
757  "loops.");
758  auto It = std::next(getVarRefs().end(), NumLoop);
759  return *It;
760 }
761 
762 const Expr *OMPDependClause::getLoopData(unsigned NumLoop) const {
763  assert((getDependencyKind() == OMPC_DEPEND_sink ||
764  getDependencyKind() == OMPC_DEPEND_source) &&
765  NumLoop < NumLoops &&
766  "Expected sink or source depend + loop index must be less number of "
767  "loops.");
768  auto It = std::next(getVarRefs().end(), NumLoop);
769  return *It;
770 }
771 
773  MappableExprComponentListsRef ComponentLists) {
774  unsigned TotalNum = 0u;
775  for (auto &C : ComponentLists)
776  TotalNum += C.size();
777  return TotalNum;
778 }
779 
781  ArrayRef<const ValueDecl *> Declarations) {
782  unsigned TotalNum = 0u;
783  llvm::SmallPtrSet<const ValueDecl *, 8> Cache;
784  for (const ValueDecl *D : Declarations) {
785  const ValueDecl *VD = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr;
786  if (Cache.count(VD))
787  continue;
788  ++TotalNum;
789  Cache.insert(VD);
790  }
791  return TotalNum;
792 }
793 
794 OMPMapClause *
796  SourceLocation LParenLoc, SourceLocation EndLoc,
797  ArrayRef<Expr *> Vars, ArrayRef<ValueDecl *> Declarations,
798  MappableExprComponentListsRef ComponentLists,
799  ArrayRef<OpenMPMapModifierKind> MapModifiers,
800  ArrayRef<SourceLocation> MapModifiersLoc,
801  OpenMPMapClauseKind Type, bool TypeIsImplicit,
803  unsigned NumVars = Vars.size();
804  unsigned NumUniqueDeclarations =
805  getUniqueDeclarationsTotalNumber(Declarations);
806  unsigned NumComponentLists = ComponentLists.size();
807  unsigned NumComponents = getComponentsTotalNumber(ComponentLists);
808 
809  // We need to allocate:
810  // NumVars x Expr* - we have an original list expression for each clause list
811  // entry.
812  // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
813  // with each component list.
814  // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
815  // number of lists for each unique declaration and the size of each component
816  // list.
817  // NumComponents x MappableComponent - the total of all the components in all
818  // the lists.
819  void *Mem = C.Allocate(
820  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
822  NumVars, NumUniqueDeclarations,
823  NumUniqueDeclarations + NumComponentLists, NumComponents));
824  OMPMapClause *Clause = new (Mem) OMPMapClause(
825  MapModifiers, MapModifiersLoc, Type, TypeIsImplicit, TypeLoc, StartLoc,
826  LParenLoc, EndLoc, NumVars, NumUniqueDeclarations, NumComponentLists,
827  NumComponents);
828 
829  Clause->setVarRefs(Vars);
830  Clause->setClauseInfo(Declarations, ComponentLists);
831  Clause->setMapType(Type);
832  Clause->setMapLoc(TypeLoc);
833  return Clause;
834 }
835 
837  unsigned NumUniqueDeclarations,
838  unsigned NumComponentLists,
839  unsigned NumComponents) {
840  void *Mem = C.Allocate(
841  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
843  NumVars, NumUniqueDeclarations,
844  NumUniqueDeclarations + NumComponentLists, NumComponents));
845  return new (Mem) OMPMapClause(NumVars, NumUniqueDeclarations,
846  NumComponentLists, NumComponents);
847 }
848 
850  SourceLocation LParenLoc,
851  SourceLocation EndLoc, ArrayRef<Expr *> Vars,
852  ArrayRef<ValueDecl *> Declarations,
853  MappableExprComponentListsRef ComponentLists) {
854  unsigned NumVars = Vars.size();
855  unsigned NumUniqueDeclarations =
856  getUniqueDeclarationsTotalNumber(Declarations);
857  unsigned NumComponentLists = ComponentLists.size();
858  unsigned NumComponents = getComponentsTotalNumber(ComponentLists);
859 
860  // We need to allocate:
861  // NumVars x Expr* - we have an original list expression for each clause list
862  // entry.
863  // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
864  // with each component list.
865  // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
866  // number of lists for each unique declaration and the size of each component
867  // list.
868  // NumComponents x MappableComponent - the total of all the components in all
869  // the lists.
870  void *Mem = C.Allocate(
871  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
873  NumVars, NumUniqueDeclarations,
874  NumUniqueDeclarations + NumComponentLists, NumComponents));
875 
876  OMPToClause *Clause = new (Mem)
877  OMPToClause(StartLoc, LParenLoc, EndLoc, NumVars, NumUniqueDeclarations,
878  NumComponentLists, NumComponents);
879 
880  Clause->setVarRefs(Vars);
881  Clause->setClauseInfo(Declarations, ComponentLists);
882  return Clause;
883 }
884 
885 OMPToClause *OMPToClause::CreateEmpty(const ASTContext &C, unsigned NumVars,
886  unsigned NumUniqueDeclarations,
887  unsigned NumComponentLists,
888  unsigned NumComponents) {
889  void *Mem = C.Allocate(
890  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
892  NumVars, NumUniqueDeclarations,
893  NumUniqueDeclarations + NumComponentLists, NumComponents));
894  return new (Mem) OMPToClause(NumVars, NumUniqueDeclarations,
895  NumComponentLists, NumComponents);
896 }
897 
900  SourceLocation LParenLoc, SourceLocation EndLoc,
901  ArrayRef<Expr *> Vars, ArrayRef<ValueDecl *> Declarations,
902  MappableExprComponentListsRef ComponentLists) {
903  unsigned NumVars = Vars.size();
904  unsigned NumUniqueDeclarations =
905  getUniqueDeclarationsTotalNumber(Declarations);
906  unsigned NumComponentLists = ComponentLists.size();
907  unsigned NumComponents = getComponentsTotalNumber(ComponentLists);
908 
909  // We need to allocate:
910  // NumVars x Expr* - we have an original list expression for each clause list
911  // entry.
912  // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
913  // with each component list.
914  // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
915  // number of lists for each unique declaration and the size of each component
916  // list.
917  // NumComponents x MappableComponent - the total of all the components in all
918  // the lists.
919  void *Mem = C.Allocate(
920  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
922  NumVars, NumUniqueDeclarations,
923  NumUniqueDeclarations + NumComponentLists, NumComponents));
924 
925  OMPFromClause *Clause = new (Mem)
926  OMPFromClause(StartLoc, LParenLoc, EndLoc, NumVars, NumUniqueDeclarations,
927  NumComponentLists, NumComponents);
928 
929  Clause->setVarRefs(Vars);
930  Clause->setClauseInfo(Declarations, ComponentLists);
931  return Clause;
932 }
933 
935  unsigned NumUniqueDeclarations,
936  unsigned NumComponentLists,
937  unsigned NumComponents) {
938  void *Mem = C.Allocate(
939  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
941  NumVars, NumUniqueDeclarations,
942  NumUniqueDeclarations + NumComponentLists, NumComponents));
943  return new (Mem) OMPFromClause(NumVars, NumUniqueDeclarations,
944  NumComponentLists, NumComponents);
945 }
946 
947 void OMPUseDevicePtrClause::setPrivateCopies(ArrayRef<Expr *> VL) {
948  assert(VL.size() == varlist_size() &&
949  "Number of private copies is not the same as the preallocated buffer");
950  std::copy(VL.begin(), VL.end(), varlist_end());
951 }
952 
953 void OMPUseDevicePtrClause::setInits(ArrayRef<Expr *> VL) {
954  assert(VL.size() == varlist_size() &&
955  "Number of inits is not the same as the preallocated buffer");
956  std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
957 }
958 
960  const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
961  SourceLocation EndLoc, ArrayRef<Expr *> Vars, ArrayRef<Expr *> PrivateVars,
962  ArrayRef<Expr *> Inits, ArrayRef<ValueDecl *> Declarations,
963  MappableExprComponentListsRef ComponentLists) {
964  unsigned NumVars = Vars.size();
965  unsigned NumUniqueDeclarations =
966  getUniqueDeclarationsTotalNumber(Declarations);
967  unsigned NumComponentLists = ComponentLists.size();
968  unsigned NumComponents = getComponentsTotalNumber(ComponentLists);
969 
970  // We need to allocate:
971  // 3 x NumVars x Expr* - we have an original list expression for each clause
972  // list entry and an equal number of private copies and inits.
973  // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
974  // with each component list.
975  // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
976  // number of lists for each unique declaration and the size of each component
977  // list.
978  // NumComponents x MappableComponent - the total of all the components in all
979  // the lists.
980  void *Mem = C.Allocate(
981  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
983  3 * NumVars, NumUniqueDeclarations,
984  NumUniqueDeclarations + NumComponentLists, NumComponents));
985 
986  OMPUseDevicePtrClause *Clause = new (Mem) OMPUseDevicePtrClause(
987  StartLoc, LParenLoc, EndLoc, NumVars, NumUniqueDeclarations,
988  NumComponentLists, NumComponents);
989 
990  Clause->setVarRefs(Vars);
991  Clause->setPrivateCopies(PrivateVars);
992  Clause->setInits(Inits);
993  Clause->setClauseInfo(Declarations, ComponentLists);
994  return Clause;
995 }
996 
998  const ASTContext &C, unsigned NumVars, unsigned NumUniqueDeclarations,
999  unsigned NumComponentLists, unsigned NumComponents) {
1000  void *Mem = C.Allocate(
1001  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1003  3 * NumVars, NumUniqueDeclarations,
1004  NumUniqueDeclarations + NumComponentLists, NumComponents));
1005  return new (Mem) OMPUseDevicePtrClause(NumVars, NumUniqueDeclarations,
1006  NumComponentLists, NumComponents);
1007 }
1008 
1011  SourceLocation LParenLoc, SourceLocation EndLoc,
1012  ArrayRef<Expr *> Vars,
1013  ArrayRef<ValueDecl *> Declarations,
1014  MappableExprComponentListsRef ComponentLists) {
1015  unsigned NumVars = Vars.size();
1016  unsigned NumUniqueDeclarations =
1017  getUniqueDeclarationsTotalNumber(Declarations);
1018  unsigned NumComponentLists = ComponentLists.size();
1019  unsigned NumComponents = getComponentsTotalNumber(ComponentLists);
1020 
1021  // We need to allocate:
1022  // NumVars x Expr* - we have an original list expression for each clause list
1023  // entry.
1024  // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1025  // with each component list.
1026  // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1027  // number of lists for each unique declaration and the size of each component
1028  // list.
1029  // NumComponents x MappableComponent - the total of all the components in all
1030  // the lists.
1031  void *Mem = C.Allocate(
1032  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1034  NumVars, NumUniqueDeclarations,
1035  NumUniqueDeclarations + NumComponentLists, NumComponents));
1036 
1037  OMPIsDevicePtrClause *Clause = new (Mem) OMPIsDevicePtrClause(
1038  StartLoc, LParenLoc, EndLoc, NumVars, NumUniqueDeclarations,
1039  NumComponentLists, NumComponents);
1040 
1041  Clause->setVarRefs(Vars);
1042  Clause->setClauseInfo(Declarations, ComponentLists);
1043  return Clause;
1044 }
1045 
1047  const ASTContext &C, unsigned NumVars, unsigned NumUniqueDeclarations,
1048  unsigned NumComponentLists, unsigned NumComponents) {
1049  void *Mem = C.Allocate(
1050  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1052  NumVars, NumUniqueDeclarations,
1053  NumUniqueDeclarations + NumComponentLists, NumComponents));
1054  return new (Mem) OMPIsDevicePtrClause(NumVars, NumUniqueDeclarations,
1055  NumComponentLists, NumComponents);
1056 }
1057 
1058 //===----------------------------------------------------------------------===//
1059 // OpenMP clauses printing methods
1060 //===----------------------------------------------------------------------===//
1061 
1062 void OMPClausePrinter::VisitOMPIfClause(OMPIfClause *Node) {
1063  OS << "if(";
1064  if (Node->getNameModifier() != OMPD_unknown)
1065  OS << getOpenMPDirectiveName(Node->getNameModifier()) << ": ";
1066  Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
1067  OS << ")";
1068 }
1069 
1070 void OMPClausePrinter::VisitOMPFinalClause(OMPFinalClause *Node) {
1071  OS << "final(";
1072  Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
1073  OS << ")";
1074 }
1075 
1076 void OMPClausePrinter::VisitOMPNumThreadsClause(OMPNumThreadsClause *Node) {
1077  OS << "num_threads(";
1078  Node->getNumThreads()->printPretty(OS, nullptr, Policy, 0);
1079  OS << ")";
1080 }
1081 
1082 void OMPClausePrinter::VisitOMPSafelenClause(OMPSafelenClause *Node) {
1083  OS << "safelen(";
1084  Node->getSafelen()->printPretty(OS, nullptr, Policy, 0);
1085  OS << ")";
1086 }
1087 
1088 void OMPClausePrinter::VisitOMPSimdlenClause(OMPSimdlenClause *Node) {
1089  OS << "simdlen(";
1090  Node->getSimdlen()->printPretty(OS, nullptr, Policy, 0);
1091  OS << ")";
1092 }
1093 
1094 void OMPClausePrinter::VisitOMPCollapseClause(OMPCollapseClause *Node) {
1095  OS << "collapse(";
1096  Node->getNumForLoops()->printPretty(OS, nullptr, Policy, 0);
1097  OS << ")";
1098 }
1099 
1100 void OMPClausePrinter::VisitOMPDefaultClause(OMPDefaultClause *Node) {
1101  OS << "default("
1102  << getOpenMPSimpleClauseTypeName(OMPC_default, Node->getDefaultKind())
1103  << ")";
1104 }
1105 
1106 void OMPClausePrinter::VisitOMPProcBindClause(OMPProcBindClause *Node) {
1107  OS << "proc_bind("
1108  << getOpenMPSimpleClauseTypeName(OMPC_proc_bind, Node->getProcBindKind())
1109  << ")";
1110 }
1111 
1112 void OMPClausePrinter::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) {
1113  OS << "unified_address";
1114 }
1115 
1116 void OMPClausePrinter::VisitOMPUnifiedSharedMemoryClause(
1118  OS << "unified_shared_memory";
1119 }
1120 
1121 void OMPClausePrinter::VisitOMPReverseOffloadClause(OMPReverseOffloadClause *) {
1122  OS << "reverse_offload";
1123 }
1124 
1125 void OMPClausePrinter::VisitOMPDynamicAllocatorsClause(
1127  OS << "dynamic_allocators";
1128 }
1129 
1130 void OMPClausePrinter::VisitOMPAtomicDefaultMemOrderClause(
1132  OS << "atomic_default_mem_order("
1133  << getOpenMPSimpleClauseTypeName(OMPC_atomic_default_mem_order,
1135  << ")";
1136 }
1137 
1138 void OMPClausePrinter::VisitOMPScheduleClause(OMPScheduleClause *Node) {
1139  OS << "schedule(";
1141  OS << getOpenMPSimpleClauseTypeName(OMPC_schedule,
1142  Node->getFirstScheduleModifier());
1144  OS << ", ";
1145  OS << getOpenMPSimpleClauseTypeName(OMPC_schedule,
1146  Node->getSecondScheduleModifier());
1147  }
1148  OS << ": ";
1149  }
1150  OS << getOpenMPSimpleClauseTypeName(OMPC_schedule, Node->getScheduleKind());
1151  if (auto *E = Node->getChunkSize()) {
1152  OS << ", ";
1153  E->printPretty(OS, nullptr, Policy);
1154  }
1155  OS << ")";
1156 }
1157 
1158 void OMPClausePrinter::VisitOMPOrderedClause(OMPOrderedClause *Node) {
1159  OS << "ordered";
1160  if (auto *Num = Node->getNumForLoops()) {
1161  OS << "(";
1162  Num->printPretty(OS, nullptr, Policy, 0);
1163  OS << ")";
1164  }
1165 }
1166 
1167 void OMPClausePrinter::VisitOMPNowaitClause(OMPNowaitClause *) {
1168  OS << "nowait";
1169 }
1170 
1171 void OMPClausePrinter::VisitOMPUntiedClause(OMPUntiedClause *) {
1172  OS << "untied";
1173 }
1174 
1175 void OMPClausePrinter::VisitOMPNogroupClause(OMPNogroupClause *) {
1176  OS << "nogroup";
1177 }
1178 
1179 void OMPClausePrinter::VisitOMPMergeableClause(OMPMergeableClause *) {
1180  OS << "mergeable";
1181 }
1182 
1183 void OMPClausePrinter::VisitOMPReadClause(OMPReadClause *) { OS << "read"; }
1184 
1185 void OMPClausePrinter::VisitOMPWriteClause(OMPWriteClause *) { OS << "write"; }
1186 
1187 void OMPClausePrinter::VisitOMPUpdateClause(OMPUpdateClause *) {
1188  OS << "update";
1189 }
1190 
1191 void OMPClausePrinter::VisitOMPCaptureClause(OMPCaptureClause *) {
1192  OS << "capture";
1193 }
1194 
1195 void OMPClausePrinter::VisitOMPSeqCstClause(OMPSeqCstClause *) {
1196  OS << "seq_cst";
1197 }
1198 
1199 void OMPClausePrinter::VisitOMPThreadsClause(OMPThreadsClause *) {
1200  OS << "threads";
1201 }
1202 
1203 void OMPClausePrinter::VisitOMPSIMDClause(OMPSIMDClause *) { OS << "simd"; }
1204 
1205 void OMPClausePrinter::VisitOMPDeviceClause(OMPDeviceClause *Node) {
1206  OS << "device(";
1207  Node->getDevice()->printPretty(OS, nullptr, Policy, 0);
1208  OS << ")";
1209 }
1210 
1211 void OMPClausePrinter::VisitOMPNumTeamsClause(OMPNumTeamsClause *Node) {
1212  OS << "num_teams(";
1213  Node->getNumTeams()->printPretty(OS, nullptr, Policy, 0);
1214  OS << ")";
1215 }
1216 
1217 void OMPClausePrinter::VisitOMPThreadLimitClause(OMPThreadLimitClause *Node) {
1218  OS << "thread_limit(";
1219  Node->getThreadLimit()->printPretty(OS, nullptr, Policy, 0);
1220  OS << ")";
1221 }
1222 
1223 void OMPClausePrinter::VisitOMPPriorityClause(OMPPriorityClause *Node) {
1224  OS << "priority(";
1225  Node->getPriority()->printPretty(OS, nullptr, Policy, 0);
1226  OS << ")";
1227 }
1228 
1229 void OMPClausePrinter::VisitOMPGrainsizeClause(OMPGrainsizeClause *Node) {
1230  OS << "grainsize(";
1231  Node->getGrainsize()->printPretty(OS, nullptr, Policy, 0);
1232  OS << ")";
1233 }
1234 
1235 void OMPClausePrinter::VisitOMPNumTasksClause(OMPNumTasksClause *Node) {
1236  OS << "num_tasks(";
1237  Node->getNumTasks()->printPretty(OS, nullptr, Policy, 0);
1238  OS << ")";
1239 }
1240 
1241 void OMPClausePrinter::VisitOMPHintClause(OMPHintClause *Node) {
1242  OS << "hint(";
1243  Node->getHint()->printPretty(OS, nullptr, Policy, 0);
1244  OS << ")";
1245 }
1246 
1247 template<typename T>
1248 void OMPClausePrinter::VisitOMPClauseList(T *Node, char StartSym) {
1249  for (typename T::varlist_iterator I = Node->varlist_begin(),
1250  E = Node->varlist_end();
1251  I != E; ++I) {
1252  assert(*I && "Expected non-null Stmt");
1253  OS << (I == Node->varlist_begin() ? StartSym : ',');
1254  if (auto *DRE = dyn_cast<DeclRefExpr>(*I)) {
1255  if (isa<OMPCapturedExprDecl>(DRE->getDecl()))
1256  DRE->printPretty(OS, nullptr, Policy, 0);
1257  else
1258  DRE->getDecl()->printQualifiedName(OS);
1259  } else
1260  (*I)->printPretty(OS, nullptr, Policy, 0);
1261  }
1262 }
1263 
1264 void OMPClausePrinter::VisitOMPPrivateClause(OMPPrivateClause *Node) {
1265  if (!Node->varlist_empty()) {
1266  OS << "private";
1267  VisitOMPClauseList(Node, '(');
1268  OS << ")";
1269  }
1270 }
1271 
1272 void OMPClausePrinter::VisitOMPFirstprivateClause(OMPFirstprivateClause *Node) {
1273  if (!Node->varlist_empty()) {
1274  OS << "firstprivate";
1275  VisitOMPClauseList(Node, '(');
1276  OS << ")";
1277  }
1278 }
1279 
1280 void OMPClausePrinter::VisitOMPLastprivateClause(OMPLastprivateClause *Node) {
1281  if (!Node->varlist_empty()) {
1282  OS << "lastprivate";
1283  VisitOMPClauseList(Node, '(');
1284  OS << ")";
1285  }
1286 }
1287 
1288 void OMPClausePrinter::VisitOMPSharedClause(OMPSharedClause *Node) {
1289  if (!Node->varlist_empty()) {
1290  OS << "shared";
1291  VisitOMPClauseList(Node, '(');
1292  OS << ")";
1293  }
1294 }
1295 
1296 void OMPClausePrinter::VisitOMPReductionClause(OMPReductionClause *Node) {
1297  if (!Node->varlist_empty()) {
1298  OS << "reduction(";
1299  NestedNameSpecifier *QualifierLoc =
1303  if (QualifierLoc == nullptr && OOK != OO_None) {
1304  // Print reduction identifier in C format
1305  OS << getOperatorSpelling(OOK);
1306  } else {
1307  // Use C++ format
1308  if (QualifierLoc != nullptr)
1309  QualifierLoc->print(OS, Policy);
1310  OS << Node->getNameInfo();
1311  }
1312  OS << ":";
1313  VisitOMPClauseList(Node, ' ');
1314  OS << ")";
1315  }
1316 }
1317 
1318 void OMPClausePrinter::VisitOMPTaskReductionClause(
1319  OMPTaskReductionClause *Node) {
1320  if (!Node->varlist_empty()) {
1321  OS << "task_reduction(";
1322  NestedNameSpecifier *QualifierLoc =
1326  if (QualifierLoc == nullptr && OOK != OO_None) {
1327  // Print reduction identifier in C format
1328  OS << getOperatorSpelling(OOK);
1329  } else {
1330  // Use C++ format
1331  if (QualifierLoc != nullptr)
1332  QualifierLoc->print(OS, Policy);
1333  OS << Node->getNameInfo();
1334  }
1335  OS << ":";
1336  VisitOMPClauseList(Node, ' ');
1337  OS << ")";
1338  }
1339 }
1340 
1341 void OMPClausePrinter::VisitOMPInReductionClause(OMPInReductionClause *Node) {
1342  if (!Node->varlist_empty()) {
1343  OS << "in_reduction(";
1344  NestedNameSpecifier *QualifierLoc =
1348  if (QualifierLoc == nullptr && OOK != OO_None) {
1349  // Print reduction identifier in C format
1350  OS << getOperatorSpelling(OOK);
1351  } else {
1352  // Use C++ format
1353  if (QualifierLoc != nullptr)
1354  QualifierLoc->print(OS, Policy);
1355  OS << Node->getNameInfo();
1356  }
1357  OS << ":";
1358  VisitOMPClauseList(Node, ' ');
1359  OS << ")";
1360  }
1361 }
1362 
1363 void OMPClausePrinter::VisitOMPLinearClause(OMPLinearClause *Node) {
1364  if (!Node->varlist_empty()) {
1365  OS << "linear";
1366  if (Node->getModifierLoc().isValid()) {
1367  OS << '('
1368  << getOpenMPSimpleClauseTypeName(OMPC_linear, Node->getModifier());
1369  }
1370  VisitOMPClauseList(Node, '(');
1371  if (Node->getModifierLoc().isValid())
1372  OS << ')';
1373  if (Node->getStep() != nullptr) {
1374  OS << ": ";
1375  Node->getStep()->printPretty(OS, nullptr, Policy, 0);
1376  }
1377  OS << ")";
1378  }
1379 }
1380 
1381 void OMPClausePrinter::VisitOMPAlignedClause(OMPAlignedClause *Node) {
1382  if (!Node->varlist_empty()) {
1383  OS << "aligned";
1384  VisitOMPClauseList(Node, '(');
1385  if (Node->getAlignment() != nullptr) {
1386  OS << ": ";
1387  Node->getAlignment()->printPretty(OS, nullptr, Policy, 0);
1388  }
1389  OS << ")";
1390  }
1391 }
1392 
1393 void OMPClausePrinter::VisitOMPCopyinClause(OMPCopyinClause *Node) {
1394  if (!Node->varlist_empty()) {
1395  OS << "copyin";
1396  VisitOMPClauseList(Node, '(');
1397  OS << ")";
1398  }
1399 }
1400 
1401 void OMPClausePrinter::VisitOMPCopyprivateClause(OMPCopyprivateClause *Node) {
1402  if (!Node->varlist_empty()) {
1403  OS << "copyprivate";
1404  VisitOMPClauseList(Node, '(');
1405  OS << ")";
1406  }
1407 }
1408 
1409 void OMPClausePrinter::VisitOMPFlushClause(OMPFlushClause *Node) {
1410  if (!Node->varlist_empty()) {
1411  VisitOMPClauseList(Node, '(');
1412  OS << ")";
1413  }
1414 }
1415 
1416 void OMPClausePrinter::VisitOMPDependClause(OMPDependClause *Node) {
1417  OS << "depend(";
1418  OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(),
1419  Node->getDependencyKind());
1420  if (!Node->varlist_empty()) {
1421  OS << " :";
1422  VisitOMPClauseList(Node, ' ');
1423  }
1424  OS << ")";
1425 }
1426 
1427 void OMPClausePrinter::VisitOMPMapClause(OMPMapClause *Node) {
1428  if (!Node->varlist_empty()) {
1429  OS << "map(";
1430  if (Node->getMapType() != OMPC_MAP_unknown) {
1431  for (unsigned I = 0; I < OMPMapClause::NumberOfModifiers; ++I) {
1433  OS << getOpenMPSimpleClauseTypeName(OMPC_map,
1434  Node->getMapTypeModifier(I));
1435  OS << ',';
1436  }
1437  }
1438  OS << getOpenMPSimpleClauseTypeName(OMPC_map, Node->getMapType());
1439  OS << ':';
1440  }
1441  VisitOMPClauseList(Node, ' ');
1442  OS << ")";
1443  }
1444 }
1445 
1446 void OMPClausePrinter::VisitOMPToClause(OMPToClause *Node) {
1447  if (!Node->varlist_empty()) {
1448  OS << "to";
1449  VisitOMPClauseList(Node, '(');
1450  OS << ")";
1451  }
1452 }
1453 
1454 void OMPClausePrinter::VisitOMPFromClause(OMPFromClause *Node) {
1455  if (!Node->varlist_empty()) {
1456  OS << "from";
1457  VisitOMPClauseList(Node, '(');
1458  OS << ")";
1459  }
1460 }
1461 
1462 void OMPClausePrinter::VisitOMPDistScheduleClause(OMPDistScheduleClause *Node) {
1463  OS << "dist_schedule(" << getOpenMPSimpleClauseTypeName(
1464  OMPC_dist_schedule, Node->getDistScheduleKind());
1465  if (auto *E = Node->getChunkSize()) {
1466  OS << ", ";
1467  E->printPretty(OS, nullptr, Policy);
1468  }
1469  OS << ")";
1470 }
1471 
1472 void OMPClausePrinter::VisitOMPDefaultmapClause(OMPDefaultmapClause *Node) {
1473  OS << "defaultmap(";
1474  OS << getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
1475  Node->getDefaultmapModifier());
1476  OS << ": ";
1477  OS << getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
1478  Node->getDefaultmapKind());
1479  OS << ")";
1480 }
1481 
1482 void OMPClausePrinter::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *Node) {
1483  if (!Node->varlist_empty()) {
1484  OS << "use_device_ptr";
1485  VisitOMPClauseList(Node, '(');
1486  OS << ")";
1487  }
1488 }
1489 
1490 void OMPClausePrinter::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *Node) {
1491  if (!Node->varlist_empty()) {
1492  OS << "is_device_ptr";
1493  VisitOMPClauseList(Node, '(');
1494  OS << ")";
1495  }
1496 }
1497 
static OMPTaskReductionClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, ArrayRef< Expr *> Privates, ArrayRef< Expr *> LHSExprs, ArrayRef< Expr *> RHSExprs, ArrayRef< Expr *> ReductionOps, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL.
Defines the clang::ASTContext interface.
This represents &#39;thread_limit&#39; clause in the &#39;#pragma omp ...&#39; directive.
static OMPCopyinClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
This represents clause &#39;copyin&#39; in the &#39;#pragma omp ...&#39; directives.
static OMPUseDevicePtrClause * CreateEmpty(const ASTContext &C, unsigned NumVars, unsigned NumUniqueDeclarations, unsigned NumComponentLists, unsigned NumComponents)
Creates an empty clause with the place for NumVars variables.
bool varlist_empty() const
Definition: OpenMPClause.h:205
This represents &#39;atomic_default_mem_order&#39; clause in the &#39;#pragma omp requires&#39; directive.
Definition: OpenMPClause.h:870
static OMPCopyprivateClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> SrcExprs, ArrayRef< Expr *> DstExprs, ArrayRef< Expr *> AssignmentOps)
Creates clause with a list of variables VL.
TypePropertyCache< Private > Cache
Definition: Type.cpp:3494
static OMPClauseWithPreInit * get(OMPClause *C)
Stmt - This represents one statement.
Definition: Stmt.h:66
This represents clause &#39;in_reduction&#39; in the &#39;#pragma omp task&#39; directives.
Expr * getLoopData(unsigned NumLoop)
Get the loop data.
Class that handles pre-initialization statement for some clauses, like &#39;shedule&#39;, &#39;firstprivate&#39; etc...
Definition: OpenMPClause.h:99
static OMPFirstprivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
static OMPUseDevicePtrClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr *> Vars, ArrayRef< Expr *> PrivateVars, ArrayRef< Expr *> Inits, ArrayRef< ValueDecl *> Declarations, MappableExprComponentListsRef ComponentLists)
Creates clause with a list of variables Vars.
This represents &#39;grainsize&#39; clause in the &#39;#pragma omp ...&#39; directive.
static constexpr unsigned NumberOfModifiers
Number of allowed map-type-modifiers.
This represents &#39;if&#39; clause in the &#39;#pragma omp ...&#39; directive.
Definition: OpenMPClause.h:240
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
static OMPMapClause * CreateEmpty(const ASTContext &C, unsigned NumVars, unsigned NumUniqueDeclarations, unsigned NumComponentLists, unsigned NumComponents)
Creates an empty clause with the place for NumVars original expressions, NumUniqueDeclarations declar...
This represents &#39;priority&#39; clause in the &#39;#pragma omp ...&#39; directive.
The base class of the type hierarchy.
Definition: Type.h:1407
const char * getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, unsigned Type)
Expr * getCondition() const
Returns condition.
Definition: OpenMPClause.h:365
This represents &#39;update&#39; clause in the &#39;#pragma omp atomic&#39; directive.
Expr * getCondition() const
Returns condition.
Definition: OpenMPClause.h:308
Expr * getAlignment()
Returns alignment.
Expr * getNumForLoops() const
Return the number of associated for-loops.
OpenMPMapModifierKind getMapTypeModifier(unsigned Cnt) const LLVM_READONLY
Fetches the map-type-modifier at &#39;Cnt&#39; index of array of modifiers.
static OMPReductionClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents &#39;read&#39; clause in the &#39;#pragma omp atomic&#39; directive.
static OMPToClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr *> Vars, ArrayRef< ValueDecl *> Declarations, MappableExprComponentListsRef ComponentLists)
Creates clause with a list of variables Vars.
This represents clause &#39;private&#39; in the &#39;#pragma omp ...&#39; directives.
static OMPMapClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr *> Vars, ArrayRef< ValueDecl *> Declarations, MappableExprComponentListsRef ComponentLists, ArrayRef< OpenMPMapModifierKind > MapModifiers, ArrayRef< SourceLocation > MapModifiersLoc, OpenMPMapClauseKind Type, bool TypeIsImplicit, SourceLocation TypeLoc)
Creates clause with a list of variables VL.
This represents &#39;num_threads&#39; clause in the &#39;#pragma omp ...&#39; directive.
Definition: OpenMPClause.h:382
This represents &#39;defaultmap&#39; clause in the &#39;#pragma omp ...&#39; directive.
void setUpdates(ArrayRef< Expr *> UL)
Sets the list of update expressions for linear variables.
This represents implicit clause &#39;flush&#39; for the &#39;#pragma omp flush&#39; directive.
const DeclarationNameInfo & getNameInfo() const
Gets the name info for specified reduction identifier.
This represents &#39;reverse_offload&#39; clause in the &#39;#pragma omp requires&#39; directive. ...
Definition: OpenMPClause.h:807
static OMPTaskReductionClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
Expr * getGrainsize() const
Return safe iteration space distance.
This represents &#39;nogroup&#39; clause in the &#39;#pragma omp ...&#39; directive.
This represents &#39;safelen&#39; clause in the &#39;#pragma omp ...&#39; directive.
Definition: OpenMPClause.h:447
static OMPOrderedClause * CreateEmpty(const ASTContext &C, unsigned NumLoops)
Build an empty clause.
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:57
static OMPReductionClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, ArrayRef< Expr *> Privates, ArrayRef< Expr *> LHSExprs, ArrayRef< Expr *> RHSExprs, ArrayRef< Expr *> ReductionOps, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL.
CalcStep
Definition: OpenMPClause.h:152
static OMPIsDevicePtrClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr *> Vars, ArrayRef< ValueDecl *> Declarations, MappableExprComponentListsRef ComponentLists)
Creates clause with a list of variables Vars.
Step
Definition: OpenMPClause.h:152
static OMPInReductionClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, 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)
Creates clause with a list of variables VL.
clang::OMPLinearClause OMPVarListClause, OMPClauseWithPostUpdate, llvm::TrailingObjects getPrivates()
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:155
A C++ nested-name-specifier augmented with source location information.
This represents &#39;simd&#39; clause in the &#39;#pragma omp ...&#39; directive.
OpenMPLinearClauseKind
OpenMP attributes for &#39;linear&#39; clause.
Definition: OpenMPKinds.h:84
This represents clause &#39;lastprivate&#39; in the &#39;#pragma omp ...&#39; directives.
void setLoopNumIterations(unsigned NumLoop, Expr *NumIterations)
Set number of iterations for the specified loop.
Expr * getChunkSize()
Get chunk size.
This represents clause &#39;map&#39; in the &#39;#pragma omp ...&#39; directives.
This represents clause &#39;to&#39; in the &#39;#pragma omp ...&#39; directives.
Expr * getSafelen() const
Return safe iteration space distance.
Definition: OpenMPClause.h:481
Expr * getNumTeams()
Return NumTeams number.
This represents clause &#39;copyprivate&#39; in the &#39;#pragma omp ...&#39; directives.
void setLoopCounter(unsigned NumLoop, Expr *Counter)
Set loop counter for the specified loop.
NestedNameSpecifierLoc getQualifierLoc() const
Gets the nested name specifier.
static OMPIsDevicePtrClause * CreateEmpty(const ASTContext &C, unsigned NumVars, unsigned NumUniqueDeclarations, unsigned NumComponentLists, unsigned NumComponents)
Creates an empty clause with the place for NumVars variables.
static OMPInReductionClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
static OMPLastprivateClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> SrcExprs, ArrayRef< Expr *> DstExprs, ArrayRef< Expr *> AssignmentOps, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL.
static unsigned getComponentsTotalNumber(MappableExprComponentListsRef ComponentLists)
static OMPToClause * CreateEmpty(const ASTContext &C, unsigned NumVars, unsigned NumUniqueDeclarations, unsigned NumComponentLists, unsigned NumComponents)
Creates an empty clause with the place for NumVars variables.
Class that handles post-update expression for some clauses, like &#39;lastprivate&#39;, &#39;reduction&#39; etc...
Definition: OpenMPClause.h:135
This represents &#39;default&#39; clause in the &#39;#pragma omp ...&#39; directive.
Definition: OpenMPClause.h:606
This represents &#39;final&#39; clause in the &#39;#pragma omp ...&#39; directive.
Definition: OpenMPClause.h:330
This represents &#39;mergeable&#39; clause in the &#39;#pragma omp ...&#39; directive.
OpenMPDependClauseKind getDependencyKind() const
Get dependency type.
This represents clause &#39;reduction&#39; in the &#39;#pragma omp ...&#39; directives.
void setPrivates(ArrayRef< Expr *> PL)
Sets the list of the copies of original linear variables.
This represents clause &#39;is_device_ptr&#39; in the &#39;#pragma omp ...&#39; directives.
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool ResolveTemplateArguments=false) const
Print this nested name specifier to the given output stream.
void setFinals(ArrayRef< Expr *> FL)
Sets the list of final update expressions for linear variables.
static OMPCopyinClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> SrcExprs, ArrayRef< Expr *> DstExprs, ArrayRef< Expr *> AssignmentOps)
Creates clause with a list of variables VL.
static OMPDependClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, OpenMPDependClauseKind DepKind, SourceLocation DepLoc, SourceLocation ColonLoc, ArrayRef< Expr *> VL, unsigned NumLoops)
Creates clause with a list of variables VL.
This represents clause &#39;from&#39; in the &#39;#pragma omp ...&#39; directives.
child_range children()
This represents &#39;dynamic_allocators&#39; clause in the &#39;#pragma omp requires&#39; directive.
Definition: OpenMPClause.h:838
OpenMPDefaultClauseKind getDefaultKind() const
Returns kind of the clause.
Definition: OpenMPClause.h:653
OMPLinearClause(SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, unsigned NumVars)
Build &#39;linear&#39; clause with given number of variables NumVars.
Definition: OpenMPClause.h:123
This represents &#39;threads&#39; clause in the &#39;#pragma omp ...&#39; directive.
Expr * getSimdlen() const
Return safe iteration space distance.
Definition: OpenMPClause.h:535
This represents clause &#39;aligned&#39; in the &#39;#pragma omp ...&#39; directives.
OpenMPClauseKind getClauseKind() const
Returns kind of OpenMP clause (private, shared, reduction, etc.).
Definition: OpenMPClause.h:79
static OMPAlignedClause * CreateEmpty(const ASTContext &C, unsigned NumVars)
Creates an empty clause with the place for NumVars variables.
static OMPOrderedClause * Create(const ASTContext &C, Expr *Num, unsigned NumLoops, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Build &#39;ordered&#39; clause.
This represents clause &#39;task_reduction&#39; in the &#39;#pragma omp taskgroup&#39; directives.
OpenMPProcBindClauseKind getProcBindKind() const
Returns kind of the clause.
Definition: OpenMPClause.h:723
This represents implicit clause &#39;depend&#39; for the &#39;#pragma omp task&#39; directive.
This represents &#39;proc_bind&#39; clause in the &#39;#pragma omp ...&#39; directive.
Definition: OpenMPClause.h:675
This represents &#39;capture&#39; clause in the &#39;#pragma omp atomic&#39; directive.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:637
This represents one expression.
Definition: Expr.h:106
This represents &#39;simdlen&#39; clause in the &#39;#pragma omp ...&#39; directive.
Definition: OpenMPClause.h:501
MutableArrayRef< Expr * > getUpdates()
Sets the list of update expressions for linear variables.
Expr * getNumTasks() const
Return safe iteration space distance.
Inits[]
Definition: OpenMPClause.h:151
static OMPDependClause * CreateEmpty(const ASTContext &C, unsigned N, unsigned NumLoops)
Creates an empty clause with N variables.
OpenMPDistScheduleClauseKind getDistScheduleKind() const
Get kind of the clause.
This represents &#39;ordered&#39; clause in the &#39;#pragma omp ...&#39; directive.
static OMPFlushClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
static OMPLinearClause * CreateEmpty(const ASTContext &C, unsigned NumVars)
Creates an empty clause with the place for NumVars variables.
Expr * getDevice()
Return device number.
static OMPPrivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
This represents &#39;collapse&#39; clause in the &#39;#pragma omp ...&#39; directive.
Definition: OpenMPClause.h:555
This represents clause &#39;firstprivate&#39; in the &#39;#pragma omp ...&#39; directives.
This file defines OpenMP AST classes for clauses.
ArrayRef< Expr * > getLoopNumIterations() const
Get number of iterations for all the loops.
This represents &#39;seq_cst&#39; clause in the &#39;#pragma omp atomic&#39; directive.
This represents &#39;untied&#39; clause in the &#39;#pragma omp ...&#39; directive.
This represents &#39;unified_address&#39; clause in the &#39;#pragma omp requires&#39; directive. ...
Definition: OpenMPClause.h:745
void setPostUpdateExpr(Expr *S)
Set pre-initialization statement for the clause.
Definition: OpenMPClause.h:147
This represents &#39;num_teams&#39; clause in the &#39;#pragma omp ...&#39; directive.
llvm::iterator_range< child_iterator > child_range
Definition: OpenMPClause.h:85
Encodes a location in the source.
This represents &#39;hint&#39; clause in the &#39;#pragma omp ...&#39; directive.
OpenMPDependClauseKind
OpenMP attributes for &#39;depend&#39; clause.
Definition: OpenMPKinds.h:76
MutableArrayRef< Expr * > getInits()
DeclarationName getName() const
getName - Returns the embedded declaration name.
This represents &#39;schedule&#39; clause in the &#39;#pragma omp ...&#39; directive.
Definition: OpenMPClause.h:948
This represents clause &#39;shared&#39; in the &#39;#pragma omp ...&#39; directives.
Expr * getPriority()
Return Priority number.
OpenMPLinearClauseKind Modifier
Modifier of &#39;linear&#39; clause.
Definition: OpenMPClause.h:102
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
OpenMPMapClauseKind getMapType() const LLVM_READONLY
Fetches mapping kind for the clause.
This file defines OpenMP nodes for declarative directives.
static OMPSharedClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL)
Creates clause with a list of variables VL.
Expr * getLoopCounter(unsigned NumLoop)
Get loops counter for the specified loop.
void setPrivateCopies(ArrayRef< Expr *> PrivateCopies)
Set list of helper expressions, required for generation of private copies of original lastprivate var...
This is a basic class for representing single OpenMP clause.
Definition: OpenMPClause.h:51
void setVarRefs(ArrayRef< Expr *> VL)
Sets the list of variables for this clause.
Definition: OpenMPClause.h:191
Expr * getNumForLoops() const
Return the number of associated for-loops.
Definition: OpenMPClause.h:590
static OMPAlignedClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, Expr *A)
Creates clause with a list of variables VL and alignment A.
static OMPPrivateClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> PrivateVL)
Creates clause with a list of variables VL.
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:669
ast_type_traits::DynTypedNode Node
Dataflow Directional Tag Classes.
This represents &#39;device&#39; clause in the &#39;#pragma omp ...&#39; directive.
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
OpenMPDefaultmapClauseKind getDefaultmapKind() const
Get kind of the clause.
SourceLocation ModifierLoc
Location of linear modifier if any.
Definition: OpenMPClause.h:105
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
This represents &#39;unified_shared_memory&#39; clause in the &#39;#pragma omp requires&#39; directive.
Definition: OpenMPClause.h:776
This represents clause &#39;linear&#39; in the &#39;#pragma omp ...&#39; directives.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
OpenMPDefaultmapClauseModifier getDefaultmapModifier() const
Get the modifier of the clause.
static OMPFirstprivateClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> PrivateVL, ArrayRef< Expr *> InitVL, Stmt *PreInit)
Creates clause with a list of variables VL.
ArrayRef< MappableExprComponentList > MappableExprComponentListsRef
static OMPSharedClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
static OMPFromClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr *> Vars, ArrayRef< ValueDecl *> Declarations, MappableExprComponentListsRef ComponentLists)
Creates clause with a list of variables Vars.
Class that represents a component of a mappable expression.
Not an overloaded operator.
Definition: OperatorKinds.h:23
static unsigned getUniqueDeclarationsTotalNumber(ArrayRef< const ValueDecl *> Declarations)
OpenMPDirectiveKind getNameModifier() const
Return directive name modifier associated with the clause.
Definition: OpenMPClause.h:311
static OMPCopyprivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with N variables.
const char * getOperatorSpelling(OverloadedOperatorKind Operator)
Retrieve the spelling of the given overloaded operator, without the preceding "operator" keyword...
const DeclarationNameInfo & getNameInfo() const
Gets the name info for specified reduction identifier.
This represents &#39;write&#39; clause in the &#39;#pragma omp atomic&#39; directive.
const char * getOpenMPDirectiveName(OpenMPDirectiveKind Kind)
Definition: OpenMPKinds.cpp:31
void setLoopData(unsigned NumLoop, Expr *Cnt)
Set the loop data for the depend clauses with &#39;sink|source&#39; kind of dependency.
void setClauseInfo(ArrayRef< ValueDecl *> Declarations, MappableExprComponentListsRef ComponentLists)
Fill the clause information from the list of declarations and associated component lists...
const DeclarationNameInfo & getNameInfo() const
Gets the name info for specified reduction identifier.
OpenMPScheduleClauseModifier getSecondScheduleModifier() const
Get the second modifier of the clause.
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\, const ASTContext *Context=nullptr) const
This represents &#39;nowait&#39; clause in the &#39;#pragma omp ...&#39; directive.
OpenMPScheduleClauseModifier getFirstScheduleModifier() const
Get the first modifier of the clause.
This represents &#39;num_tasks&#39; clause in the &#39;#pragma omp ...&#39; directive.
OpenMPScheduleClauseKind getScheduleKind() const
Get kind of the clause.
Privates[]
Gets the list of initial values for linear variables.
Definition: OpenMPClause.h:151
OpenMPMapClauseKind
OpenMP mapping kind for &#39;map&#39; clause.
Definition: OpenMPKinds.h:92
Expr * getThreadLimit()
Return ThreadLimit number.
void setPreInitStmt(Stmt *S, OpenMPDirectiveKind ThisRegion=OMPD_unknown)
Set pre-initialization statement for the clause.
Definition: OpenMPClause.h:114
This represents &#39;dist_schedule&#39; clause in the &#39;#pragma omp ...&#39; directive.
static OMPFromClause * CreateEmpty(const ASTContext &C, unsigned NumVars, unsigned NumUniqueDeclarations, unsigned NumComponentLists, unsigned NumComponents)
Creates an empty clause with the place for NumVars variables.
Expr * getHint() const
Returns number of threads.
NestedNameSpecifierLoc getQualifierLoc() const
Gets the nested name specifier.
void setInits(ArrayRef< Expr *> IL)
Sets the list of the initial values for linear variables.
NestedNameSpecifierLoc getQualifierLoc() const
Gets the nested name specifier.
Expr * getChunkSize()
Get chunk size.
static OMPFlushClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL)
Creates clause with a list of variables VL.
Expr * getNumThreads() const
Returns number of threads.
Definition: OpenMPClause.h:426
static OMPClauseWithPostUpdate * get(OMPClause *C)
static OMPLastprivateClause * CreateEmpty(const ASTContext &C, unsigned N)
Creates an empty clause with the place for N variables.
OpenMPAtomicDefaultMemOrderClauseKind getAtomicDefaultMemOrderKind() const
Returns kind of the clause.
Definition: OpenMPClause.h:925
SourceLocation ColonLoc
Location of &#39;:&#39;.
Definition: OpenMPClause.h:108
This represents clause &#39;use_device_ptr&#39; in the &#39;#pragma omp ...&#39; directives.
static OMPLinearClause * 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)
Creates clause with a list of variables VL and a linear step Step.