clang  3.9.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 =
61  llvm::alignTo(sizeof(OMPParallelDirective), 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 =
76  llvm::alignTo(sizeof(OMPParallelDirective), 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 =
88  llvm::alignTo(sizeof(OMPSimdDirective), 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  Dir->setPreInits(Exprs.PreInits);
109  return Dir;
110 }
111 
113  unsigned NumClauses,
114  unsigned CollapsedNum,
115  EmptyShell) {
116  unsigned Size =
117  llvm::alignTo(sizeof(OMPSimdDirective), llvm::alignOf<OMPClause *>());
118  void *Mem =
119  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
120  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
121  return new (Mem) OMPSimdDirective(CollapsedNum, NumClauses);
122 }
123 
126  SourceLocation EndLoc, unsigned CollapsedNum,
127  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
128  const HelperExprs &Exprs, bool HasCancel) {
129  unsigned Size =
130  llvm::alignTo(sizeof(OMPForDirective), llvm::alignOf<OMPClause *>());
131  void *Mem =
132  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
133  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
134  OMPForDirective *Dir =
135  new (Mem) OMPForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
136  Dir->setClauses(Clauses);
137  Dir->setAssociatedStmt(AssociatedStmt);
139  Dir->setLastIteration(Exprs.LastIteration);
141  Dir->setPreCond(Exprs.PreCond);
142  Dir->setCond(Exprs.Cond);
143  Dir->setInit(Exprs.Init);
144  Dir->setInc(Exprs.Inc);
145  Dir->setIsLastIterVariable(Exprs.IL);
146  Dir->setLowerBoundVariable(Exprs.LB);
147  Dir->setUpperBoundVariable(Exprs.UB);
148  Dir->setStrideVariable(Exprs.ST);
149  Dir->setEnsureUpperBound(Exprs.EUB);
150  Dir->setNextLowerBound(Exprs.NLB);
151  Dir->setNextUpperBound(Exprs.NUB);
152  Dir->setNumIterations(Exprs.NumIterations);
153  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
154  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
155  Dir->setCounters(Exprs.Counters);
157  Dir->setInits(Exprs.Inits);
158  Dir->setUpdates(Exprs.Updates);
159  Dir->setFinals(Exprs.Finals);
160  Dir->setPreInits(Exprs.PreInits);
161  Dir->setHasCancel(HasCancel);
162  return Dir;
163 }
164 
166  unsigned NumClauses,
167  unsigned CollapsedNum,
168  EmptyShell) {
169  unsigned Size =
170  llvm::alignTo(sizeof(OMPForDirective), llvm::alignOf<OMPClause *>());
171  void *Mem =
172  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
173  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
174  return new (Mem) OMPForDirective(CollapsedNum, NumClauses);
175 }
176 
179  SourceLocation EndLoc, unsigned CollapsedNum,
180  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
181  const HelperExprs &Exprs) {
182  unsigned Size =
183  llvm::alignTo(sizeof(OMPForSimdDirective), llvm::alignOf<OMPClause *>());
184  void *Mem =
185  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
186  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
187  OMPForSimdDirective *Dir = new (Mem)
188  OMPForSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
189  Dir->setClauses(Clauses);
190  Dir->setAssociatedStmt(AssociatedStmt);
192  Dir->setLastIteration(Exprs.LastIteration);
194  Dir->setPreCond(Exprs.PreCond);
195  Dir->setCond(Exprs.Cond);
196  Dir->setInit(Exprs.Init);
197  Dir->setInc(Exprs.Inc);
198  Dir->setIsLastIterVariable(Exprs.IL);
199  Dir->setLowerBoundVariable(Exprs.LB);
200  Dir->setUpperBoundVariable(Exprs.UB);
201  Dir->setStrideVariable(Exprs.ST);
202  Dir->setEnsureUpperBound(Exprs.EUB);
203  Dir->setNextLowerBound(Exprs.NLB);
204  Dir->setNextUpperBound(Exprs.NUB);
205  Dir->setNumIterations(Exprs.NumIterations);
206  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
207  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
208  Dir->setCounters(Exprs.Counters);
210  Dir->setInits(Exprs.Inits);
211  Dir->setUpdates(Exprs.Updates);
212  Dir->setFinals(Exprs.Finals);
213  Dir->setPreInits(Exprs.PreInits);
214  return Dir;
215 }
216 
218  unsigned NumClauses,
219  unsigned CollapsedNum,
220  EmptyShell) {
221  unsigned Size =
222  llvm::alignTo(sizeof(OMPForSimdDirective), llvm::alignOf<OMPClause *>());
223  void *Mem =
224  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
225  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
226  return new (Mem) OMPForSimdDirective(CollapsedNum, NumClauses);
227 }
228 
230  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
231  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
232  unsigned Size =
233  llvm::alignTo(sizeof(OMPSectionsDirective), llvm::alignOf<OMPClause *>());
234  void *Mem =
235  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
236  OMPSectionsDirective *Dir =
237  new (Mem) OMPSectionsDirective(StartLoc, EndLoc, Clauses.size());
238  Dir->setClauses(Clauses);
239  Dir->setAssociatedStmt(AssociatedStmt);
240  Dir->setHasCancel(HasCancel);
241  return Dir;
242 }
243 
245  unsigned NumClauses,
246  EmptyShell) {
247  unsigned Size =
248  llvm::alignTo(sizeof(OMPSectionsDirective), llvm::alignOf<OMPClause *>());
249  void *Mem =
250  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
251  return new (Mem) OMPSectionsDirective(NumClauses);
252 }
253 
255  SourceLocation StartLoc,
256  SourceLocation EndLoc,
257  Stmt *AssociatedStmt,
258  bool HasCancel) {
259  unsigned Size =
260  llvm::alignTo(sizeof(OMPSectionDirective), llvm::alignOf<Stmt *>());
261  void *Mem = C.Allocate(Size + sizeof(Stmt *));
262  OMPSectionDirective *Dir = new (Mem) OMPSectionDirective(StartLoc, EndLoc);
263  Dir->setAssociatedStmt(AssociatedStmt);
264  Dir->setHasCancel(HasCancel);
265  return Dir;
266 }
267 
269  EmptyShell) {
270  unsigned Size =
271  llvm::alignTo(sizeof(OMPSectionDirective), llvm::alignOf<Stmt *>());
272  void *Mem = C.Allocate(Size + sizeof(Stmt *));
273  return new (Mem) OMPSectionDirective();
274 }
275 
277  SourceLocation StartLoc,
278  SourceLocation EndLoc,
279  ArrayRef<OMPClause *> Clauses,
280  Stmt *AssociatedStmt) {
281  unsigned Size =
282  llvm::alignTo(sizeof(OMPSingleDirective), llvm::alignOf<OMPClause *>());
283  void *Mem =
284  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
285  OMPSingleDirective *Dir =
286  new (Mem) OMPSingleDirective(StartLoc, EndLoc, Clauses.size());
287  Dir->setClauses(Clauses);
288  Dir->setAssociatedStmt(AssociatedStmt);
289  return Dir;
290 }
291 
293  unsigned NumClauses,
294  EmptyShell) {
295  unsigned Size =
296  llvm::alignTo(sizeof(OMPSingleDirective), llvm::alignOf<OMPClause *>());
297  void *Mem =
298  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
299  return new (Mem) OMPSingleDirective(NumClauses);
300 }
301 
303  SourceLocation StartLoc,
304  SourceLocation EndLoc,
305  Stmt *AssociatedStmt) {
306  unsigned Size =
307  llvm::alignTo(sizeof(OMPMasterDirective), llvm::alignOf<Stmt *>());
308  void *Mem = C.Allocate(Size + sizeof(Stmt *));
309  OMPMasterDirective *Dir = new (Mem) OMPMasterDirective(StartLoc, EndLoc);
310  Dir->setAssociatedStmt(AssociatedStmt);
311  return Dir;
312 }
313 
315  EmptyShell) {
316  unsigned Size =
317  llvm::alignTo(sizeof(OMPMasterDirective), llvm::alignOf<Stmt *>());
318  void *Mem = C.Allocate(Size + sizeof(Stmt *));
319  return new (Mem) OMPMasterDirective();
320 }
321 
323  const ASTContext &C, const DeclarationNameInfo &Name,
324  SourceLocation StartLoc, SourceLocation EndLoc,
325  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
326  unsigned Size =
327  llvm::alignTo(sizeof(OMPCriticalDirective), llvm::alignOf<OMPClause *>());
328  void *Mem =
329  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
330  OMPCriticalDirective *Dir =
331  new (Mem) OMPCriticalDirective(Name, StartLoc, EndLoc, Clauses.size());
332  Dir->setClauses(Clauses);
333  Dir->setAssociatedStmt(AssociatedStmt);
334  return Dir;
335 }
336 
338  unsigned NumClauses,
339  EmptyShell) {
340  unsigned Size =
341  llvm::alignTo(sizeof(OMPCriticalDirective), llvm::alignOf<OMPClause *>());
342  void *Mem =
343  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
344  return new (Mem) OMPCriticalDirective(NumClauses);
345 }
346 
348  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
349  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
350  const HelperExprs &Exprs, bool HasCancel) {
351  unsigned Size = llvm::alignTo(sizeof(OMPParallelForDirective),
352  llvm::alignOf<OMPClause *>());
353  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
354  sizeof(Stmt *) *
355  numLoopChildren(CollapsedNum, OMPD_parallel_for));
356  OMPParallelForDirective *Dir = new (Mem)
357  OMPParallelForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
358  Dir->setClauses(Clauses);
359  Dir->setAssociatedStmt(AssociatedStmt);
361  Dir->setLastIteration(Exprs.LastIteration);
363  Dir->setPreCond(Exprs.PreCond);
364  Dir->setCond(Exprs.Cond);
365  Dir->setInit(Exprs.Init);
366  Dir->setInc(Exprs.Inc);
367  Dir->setIsLastIterVariable(Exprs.IL);
368  Dir->setLowerBoundVariable(Exprs.LB);
369  Dir->setUpperBoundVariable(Exprs.UB);
370  Dir->setStrideVariable(Exprs.ST);
371  Dir->setEnsureUpperBound(Exprs.EUB);
372  Dir->setNextLowerBound(Exprs.NLB);
373  Dir->setNextUpperBound(Exprs.NUB);
374  Dir->setNumIterations(Exprs.NumIterations);
375  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
376  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
377  Dir->setCounters(Exprs.Counters);
379  Dir->setInits(Exprs.Inits);
380  Dir->setUpdates(Exprs.Updates);
381  Dir->setFinals(Exprs.Finals);
382  Dir->setPreInits(Exprs.PreInits);
383  Dir->setHasCancel(HasCancel);
384  return Dir;
385 }
386 
388 OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
389  unsigned CollapsedNum, EmptyShell) {
390  unsigned Size = llvm::alignTo(sizeof(OMPParallelForDirective),
391  llvm::alignOf<OMPClause *>());
392  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
393  sizeof(Stmt *) *
394  numLoopChildren(CollapsedNum, OMPD_parallel_for));
395  return new (Mem) OMPParallelForDirective(CollapsedNum, NumClauses);
396 }
397 
399  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
400  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
401  const HelperExprs &Exprs) {
402  unsigned Size = llvm::alignTo(sizeof(OMPParallelForSimdDirective),
403  llvm::alignOf<OMPClause *>());
404  void *Mem = C.Allocate(
405  Size + sizeof(OMPClause *) * Clauses.size() +
406  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
408  StartLoc, EndLoc, CollapsedNum, Clauses.size());
409  Dir->setClauses(Clauses);
410  Dir->setAssociatedStmt(AssociatedStmt);
412  Dir->setLastIteration(Exprs.LastIteration);
414  Dir->setPreCond(Exprs.PreCond);
415  Dir->setCond(Exprs.Cond);
416  Dir->setInit(Exprs.Init);
417  Dir->setInc(Exprs.Inc);
418  Dir->setIsLastIterVariable(Exprs.IL);
419  Dir->setLowerBoundVariable(Exprs.LB);
420  Dir->setUpperBoundVariable(Exprs.UB);
421  Dir->setStrideVariable(Exprs.ST);
422  Dir->setEnsureUpperBound(Exprs.EUB);
423  Dir->setNextLowerBound(Exprs.NLB);
424  Dir->setNextUpperBound(Exprs.NUB);
425  Dir->setNumIterations(Exprs.NumIterations);
426  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
427  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
428  Dir->setCounters(Exprs.Counters);
430  Dir->setInits(Exprs.Inits);
431  Dir->setUpdates(Exprs.Updates);
432  Dir->setFinals(Exprs.Finals);
433  Dir->setPreInits(Exprs.PreInits);
434  return Dir;
435 }
436 
439  unsigned NumClauses,
440  unsigned CollapsedNum, EmptyShell) {
441  unsigned Size = llvm::alignTo(sizeof(OMPParallelForSimdDirective),
442  llvm::alignOf<OMPClause *>());
443  void *Mem = C.Allocate(
444  Size + sizeof(OMPClause *) * NumClauses +
445  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
446  return new (Mem) OMPParallelForSimdDirective(CollapsedNum, NumClauses);
447 }
448 
450  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
451  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
452  unsigned Size = llvm::alignTo(sizeof(OMPParallelSectionsDirective),
453  llvm::alignOf<OMPClause *>());
454  void *Mem =
455  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
457  new (Mem) OMPParallelSectionsDirective(StartLoc, EndLoc, Clauses.size());
458  Dir->setClauses(Clauses);
459  Dir->setAssociatedStmt(AssociatedStmt);
460  Dir->setHasCancel(HasCancel);
461  return Dir;
462 }
463 
466  unsigned NumClauses, EmptyShell) {
467  unsigned Size = llvm::alignTo(sizeof(OMPParallelSectionsDirective),
468  llvm::alignOf<OMPClause *>());
469  void *Mem =
470  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
471  return new (Mem) OMPParallelSectionsDirective(NumClauses);
472 }
473 
476  SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
477  Stmt *AssociatedStmt, bool HasCancel) {
478  unsigned Size =
479  llvm::alignTo(sizeof(OMPTaskDirective), llvm::alignOf<OMPClause *>());
480  void *Mem =
481  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
482  OMPTaskDirective *Dir =
483  new (Mem) OMPTaskDirective(StartLoc, EndLoc, Clauses.size());
484  Dir->setClauses(Clauses);
485  Dir->setAssociatedStmt(AssociatedStmt);
486  Dir->setHasCancel(HasCancel);
487  return Dir;
488 }
489 
491  unsigned NumClauses,
492  EmptyShell) {
493  unsigned Size =
494  llvm::alignTo(sizeof(OMPTaskDirective), llvm::alignOf<OMPClause *>());
495  void *Mem =
496  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
497  return new (Mem) OMPTaskDirective(NumClauses);
498 }
499 
501  SourceLocation StartLoc,
502  SourceLocation EndLoc) {
503  void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
504  OMPTaskyieldDirective *Dir =
505  new (Mem) OMPTaskyieldDirective(StartLoc, EndLoc);
506  return Dir;
507 }
508 
510  EmptyShell) {
511  void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
512  return new (Mem) OMPTaskyieldDirective();
513 }
514 
516  SourceLocation StartLoc,
517  SourceLocation EndLoc) {
518  void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
519  OMPBarrierDirective *Dir = new (Mem) OMPBarrierDirective(StartLoc, EndLoc);
520  return Dir;
521 }
522 
524  EmptyShell) {
525  void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
526  return new (Mem) OMPBarrierDirective();
527 }
528 
530  SourceLocation StartLoc,
531  SourceLocation EndLoc) {
532  void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
533  OMPTaskwaitDirective *Dir = new (Mem) OMPTaskwaitDirective(StartLoc, EndLoc);
534  return Dir;
535 }
536 
538  EmptyShell) {
539  void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
540  return new (Mem) OMPTaskwaitDirective();
541 }
542 
544  SourceLocation StartLoc,
545  SourceLocation EndLoc,
546  Stmt *AssociatedStmt) {
547  unsigned Size =
548  llvm::alignTo(sizeof(OMPTaskgroupDirective), llvm::alignOf<Stmt *>());
549  void *Mem = C.Allocate(Size + sizeof(Stmt *));
550  OMPTaskgroupDirective *Dir =
551  new (Mem) OMPTaskgroupDirective(StartLoc, EndLoc);
552  Dir->setAssociatedStmt(AssociatedStmt);
553  return Dir;
554 }
555 
557  EmptyShell) {
558  unsigned Size =
559  llvm::alignTo(sizeof(OMPTaskgroupDirective), llvm::alignOf<Stmt *>());
560  void *Mem = C.Allocate(Size + sizeof(Stmt *));
561  return new (Mem) OMPTaskgroupDirective();
562 }
563 
565  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
566  OpenMPDirectiveKind CancelRegion) {
567  unsigned Size = llvm::alignTo(sizeof(OMPCancellationPointDirective),
568  llvm::alignOf<Stmt *>());
569  void *Mem = C.Allocate(Size);
571  new (Mem) OMPCancellationPointDirective(StartLoc, EndLoc);
572  Dir->setCancelRegion(CancelRegion);
573  return Dir;
574 }
575 
578  unsigned Size = llvm::alignTo(sizeof(OMPCancellationPointDirective),
579  llvm::alignOf<Stmt *>());
580  void *Mem = C.Allocate(Size);
581  return new (Mem) OMPCancellationPointDirective();
582 }
583 
586  SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
587  OpenMPDirectiveKind CancelRegion) {
588  unsigned Size = llvm::alignTo(sizeof(OMPCancelDirective) +
589  sizeof(OMPClause *) * Clauses.size(),
590  llvm::alignOf<Stmt *>());
591  void *Mem = C.Allocate(Size);
592  OMPCancelDirective *Dir =
593  new (Mem) OMPCancelDirective(StartLoc, EndLoc, Clauses.size());
594  Dir->setClauses(Clauses);
595  Dir->setCancelRegion(CancelRegion);
596  return Dir;
597 }
598 
600  unsigned NumClauses,
601  EmptyShell) {
602  unsigned Size = llvm::alignTo(sizeof(OMPCancelDirective) +
603  sizeof(OMPClause *) * NumClauses,
604  llvm::alignOf<Stmt *>());
605  void *Mem = C.Allocate(Size);
606  return new (Mem) OMPCancelDirective(NumClauses);
607 }
608 
610  SourceLocation StartLoc,
611  SourceLocation EndLoc,
612  ArrayRef<OMPClause *> Clauses) {
613  unsigned Size =
614  llvm::alignTo(sizeof(OMPFlushDirective), llvm::alignOf<OMPClause *>());
615  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size());
616  OMPFlushDirective *Dir =
617  new (Mem) OMPFlushDirective(StartLoc, EndLoc, Clauses.size());
618  Dir->setClauses(Clauses);
619  return Dir;
620 }
621 
623  unsigned NumClauses,
624  EmptyShell) {
625  unsigned Size =
626  llvm::alignTo(sizeof(OMPFlushDirective), llvm::alignOf<OMPClause *>());
627  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses);
628  return new (Mem) OMPFlushDirective(NumClauses);
629 }
630 
632  SourceLocation StartLoc,
633  SourceLocation EndLoc,
634  ArrayRef<OMPClause *> Clauses,
635  Stmt *AssociatedStmt) {
636  unsigned Size =
637  llvm::alignTo(sizeof(OMPOrderedDirective), llvm::alignOf<OMPClause *>());
638  void *Mem =
639  C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * Clauses.size());
640  OMPOrderedDirective *Dir =
641  new (Mem) OMPOrderedDirective(StartLoc, EndLoc, Clauses.size());
642  Dir->setClauses(Clauses);
643  Dir->setAssociatedStmt(AssociatedStmt);
644  return Dir;
645 }
646 
648  unsigned NumClauses,
649  EmptyShell) {
650  unsigned Size =
651  llvm::alignTo(sizeof(OMPOrderedDirective), llvm::alignOf<OMPClause *>());
652  void *Mem =
653  C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * NumClauses);
654  return new (Mem) OMPOrderedDirective(NumClauses);
655 }
656 
658  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
659  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
660  Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {
661  unsigned Size =
662  llvm::alignTo(sizeof(OMPAtomicDirective), llvm::alignOf<OMPClause *>());
663  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
664  5 * sizeof(Stmt *));
665  OMPAtomicDirective *Dir =
666  new (Mem) OMPAtomicDirective(StartLoc, EndLoc, Clauses.size());
667  Dir->setClauses(Clauses);
668  Dir->setAssociatedStmt(AssociatedStmt);
669  Dir->setX(X);
670  Dir->setV(V);
671  Dir->setExpr(E);
672  Dir->setUpdateExpr(UE);
673  Dir->IsXLHSInRHSPart = IsXLHSInRHSPart;
674  Dir->IsPostfixUpdate = IsPostfixUpdate;
675  return Dir;
676 }
677 
679  unsigned NumClauses,
680  EmptyShell) {
681  unsigned Size =
682  llvm::alignTo(sizeof(OMPAtomicDirective), llvm::alignOf<OMPClause *>());
683  void *Mem =
684  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 5 * sizeof(Stmt *));
685  return new (Mem) OMPAtomicDirective(NumClauses);
686 }
687 
689  SourceLocation StartLoc,
690  SourceLocation EndLoc,
691  ArrayRef<OMPClause *> Clauses,
692  Stmt *AssociatedStmt) {
693  unsigned Size =
694  llvm::alignTo(sizeof(OMPTargetDirective), llvm::alignOf<OMPClause *>());
695  void *Mem =
696  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
697  OMPTargetDirective *Dir =
698  new (Mem) OMPTargetDirective(StartLoc, EndLoc, Clauses.size());
699  Dir->setClauses(Clauses);
700  Dir->setAssociatedStmt(AssociatedStmt);
701  return Dir;
702 }
703 
705  unsigned NumClauses,
706  EmptyShell) {
707  unsigned Size =
708  llvm::alignTo(sizeof(OMPTargetDirective), llvm::alignOf<OMPClause *>());
709  void *Mem =
710  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
711  return new (Mem) OMPTargetDirective(NumClauses);
712 }
713 
715  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
716  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
717  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelDirective),
718  llvm::alignOf<OMPClause *>());
719  void *Mem =
720  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
722  new (Mem) OMPTargetParallelDirective(StartLoc, EndLoc, Clauses.size());
723  Dir->setClauses(Clauses);
724  Dir->setAssociatedStmt(AssociatedStmt);
725  return Dir;
726 }
727 
730  unsigned NumClauses, EmptyShell) {
731  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelDirective),
732  llvm::alignOf<OMPClause *>());
733  void *Mem =
734  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
735  return new (Mem) OMPTargetParallelDirective(NumClauses);
736 }
737 
739  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
740  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
741  const HelperExprs &Exprs, bool HasCancel) {
742  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForDirective),
743  llvm::alignOf<OMPClause *>());
744  void *Mem = C.Allocate(
745  Size + sizeof(OMPClause *) * Clauses.size() +
746  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_parallel_for));
748  StartLoc, EndLoc, CollapsedNum, Clauses.size());
749  Dir->setClauses(Clauses);
750  Dir->setAssociatedStmt(AssociatedStmt);
752  Dir->setLastIteration(Exprs.LastIteration);
754  Dir->setPreCond(Exprs.PreCond);
755  Dir->setCond(Exprs.Cond);
756  Dir->setInit(Exprs.Init);
757  Dir->setInc(Exprs.Inc);
758  Dir->setIsLastIterVariable(Exprs.IL);
759  Dir->setLowerBoundVariable(Exprs.LB);
760  Dir->setUpperBoundVariable(Exprs.UB);
761  Dir->setStrideVariable(Exprs.ST);
762  Dir->setEnsureUpperBound(Exprs.EUB);
763  Dir->setNextLowerBound(Exprs.NLB);
764  Dir->setNextUpperBound(Exprs.NUB);
765  Dir->setNumIterations(Exprs.NumIterations);
766  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
767  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
768  Dir->setCounters(Exprs.Counters);
770  Dir->setInits(Exprs.Inits);
771  Dir->setUpdates(Exprs.Updates);
772  Dir->setFinals(Exprs.Finals);
773  Dir->setPreInits(Exprs.PreInits);
774  Dir->setHasCancel(HasCancel);
775  return Dir;
776 }
777 
780  unsigned NumClauses,
781  unsigned CollapsedNum, EmptyShell) {
782  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForDirective),
783  llvm::alignOf<OMPClause *>());
784  void *Mem = C.Allocate(
785  Size + sizeof(OMPClause *) * NumClauses +
786  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_parallel_for));
787  return new (Mem) OMPTargetParallelForDirective(CollapsedNum, NumClauses);
788 }
789 
791  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
792  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
793  void *Mem = C.Allocate(llvm::alignTo(sizeof(OMPTargetDataDirective),
794  llvm::alignOf<OMPClause *>()) +
795  sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
797  new (Mem) OMPTargetDataDirective(StartLoc, EndLoc, Clauses.size());
798  Dir->setClauses(Clauses);
799  Dir->setAssociatedStmt(AssociatedStmt);
800  return Dir;
801 }
802 
804  unsigned N,
805  EmptyShell) {
806  void *Mem = C.Allocate(llvm::alignTo(sizeof(OMPTargetDataDirective),
807  llvm::alignOf<OMPClause *>()) +
808  sizeof(OMPClause *) * N + sizeof(Stmt *));
809  return new (Mem) OMPTargetDataDirective(N);
810 }
811 
813  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
814  ArrayRef<OMPClause *> Clauses) {
815  void *Mem = C.Allocate(llvm::alignTo(sizeof(OMPTargetEnterDataDirective),
816  llvm::alignOf<OMPClause *>()) +
817  sizeof(OMPClause *) * Clauses.size());
819  new (Mem) OMPTargetEnterDataDirective(StartLoc, EndLoc, Clauses.size());
820  Dir->setClauses(Clauses);
821  return Dir;
822 }
823 
826  EmptyShell) {
827  void *Mem = C.Allocate(llvm::alignTo(sizeof(OMPTargetEnterDataDirective),
828  llvm::alignOf<OMPClause *>()) +
829  sizeof(OMPClause *) * N);
830  return new (Mem) OMPTargetEnterDataDirective(N);
831 }
832 
835  SourceLocation EndLoc,
836  ArrayRef<OMPClause *> Clauses) {
837  void *Mem = C.Allocate(llvm::alignTo(sizeof(OMPTargetExitDataDirective),
838  llvm::alignOf<OMPClause *>()) +
839  sizeof(OMPClause *) * Clauses.size());
841  new (Mem) OMPTargetExitDataDirective(StartLoc, EndLoc, Clauses.size());
842  Dir->setClauses(Clauses);
843  return Dir;
844 }
845 
848  EmptyShell) {
849  void *Mem = C.Allocate(llvm::alignTo(sizeof(OMPTargetExitDataDirective),
850  llvm::alignOf<OMPClause *>()) +
851  sizeof(OMPClause *) * N);
852  return new (Mem) OMPTargetExitDataDirective(N);
853 }
854 
856  SourceLocation StartLoc,
857  SourceLocation EndLoc,
858  ArrayRef<OMPClause *> Clauses,
859  Stmt *AssociatedStmt) {
860  unsigned Size =
861  llvm::alignTo(sizeof(OMPTeamsDirective), llvm::alignOf<OMPClause *>());
862  void *Mem =
863  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
864  OMPTeamsDirective *Dir =
865  new (Mem) OMPTeamsDirective(StartLoc, EndLoc, Clauses.size());
866  Dir->setClauses(Clauses);
867  Dir->setAssociatedStmt(AssociatedStmt);
868  return Dir;
869 }
870 
872  unsigned NumClauses,
873  EmptyShell) {
874  unsigned Size =
875  llvm::alignTo(sizeof(OMPTeamsDirective), llvm::alignOf<OMPClause *>());
876  void *Mem =
877  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
878  return new (Mem) OMPTeamsDirective(NumClauses);
879 }
880 
882  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
883  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
884  const HelperExprs &Exprs) {
885  unsigned Size =
886  llvm::alignTo(sizeof(OMPTaskLoopDirective), llvm::alignOf<OMPClause *>());
887  void *Mem =
888  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
889  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
890  OMPTaskLoopDirective *Dir = new (Mem)
891  OMPTaskLoopDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
892  Dir->setClauses(Clauses);
893  Dir->setAssociatedStmt(AssociatedStmt);
895  Dir->setLastIteration(Exprs.LastIteration);
897  Dir->setPreCond(Exprs.PreCond);
898  Dir->setCond(Exprs.Cond);
899  Dir->setInit(Exprs.Init);
900  Dir->setInc(Exprs.Inc);
901  Dir->setIsLastIterVariable(Exprs.IL);
902  Dir->setLowerBoundVariable(Exprs.LB);
903  Dir->setUpperBoundVariable(Exprs.UB);
904  Dir->setStrideVariable(Exprs.ST);
905  Dir->setEnsureUpperBound(Exprs.EUB);
906  Dir->setNextLowerBound(Exprs.NLB);
907  Dir->setNextUpperBound(Exprs.NUB);
908  Dir->setNumIterations(Exprs.NumIterations);
909  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
910  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
911  Dir->setCounters(Exprs.Counters);
913  Dir->setInits(Exprs.Inits);
914  Dir->setUpdates(Exprs.Updates);
915  Dir->setFinals(Exprs.Finals);
916  Dir->setPreInits(Exprs.PreInits);
917  return Dir;
918 }
919 
921  unsigned NumClauses,
922  unsigned CollapsedNum,
923  EmptyShell) {
924  unsigned Size =
925  llvm::alignTo(sizeof(OMPTaskLoopDirective), llvm::alignOf<OMPClause *>());
926  void *Mem =
927  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
928  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
929  return new (Mem) OMPTaskLoopDirective(CollapsedNum, NumClauses);
930 }
931 
933  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
934  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
935  const HelperExprs &Exprs) {
936  unsigned Size = llvm::alignTo(sizeof(OMPTaskLoopSimdDirective),
937  llvm::alignOf<OMPClause *>());
938  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
939  sizeof(Stmt *) *
940  numLoopChildren(CollapsedNum, OMPD_taskloop_simd));
941  OMPTaskLoopSimdDirective *Dir = new (Mem)
942  OMPTaskLoopSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
943  Dir->setClauses(Clauses);
944  Dir->setAssociatedStmt(AssociatedStmt);
946  Dir->setLastIteration(Exprs.LastIteration);
948  Dir->setPreCond(Exprs.PreCond);
949  Dir->setCond(Exprs.Cond);
950  Dir->setInit(Exprs.Init);
951  Dir->setInc(Exprs.Inc);
952  Dir->setIsLastIterVariable(Exprs.IL);
953  Dir->setLowerBoundVariable(Exprs.LB);
954  Dir->setUpperBoundVariable(Exprs.UB);
955  Dir->setStrideVariable(Exprs.ST);
956  Dir->setEnsureUpperBound(Exprs.EUB);
957  Dir->setNextLowerBound(Exprs.NLB);
958  Dir->setNextUpperBound(Exprs.NUB);
959  Dir->setNumIterations(Exprs.NumIterations);
960  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
961  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
962  Dir->setCounters(Exprs.Counters);
964  Dir->setInits(Exprs.Inits);
965  Dir->setUpdates(Exprs.Updates);
966  Dir->setFinals(Exprs.Finals);
967  Dir->setPreInits(Exprs.PreInits);
968  return Dir;
969 }
970 
972 OMPTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
973  unsigned CollapsedNum, EmptyShell) {
974  unsigned Size = llvm::alignTo(sizeof(OMPTaskLoopSimdDirective),
975  llvm::alignOf<OMPClause *>());
976  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
977  sizeof(Stmt *) *
978  numLoopChildren(CollapsedNum, OMPD_taskloop_simd));
979  return new (Mem) OMPTaskLoopSimdDirective(CollapsedNum, NumClauses);
980 }
981 
983  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
984  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
985  const HelperExprs &Exprs) {
986  unsigned Size = llvm::alignTo(sizeof(OMPDistributeDirective),
987  llvm::alignOf<OMPClause *>());
988  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
989  sizeof(Stmt *) *
990  numLoopChildren(CollapsedNum, OMPD_distribute));
991  OMPDistributeDirective *Dir = new (Mem)
992  OMPDistributeDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
993  Dir->setClauses(Clauses);
994  Dir->setAssociatedStmt(AssociatedStmt);
996  Dir->setLastIteration(Exprs.LastIteration);
998  Dir->setPreCond(Exprs.PreCond);
999  Dir->setCond(Exprs.Cond);
1000  Dir->setInit(Exprs.Init);
1001  Dir->setInc(Exprs.Inc);
1002  Dir->setIsLastIterVariable(Exprs.IL);
1003  Dir->setLowerBoundVariable(Exprs.LB);
1004  Dir->setUpperBoundVariable(Exprs.UB);
1005  Dir->setStrideVariable(Exprs.ST);
1006  Dir->setEnsureUpperBound(Exprs.EUB);
1007  Dir->setNextLowerBound(Exprs.NLB);
1008  Dir->setNextUpperBound(Exprs.NUB);
1009  Dir->setNumIterations(Exprs.NumIterations);
1010  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1011  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1012  Dir->setCounters(Exprs.Counters);
1013  Dir->setPrivateCounters(Exprs.PrivateCounters);
1014  Dir->setInits(Exprs.Inits);
1015  Dir->setUpdates(Exprs.Updates);
1016  Dir->setFinals(Exprs.Finals);
1017  Dir->setPreInits(Exprs.PreInits);
1018  return Dir;
1019 }
1020 
1022 OMPDistributeDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1023  unsigned CollapsedNum, EmptyShell) {
1024  unsigned Size = llvm::alignTo(sizeof(OMPDistributeDirective),
1025  llvm::alignOf<OMPClause *>());
1026  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1027  sizeof(Stmt *) *
1028  numLoopChildren(CollapsedNum, OMPD_distribute));
1029  return new (Mem) OMPDistributeDirective(CollapsedNum, NumClauses);
1030 }
1031 
1034  SourceLocation EndLoc,
1035  ArrayRef<OMPClause *> Clauses) {
1036  unsigned Size = llvm::alignTo(sizeof(OMPTargetUpdateDirective),
1037  llvm::alignOf<OMPClause *>());
1038  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size());
1040  new (Mem) OMPTargetUpdateDirective(StartLoc, EndLoc, Clauses.size());
1041  Dir->setClauses(Clauses);
1042  return Dir;
1043 }
1044 
1047  EmptyShell) {
1048  unsigned Size = llvm::alignTo(sizeof(OMPTargetUpdateDirective),
1049  llvm::alignOf<OMPClause *>());
1050  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses);
1051  return new (Mem) OMPTargetUpdateDirective(NumClauses);
1052 }
1053 
1055  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1056  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1057  const HelperExprs &Exprs) {
1058  unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForDirective),
1059  llvm::alignOf<OMPClause *>());
1060  void *Mem = C.Allocate(
1061  Size + sizeof(OMPClause *) * Clauses.size() +
1062  sizeof(Stmt *) *
1063  numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for));
1065  new (Mem) OMPDistributeParallelForDirective(StartLoc, EndLoc,
1066  CollapsedNum, Clauses.size());
1067  Dir->setClauses(Clauses);
1068  Dir->setAssociatedStmt(AssociatedStmt);
1070  Dir->setLastIteration(Exprs.LastIteration);
1072  Dir->setPreCond(Exprs.PreCond);
1073  Dir->setCond(Exprs.Cond);
1074  Dir->setInit(Exprs.Init);
1075  Dir->setInc(Exprs.Inc);
1076  Dir->setIsLastIterVariable(Exprs.IL);
1077  Dir->setLowerBoundVariable(Exprs.LB);
1078  Dir->setUpperBoundVariable(Exprs.UB);
1079  Dir->setStrideVariable(Exprs.ST);
1080  Dir->setEnsureUpperBound(Exprs.EUB);
1081  Dir->setNextLowerBound(Exprs.NLB);
1082  Dir->setNextUpperBound(Exprs.NUB);
1083  Dir->setNumIterations(Exprs.NumIterations);
1084  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1085  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1086  Dir->setCounters(Exprs.Counters);
1087  Dir->setPrivateCounters(Exprs.PrivateCounters);
1088  Dir->setInits(Exprs.Inits);
1089  Dir->setUpdates(Exprs.Updates);
1090  Dir->setFinals(Exprs.Finals);
1091  Dir->setPreInits(Exprs.PreInits);
1092  return Dir;
1093 }
1094 
1097  unsigned NumClauses,
1098  unsigned CollapsedNum,
1099  EmptyShell) {
1100  unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForDirective),
1101  llvm::alignOf<OMPClause *>());
1102  void *Mem = C.Allocate(
1103  Size + sizeof(OMPClause *) * NumClauses +
1104  sizeof(Stmt *) *
1105  numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for));
1106  return new (Mem) OMPDistributeParallelForDirective(CollapsedNum, NumClauses);
1107 }
1108 
1111  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1112  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1113  const HelperExprs &Exprs) {
1114  unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForSimdDirective),
1115  llvm::alignOf<OMPClause *>());
1116  void *Mem = C.Allocate(
1117  Size + sizeof(OMPClause *) * Clauses.size() +
1118  sizeof(Stmt *) *
1119  numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd));
1120  OMPDistributeParallelForSimdDirective *Dir = new (Mem)
1121  OMPDistributeParallelForSimdDirective(StartLoc, EndLoc, CollapsedNum,
1122  Clauses.size());
1123  Dir->setClauses(Clauses);
1124  Dir->setAssociatedStmt(AssociatedStmt);
1126  Dir->setLastIteration(Exprs.LastIteration);
1128  Dir->setPreCond(Exprs.PreCond);
1129  Dir->setCond(Exprs.Cond);
1130  Dir->setInit(Exprs.Init);
1131  Dir->setInc(Exprs.Inc);
1132  Dir->setIsLastIterVariable(Exprs.IL);
1133  Dir->setLowerBoundVariable(Exprs.LB);
1134  Dir->setUpperBoundVariable(Exprs.UB);
1135  Dir->setStrideVariable(Exprs.ST);
1136  Dir->setEnsureUpperBound(Exprs.EUB);
1137  Dir->setNextLowerBound(Exprs.NLB);
1138  Dir->setNextUpperBound(Exprs.NUB);
1139  Dir->setNumIterations(Exprs.NumIterations);
1140  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1141  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1142  Dir->setCounters(Exprs.Counters);
1143  Dir->setPrivateCounters(Exprs.PrivateCounters);
1144  Dir->setInits(Exprs.Inits);
1145  Dir->setUpdates(Exprs.Updates);
1146  Dir->setFinals(Exprs.Finals);
1147  Dir->setPreInits(Exprs.PreInits);
1148  return Dir;
1149 }
1150 
1153  unsigned NumClauses,
1154  unsigned CollapsedNum,
1155  EmptyShell) {
1156  unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForSimdDirective),
1157  llvm::alignOf<OMPClause *>());
1158  void *Mem = C.Allocate(
1159  Size + sizeof(OMPClause *) * NumClauses +
1160  sizeof(Stmt *) *
1161  numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd));
1162  return new (Mem)
1163  OMPDistributeParallelForSimdDirective(CollapsedNum, NumClauses);
1164 }
1165 
1167  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1168  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1169  const HelperExprs &Exprs) {
1170  unsigned Size = llvm::alignTo(sizeof(OMPDistributeSimdDirective),
1171  llvm::alignOf<OMPClause *>());
1172  void *Mem = C.Allocate(
1173  Size + sizeof(OMPClause *) * Clauses.size() +
1174  sizeof(Stmt *) *
1175  numLoopChildren(CollapsedNum, OMPD_distribute_simd));
1177  StartLoc, EndLoc, CollapsedNum, Clauses.size());
1178  Dir->setClauses(Clauses);
1179  Dir->setAssociatedStmt(AssociatedStmt);
1181  Dir->setLastIteration(Exprs.LastIteration);
1183  Dir->setPreCond(Exprs.PreCond);
1184  Dir->setCond(Exprs.Cond);
1185  Dir->setInit(Exprs.Init);
1186  Dir->setInc(Exprs.Inc);
1187  Dir->setIsLastIterVariable(Exprs.IL);
1188  Dir->setLowerBoundVariable(Exprs.LB);
1189  Dir->setUpperBoundVariable(Exprs.UB);
1190  Dir->setStrideVariable(Exprs.ST);
1191  Dir->setEnsureUpperBound(Exprs.EUB);
1192  Dir->setNextLowerBound(Exprs.NLB);
1193  Dir->setNextUpperBound(Exprs.NUB);
1194  Dir->setNumIterations(Exprs.NumIterations);
1195  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1196  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1197  Dir->setCounters(Exprs.Counters);
1198  Dir->setPrivateCounters(Exprs.PrivateCounters);
1199  Dir->setInits(Exprs.Inits);
1200  Dir->setUpdates(Exprs.Updates);
1201  Dir->setFinals(Exprs.Finals);
1202  Dir->setPreInits(Exprs.PreInits);
1203  return Dir;
1204 }
1205 
1208  unsigned NumClauses,
1209  unsigned CollapsedNum, EmptyShell) {
1210  unsigned Size = llvm::alignTo(sizeof(OMPDistributeSimdDirective),
1211  llvm::alignOf<OMPClause *>());
1212  void *Mem = C.Allocate(
1213  Size + sizeof(OMPClause *) * NumClauses +
1214  sizeof(Stmt *) *
1215  numLoopChildren(CollapsedNum, OMPD_distribute_simd));
1216  return new (Mem) OMPDistributeSimdDirective(CollapsedNum, NumClauses);
1217 }
1218 
1220  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1221  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1222  const HelperExprs &Exprs) {
1223  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForSimdDirective),
1224  llvm::alignOf<OMPClause *>());
1225  void *Mem = C.Allocate(
1226  Size + sizeof(OMPClause *) * Clauses.size() +
1227  sizeof(Stmt *) *
1228  numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd));
1230  new (Mem) OMPTargetParallelForSimdDirective(StartLoc, EndLoc,
1231  CollapsedNum, Clauses.size());
1232  Dir->setClauses(Clauses);
1233  Dir->setAssociatedStmt(AssociatedStmt);
1235  Dir->setLastIteration(Exprs.LastIteration);
1237  Dir->setPreCond(Exprs.PreCond);
1238  Dir->setCond(Exprs.Cond);
1239  Dir->setInit(Exprs.Init);
1240  Dir->setInc(Exprs.Inc);
1241  Dir->setIsLastIterVariable(Exprs.IL);
1242  Dir->setLowerBoundVariable(Exprs.LB);
1243  Dir->setUpperBoundVariable(Exprs.UB);
1244  Dir->setStrideVariable(Exprs.ST);
1245  Dir->setEnsureUpperBound(Exprs.EUB);
1246  Dir->setNextLowerBound(Exprs.NLB);
1247  Dir->setNextUpperBound(Exprs.NUB);
1248  Dir->setNumIterations(Exprs.NumIterations);
1249  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1250  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1251  Dir->setCounters(Exprs.Counters);
1252  Dir->setPrivateCounters(Exprs.PrivateCounters);
1253  Dir->setInits(Exprs.Inits);
1254  Dir->setUpdates(Exprs.Updates);
1255  Dir->setFinals(Exprs.Finals);
1256  Dir->setPreInits(Exprs.PreInits);
1257  return Dir;
1258 }
1259 
1262  unsigned NumClauses,
1263  unsigned CollapsedNum,
1264  EmptyShell) {
1265  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForSimdDirective),
1266  llvm::alignOf<OMPClause *>());
1267  void *Mem = C.Allocate(
1268  Size + sizeof(OMPClause *) * NumClauses +
1269  sizeof(Stmt *) *
1270  numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd));
1271  return new (Mem) OMPTargetParallelForSimdDirective(CollapsedNum, NumClauses);
1272 }
void setPreInits(Stmt *PreInits)
Definition: StmtOpenMP.h:431
Expr * NLB
Update of LowerBound for statically sheduled 'omp for' loops.
Definition: StmtOpenMP.h:541
Defines the clang::ASTContext interface.
This represents '#pragma omp distribute simd' composite directive.
Definition: StmtOpenMP.h:2966
SmallVector< Expr *, 4 > Finals
Final loop counter values for GodeGen.
Definition: StmtOpenMP.h:559
This represents '#pragma omp master' directive.
Definition: StmtOpenMP.h:1181
SmallVector< Expr *, 4 > Updates
Expressions for loop counters update for CodeGen.
Definition: StmtOpenMP.h:557
This represents '#pragma omp task' directive.
Definition: StmtOpenMP.h:1521
void setEnsureUpperBound(Expr *EUB)
Definition: StmtOpenMP.h:462
static OMPDistributeSimdDirective * 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.
static OMPMasterDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:314
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:982
static OMPDistributeParallelForSimdDirective * 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.
static OMPTaskwaitDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:537
static OMPTargetParallelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:729
void setHasCancel(bool Has)
Set cancel state.
Definition: StmtOpenMP.h:1108
void setLastIteration(Expr *LI)
Definition: StmtOpenMP.h:417
This represents '#pragma omp for simd' directive.
Definition: StmtOpenMP.h:931
Expr * EUB
EnsureUpperBound – expression LB = min(LB, NumIterations).
Definition: StmtOpenMP.h:539
static OMPTargetUpdateDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive with a list of Clauses.
static OMPSectionDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt, bool HasCancel)
Creates directive.
Definition: StmtOpenMP.cpp:254
void setUpperBoundVariable(Expr *UB)
Definition: StmtOpenMP.h:448
void setNumIterations(Expr *NI)
Definition: StmtOpenMP.h:483
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:657
static OMPCriticalDirective * Create(const ASTContext &C, const DeclarationNameInfo &Name, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive.
Definition: StmtOpenMP.cpp:322
void setNextLowerBound(Expr *NLB)
Definition: StmtOpenMP.h:469
This represents '#pragma omp parallel for' directive.
Definition: StmtOpenMP.h:1302
void setIsLastIterVariable(Expr *IL)
Definition: StmtOpenMP.h:434
Expr * PrevLB
PreviousLowerBound - local variable passed to runtime in the enclosing schedule or null if that does ...
Definition: StmtOpenMP.h:546
This represents '#pragma omp target exit data' directive.
Definition: StmtOpenMP.h:2191
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:932
static OMPTargetParallelForSimdDirective * 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.
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:347
static OMPDistributeParallelForDirective * 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.
void setInit(Expr *Init)
Definition: StmtOpenMP.h:429
Expr * LastIteration
Loop last iteration number.
Definition: StmtOpenMP.h:517
static OMPTargetExitDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:847
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:704
This represents '#pragma omp parallel' directive.
Definition: StmtOpenMP.h:231
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4549
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:92
static OMPTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:972
static OMPTargetParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:779
static OMPFlushDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:622
static OMPTargetExitDataDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:834
This represents '#pragma omp barrier' directive.
Definition: StmtOpenMP.h:1633
This represents '#pragma omp critical' directive.
Definition: StmtOpenMP.h:1228
static OMPCriticalDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:337
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:449
void setCond(Expr *Cond)
Definition: StmtOpenMP.h:426
static OMPTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:920
static OMPTargetParallelForDirective * 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:738
This represents '#pragma omp distribute parallel for' composite directive.
Definition: StmtOpenMP.h:2827
static OMPCancelDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, OpenMPDirectiveKind CancelRegion)
Creates directive.
Definition: StmtOpenMP.cpp:585
void setCounters(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:26
static OMPDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp cancellation point' directive.
Definition: StmtOpenMP.h:2446
This represents '#pragma omp teams' directive.
Definition: StmtOpenMP.h:2389
Expr * CalcLastIteration
Calculation of last iteration.
Definition: StmtOpenMP.h:521
static OMPTargetParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTaskyieldDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:509
static OMPTargetEnterDataDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:812
Expr * NUB
Update of UpperBound for statically sheduled 'omp for' loops.
Definition: StmtOpenMP.h:543
Expr * Cond
Loop condition.
Definition: StmtOpenMP.h:525
static OMPTargetDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:803
Expr * PreCond
Loop pre-condition.
Definition: StmtOpenMP.h:523
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
This represents '#pragma omp target parallel for simd' directive.
Definition: StmtOpenMP.h:3034
The expressions built for the OpenMP loop CodeGen for the whole collapsed loop nest.
Definition: StmtOpenMP.h:513
static OMPTaskgroupDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:556
This represents '#pragma omp taskgroup' directive.
Definition: StmtOpenMP.h:1721
static OMPSingleDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:292
Expr * IterationVarRef
Loop iteration variable.
Definition: StmtOpenMP.h:515
static OMPTeamsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:871
This represents '#pragma omp distribute' directive.
Definition: StmtOpenMP.h:2700
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:688
static OMPSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:112
Expr - This represents one expression.
Definition: Expr.h:105
static unsigned numLoopChildren(unsigned CollapsedNum, OpenMPDirectiveKind Kind)
Children number.
Definition: StmtOpenMP.h:407
static OMPDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPMasterDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt)
Creates directive.
Definition: StmtOpenMP.cpp:302
Expr * PrevUB
PreviousUpperBound - local variable passed to runtime in the enclosing schedule or null if that does ...
Definition: StmtOpenMP.h:549
static OMPOrderedDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive.
Definition: StmtOpenMP.cpp:631
This represents '#pragma omp for' directive.
Definition: StmtOpenMP.h:854
static OMPTargetEnterDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:825
void setAssociatedStmt(Stmt *S)
Set the associated statement for the directive.
Definition: StmtOpenMP.h:85
static OMPDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:438
This represents '#pragma omp cancel' directive.
Definition: StmtOpenMP.h:2504
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:790
unsigned getNumClauses() const
Get number of clauses.
Definition: StmtOpenMP.h:184
static OMPDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
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:881
This represents '#pragma omp flush' directive.
Definition: StmtOpenMP.h:1772
This represents '#pragma omp parallel for simd' directive.
Definition: StmtOpenMP.h:1382
Expr * NumIterations
Loop number of iterations.
Definition: StmtOpenMP.h:519
Expr * ST
Stride - local variable passed to runtime.
Definition: StmtOpenMP.h:537
static OMPParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:388
This represents '#pragma omp target enter data' directive.
Definition: StmtOpenMP.h:2132
SmallVector< Expr *, 4 > PrivateCounters
PrivateCounters Loop counters.
Definition: StmtOpenMP.h:553
void setLowerBoundVariable(Expr *LB)
Definition: StmtOpenMP.h:441
static OMPSectionDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:268
SmallVector< Expr *, 4 > Counters
Counters Loop counters.
Definition: StmtOpenMP.h:551
This represents '#pragma omp single' directive.
Definition: StmtOpenMP.h:1126
Encodes a location in the source.
void setPrevLowerBoundVariable(Expr *PrevLB)
Definition: StmtOpenMP.h:490
void setIterationVariable(Expr *IV)
Definition: StmtOpenMP.h:414
static OMPTaskDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:490
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:855
static OMPTargetUpdateDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
unsigned getCollapsedNumber() const
Get number of collapsed loops.
Definition: StmtOpenMP.h:608
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:678
This represents '#pragma omp taskwait' directive.
Definition: StmtOpenMP.h:1677
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:647
This represents '#pragma omp target' directive.
Definition: StmtOpenMP.h:2016
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:125
This represents '#pragma omp ordered' directive.
Definition: StmtOpenMP.h:1827
Expr * LB
LowerBound - local variable passed to runtime.
Definition: StmtOpenMP.h:533
This represents '#pragma omp target update' directive.
Definition: StmtOpenMP.h:2768
Expr * Init
Loop iteration variable init.
Definition: StmtOpenMP.h:527
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:475
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:398
void setPrevUpperBoundVariable(Expr *PrevUB)
Definition: StmtOpenMP.h:497
static OMPForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:165
SmallVector< Expr *, 4 > Inits
Expressions for loop counters inits for CodeGen.
Definition: StmtOpenMP.h:555
This represents '#pragma omp section' directive.
Definition: StmtOpenMP.h:1064
This represents '#pragma omp simd' directive.
Definition: StmtOpenMP.h:789
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:1882
static OMPForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:217
static OMPBarrierDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:523
This file defines OpenMP AST classes for executable directives and clauses.
Expr * Inc
Loop increment.
Definition: StmtOpenMP.h:529
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:178
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:276
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:12171
static OMPTaskyieldDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Creates directive.
Definition: StmtOpenMP.cpp:500
Expr * UB
UpperBound - local variable passed to runtime.
Definition: StmtOpenMP.h:535
This represents '#pragma omp target parallel' directive.
Definition: StmtOpenMP.h:2249
void setStrideVariable(Expr *ST)
Definition: StmtOpenMP.h:455
static OMPParallelSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:465
static OMPBarrierDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Creates directive.
Definition: StmtOpenMP.cpp:515
void setUpdates(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:45
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:568
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:229
This represents '#pragma omp taskloop simd' directive.
Definition: StmtOpenMP.h:2634
static OMPSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:244
static OMPTaskgroupDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt)
Creates directive.
Definition: StmtOpenMP.cpp:543
void setPreCond(Expr *PC)
Definition: StmtOpenMP.h:423
static OMPCancelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:599
static OMPTaskwaitDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Creates directive.
Definition: StmtOpenMP.cpp:529
This represents '#pragma omp sections' directive.
Definition: StmtOpenMP.h:996
Stmt * PreInits
Init statement for all captured expressions.
Definition: StmtOpenMP.h:561
This represents '#pragma omp target data' directive.
Definition: StmtOpenMP.h:2074
void setNextUpperBound(Expr *NUB)
Definition: StmtOpenMP.h:476
static OMPTargetParallelDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:714
void setInc(Expr *Inc)
Definition: StmtOpenMP.h:430
Expr * IL
IsLastIteration - local flag variable passed to runtime.
Definition: StmtOpenMP.h:531
This represents '#pragma omp taskyield' directive.
Definition: StmtOpenMP.h:1589
This represents '#pragma omp distribute parallel for simd' composite directive.
Definition: StmtOpenMP.h:2897
static OMPCancellationPointDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, OpenMPDirectiveKind CancelRegion)
Creates directive.
Definition: StmtOpenMP.cpp:564
static OMPFlushDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:609
This represents '#pragma omp parallel sections' directive.
Definition: StmtOpenMP.h:1450
void setCalcLastIteration(Expr *CLI)
Definition: StmtOpenMP.h:420
void setInits(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:39
This represents '#pragma omp target parallel for' directive.
Definition: StmtOpenMP.h:2309
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:577
This represents '#pragma omp taskloop' directive.
Definition: StmtOpenMP.h:2569