clang  3.8.0
StmtOpenMP.cpp
Go to the documentation of this file.
1 //===--- StmtOpenMP.cpp - Classes for OpenMP directives -------------------===//
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 StmtOpenMP.h
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/AST/StmtOpenMP.h"
15 
16 #include "clang/AST/ASTContext.h"
17 
18 using namespace clang;
19 
21  assert(Clauses.size() == getNumClauses() &&
22  "Number of clauses is not the same as the preallocated buffer");
23  std::copy(Clauses.begin(), Clauses.end(), getClauses().begin());
24 }
25 
27  assert(A.size() == getCollapsedNumber() &&
28  "Number of loop counters is not the same as the collapsed number");
29  std::copy(A.begin(), A.end(), getCounters().begin());
30 }
31 
33  assert(A.size() == getCollapsedNumber() && "Number of loop private counters "
34  "is not the same as the collapsed "
35  "number");
36  std::copy(A.begin(), A.end(), getPrivateCounters().begin());
37 }
38 
40  assert(A.size() == getCollapsedNumber() &&
41  "Number of counter inits is not the same as the collapsed number");
42  std::copy(A.begin(), A.end(), getInits().begin());
43 }
44 
46  assert(A.size() == getCollapsedNumber() &&
47  "Number of counter updates is not the same as the collapsed number");
48  std::copy(A.begin(), A.end(), getUpdates().begin());
49 }
50 
52  assert(A.size() == getCollapsedNumber() &&
53  "Number of counter finals is not the same as the collapsed number");
54  std::copy(A.begin(), A.end(), getFinals().begin());
55 }
56 
58  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
59  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
60  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelDirective),
61  llvm::alignOf<OMPClause *>());
62  void *Mem =
63  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
65  new (Mem) OMPParallelDirective(StartLoc, EndLoc, Clauses.size());
66  Dir->setClauses(Clauses);
67  Dir->setAssociatedStmt(AssociatedStmt);
68  Dir->setHasCancel(HasCancel);
69  return Dir;
70 }
71 
73  unsigned NumClauses,
74  EmptyShell) {
75  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelDirective),
76  llvm::alignOf<OMPClause *>());
77  void *Mem =
78  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
79  return new (Mem) OMPParallelDirective(NumClauses);
80 }
81 
84  SourceLocation EndLoc, unsigned CollapsedNum,
85  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
86  const HelperExprs &Exprs) {
87  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective),
88  llvm::alignOf<OMPClause *>());
89  void *Mem =
90  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
91  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
92  OMPSimdDirective *Dir = new (Mem)
93  OMPSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
94  Dir->setClauses(Clauses);
95  Dir->setAssociatedStmt(AssociatedStmt);
97  Dir->setLastIteration(Exprs.LastIteration);
99  Dir->setPreCond(Exprs.PreCond);
100  Dir->setCond(Exprs.Cond);
101  Dir->setInit(Exprs.Init);
102  Dir->setInc(Exprs.Inc);
103  Dir->setCounters(Exprs.Counters);
105  Dir->setInits(Exprs.Inits);
106  Dir->setUpdates(Exprs.Updates);
107  Dir->setFinals(Exprs.Finals);
108  return Dir;
109 }
110 
112  unsigned NumClauses,
113  unsigned CollapsedNum,
114  EmptyShell) {
115  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective),
116  llvm::alignOf<OMPClause *>());
117  void *Mem =
118  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
119  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
120  return new (Mem) OMPSimdDirective(CollapsedNum, NumClauses);
121 }
122 
125  SourceLocation EndLoc, unsigned CollapsedNum,
126  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
127  const HelperExprs &Exprs, bool HasCancel) {
128  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForDirective),
129  llvm::alignOf<OMPClause *>());
130  void *Mem =
131  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
132  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
133  OMPForDirective *Dir =
134  new (Mem) OMPForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
135  Dir->setClauses(Clauses);
136  Dir->setAssociatedStmt(AssociatedStmt);
138  Dir->setLastIteration(Exprs.LastIteration);
140  Dir->setPreCond(Exprs.PreCond);
141  Dir->setCond(Exprs.Cond);
142  Dir->setInit(Exprs.Init);
143  Dir->setInc(Exprs.Inc);
144  Dir->setIsLastIterVariable(Exprs.IL);
145  Dir->setLowerBoundVariable(Exprs.LB);
146  Dir->setUpperBoundVariable(Exprs.UB);
147  Dir->setStrideVariable(Exprs.ST);
148  Dir->setEnsureUpperBound(Exprs.EUB);
149  Dir->setNextLowerBound(Exprs.NLB);
150  Dir->setNextUpperBound(Exprs.NUB);
151  Dir->setCounters(Exprs.Counters);
153  Dir->setInits(Exprs.Inits);
154  Dir->setUpdates(Exprs.Updates);
155  Dir->setFinals(Exprs.Finals);
156  Dir->setHasCancel(HasCancel);
157  return Dir;
158 }
159 
161  unsigned NumClauses,
162  unsigned CollapsedNum,
163  EmptyShell) {
164  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForDirective),
165  llvm::alignOf<OMPClause *>());
166  void *Mem =
167  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
168  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
169  return new (Mem) OMPForDirective(CollapsedNum, NumClauses);
170 }
171 
174  SourceLocation EndLoc, unsigned CollapsedNum,
175  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
176  const HelperExprs &Exprs) {
177  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForSimdDirective),
178  llvm::alignOf<OMPClause *>());
179  void *Mem =
180  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
181  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
182  OMPForSimdDirective *Dir = new (Mem)
183  OMPForSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
184  Dir->setClauses(Clauses);
185  Dir->setAssociatedStmt(AssociatedStmt);
187  Dir->setLastIteration(Exprs.LastIteration);
189  Dir->setPreCond(Exprs.PreCond);
190  Dir->setCond(Exprs.Cond);
191  Dir->setInit(Exprs.Init);
192  Dir->setInc(Exprs.Inc);
193  Dir->setIsLastIterVariable(Exprs.IL);
194  Dir->setLowerBoundVariable(Exprs.LB);
195  Dir->setUpperBoundVariable(Exprs.UB);
196  Dir->setStrideVariable(Exprs.ST);
197  Dir->setEnsureUpperBound(Exprs.EUB);
198  Dir->setNextLowerBound(Exprs.NLB);
199  Dir->setNextUpperBound(Exprs.NUB);
200  Dir->setCounters(Exprs.Counters);
202  Dir->setInits(Exprs.Inits);
203  Dir->setUpdates(Exprs.Updates);
204  Dir->setFinals(Exprs.Finals);
205  return Dir;
206 }
207 
209  unsigned NumClauses,
210  unsigned CollapsedNum,
211  EmptyShell) {
212  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForSimdDirective),
213  llvm::alignOf<OMPClause *>());
214  void *Mem =
215  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
216  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
217  return new (Mem) OMPForSimdDirective(CollapsedNum, NumClauses);
218 }
219 
221  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
222  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
223  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective),
224  llvm::alignOf<OMPClause *>());
225  void *Mem =
226  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
227  OMPSectionsDirective *Dir =
228  new (Mem) OMPSectionsDirective(StartLoc, EndLoc, Clauses.size());
229  Dir->setClauses(Clauses);
230  Dir->setAssociatedStmt(AssociatedStmt);
231  Dir->setHasCancel(HasCancel);
232  return Dir;
233 }
234 
236  unsigned NumClauses,
237  EmptyShell) {
238  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective),
239  llvm::alignOf<OMPClause *>());
240  void *Mem =
241  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
242  return new (Mem) OMPSectionsDirective(NumClauses);
243 }
244 
246  SourceLocation StartLoc,
247  SourceLocation EndLoc,
248  Stmt *AssociatedStmt,
249  bool HasCancel) {
250  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionDirective),
251  llvm::alignOf<Stmt *>());
252  void *Mem = C.Allocate(Size + sizeof(Stmt *));
253  OMPSectionDirective *Dir = new (Mem) OMPSectionDirective(StartLoc, EndLoc);
254  Dir->setAssociatedStmt(AssociatedStmt);
255  Dir->setHasCancel(HasCancel);
256  return Dir;
257 }
258 
260  EmptyShell) {
261  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionDirective),
262  llvm::alignOf<Stmt *>());
263  void *Mem = C.Allocate(Size + sizeof(Stmt *));
264  return new (Mem) OMPSectionDirective();
265 }
266 
268  SourceLocation StartLoc,
269  SourceLocation EndLoc,
270  ArrayRef<OMPClause *> Clauses,
271  Stmt *AssociatedStmt) {
272  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSingleDirective),
273  llvm::alignOf<OMPClause *>());
274  void *Mem =
275  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
276  OMPSingleDirective *Dir =
277  new (Mem) OMPSingleDirective(StartLoc, EndLoc, Clauses.size());
278  Dir->setClauses(Clauses);
279  Dir->setAssociatedStmt(AssociatedStmt);
280  return Dir;
281 }
282 
284  unsigned NumClauses,
285  EmptyShell) {
286  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSingleDirective),
287  llvm::alignOf<OMPClause *>());
288  void *Mem =
289  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
290  return new (Mem) OMPSingleDirective(NumClauses);
291 }
292 
294  SourceLocation StartLoc,
295  SourceLocation EndLoc,
296  Stmt *AssociatedStmt) {
297  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPMasterDirective),
298  llvm::alignOf<Stmt *>());
299  void *Mem = C.Allocate(Size + sizeof(Stmt *));
300  OMPMasterDirective *Dir = new (Mem) OMPMasterDirective(StartLoc, EndLoc);
301  Dir->setAssociatedStmt(AssociatedStmt);
302  return Dir;
303 }
304 
306  EmptyShell) {
307  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPMasterDirective),
308  llvm::alignOf<Stmt *>());
309  void *Mem = C.Allocate(Size + sizeof(Stmt *));
310  return new (Mem) OMPMasterDirective();
311 }
312 
314  const ASTContext &C, const DeclarationNameInfo &Name,
315  SourceLocation StartLoc, SourceLocation EndLoc,
316  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
317  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective),
318  llvm::alignOf<OMPClause *>());
319  void *Mem =
320  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
321  OMPCriticalDirective *Dir =
322  new (Mem) OMPCriticalDirective(Name, StartLoc, EndLoc, Clauses.size());
323  Dir->setClauses(Clauses);
324  Dir->setAssociatedStmt(AssociatedStmt);
325  return Dir;
326 }
327 
329  unsigned NumClauses,
330  EmptyShell) {
331  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective),
332  llvm::alignOf<OMPClause *>());
333  void *Mem =
334  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
335  return new (Mem) OMPCriticalDirective(NumClauses);
336 }
337 
339  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
340  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
341  const HelperExprs &Exprs, bool HasCancel) {
342  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective),
343  llvm::alignOf<OMPClause *>());
344  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
345  sizeof(Stmt *) *
346  numLoopChildren(CollapsedNum, OMPD_parallel_for));
347  OMPParallelForDirective *Dir = new (Mem)
348  OMPParallelForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
349  Dir->setClauses(Clauses);
350  Dir->setAssociatedStmt(AssociatedStmt);
352  Dir->setLastIteration(Exprs.LastIteration);
354  Dir->setPreCond(Exprs.PreCond);
355  Dir->setCond(Exprs.Cond);
356  Dir->setInit(Exprs.Init);
357  Dir->setInc(Exprs.Inc);
358  Dir->setIsLastIterVariable(Exprs.IL);
359  Dir->setLowerBoundVariable(Exprs.LB);
360  Dir->setUpperBoundVariable(Exprs.UB);
361  Dir->setStrideVariable(Exprs.ST);
362  Dir->setEnsureUpperBound(Exprs.EUB);
363  Dir->setNextLowerBound(Exprs.NLB);
364  Dir->setNextUpperBound(Exprs.NUB);
365  Dir->setCounters(Exprs.Counters);
367  Dir->setInits(Exprs.Inits);
368  Dir->setUpdates(Exprs.Updates);
369  Dir->setFinals(Exprs.Finals);
370  Dir->setHasCancel(HasCancel);
371  return Dir;
372 }
373 
376  unsigned CollapsedNum, EmptyShell) {
377  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective),
378  llvm::alignOf<OMPClause *>());
379  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
380  sizeof(Stmt *) *
381  numLoopChildren(CollapsedNum, OMPD_parallel_for));
382  return new (Mem) OMPParallelForDirective(CollapsedNum, NumClauses);
383 }
384 
386  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
387  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
388  const HelperExprs &Exprs) {
389  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective),
390  llvm::alignOf<OMPClause *>());
391  void *Mem = C.Allocate(
392  Size + sizeof(OMPClause *) * Clauses.size() +
393  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
395  StartLoc, EndLoc, CollapsedNum, Clauses.size());
396  Dir->setClauses(Clauses);
397  Dir->setAssociatedStmt(AssociatedStmt);
399  Dir->setLastIteration(Exprs.LastIteration);
401  Dir->setPreCond(Exprs.PreCond);
402  Dir->setCond(Exprs.Cond);
403  Dir->setInit(Exprs.Init);
404  Dir->setInc(Exprs.Inc);
405  Dir->setIsLastIterVariable(Exprs.IL);
406  Dir->setLowerBoundVariable(Exprs.LB);
407  Dir->setUpperBoundVariable(Exprs.UB);
408  Dir->setStrideVariable(Exprs.ST);
409  Dir->setEnsureUpperBound(Exprs.EUB);
410  Dir->setNextLowerBound(Exprs.NLB);
411  Dir->setNextUpperBound(Exprs.NUB);
412  Dir->setCounters(Exprs.Counters);
414  Dir->setInits(Exprs.Inits);
415  Dir->setUpdates(Exprs.Updates);
416  Dir->setFinals(Exprs.Finals);
417  return Dir;
418 }
419 
422  unsigned NumClauses,
423  unsigned CollapsedNum, EmptyShell) {
424  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective),
425  llvm::alignOf<OMPClause *>());
426  void *Mem = C.Allocate(
427  Size + sizeof(OMPClause *) * NumClauses +
428  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
429  return new (Mem) OMPParallelForSimdDirective(CollapsedNum, NumClauses);
430 }
431 
433  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
434  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
435  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective),
436  llvm::alignOf<OMPClause *>());
437  void *Mem =
438  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
440  new (Mem) OMPParallelSectionsDirective(StartLoc, EndLoc, Clauses.size());
441  Dir->setClauses(Clauses);
442  Dir->setAssociatedStmt(AssociatedStmt);
443  Dir->setHasCancel(HasCancel);
444  return Dir;
445 }
446 
449  unsigned NumClauses, EmptyShell) {
450  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective),
451  llvm::alignOf<OMPClause *>());
452  void *Mem =
453  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
454  return new (Mem) OMPParallelSectionsDirective(NumClauses);
455 }
456 
459  SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
460  Stmt *AssociatedStmt, bool HasCancel) {
461  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective),
462  llvm::alignOf<OMPClause *>());
463  void *Mem =
464  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
465  OMPTaskDirective *Dir =
466  new (Mem) OMPTaskDirective(StartLoc, EndLoc, Clauses.size());
467  Dir->setClauses(Clauses);
468  Dir->setAssociatedStmt(AssociatedStmt);
469  Dir->setHasCancel(HasCancel);
470  return Dir;
471 }
472 
474  unsigned NumClauses,
475  EmptyShell) {
476  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective),
477  llvm::alignOf<OMPClause *>());
478  void *Mem =
479  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
480  return new (Mem) OMPTaskDirective(NumClauses);
481 }
482 
484  SourceLocation StartLoc,
485  SourceLocation EndLoc) {
486  void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
487  OMPTaskyieldDirective *Dir =
488  new (Mem) OMPTaskyieldDirective(StartLoc, EndLoc);
489  return Dir;
490 }
491 
493  EmptyShell) {
494  void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
495  return new (Mem) OMPTaskyieldDirective();
496 }
497 
499  SourceLocation StartLoc,
500  SourceLocation EndLoc) {
501  void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
502  OMPBarrierDirective *Dir = new (Mem) OMPBarrierDirective(StartLoc, EndLoc);
503  return Dir;
504 }
505 
507  EmptyShell) {
508  void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
509  return new (Mem) OMPBarrierDirective();
510 }
511 
513  SourceLocation StartLoc,
514  SourceLocation EndLoc) {
515  void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
516  OMPTaskwaitDirective *Dir = new (Mem) OMPTaskwaitDirective(StartLoc, EndLoc);
517  return Dir;
518 }
519 
521  EmptyShell) {
522  void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
523  return new (Mem) OMPTaskwaitDirective();
524 }
525 
527  SourceLocation StartLoc,
528  SourceLocation EndLoc,
529  Stmt *AssociatedStmt) {
530  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskgroupDirective),
531  llvm::alignOf<Stmt *>());
532  void *Mem = C.Allocate(Size + sizeof(Stmt *));
533  OMPTaskgroupDirective *Dir =
534  new (Mem) OMPTaskgroupDirective(StartLoc, EndLoc);
535  Dir->setAssociatedStmt(AssociatedStmt);
536  return Dir;
537 }
538 
540  EmptyShell) {
541  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskgroupDirective),
542  llvm::alignOf<Stmt *>());
543  void *Mem = C.Allocate(Size + sizeof(Stmt *));
544  return new (Mem) OMPTaskgroupDirective();
545 }
546 
548  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
549  OpenMPDirectiveKind CancelRegion) {
550  unsigned Size = llvm::RoundUpToAlignment(
551  sizeof(OMPCancellationPointDirective), llvm::alignOf<Stmt *>());
552  void *Mem = C.Allocate(Size);
554  new (Mem) OMPCancellationPointDirective(StartLoc, EndLoc);
555  Dir->setCancelRegion(CancelRegion);
556  return Dir;
557 }
558 
561  unsigned Size = llvm::RoundUpToAlignment(
562  sizeof(OMPCancellationPointDirective), llvm::alignOf<Stmt *>());
563  void *Mem = C.Allocate(Size);
564  return new (Mem) OMPCancellationPointDirective();
565 }
566 
569  SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
570  OpenMPDirectiveKind CancelRegion) {
571  unsigned Size = llvm::RoundUpToAlignment(
572  sizeof(OMPCancelDirective) + sizeof(OMPClause *) * Clauses.size(),
573  llvm::alignOf<Stmt *>());
574  void *Mem = C.Allocate(Size);
575  OMPCancelDirective *Dir =
576  new (Mem) OMPCancelDirective(StartLoc, EndLoc, Clauses.size());
577  Dir->setClauses(Clauses);
578  Dir->setCancelRegion(CancelRegion);
579  return Dir;
580 }
581 
583  unsigned NumClauses,
584  EmptyShell) {
585  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCancelDirective) +
586  sizeof(OMPClause *) * NumClauses,
587  llvm::alignOf<Stmt *>());
588  void *Mem = C.Allocate(Size);
589  return new (Mem) OMPCancelDirective(NumClauses);
590 }
591 
593  SourceLocation StartLoc,
594  SourceLocation EndLoc,
595  ArrayRef<OMPClause *> Clauses) {
596  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPFlushDirective),
597  llvm::alignOf<OMPClause *>());
598  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size());
599  OMPFlushDirective *Dir =
600  new (Mem) OMPFlushDirective(StartLoc, EndLoc, Clauses.size());
601  Dir->setClauses(Clauses);
602  return Dir;
603 }
604 
606  unsigned NumClauses,
607  EmptyShell) {
608  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPFlushDirective),
609  llvm::alignOf<OMPClause *>());
610  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses);
611  return new (Mem) OMPFlushDirective(NumClauses);
612 }
613 
615  SourceLocation StartLoc,
616  SourceLocation EndLoc,
617  ArrayRef<OMPClause *> Clauses,
618  Stmt *AssociatedStmt) {
619  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective),
620  llvm::alignOf<OMPClause *>());
621  void *Mem =
622  C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * Clauses.size());
623  OMPOrderedDirective *Dir =
624  new (Mem) OMPOrderedDirective(StartLoc, EndLoc, Clauses.size());
625  Dir->setClauses(Clauses);
626  Dir->setAssociatedStmt(AssociatedStmt);
627  return Dir;
628 }
629 
631  unsigned NumClauses,
632  EmptyShell) {
633  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective),
634  llvm::alignOf<OMPClause *>());
635  void *Mem =
636  C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * NumClauses);
637  return new (Mem) OMPOrderedDirective(NumClauses);
638 }
639 
641  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
642  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
643  Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {
644  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective),
645  llvm::alignOf<OMPClause *>());
646  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
647  5 * sizeof(Stmt *));
648  OMPAtomicDirective *Dir =
649  new (Mem) OMPAtomicDirective(StartLoc, EndLoc, Clauses.size());
650  Dir->setClauses(Clauses);
651  Dir->setAssociatedStmt(AssociatedStmt);
652  Dir->setX(X);
653  Dir->setV(V);
654  Dir->setExpr(E);
655  Dir->setUpdateExpr(UE);
656  Dir->IsXLHSInRHSPart = IsXLHSInRHSPart;
657  Dir->IsPostfixUpdate = IsPostfixUpdate;
658  return Dir;
659 }
660 
662  unsigned NumClauses,
663  EmptyShell) {
664  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective),
665  llvm::alignOf<OMPClause *>());
666  void *Mem =
667  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 5 * sizeof(Stmt *));
668  return new (Mem) OMPAtomicDirective(NumClauses);
669 }
670 
672  SourceLocation StartLoc,
673  SourceLocation EndLoc,
674  ArrayRef<OMPClause *> Clauses,
675  Stmt *AssociatedStmt) {
676  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective),
677  llvm::alignOf<OMPClause *>());
678  void *Mem =
679  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
680  OMPTargetDirective *Dir =
681  new (Mem) OMPTargetDirective(StartLoc, EndLoc, Clauses.size());
682  Dir->setClauses(Clauses);
683  Dir->setAssociatedStmt(AssociatedStmt);
684  return Dir;
685 }
686 
688  unsigned NumClauses,
689  EmptyShell) {
690  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective),
691  llvm::alignOf<OMPClause *>());
692  void *Mem =
693  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
694  return new (Mem) OMPTargetDirective(NumClauses);
695 }
696 
698  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
699  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
700  void *Mem =
701  C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPTargetDataDirective),
702  llvm::alignOf<OMPClause *>()) +
703  sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
705  new (Mem) OMPTargetDataDirective(StartLoc, EndLoc, Clauses.size());
706  Dir->setClauses(Clauses);
707  Dir->setAssociatedStmt(AssociatedStmt);
708  return Dir;
709 }
710 
712  unsigned N,
713  EmptyShell) {
714  void *Mem =
715  C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPTargetDataDirective),
716  llvm::alignOf<OMPClause *>()) +
717  sizeof(OMPClause *) * N + sizeof(Stmt *));
718  return new (Mem) OMPTargetDataDirective(N);
719 }
720 
722  SourceLocation StartLoc,
723  SourceLocation EndLoc,
724  ArrayRef<OMPClause *> Clauses,
725  Stmt *AssociatedStmt) {
726  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective),
727  llvm::alignOf<OMPClause *>());
728  void *Mem =
729  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
730  OMPTeamsDirective *Dir =
731  new (Mem) OMPTeamsDirective(StartLoc, EndLoc, Clauses.size());
732  Dir->setClauses(Clauses);
733  Dir->setAssociatedStmt(AssociatedStmt);
734  return Dir;
735 }
736 
738  unsigned NumClauses,
739  EmptyShell) {
740  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective),
741  llvm::alignOf<OMPClause *>());
742  void *Mem =
743  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
744  return new (Mem) OMPTeamsDirective(NumClauses);
745 }
746 
748  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
749  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
750  const HelperExprs &Exprs) {
751  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskLoopDirective),
752  llvm::alignOf<OMPClause *>());
753  void *Mem =
754  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
755  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
756  OMPTaskLoopDirective *Dir = new (Mem)
757  OMPTaskLoopDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
758  Dir->setClauses(Clauses);
759  Dir->setAssociatedStmt(AssociatedStmt);
761  Dir->setLastIteration(Exprs.LastIteration);
763  Dir->setPreCond(Exprs.PreCond);
764  Dir->setCond(Exprs.Cond);
765  Dir->setInit(Exprs.Init);
766  Dir->setInc(Exprs.Inc);
767  Dir->setIsLastIterVariable(Exprs.IL);
768  Dir->setLowerBoundVariable(Exprs.LB);
769  Dir->setUpperBoundVariable(Exprs.UB);
770  Dir->setStrideVariable(Exprs.ST);
771  Dir->setEnsureUpperBound(Exprs.EUB);
772  Dir->setNextLowerBound(Exprs.NLB);
773  Dir->setNextUpperBound(Exprs.NUB);
774  Dir->setCounters(Exprs.Counters);
776  Dir->setInits(Exprs.Inits);
777  Dir->setUpdates(Exprs.Updates);
778  Dir->setFinals(Exprs.Finals);
779  return Dir;
780 }
781 
783  unsigned NumClauses,
784  unsigned CollapsedNum,
785  EmptyShell) {
786  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskLoopDirective),
787  llvm::alignOf<OMPClause *>());
788  void *Mem =
789  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
790  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
791  return new (Mem) OMPTaskLoopDirective(CollapsedNum, NumClauses);
792 }
793 
795  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
796  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
797  const HelperExprs &Exprs) {
798  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskLoopSimdDirective),
799  llvm::alignOf<OMPClause *>());
800  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
801  sizeof(Stmt *) *
802  numLoopChildren(CollapsedNum, OMPD_taskloop_simd));
803  OMPTaskLoopSimdDirective *Dir = new (Mem)
804  OMPTaskLoopSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
805  Dir->setClauses(Clauses);
806  Dir->setAssociatedStmt(AssociatedStmt);
808  Dir->setLastIteration(Exprs.LastIteration);
810  Dir->setPreCond(Exprs.PreCond);
811  Dir->setCond(Exprs.Cond);
812  Dir->setInit(Exprs.Init);
813  Dir->setInc(Exprs.Inc);
814  Dir->setIsLastIterVariable(Exprs.IL);
815  Dir->setLowerBoundVariable(Exprs.LB);
816  Dir->setUpperBoundVariable(Exprs.UB);
817  Dir->setStrideVariable(Exprs.ST);
818  Dir->setEnsureUpperBound(Exprs.EUB);
819  Dir->setNextLowerBound(Exprs.NLB);
820  Dir->setNextUpperBound(Exprs.NUB);
821  Dir->setCounters(Exprs.Counters);
823  Dir->setInits(Exprs.Inits);
824  Dir->setUpdates(Exprs.Updates);
825  Dir->setFinals(Exprs.Finals);
826  return Dir;
827 }
828 
831  unsigned CollapsedNum, EmptyShell) {
832  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskLoopSimdDirective),
833  llvm::alignOf<OMPClause *>());
834  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
835  sizeof(Stmt *) *
836  numLoopChildren(CollapsedNum, OMPD_taskloop_simd));
837  return new (Mem) OMPTaskLoopSimdDirective(CollapsedNum, NumClauses);
838 }
839 
841  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
842  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
843  const HelperExprs &Exprs) {
844  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPDistributeDirective),
845  llvm::alignOf<OMPClause *>());
846  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
847  sizeof(Stmt *) *
848  numLoopChildren(CollapsedNum, OMPD_distribute));
849  OMPDistributeDirective *Dir = new (Mem)
850  OMPDistributeDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
851  Dir->setClauses(Clauses);
852  Dir->setAssociatedStmt(AssociatedStmt);
854  Dir->setLastIteration(Exprs.LastIteration);
856  Dir->setPreCond(Exprs.PreCond);
857  Dir->setCond(Exprs.Cond);
858  Dir->setInit(Exprs.Init);
859  Dir->setInc(Exprs.Inc);
860  Dir->setIsLastIterVariable(Exprs.IL);
861  Dir->setLowerBoundVariable(Exprs.LB);
862  Dir->setUpperBoundVariable(Exprs.UB);
863  Dir->setStrideVariable(Exprs.ST);
864  Dir->setEnsureUpperBound(Exprs.EUB);
865  Dir->setNextLowerBound(Exprs.NLB);
866  Dir->setNextUpperBound(Exprs.NUB);
867  Dir->setCounters(Exprs.Counters);
869  Dir->setInits(Exprs.Inits);
870  Dir->setUpdates(Exprs.Updates);
871  Dir->setFinals(Exprs.Finals);
872  return Dir;
873 }
874 
877  unsigned CollapsedNum, EmptyShell) {
878  unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPDistributeDirective),
879  llvm::alignOf<OMPClause *>());
880  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
881  sizeof(Stmt *) *
882  numLoopChildren(CollapsedNum, OMPD_distribute));
883  return new (Mem) OMPDistributeDirective(CollapsedNum, NumClauses);
884 }
Expr * NLB
Update of LowerBound for statically sheduled 'omp for' loops.
Definition: StmtOpenMP.h:512
Defines the clang::ASTContext interface.
SmallVector< Expr *, 4 > Finals
Final loop counter values for GodeGen.
Definition: StmtOpenMP.h:524
This represents '#pragma omp master' directive.
Definition: StmtOpenMP.h:1100
SmallVector< Expr *, 4 > Updates
Expressions for loop counters update for CodeGen.
Definition: StmtOpenMP.h:522
This represents '#pragma omp task' directive.
Definition: StmtOpenMP.h:1440
void setEnsureUpperBound(Expr *EUB)
Definition: StmtOpenMP.h:454
static OMPMasterDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:305
static OMPDistributeDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:840
static OMPTaskwaitDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:520
void setHasCancel(bool Has)
Set cancel state.
Definition: StmtOpenMP.h:1027
void setLastIteration(Expr *LI)
Definition: StmtOpenMP.h:412
This represents '#pragma omp for simd' directive.
Definition: StmtOpenMP.h:850
Expr * EUB
EnsureUpperBound – expression LB = min(LB, NumIterations).
Definition: StmtOpenMP.h:510
static OMPSectionDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt, bool HasCancel)
Creates directive.
Definition: StmtOpenMP.cpp:245
void setUpperBoundVariable(Expr *UB)
Definition: StmtOpenMP.h:440
static OMPAtomicDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V, Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate)
Creates directive with a list of Clauses and 'x', 'v' and 'expr' parts of the atomic construct (see S...
Definition: StmtOpenMP.cpp:640
static OMPCriticalDirective * Create(const ASTContext &C, const DeclarationNameInfo &Name, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive.
Definition: StmtOpenMP.cpp:313
void setNextLowerBound(Expr *NLB)
Definition: StmtOpenMP.h:461
This represents '#pragma omp parallel for' directive.
Definition: StmtOpenMP.h:1221
void setIsLastIterVariable(Expr *IL)
Definition: StmtOpenMP.h:426
static OMPParallelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:72
static OMPTaskLoopSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:794
static OMPParallelForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:338
void setInit(Expr *Init)
Definition: StmtOpenMP.h:424
Expr * LastIteration
Loop last iteration number.
Definition: StmtOpenMP.h:488
void setFinals(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:51
static OMPTargetDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:687
This represents '#pragma omp parallel' directive.
Definition: StmtOpenMP.h:232
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4381
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:91
static OMPTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:830
static OMPFlushDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:605
This represents '#pragma omp barrier' directive.
Definition: StmtOpenMP.h:1552
This represents '#pragma omp critical' directive.
Definition: StmtOpenMP.h:1147
static OMPCriticalDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:328
static OMPParallelSectionsDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, bool HasCancel)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:432
void setCond(Expr *Cond)
Definition: StmtOpenMP.h:421
static OMPTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:782
static OMPCancelDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, OpenMPDirectiveKind CancelRegion)
Creates directive.
Definition: StmtOpenMP.cpp:568
void setCounters(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:26
This represents '#pragma omp cancellation point' directive.
Definition: StmtOpenMP.h:2107
This represents '#pragma omp teams' directive.
Definition: StmtOpenMP.h:2050
Expr * CalcLastIteration
Calculation of last iteration.
Definition: StmtOpenMP.h:492
static OMPTaskyieldDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:492
Expr * NUB
Update of UpperBound for statically sheduled 'omp for' loops.
Definition: StmtOpenMP.h:514
Expr * Cond
Loop condition.
Definition: StmtOpenMP.h:496
static OMPTargetDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:711
Expr * PreCond
Loop pre-condition.
Definition: StmtOpenMP.h:494
static OMPSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:83
The expressions built for the OpenMP loop CodeGen for the whole collapsed loop nest.
Definition: StmtOpenMP.h:484
static OMPTaskgroupDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:539
This represents '#pragma omp taskgroup' directive.
Definition: StmtOpenMP.h:1640
static OMPSingleDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:283
Expr * IterationVarRef
Loop iteration variable.
Definition: StmtOpenMP.h:486
static OMPTeamsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:737
This represents '#pragma omp distribute' directive.
Definition: StmtOpenMP.h:2361
static OMPTargetDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:671
static OMPSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:111
Expr - This represents one expression.
Definition: Expr.h:104
static unsigned numLoopChildren(unsigned CollapsedNum, OpenMPDirectiveKind Kind)
Children number.
Definition: StmtOpenMP.h:402
static OMPMasterDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt)
Creates directive.
Definition: StmtOpenMP.cpp:293
static OMPOrderedDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive.
Definition: StmtOpenMP.cpp:614
This represents '#pragma omp for' directive.
Definition: StmtOpenMP.h:773
void setAssociatedStmt(Stmt *S)
Set the associated statement for the directive.
Definition: StmtOpenMP.h:86
static OMPDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:876
static OMPParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:421
This represents '#pragma omp cancel' directive.
Definition: StmtOpenMP.h:2165
static OMPTargetDataDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:697
unsigned getNumClauses() const
Get number of clauses.
Definition: StmtOpenMP.h:185
static OMPTaskLoopDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:747
This represents '#pragma omp flush' directive.
Definition: StmtOpenMP.h:1691
This represents '#pragma omp parallel for simd' directive.
Definition: StmtOpenMP.h:1301
Expr * ST
Stride - local variable passed to runtime.
Definition: StmtOpenMP.h:508
static OMPParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:375
SmallVector< Expr *, 4 > PrivateCounters
PrivateCounters Loop counters.
Definition: StmtOpenMP.h:518
void setLowerBoundVariable(Expr *LB)
Definition: StmtOpenMP.h:433
static OMPSectionDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:259
SmallVector< Expr *, 4 > Counters
Counters Loop counters.
Definition: StmtOpenMP.h:516
This represents '#pragma omp single' directive.
Definition: StmtOpenMP.h:1045
Encodes a location in the source.
void setIterationVariable(Expr *IV)
Definition: StmtOpenMP.h:409
static OMPTaskDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:473
static OMPTeamsDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:721
unsigned getCollapsedNumber() const
Get number of collapsed loops.
Definition: StmtOpenMP.h:567
OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:23
static OMPAtomicDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:661
This represents '#pragma omp taskwait' directive.
Definition: StmtOpenMP.h:1596
This is a basic class for representing single OpenMP clause.
Definition: OpenMPClause.h:32
static OMPOrderedDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:630
This represents '#pragma omp target' directive.
Definition: StmtOpenMP.h:1935
void setClauses(ArrayRef< OMPClause * > Clauses)
Sets the list of variables for this clause.
Definition: StmtOpenMP.cpp:20
static OMPForDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:124
This represents '#pragma omp ordered' directive.
Definition: StmtOpenMP.h:1746
Expr * LB
LowerBound - local variable passed to runtime.
Definition: StmtOpenMP.h:504
Expr * Init
Loop iteration variable init.
Definition: StmtOpenMP.h:498
void setPrivateCounters(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:32
static OMPTaskDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, bool HasCancel)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:458
static OMPParallelForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:385
static OMPForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:160
SmallVector< Expr *, 4 > Inits
Expressions for loop counters inits for CodeGen.
Definition: StmtOpenMP.h:520
This represents '#pragma omp section' directive.
Definition: StmtOpenMP.h:983
This represents '#pragma omp simd' directive.
Definition: StmtOpenMP.h:708
detail::InMemoryDirectory::const_iterator E
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
This represents '#pragma omp atomic' directive.
Definition: StmtOpenMP.h:1801
static OMPForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:208
static OMPBarrierDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:506
This file defines OpenMP AST classes for executable directives and clauses.
Expr * Inc
Loop increment.
Definition: StmtOpenMP.h:500
static OMPForSimdDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, const HelperExprs &Exprs)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:173
static OMPSingleDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:267
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:11761
static OMPTaskyieldDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Creates directive.
Definition: StmtOpenMP.cpp:483
Expr * UB
UpperBound - local variable passed to runtime.
Definition: StmtOpenMP.h:506
void setStrideVariable(Expr *ST)
Definition: StmtOpenMP.h:447
static OMPParallelSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:448
static OMPBarrierDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Creates directive.
Definition: StmtOpenMP.cpp:498
void setUpdates(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:45
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:560
static OMPSectionsDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, bool HasCancel)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:220
This represents '#pragma omp taskloop simd' directive.
Definition: StmtOpenMP.h:2295
static OMPSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:235
static OMPTaskgroupDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt)
Creates directive.
Definition: StmtOpenMP.cpp:526
void setPreCond(Expr *PC)
Definition: StmtOpenMP.h:418
static OMPCancelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:582
static OMPTaskwaitDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Creates directive.
Definition: StmtOpenMP.cpp:512
This represents '#pragma omp sections' directive.
Definition: StmtOpenMP.h:915
This represents '#pragma omp target data' directive.
Definition: StmtOpenMP.h:1993
void setNextUpperBound(Expr *NUB)
Definition: StmtOpenMP.h:468
void setInc(Expr *Inc)
Definition: StmtOpenMP.h:425
Expr * IL
IsLastIteration - local flag variable passed to runtime.
Definition: StmtOpenMP.h:502
This represents '#pragma omp taskyield' directive.
Definition: StmtOpenMP.h:1508
static OMPCancellationPointDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, OpenMPDirectiveKind CancelRegion)
Creates directive.
Definition: StmtOpenMP.cpp:547
static OMPFlushDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:592
This represents '#pragma omp parallel sections' directive.
Definition: StmtOpenMP.h:1369
void setCalcLastIteration(Expr *CLI)
Definition: StmtOpenMP.h:415
void setInits(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:39
static OMPParallelDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, bool HasCancel)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:57
static OMPCancellationPointDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:560
This represents '#pragma omp taskloop' directive.
Definition: StmtOpenMP.h:2230