clang  8.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,
800  bool TypeIsImplicit, SourceLocation TypeLoc) {
801  unsigned NumVars = Vars.size();
802  unsigned NumUniqueDeclarations =
803  getUniqueDeclarationsTotalNumber(Declarations);
804  unsigned NumComponentLists = ComponentLists.size();
805  unsigned NumComponents = getComponentsTotalNumber(ComponentLists);
806 
807  // We need to allocate:
808  // NumVars x Expr* - we have an original list expression for each clause list
809  // entry.
810  // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
811  // with each component list.
812  // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
813  // number of lists for each unique declaration and the size of each component
814  // list.
815  // NumComponents x MappableComponent - the total of all the components in all
816  // the lists.
817  void *Mem = C.Allocate(
818  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
820  NumVars, NumUniqueDeclarations,
821  NumUniqueDeclarations + NumComponentLists, NumComponents));
822  OMPMapClause *Clause = new (Mem) OMPMapClause(
823  TypeModifier, Type, TypeIsImplicit, TypeLoc, StartLoc, LParenLoc, EndLoc,
824  NumVars, NumUniqueDeclarations, NumComponentLists, NumComponents);
825 
826  Clause->setVarRefs(Vars);
827  Clause->setClauseInfo(Declarations, ComponentLists);
828  Clause->setMapTypeModifier(TypeModifier);
829  Clause->setMapType(Type);
830  Clause->setMapLoc(TypeLoc);
831  return Clause;
832 }
833 
835  unsigned NumUniqueDeclarations,
836  unsigned NumComponentLists,
837  unsigned NumComponents) {
838  void *Mem = C.Allocate(
839  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
841  NumVars, NumUniqueDeclarations,
842  NumUniqueDeclarations + NumComponentLists, NumComponents));
843  return new (Mem) OMPMapClause(NumVars, NumUniqueDeclarations,
844  NumComponentLists, NumComponents);
845 }
846 
848  SourceLocation LParenLoc,
849  SourceLocation EndLoc, ArrayRef<Expr *> Vars,
850  ArrayRef<ValueDecl *> Declarations,
851  MappableExprComponentListsRef ComponentLists) {
852  unsigned NumVars = Vars.size();
853  unsigned NumUniqueDeclarations =
854  getUniqueDeclarationsTotalNumber(Declarations);
855  unsigned NumComponentLists = ComponentLists.size();
856  unsigned NumComponents = getComponentsTotalNumber(ComponentLists);
857 
858  // We need to allocate:
859  // NumVars x Expr* - we have an original list expression for each clause list
860  // entry.
861  // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
862  // with each component list.
863  // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
864  // number of lists for each unique declaration and the size of each component
865  // list.
866  // NumComponents x MappableComponent - the total of all the components in all
867  // the lists.
868  void *Mem = C.Allocate(
869  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
871  NumVars, NumUniqueDeclarations,
872  NumUniqueDeclarations + NumComponentLists, NumComponents));
873 
874  OMPToClause *Clause = new (Mem)
875  OMPToClause(StartLoc, LParenLoc, EndLoc, NumVars, NumUniqueDeclarations,
876  NumComponentLists, NumComponents);
877 
878  Clause->setVarRefs(Vars);
879  Clause->setClauseInfo(Declarations, ComponentLists);
880  return Clause;
881 }
882 
883 OMPToClause *OMPToClause::CreateEmpty(const ASTContext &C, unsigned NumVars,
884  unsigned NumUniqueDeclarations,
885  unsigned NumComponentLists,
886  unsigned NumComponents) {
887  void *Mem = C.Allocate(
888  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
890  NumVars, NumUniqueDeclarations,
891  NumUniqueDeclarations + NumComponentLists, NumComponents));
892  return new (Mem) OMPToClause(NumVars, NumUniqueDeclarations,
893  NumComponentLists, NumComponents);
894 }
895 
898  SourceLocation LParenLoc, SourceLocation EndLoc,
899  ArrayRef<Expr *> Vars, ArrayRef<ValueDecl *> Declarations,
900  MappableExprComponentListsRef ComponentLists) {
901  unsigned NumVars = Vars.size();
902  unsigned NumUniqueDeclarations =
903  getUniqueDeclarationsTotalNumber(Declarations);
904  unsigned NumComponentLists = ComponentLists.size();
905  unsigned NumComponents = getComponentsTotalNumber(ComponentLists);
906 
907  // We need to allocate:
908  // NumVars x Expr* - we have an original list expression for each clause list
909  // entry.
910  // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
911  // with each component list.
912  // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
913  // number of lists for each unique declaration and the size of each component
914  // list.
915  // NumComponents x MappableComponent - the total of all the components in all
916  // the lists.
917  void *Mem = C.Allocate(
918  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
920  NumVars, NumUniqueDeclarations,
921  NumUniqueDeclarations + NumComponentLists, NumComponents));
922 
923  OMPFromClause *Clause = new (Mem)
924  OMPFromClause(StartLoc, LParenLoc, EndLoc, NumVars, NumUniqueDeclarations,
925  NumComponentLists, NumComponents);
926 
927  Clause->setVarRefs(Vars);
928  Clause->setClauseInfo(Declarations, ComponentLists);
929  return Clause;
930 }
931 
933  unsigned NumUniqueDeclarations,
934  unsigned NumComponentLists,
935  unsigned NumComponents) {
936  void *Mem = C.Allocate(
937  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
939  NumVars, NumUniqueDeclarations,
940  NumUniqueDeclarations + NumComponentLists, NumComponents));
941  return new (Mem) OMPFromClause(NumVars, NumUniqueDeclarations,
942  NumComponentLists, NumComponents);
943 }
944 
945 void OMPUseDevicePtrClause::setPrivateCopies(ArrayRef<Expr *> VL) {
946  assert(VL.size() == varlist_size() &&
947  "Number of private copies is not the same as the preallocated buffer");
948  std::copy(VL.begin(), VL.end(), varlist_end());
949 }
950 
951 void OMPUseDevicePtrClause::setInits(ArrayRef<Expr *> VL) {
952  assert(VL.size() == varlist_size() &&
953  "Number of inits is not the same as the preallocated buffer");
954  std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
955 }
956 
958  const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
959  SourceLocation EndLoc, ArrayRef<Expr *> Vars, ArrayRef<Expr *> PrivateVars,
960  ArrayRef<Expr *> Inits, ArrayRef<ValueDecl *> Declarations,
961  MappableExprComponentListsRef ComponentLists) {
962  unsigned NumVars = Vars.size();
963  unsigned NumUniqueDeclarations =
964  getUniqueDeclarationsTotalNumber(Declarations);
965  unsigned NumComponentLists = ComponentLists.size();
966  unsigned NumComponents = getComponentsTotalNumber(ComponentLists);
967 
968  // We need to allocate:
969  // 3 x NumVars x Expr* - we have an original list expression for each clause
970  // list entry and an equal number of private copies and inits.
971  // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
972  // with each component list.
973  // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
974  // number of lists for each unique declaration and the size of each component
975  // list.
976  // NumComponents x MappableComponent - the total of all the components in all
977  // the lists.
978  void *Mem = C.Allocate(
979  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
981  3 * NumVars, NumUniqueDeclarations,
982  NumUniqueDeclarations + NumComponentLists, NumComponents));
983 
984  OMPUseDevicePtrClause *Clause = new (Mem) OMPUseDevicePtrClause(
985  StartLoc, LParenLoc, EndLoc, NumVars, NumUniqueDeclarations,
986  NumComponentLists, NumComponents);
987 
988  Clause->setVarRefs(Vars);
989  Clause->setPrivateCopies(PrivateVars);
990  Clause->setInits(Inits);
991  Clause->setClauseInfo(Declarations, ComponentLists);
992  return Clause;
993 }
994 
996  const ASTContext &C, unsigned NumVars, unsigned NumUniqueDeclarations,
997  unsigned NumComponentLists, unsigned NumComponents) {
998  void *Mem = C.Allocate(
999  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1001  3 * NumVars, NumUniqueDeclarations,
1002  NumUniqueDeclarations + NumComponentLists, NumComponents));
1003  return new (Mem) OMPUseDevicePtrClause(NumVars, NumUniqueDeclarations,
1004  NumComponentLists, NumComponents);
1005 }
1006 
1009  SourceLocation LParenLoc, SourceLocation EndLoc,
1010  ArrayRef<Expr *> Vars,
1011  ArrayRef<ValueDecl *> Declarations,
1012  MappableExprComponentListsRef ComponentLists) {
1013  unsigned NumVars = Vars.size();
1014  unsigned NumUniqueDeclarations =
1015  getUniqueDeclarationsTotalNumber(Declarations);
1016  unsigned NumComponentLists = ComponentLists.size();
1017  unsigned NumComponents = getComponentsTotalNumber(ComponentLists);
1018 
1019  // We need to allocate:
1020  // NumVars x Expr* - we have an original list expression for each clause list
1021  // entry.
1022  // NumUniqueDeclarations x ValueDecl* - unique base declarations associated
1023  // with each component list.
1024  // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the
1025  // number of lists for each unique declaration and the size of each component
1026  // list.
1027  // NumComponents x MappableComponent - the total of all the components in all
1028  // the lists.
1029  void *Mem = C.Allocate(
1030  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1032  NumVars, NumUniqueDeclarations,
1033  NumUniqueDeclarations + NumComponentLists, NumComponents));
1034 
1035  OMPIsDevicePtrClause *Clause = new (Mem) OMPIsDevicePtrClause(
1036  StartLoc, LParenLoc, EndLoc, NumVars, NumUniqueDeclarations,
1037  NumComponentLists, NumComponents);
1038 
1039  Clause->setVarRefs(Vars);
1040  Clause->setClauseInfo(Declarations, ComponentLists);
1041  return Clause;
1042 }
1043 
1045  const ASTContext &C, unsigned NumVars, unsigned NumUniqueDeclarations,
1046  unsigned NumComponentLists, unsigned NumComponents) {
1047  void *Mem = C.Allocate(
1048  totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
1050  NumVars, NumUniqueDeclarations,
1051  NumUniqueDeclarations + NumComponentLists, NumComponents));
1052  return new (Mem) OMPIsDevicePtrClause(NumVars, NumUniqueDeclarations,
1053  NumComponentLists, NumComponents);
1054 }
1055 
1056 //===----------------------------------------------------------------------===//
1057 // OpenMP clauses printing methods
1058 //===----------------------------------------------------------------------===//
1059 
1060 void OMPClausePrinter::VisitOMPIfClause(OMPIfClause *Node) {
1061  OS << "if(";
1062  if (Node->getNameModifier() != OMPD_unknown)
1063  OS << getOpenMPDirectiveName(Node->getNameModifier()) << ": ";
1064  Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
1065  OS << ")";
1066 }
1067 
1068 void OMPClausePrinter::VisitOMPFinalClause(OMPFinalClause *Node) {
1069  OS << "final(";
1070  Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
1071  OS << ")";
1072 }
1073 
1074 void OMPClausePrinter::VisitOMPNumThreadsClause(OMPNumThreadsClause *Node) {
1075  OS << "num_threads(";
1076  Node->getNumThreads()->printPretty(OS, nullptr, Policy, 0);
1077  OS << ")";
1078 }
1079 
1080 void OMPClausePrinter::VisitOMPSafelenClause(OMPSafelenClause *Node) {
1081  OS << "safelen(";
1082  Node->getSafelen()->printPretty(OS, nullptr, Policy, 0);
1083  OS << ")";
1084 }
1085 
1086 void OMPClausePrinter::VisitOMPSimdlenClause(OMPSimdlenClause *Node) {
1087  OS << "simdlen(";
1088  Node->getSimdlen()->printPretty(OS, nullptr, Policy, 0);
1089  OS << ")";
1090 }
1091 
1092 void OMPClausePrinter::VisitOMPCollapseClause(OMPCollapseClause *Node) {
1093  OS << "collapse(";
1094  Node->getNumForLoops()->printPretty(OS, nullptr, Policy, 0);
1095  OS << ")";
1096 }
1097 
1098 void OMPClausePrinter::VisitOMPDefaultClause(OMPDefaultClause *Node) {
1099  OS << "default("
1100  << getOpenMPSimpleClauseTypeName(OMPC_default, Node->getDefaultKind())
1101  << ")";
1102 }
1103 
1104 void OMPClausePrinter::VisitOMPProcBindClause(OMPProcBindClause *Node) {
1105  OS << "proc_bind("
1106  << getOpenMPSimpleClauseTypeName(OMPC_proc_bind, Node->getProcBindKind())
1107  << ")";
1108 }
1109 
1110 void OMPClausePrinter::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) {
1111  OS << "unified_address";
1112 }
1113 
1114 void OMPClausePrinter::VisitOMPUnifiedSharedMemoryClause(
1116  OS << "unified_shared_memory";
1117 }
1118 
1119 void OMPClausePrinter::VisitOMPReverseOffloadClause(OMPReverseOffloadClause *) {
1120  OS << "reverse_offload";
1121 }
1122 
1123 void OMPClausePrinter::VisitOMPDynamicAllocatorsClause(
1125  OS << "dynamic_allocators";
1126 }
1127 
1128 void OMPClausePrinter::VisitOMPAtomicDefaultMemOrderClause(
1130  OS << "atomic_default_mem_order("
1131  << getOpenMPSimpleClauseTypeName(OMPC_atomic_default_mem_order,
1133  << ")";
1134 }
1135 
1136 void OMPClausePrinter::VisitOMPScheduleClause(OMPScheduleClause *Node) {
1137  OS << "schedule(";
1139  OS << getOpenMPSimpleClauseTypeName(OMPC_schedule,
1140  Node->getFirstScheduleModifier());
1142  OS << ", ";
1143  OS << getOpenMPSimpleClauseTypeName(OMPC_schedule,
1144  Node->getSecondScheduleModifier());
1145  }
1146  OS << ": ";
1147  }
1148  OS << getOpenMPSimpleClauseTypeName(OMPC_schedule, Node->getScheduleKind());
1149  if (auto *E = Node->getChunkSize()) {
1150  OS << ", ";
1151  E->printPretty(OS, nullptr, Policy);
1152  }
1153  OS << ")";
1154 }
1155 
1156 void OMPClausePrinter::VisitOMPOrderedClause(OMPOrderedClause *Node) {
1157  OS << "ordered";
1158  if (auto *Num = Node->getNumForLoops()) {
1159  OS << "(";
1160  Num->printPretty(OS, nullptr, Policy, 0);
1161  OS << ")";
1162  }
1163 }
1164 
1165 void OMPClausePrinter::VisitOMPNowaitClause(OMPNowaitClause *) {
1166  OS << "nowait";
1167 }
1168 
1169 void OMPClausePrinter::VisitOMPUntiedClause(OMPUntiedClause *) {
1170  OS << "untied";
1171 }
1172 
1173 void OMPClausePrinter::VisitOMPNogroupClause(OMPNogroupClause *) {
1174  OS << "nogroup";
1175 }
1176 
1177 void OMPClausePrinter::VisitOMPMergeableClause(OMPMergeableClause *) {
1178  OS << "mergeable";
1179 }
1180 
1181 void OMPClausePrinter::VisitOMPReadClause(OMPReadClause *) { OS << "read"; }
1182 
1183 void OMPClausePrinter::VisitOMPWriteClause(OMPWriteClause *) { OS << "write"; }
1184 
1185 void OMPClausePrinter::VisitOMPUpdateClause(OMPUpdateClause *) {
1186  OS << "update";
1187 }
1188 
1189 void OMPClausePrinter::VisitOMPCaptureClause(OMPCaptureClause *) {
1190  OS << "capture";
1191 }
1192 
1193 void OMPClausePrinter::VisitOMPSeqCstClause(OMPSeqCstClause *) {
1194  OS << "seq_cst";
1195 }
1196 
1197 void OMPClausePrinter::VisitOMPThreadsClause(OMPThreadsClause *) {
1198  OS << "threads";
1199 }
1200 
1201 void OMPClausePrinter::VisitOMPSIMDClause(OMPSIMDClause *) { OS << "simd"; }
1202 
1203 void OMPClausePrinter::VisitOMPDeviceClause(OMPDeviceClause *Node) {
1204  OS << "device(";
1205  Node->getDevice()->printPretty(OS, nullptr, Policy, 0);
1206  OS << ")";
1207 }
1208 
1209 void OMPClausePrinter::VisitOMPNumTeamsClause(OMPNumTeamsClause *Node) {
1210  OS << "num_teams(";
1211  Node->getNumTeams()->printPretty(OS, nullptr, Policy, 0);
1212  OS << ")";
1213 }
1214 
1215 void OMPClausePrinter::VisitOMPThreadLimitClause(OMPThreadLimitClause *Node) {
1216  OS << "thread_limit(";
1217  Node->getThreadLimit()->printPretty(OS, nullptr, Policy, 0);
1218  OS << ")";
1219 }
1220 
1221 void OMPClausePrinter::VisitOMPPriorityClause(OMPPriorityClause *Node) {
1222  OS << "priority(";
1223  Node->getPriority()->printPretty(OS, nullptr, Policy, 0);
1224  OS << ")";
1225 }
1226 
1227 void OMPClausePrinter::VisitOMPGrainsizeClause(OMPGrainsizeClause *Node) {
1228  OS << "grainsize(";
1229  Node->getGrainsize()->printPretty(OS, nullptr, Policy, 0);
1230  OS << ")";
1231 }
1232 
1233 void OMPClausePrinter::VisitOMPNumTasksClause(OMPNumTasksClause *Node) {
1234  OS << "num_tasks(";
1235  Node->getNumTasks()->printPretty(OS, nullptr, Policy, 0);
1236  OS << ")";
1237 }
1238 
1239 void OMPClausePrinter::VisitOMPHintClause(OMPHintClause *Node) {
1240  OS << "hint(";
1241  Node->getHint()->printPretty(OS, nullptr, Policy, 0);
1242  OS << ")";
1243 }
1244 
1245 template<typename T>
1246 void OMPClausePrinter::VisitOMPClauseList(T *Node, char StartSym) {
1247  for (typename T::varlist_iterator I = Node->varlist_begin(),
1248  E = Node->varlist_end();
1249  I != E; ++I) {
1250  assert(*I && "Expected non-null Stmt");
1251  OS << (I == Node->varlist_begin() ? StartSym : ',');
1252  if (auto *DRE = dyn_cast<DeclRefExpr>(*I)) {
1253  if (isa<OMPCapturedExprDecl>(DRE->getDecl()))
1254  DRE->printPretty(OS, nullptr, Policy, 0);
1255  else
1256  DRE->getDecl()->printQualifiedName(OS);
1257  } else
1258  (*I)->printPretty(OS, nullptr, Policy, 0);
1259  }
1260 }
1261 
1262 void OMPClausePrinter::VisitOMPPrivateClause(OMPPrivateClause *Node) {
1263  if (!Node->varlist_empty()) {
1264  OS << "private";
1265  VisitOMPClauseList(Node, '(');
1266  OS << ")";
1267  }
1268 }
1269 
1270 void OMPClausePrinter::VisitOMPFirstprivateClause(OMPFirstprivateClause *Node) {
1271  if (!Node->varlist_empty()) {
1272  OS << "firstprivate";
1273  VisitOMPClauseList(Node, '(');
1274  OS << ")";
1275  }
1276 }
1277 
1278 void OMPClausePrinter::VisitOMPLastprivateClause(OMPLastprivateClause *Node) {
1279  if (!Node->varlist_empty()) {
1280  OS << "lastprivate";
1281  VisitOMPClauseList(Node, '(');
1282  OS << ")";
1283  }
1284 }
1285 
1286 void OMPClausePrinter::VisitOMPSharedClause(OMPSharedClause *Node) {
1287  if (!Node->varlist_empty()) {
1288  OS << "shared";
1289  VisitOMPClauseList(Node, '(');
1290  OS << ")";
1291  }
1292 }
1293 
1294 void OMPClausePrinter::VisitOMPReductionClause(OMPReductionClause *Node) {
1295  if (!Node->varlist_empty()) {
1296  OS << "reduction(";
1297  NestedNameSpecifier *QualifierLoc =
1301  if (QualifierLoc == nullptr && OOK != OO_None) {
1302  // Print reduction identifier in C format
1303  OS << getOperatorSpelling(OOK);
1304  } else {
1305  // Use C++ format
1306  if (QualifierLoc != nullptr)
1307  QualifierLoc->print(OS, Policy);
1308  OS << Node->getNameInfo();
1309  }
1310  OS << ":";
1311  VisitOMPClauseList(Node, ' ');
1312  OS << ")";
1313  }
1314 }
1315 
1316 void OMPClausePrinter::VisitOMPTaskReductionClause(
1317  OMPTaskReductionClause *Node) {
1318  if (!Node->varlist_empty()) {
1319  OS << "task_reduction(";
1320  NestedNameSpecifier *QualifierLoc =
1324  if (QualifierLoc == nullptr && OOK != OO_None) {
1325  // Print reduction identifier in C format
1326  OS << getOperatorSpelling(OOK);
1327  } else {
1328  // Use C++ format
1329  if (QualifierLoc != nullptr)
1330  QualifierLoc->print(OS, Policy);
1331  OS << Node->getNameInfo();
1332  }
1333  OS << ":";
1334  VisitOMPClauseList(Node, ' ');
1335  OS << ")";
1336  }
1337 }
1338 
1339 void OMPClausePrinter::VisitOMPInReductionClause(OMPInReductionClause *Node) {
1340  if (!Node->varlist_empty()) {
1341  OS << "in_reduction(";
1342  NestedNameSpecifier *QualifierLoc =
1346  if (QualifierLoc == nullptr && OOK != OO_None) {
1347  // Print reduction identifier in C format
1348  OS << getOperatorSpelling(OOK);
1349  } else {
1350  // Use C++ format
1351  if (QualifierLoc != nullptr)
1352  QualifierLoc->print(OS, Policy);
1353  OS << Node->getNameInfo();
1354  }
1355  OS << ":";
1356  VisitOMPClauseList(Node, ' ');
1357  OS << ")";
1358  }
1359 }
1360 
1361 void OMPClausePrinter::VisitOMPLinearClause(OMPLinearClause *Node) {
1362  if (!Node->varlist_empty()) {
1363  OS << "linear";
1364  if (Node->getModifierLoc().isValid()) {
1365  OS << '('
1366  << getOpenMPSimpleClauseTypeName(OMPC_linear, Node->getModifier());
1367  }
1368  VisitOMPClauseList(Node, '(');
1369  if (Node->getModifierLoc().isValid())
1370  OS << ')';
1371  if (Node->getStep() != nullptr) {
1372  OS << ": ";
1373  Node->getStep()->printPretty(OS, nullptr, Policy, 0);
1374  }
1375  OS << ")";
1376  }
1377 }
1378 
1379 void OMPClausePrinter::VisitOMPAlignedClause(OMPAlignedClause *Node) {
1380  if (!Node->varlist_empty()) {
1381  OS << "aligned";
1382  VisitOMPClauseList(Node, '(');
1383  if (Node->getAlignment() != nullptr) {
1384  OS << ": ";
1385  Node->getAlignment()->printPretty(OS, nullptr, Policy, 0);
1386  }
1387  OS << ")";
1388  }
1389 }
1390 
1391 void OMPClausePrinter::VisitOMPCopyinClause(OMPCopyinClause *Node) {
1392  if (!Node->varlist_empty()) {
1393  OS << "copyin";
1394  VisitOMPClauseList(Node, '(');
1395  OS << ")";
1396  }
1397 }
1398 
1399 void OMPClausePrinter::VisitOMPCopyprivateClause(OMPCopyprivateClause *Node) {
1400  if (!Node->varlist_empty()) {
1401  OS << "copyprivate";
1402  VisitOMPClauseList(Node, '(');
1403  OS << ")";
1404  }
1405 }
1406 
1407 void OMPClausePrinter::VisitOMPFlushClause(OMPFlushClause *Node) {
1408  if (!Node->varlist_empty()) {
1409  VisitOMPClauseList(Node, '(');
1410  OS << ")";
1411  }
1412 }
1413 
1414 void OMPClausePrinter::VisitOMPDependClause(OMPDependClause *Node) {
1415  OS << "depend(";
1416  OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(),
1417  Node->getDependencyKind());
1418  if (!Node->varlist_empty()) {
1419  OS << " :";
1420  VisitOMPClauseList(Node, ' ');
1421  }
1422  OS << ")";
1423 }
1424 
1425 void OMPClausePrinter::VisitOMPMapClause(OMPMapClause *Node) {
1426  if (!Node->varlist_empty()) {
1427  OS << "map(";
1428  if (Node->getMapType() != OMPC_MAP_unknown) {
1429  if (Node->getMapTypeModifier() != OMPC_MAP_unknown) {
1430  OS << getOpenMPSimpleClauseTypeName(OMPC_map,
1431  Node->getMapTypeModifier());
1432  OS << ',';
1433  }
1434  OS << getOpenMPSimpleClauseTypeName(OMPC_map, Node->getMapType());
1435  OS << ':';
1436  }
1437  VisitOMPClauseList(Node, ' ');
1438  OS << ")";
1439  }
1440 }
1441 
1442 void OMPClausePrinter::VisitOMPToClause(OMPToClause *Node) {
1443  if (!Node->varlist_empty()) {
1444  OS << "to";
1445  VisitOMPClauseList(Node, '(');
1446  OS << ")";
1447  }
1448 }
1449 
1450 void OMPClausePrinter::VisitOMPFromClause(OMPFromClause *Node) {
1451  if (!Node->varlist_empty()) {
1452  OS << "from";
1453  VisitOMPClauseList(Node, '(');
1454  OS << ")";
1455  }
1456 }
1457 
1458 void OMPClausePrinter::VisitOMPDistScheduleClause(OMPDistScheduleClause *Node) {
1459  OS << "dist_schedule(" << getOpenMPSimpleClauseTypeName(
1460  OMPC_dist_schedule, Node->getDistScheduleKind());
1461  if (auto *E = Node->getChunkSize()) {
1462  OS << ", ";
1463  E->printPretty(OS, nullptr, Policy);
1464  }
1465  OS << ")";
1466 }
1467 
1468 void OMPClausePrinter::VisitOMPDefaultmapClause(OMPDefaultmapClause *Node) {
1469  OS << "defaultmap(";
1470  OS << getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
1471  Node->getDefaultmapModifier());
1472  OS << ": ";
1473  OS << getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
1474  Node->getDefaultmapKind());
1475  OS << ")";
1476 }
1477 
1478 void OMPClausePrinter::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *Node) {
1479  if (!Node->varlist_empty()) {
1480  OS << "use_device_ptr";
1481  VisitOMPClauseList(Node, '(');
1482  OS << ")";
1483  }
1484 }
1485 
1486 void OMPClausePrinter::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *Node) {
1487  if (!Node->varlist_empty()) {
1488  OS << "is_device_ptr";
1489  VisitOMPClauseList(Node, '(');
1490  OS << ")";
1491  }
1492 }
1493 
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:3469
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.
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:1415
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.
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.
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:154
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 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.
void print(raw_ostream &OS, const PrintingPolicy &Policy) const
Print this nested name specifier to the given output stream.
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:636
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()
static OMPMapClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< Expr *> Vars, ArrayRef< ValueDecl *> Declarations, MappableExprComponentListsRef ComponentLists, OpenMPMapClauseKind TypeModifier, OpenMPMapClauseKind Type, bool TypeIsImplicit, SourceLocation TypeLoc)
Creates clause with a list of variables VL.
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
OpenMPMapClauseKind getMapTypeModifier() const LLVM_READONLY
Fetches the map type modifier for the clause.
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:678
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.