clang  5.0.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), 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), 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::alignTo(sizeof(OMPSimdDirective), alignof(OMPClause *));
88  void *Mem =
89  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
90  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
91  OMPSimdDirective *Dir = new (Mem)
92  OMPSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
93  Dir->setClauses(Clauses);
94  Dir->setAssociatedStmt(AssociatedStmt);
96  Dir->setLastIteration(Exprs.LastIteration);
98  Dir->setPreCond(Exprs.PreCond);
99  Dir->setCond(Exprs.Cond);
100  Dir->setInit(Exprs.Init);
101  Dir->setInc(Exprs.Inc);
102  Dir->setCounters(Exprs.Counters);
104  Dir->setInits(Exprs.Inits);
105  Dir->setUpdates(Exprs.Updates);
106  Dir->setFinals(Exprs.Finals);
107  Dir->setPreInits(Exprs.PreInits);
108  return Dir;
109 }
110 
112  unsigned NumClauses,
113  unsigned CollapsedNum,
114  EmptyShell) {
115  unsigned Size = llvm::alignTo(sizeof(OMPSimdDirective), alignof(OMPClause *));
116  void *Mem =
117  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
118  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
119  return new (Mem) OMPSimdDirective(CollapsedNum, NumClauses);
120 }
121 
124  SourceLocation EndLoc, unsigned CollapsedNum,
125  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
126  const HelperExprs &Exprs, bool HasCancel) {
127  unsigned Size = llvm::alignTo(sizeof(OMPForDirective), alignof(OMPClause *));
128  void *Mem =
129  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
130  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
131  OMPForDirective *Dir =
132  new (Mem) OMPForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
133  Dir->setClauses(Clauses);
134  Dir->setAssociatedStmt(AssociatedStmt);
136  Dir->setLastIteration(Exprs.LastIteration);
138  Dir->setPreCond(Exprs.PreCond);
139  Dir->setCond(Exprs.Cond);
140  Dir->setInit(Exprs.Init);
141  Dir->setInc(Exprs.Inc);
142  Dir->setIsLastIterVariable(Exprs.IL);
143  Dir->setLowerBoundVariable(Exprs.LB);
144  Dir->setUpperBoundVariable(Exprs.UB);
145  Dir->setStrideVariable(Exprs.ST);
146  Dir->setEnsureUpperBound(Exprs.EUB);
147  Dir->setNextLowerBound(Exprs.NLB);
148  Dir->setNextUpperBound(Exprs.NUB);
149  Dir->setNumIterations(Exprs.NumIterations);
150  Dir->setCounters(Exprs.Counters);
152  Dir->setInits(Exprs.Inits);
153  Dir->setUpdates(Exprs.Updates);
154  Dir->setFinals(Exprs.Finals);
155  Dir->setPreInits(Exprs.PreInits);
156  Dir->setHasCancel(HasCancel);
157  return Dir;
158 }
159 
161  unsigned NumClauses,
162  unsigned CollapsedNum,
163  EmptyShell) {
164  unsigned Size = llvm::alignTo(sizeof(OMPForDirective), alignof(OMPClause *));
165  void *Mem =
166  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
167  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
168  return new (Mem) OMPForDirective(CollapsedNum, NumClauses);
169 }
170 
173  SourceLocation EndLoc, unsigned CollapsedNum,
174  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
175  const HelperExprs &Exprs) {
176  unsigned Size =
177  llvm::alignTo(sizeof(OMPForSimdDirective), alignof(OMPClause *));
178  void *Mem =
179  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
180  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
181  OMPForSimdDirective *Dir = new (Mem)
182  OMPForSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
183  Dir->setClauses(Clauses);
184  Dir->setAssociatedStmt(AssociatedStmt);
186  Dir->setLastIteration(Exprs.LastIteration);
188  Dir->setPreCond(Exprs.PreCond);
189  Dir->setCond(Exprs.Cond);
190  Dir->setInit(Exprs.Init);
191  Dir->setInc(Exprs.Inc);
192  Dir->setIsLastIterVariable(Exprs.IL);
193  Dir->setLowerBoundVariable(Exprs.LB);
194  Dir->setUpperBoundVariable(Exprs.UB);
195  Dir->setStrideVariable(Exprs.ST);
196  Dir->setEnsureUpperBound(Exprs.EUB);
197  Dir->setNextLowerBound(Exprs.NLB);
198  Dir->setNextUpperBound(Exprs.NUB);
199  Dir->setNumIterations(Exprs.NumIterations);
200  Dir->setCounters(Exprs.Counters);
202  Dir->setInits(Exprs.Inits);
203  Dir->setUpdates(Exprs.Updates);
204  Dir->setFinals(Exprs.Finals);
205  Dir->setPreInits(Exprs.PreInits);
206  return Dir;
207 }
208 
210  unsigned NumClauses,
211  unsigned CollapsedNum,
212  EmptyShell) {
213  unsigned Size =
214  llvm::alignTo(sizeof(OMPForSimdDirective), alignof(OMPClause *));
215  void *Mem =
216  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
217  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
218  return new (Mem) OMPForSimdDirective(CollapsedNum, NumClauses);
219 }
220 
222  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
223  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
224  unsigned Size =
225  llvm::alignTo(sizeof(OMPSectionsDirective), alignof(OMPClause *));
226  void *Mem =
227  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
228  OMPSectionsDirective *Dir =
229  new (Mem) OMPSectionsDirective(StartLoc, EndLoc, Clauses.size());
230  Dir->setClauses(Clauses);
231  Dir->setAssociatedStmt(AssociatedStmt);
232  Dir->setHasCancel(HasCancel);
233  return Dir;
234 }
235 
237  unsigned NumClauses,
238  EmptyShell) {
239  unsigned Size =
240  llvm::alignTo(sizeof(OMPSectionsDirective), alignof(OMPClause *));
241  void *Mem =
242  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
243  return new (Mem) OMPSectionsDirective(NumClauses);
244 }
245 
247  SourceLocation StartLoc,
248  SourceLocation EndLoc,
249  Stmt *AssociatedStmt,
250  bool HasCancel) {
251  unsigned Size = llvm::alignTo(sizeof(OMPSectionDirective), 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::alignTo(sizeof(OMPSectionDirective), alignof(Stmt *));
262  void *Mem = C.Allocate(Size + sizeof(Stmt *));
263  return new (Mem) OMPSectionDirective();
264 }
265 
267  SourceLocation StartLoc,
268  SourceLocation EndLoc,
269  ArrayRef<OMPClause *> Clauses,
270  Stmt *AssociatedStmt) {
271  unsigned Size =
272  llvm::alignTo(sizeof(OMPSingleDirective), alignof(OMPClause *));
273  void *Mem =
274  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
275  OMPSingleDirective *Dir =
276  new (Mem) OMPSingleDirective(StartLoc, EndLoc, Clauses.size());
277  Dir->setClauses(Clauses);
278  Dir->setAssociatedStmt(AssociatedStmt);
279  return Dir;
280 }
281 
283  unsigned NumClauses,
284  EmptyShell) {
285  unsigned Size =
286  llvm::alignTo(sizeof(OMPSingleDirective), alignof(OMPClause *));
287  void *Mem =
288  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
289  return new (Mem) OMPSingleDirective(NumClauses);
290 }
291 
293  SourceLocation StartLoc,
294  SourceLocation EndLoc,
295  Stmt *AssociatedStmt) {
296  unsigned Size = llvm::alignTo(sizeof(OMPMasterDirective), alignof(Stmt *));
297  void *Mem = C.Allocate(Size + sizeof(Stmt *));
298  OMPMasterDirective *Dir = new (Mem) OMPMasterDirective(StartLoc, EndLoc);
299  Dir->setAssociatedStmt(AssociatedStmt);
300  return Dir;
301 }
302 
304  EmptyShell) {
305  unsigned Size = llvm::alignTo(sizeof(OMPMasterDirective), alignof(Stmt *));
306  void *Mem = C.Allocate(Size + sizeof(Stmt *));
307  return new (Mem) OMPMasterDirective();
308 }
309 
311  const ASTContext &C, const DeclarationNameInfo &Name,
312  SourceLocation StartLoc, SourceLocation EndLoc,
313  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
314  unsigned Size =
315  llvm::alignTo(sizeof(OMPCriticalDirective), alignof(OMPClause *));
316  void *Mem =
317  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
318  OMPCriticalDirective *Dir =
319  new (Mem) OMPCriticalDirective(Name, StartLoc, EndLoc, Clauses.size());
320  Dir->setClauses(Clauses);
321  Dir->setAssociatedStmt(AssociatedStmt);
322  return Dir;
323 }
324 
326  unsigned NumClauses,
327  EmptyShell) {
328  unsigned Size =
329  llvm::alignTo(sizeof(OMPCriticalDirective), alignof(OMPClause *));
330  void *Mem =
331  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
332  return new (Mem) OMPCriticalDirective(NumClauses);
333 }
334 
336  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
337  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
338  const HelperExprs &Exprs, bool HasCancel) {
339  unsigned Size =
340  llvm::alignTo(sizeof(OMPParallelForDirective), alignof(OMPClause *));
341  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
342  sizeof(Stmt *) *
343  numLoopChildren(CollapsedNum, OMPD_parallel_for));
344  OMPParallelForDirective *Dir = new (Mem)
345  OMPParallelForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
346  Dir->setClauses(Clauses);
347  Dir->setAssociatedStmt(AssociatedStmt);
349  Dir->setLastIteration(Exprs.LastIteration);
351  Dir->setPreCond(Exprs.PreCond);
352  Dir->setCond(Exprs.Cond);
353  Dir->setInit(Exprs.Init);
354  Dir->setInc(Exprs.Inc);
355  Dir->setIsLastIterVariable(Exprs.IL);
356  Dir->setLowerBoundVariable(Exprs.LB);
357  Dir->setUpperBoundVariable(Exprs.UB);
358  Dir->setStrideVariable(Exprs.ST);
359  Dir->setEnsureUpperBound(Exprs.EUB);
360  Dir->setNextLowerBound(Exprs.NLB);
361  Dir->setNextUpperBound(Exprs.NUB);
362  Dir->setNumIterations(Exprs.NumIterations);
363  Dir->setCounters(Exprs.Counters);
365  Dir->setInits(Exprs.Inits);
366  Dir->setUpdates(Exprs.Updates);
367  Dir->setFinals(Exprs.Finals);
368  Dir->setPreInits(Exprs.PreInits);
369  Dir->setHasCancel(HasCancel);
370  return Dir;
371 }
372 
374 OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
375  unsigned CollapsedNum, EmptyShell) {
376  unsigned Size =
377  llvm::alignTo(sizeof(OMPParallelForDirective), alignof(OMPClause *));
378  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
379  sizeof(Stmt *) *
380  numLoopChildren(CollapsedNum, OMPD_parallel_for));
381  return new (Mem) OMPParallelForDirective(CollapsedNum, NumClauses);
382 }
383 
385  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
386  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
387  const HelperExprs &Exprs) {
388  unsigned Size =
389  llvm::alignTo(sizeof(OMPParallelForSimdDirective), alignof(OMPClause *));
390  void *Mem = C.Allocate(
391  Size + sizeof(OMPClause *) * Clauses.size() +
392  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
394  StartLoc, EndLoc, CollapsedNum, Clauses.size());
395  Dir->setClauses(Clauses);
396  Dir->setAssociatedStmt(AssociatedStmt);
398  Dir->setLastIteration(Exprs.LastIteration);
400  Dir->setPreCond(Exprs.PreCond);
401  Dir->setCond(Exprs.Cond);
402  Dir->setInit(Exprs.Init);
403  Dir->setInc(Exprs.Inc);
404  Dir->setIsLastIterVariable(Exprs.IL);
405  Dir->setLowerBoundVariable(Exprs.LB);
406  Dir->setUpperBoundVariable(Exprs.UB);
407  Dir->setStrideVariable(Exprs.ST);
408  Dir->setEnsureUpperBound(Exprs.EUB);
409  Dir->setNextLowerBound(Exprs.NLB);
410  Dir->setNextUpperBound(Exprs.NUB);
411  Dir->setNumIterations(Exprs.NumIterations);
412  Dir->setCounters(Exprs.Counters);
414  Dir->setInits(Exprs.Inits);
415  Dir->setUpdates(Exprs.Updates);
416  Dir->setFinals(Exprs.Finals);
417  Dir->setPreInits(Exprs.PreInits);
418  return Dir;
419 }
420 
423  unsigned NumClauses,
424  unsigned CollapsedNum, EmptyShell) {
425  unsigned Size =
426  llvm::alignTo(sizeof(OMPParallelForSimdDirective), alignof(OMPClause *));
427  void *Mem = C.Allocate(
428  Size + sizeof(OMPClause *) * NumClauses +
429  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
430  return new (Mem) OMPParallelForSimdDirective(CollapsedNum, NumClauses);
431 }
432 
434  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
435  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
436  unsigned Size =
437  llvm::alignTo(sizeof(OMPParallelSectionsDirective), alignof(OMPClause *));
438  void *Mem =
439  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
441  new (Mem) OMPParallelSectionsDirective(StartLoc, EndLoc, Clauses.size());
442  Dir->setClauses(Clauses);
443  Dir->setAssociatedStmt(AssociatedStmt);
444  Dir->setHasCancel(HasCancel);
445  return Dir;
446 }
447 
450  unsigned NumClauses, EmptyShell) {
451  unsigned Size =
452  llvm::alignTo(sizeof(OMPParallelSectionsDirective), alignof(OMPClause *));
453  void *Mem =
454  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
455  return new (Mem) OMPParallelSectionsDirective(NumClauses);
456 }
457 
460  SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
461  Stmt *AssociatedStmt, bool HasCancel) {
462  unsigned Size = llvm::alignTo(sizeof(OMPTaskDirective), 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::alignTo(sizeof(OMPTaskDirective), alignof(OMPClause *));
477  void *Mem =
478  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
479  return new (Mem) OMPTaskDirective(NumClauses);
480 }
481 
483  SourceLocation StartLoc,
484  SourceLocation EndLoc) {
485  void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
486  OMPTaskyieldDirective *Dir =
487  new (Mem) OMPTaskyieldDirective(StartLoc, EndLoc);
488  return Dir;
489 }
490 
492  EmptyShell) {
493  void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
494  return new (Mem) OMPTaskyieldDirective();
495 }
496 
498  SourceLocation StartLoc,
499  SourceLocation EndLoc) {
500  void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
501  OMPBarrierDirective *Dir = new (Mem) OMPBarrierDirective(StartLoc, EndLoc);
502  return Dir;
503 }
504 
506  EmptyShell) {
507  void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
508  return new (Mem) OMPBarrierDirective();
509 }
510 
512  SourceLocation StartLoc,
513  SourceLocation EndLoc) {
514  void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
515  OMPTaskwaitDirective *Dir = new (Mem) OMPTaskwaitDirective(StartLoc, EndLoc);
516  return Dir;
517 }
518 
520  EmptyShell) {
521  void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
522  return new (Mem) OMPTaskwaitDirective();
523 }
524 
526  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
527  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
528  unsigned Size = llvm::alignTo(sizeof(OMPTaskgroupDirective) +
529  sizeof(OMPClause *) * Clauses.size(),
530  alignof(Stmt *));
531  void *Mem = C.Allocate(Size + sizeof(Stmt *));
532  OMPTaskgroupDirective *Dir =
533  new (Mem) OMPTaskgroupDirective(StartLoc, EndLoc, Clauses.size());
534  Dir->setAssociatedStmt(AssociatedStmt);
535  Dir->setClauses(Clauses);
536  return Dir;
537 }
538 
540  unsigned NumClauses,
541  EmptyShell) {
542  unsigned Size = llvm::alignTo(sizeof(OMPTaskgroupDirective) +
543  sizeof(OMPClause *) * NumClauses,
544  alignof(Stmt *));
545  void *Mem = C.Allocate(Size + sizeof(Stmt *));
546  return new (Mem) OMPTaskgroupDirective(NumClauses);
547 }
548 
550  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
551  OpenMPDirectiveKind CancelRegion) {
552  unsigned Size =
553  llvm::alignTo(sizeof(OMPCancellationPointDirective), alignof(Stmt *));
554  void *Mem = C.Allocate(Size);
556  new (Mem) OMPCancellationPointDirective(StartLoc, EndLoc);
557  Dir->setCancelRegion(CancelRegion);
558  return Dir;
559 }
560 
563  unsigned Size =
564  llvm::alignTo(sizeof(OMPCancellationPointDirective), alignof(Stmt *));
565  void *Mem = C.Allocate(Size);
566  return new (Mem) OMPCancellationPointDirective();
567 }
568 
571  SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
572  OpenMPDirectiveKind CancelRegion) {
573  unsigned Size = llvm::alignTo(sizeof(OMPCancelDirective) +
574  sizeof(OMPClause *) * Clauses.size(),
575  alignof(Stmt *));
576  void *Mem = C.Allocate(Size);
577  OMPCancelDirective *Dir =
578  new (Mem) OMPCancelDirective(StartLoc, EndLoc, Clauses.size());
579  Dir->setClauses(Clauses);
580  Dir->setCancelRegion(CancelRegion);
581  return Dir;
582 }
583 
585  unsigned NumClauses,
586  EmptyShell) {
587  unsigned Size = llvm::alignTo(sizeof(OMPCancelDirective) +
588  sizeof(OMPClause *) * NumClauses,
589  alignof(Stmt *));
590  void *Mem = C.Allocate(Size);
591  return new (Mem) OMPCancelDirective(NumClauses);
592 }
593 
595  SourceLocation StartLoc,
596  SourceLocation EndLoc,
597  ArrayRef<OMPClause *> Clauses) {
598  unsigned Size =
599  llvm::alignTo(sizeof(OMPFlushDirective), alignof(OMPClause *));
600  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size());
601  OMPFlushDirective *Dir =
602  new (Mem) OMPFlushDirective(StartLoc, EndLoc, Clauses.size());
603  Dir->setClauses(Clauses);
604  return Dir;
605 }
606 
608  unsigned NumClauses,
609  EmptyShell) {
610  unsigned Size =
611  llvm::alignTo(sizeof(OMPFlushDirective), alignof(OMPClause *));
612  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses);
613  return new (Mem) OMPFlushDirective(NumClauses);
614 }
615 
617  SourceLocation StartLoc,
618  SourceLocation EndLoc,
619  ArrayRef<OMPClause *> Clauses,
620  Stmt *AssociatedStmt) {
621  unsigned Size =
622  llvm::alignTo(sizeof(OMPOrderedDirective), alignof(OMPClause *));
623  void *Mem =
624  C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * Clauses.size());
625  OMPOrderedDirective *Dir =
626  new (Mem) OMPOrderedDirective(StartLoc, EndLoc, Clauses.size());
627  Dir->setClauses(Clauses);
628  Dir->setAssociatedStmt(AssociatedStmt);
629  return Dir;
630 }
631 
633  unsigned NumClauses,
634  EmptyShell) {
635  unsigned Size =
636  llvm::alignTo(sizeof(OMPOrderedDirective), alignof(OMPClause *));
637  void *Mem =
638  C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * NumClauses);
639  return new (Mem) OMPOrderedDirective(NumClauses);
640 }
641 
643  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
644  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
645  Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {
646  unsigned Size =
647  llvm::alignTo(sizeof(OMPAtomicDirective), alignof(OMPClause *));
648  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
649  5 * sizeof(Stmt *));
650  OMPAtomicDirective *Dir =
651  new (Mem) OMPAtomicDirective(StartLoc, EndLoc, Clauses.size());
652  Dir->setClauses(Clauses);
653  Dir->setAssociatedStmt(AssociatedStmt);
654  Dir->setX(X);
655  Dir->setV(V);
656  Dir->setExpr(E);
657  Dir->setUpdateExpr(UE);
658  Dir->IsXLHSInRHSPart = IsXLHSInRHSPart;
659  Dir->IsPostfixUpdate = IsPostfixUpdate;
660  return Dir;
661 }
662 
664  unsigned NumClauses,
665  EmptyShell) {
666  unsigned Size =
667  llvm::alignTo(sizeof(OMPAtomicDirective), alignof(OMPClause *));
668  void *Mem =
669  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 5 * sizeof(Stmt *));
670  return new (Mem) OMPAtomicDirective(NumClauses);
671 }
672 
674  SourceLocation StartLoc,
675  SourceLocation EndLoc,
676  ArrayRef<OMPClause *> Clauses,
677  Stmt *AssociatedStmt) {
678  unsigned Size =
679  llvm::alignTo(sizeof(OMPTargetDirective), alignof(OMPClause *));
680  void *Mem =
681  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
682  OMPTargetDirective *Dir =
683  new (Mem) OMPTargetDirective(StartLoc, EndLoc, Clauses.size());
684  Dir->setClauses(Clauses);
685  Dir->setAssociatedStmt(AssociatedStmt);
686  return Dir;
687 }
688 
690  unsigned NumClauses,
691  EmptyShell) {
692  unsigned Size =
693  llvm::alignTo(sizeof(OMPTargetDirective), alignof(OMPClause *));
694  void *Mem =
695  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
696  return new (Mem) OMPTargetDirective(NumClauses);
697 }
698 
700  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
701  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
702  unsigned Size =
703  llvm::alignTo(sizeof(OMPTargetParallelDirective), alignof(OMPClause *));
704  void *Mem =
705  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
707  new (Mem) OMPTargetParallelDirective(StartLoc, EndLoc, Clauses.size());
708  Dir->setClauses(Clauses);
709  Dir->setAssociatedStmt(AssociatedStmt);
710  return Dir;
711 }
712 
715  unsigned NumClauses, EmptyShell) {
716  unsigned Size =
717  llvm::alignTo(sizeof(OMPTargetParallelDirective), alignof(OMPClause *));
718  void *Mem =
719  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
720  return new (Mem) OMPTargetParallelDirective(NumClauses);
721 }
722 
724  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
725  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
726  const HelperExprs &Exprs, bool HasCancel) {
727  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForDirective),
728  alignof(OMPClause *));
729  void *Mem = C.Allocate(
730  Size + sizeof(OMPClause *) * Clauses.size() +
731  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_parallel_for));
733  StartLoc, EndLoc, CollapsedNum, Clauses.size());
734  Dir->setClauses(Clauses);
735  Dir->setAssociatedStmt(AssociatedStmt);
737  Dir->setLastIteration(Exprs.LastIteration);
739  Dir->setPreCond(Exprs.PreCond);
740  Dir->setCond(Exprs.Cond);
741  Dir->setInit(Exprs.Init);
742  Dir->setInc(Exprs.Inc);
743  Dir->setIsLastIterVariable(Exprs.IL);
744  Dir->setLowerBoundVariable(Exprs.LB);
745  Dir->setUpperBoundVariable(Exprs.UB);
746  Dir->setStrideVariable(Exprs.ST);
747  Dir->setEnsureUpperBound(Exprs.EUB);
748  Dir->setNextLowerBound(Exprs.NLB);
749  Dir->setNextUpperBound(Exprs.NUB);
750  Dir->setNumIterations(Exprs.NumIterations);
751  Dir->setCounters(Exprs.Counters);
753  Dir->setInits(Exprs.Inits);
754  Dir->setUpdates(Exprs.Updates);
755  Dir->setFinals(Exprs.Finals);
756  Dir->setPreInits(Exprs.PreInits);
757  Dir->setHasCancel(HasCancel);
758  return Dir;
759 }
760 
763  unsigned NumClauses,
764  unsigned CollapsedNum, EmptyShell) {
765  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForDirective),
766  alignof(OMPClause *));
767  void *Mem = C.Allocate(
768  Size + sizeof(OMPClause *) * NumClauses +
769  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_parallel_for));
770  return new (Mem) OMPTargetParallelForDirective(CollapsedNum, NumClauses);
771 }
772 
774  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
775  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
776  void *Mem = C.Allocate(
777  llvm::alignTo(sizeof(OMPTargetDataDirective), alignof(OMPClause *)) +
778  sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
780  new (Mem) OMPTargetDataDirective(StartLoc, EndLoc, Clauses.size());
781  Dir->setClauses(Clauses);
782  Dir->setAssociatedStmt(AssociatedStmt);
783  return Dir;
784 }
785 
787  unsigned N,
788  EmptyShell) {
789  void *Mem = C.Allocate(
790  llvm::alignTo(sizeof(OMPTargetDataDirective), alignof(OMPClause *)) +
791  sizeof(OMPClause *) * N + sizeof(Stmt *));
792  return new (Mem) OMPTargetDataDirective(N);
793 }
794 
796  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
797  ArrayRef<OMPClause *> Clauses) {
798  void *Mem = C.Allocate(
799  llvm::alignTo(sizeof(OMPTargetEnterDataDirective), alignof(OMPClause *)) +
800  sizeof(OMPClause *) * Clauses.size());
802  new (Mem) OMPTargetEnterDataDirective(StartLoc, EndLoc, Clauses.size());
803  Dir->setClauses(Clauses);
804  return Dir;
805 }
806 
809  EmptyShell) {
810  void *Mem = C.Allocate(
811  llvm::alignTo(sizeof(OMPTargetEnterDataDirective), alignof(OMPClause *)) +
812  sizeof(OMPClause *) * N);
813  return new (Mem) OMPTargetEnterDataDirective(N);
814 }
815 
818  SourceLocation EndLoc,
819  ArrayRef<OMPClause *> Clauses) {
820  void *Mem = C.Allocate(
821  llvm::alignTo(sizeof(OMPTargetExitDataDirective), alignof(OMPClause *)) +
822  sizeof(OMPClause *) * Clauses.size());
824  new (Mem) OMPTargetExitDataDirective(StartLoc, EndLoc, Clauses.size());
825  Dir->setClauses(Clauses);
826  return Dir;
827 }
828 
831  EmptyShell) {
832  void *Mem = C.Allocate(
833  llvm::alignTo(sizeof(OMPTargetExitDataDirective), alignof(OMPClause *)) +
834  sizeof(OMPClause *) * N);
835  return new (Mem) OMPTargetExitDataDirective(N);
836 }
837 
839  SourceLocation StartLoc,
840  SourceLocation EndLoc,
841  ArrayRef<OMPClause *> Clauses,
842  Stmt *AssociatedStmt) {
843  unsigned Size =
844  llvm::alignTo(sizeof(OMPTeamsDirective), alignof(OMPClause *));
845  void *Mem =
846  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
847  OMPTeamsDirective *Dir =
848  new (Mem) OMPTeamsDirective(StartLoc, EndLoc, Clauses.size());
849  Dir->setClauses(Clauses);
850  Dir->setAssociatedStmt(AssociatedStmt);
851  return Dir;
852 }
853 
855  unsigned NumClauses,
856  EmptyShell) {
857  unsigned Size =
858  llvm::alignTo(sizeof(OMPTeamsDirective), alignof(OMPClause *));
859  void *Mem =
860  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
861  return new (Mem) OMPTeamsDirective(NumClauses);
862 }
863 
865  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
866  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
867  const HelperExprs &Exprs) {
868  unsigned Size =
869  llvm::alignTo(sizeof(OMPTaskLoopDirective), alignof(OMPClause *));
870  void *Mem =
871  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
872  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
873  OMPTaskLoopDirective *Dir = new (Mem)
874  OMPTaskLoopDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
875  Dir->setClauses(Clauses);
876  Dir->setAssociatedStmt(AssociatedStmt);
878  Dir->setLastIteration(Exprs.LastIteration);
880  Dir->setPreCond(Exprs.PreCond);
881  Dir->setCond(Exprs.Cond);
882  Dir->setInit(Exprs.Init);
883  Dir->setInc(Exprs.Inc);
884  Dir->setIsLastIterVariable(Exprs.IL);
885  Dir->setLowerBoundVariable(Exprs.LB);
886  Dir->setUpperBoundVariable(Exprs.UB);
887  Dir->setStrideVariable(Exprs.ST);
888  Dir->setEnsureUpperBound(Exprs.EUB);
889  Dir->setNextLowerBound(Exprs.NLB);
890  Dir->setNextUpperBound(Exprs.NUB);
891  Dir->setNumIterations(Exprs.NumIterations);
892  Dir->setCounters(Exprs.Counters);
894  Dir->setInits(Exprs.Inits);
895  Dir->setUpdates(Exprs.Updates);
896  Dir->setFinals(Exprs.Finals);
897  Dir->setPreInits(Exprs.PreInits);
898  return Dir;
899 }
900 
902  unsigned NumClauses,
903  unsigned CollapsedNum,
904  EmptyShell) {
905  unsigned Size =
906  llvm::alignTo(sizeof(OMPTaskLoopDirective), alignof(OMPClause *));
907  void *Mem =
908  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
909  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
910  return new (Mem) OMPTaskLoopDirective(CollapsedNum, NumClauses);
911 }
912 
914  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
915  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
916  const HelperExprs &Exprs) {
917  unsigned Size =
918  llvm::alignTo(sizeof(OMPTaskLoopSimdDirective), alignof(OMPClause *));
919  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
920  sizeof(Stmt *) *
921  numLoopChildren(CollapsedNum, OMPD_taskloop_simd));
922  OMPTaskLoopSimdDirective *Dir = new (Mem)
923  OMPTaskLoopSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
924  Dir->setClauses(Clauses);
925  Dir->setAssociatedStmt(AssociatedStmt);
927  Dir->setLastIteration(Exprs.LastIteration);
929  Dir->setPreCond(Exprs.PreCond);
930  Dir->setCond(Exprs.Cond);
931  Dir->setInit(Exprs.Init);
932  Dir->setInc(Exprs.Inc);
933  Dir->setIsLastIterVariable(Exprs.IL);
934  Dir->setLowerBoundVariable(Exprs.LB);
935  Dir->setUpperBoundVariable(Exprs.UB);
936  Dir->setStrideVariable(Exprs.ST);
937  Dir->setEnsureUpperBound(Exprs.EUB);
938  Dir->setNextLowerBound(Exprs.NLB);
939  Dir->setNextUpperBound(Exprs.NUB);
940  Dir->setNumIterations(Exprs.NumIterations);
941  Dir->setCounters(Exprs.Counters);
943  Dir->setInits(Exprs.Inits);
944  Dir->setUpdates(Exprs.Updates);
945  Dir->setFinals(Exprs.Finals);
946  Dir->setPreInits(Exprs.PreInits);
947  return Dir;
948 }
949 
951 OMPTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
952  unsigned CollapsedNum, EmptyShell) {
953  unsigned Size =
954  llvm::alignTo(sizeof(OMPTaskLoopSimdDirective), alignof(OMPClause *));
955  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
956  sizeof(Stmt *) *
957  numLoopChildren(CollapsedNum, OMPD_taskloop_simd));
958  return new (Mem) OMPTaskLoopSimdDirective(CollapsedNum, NumClauses);
959 }
960 
962  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
963  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
964  const HelperExprs &Exprs) {
965  unsigned Size =
966  llvm::alignTo(sizeof(OMPDistributeDirective), alignof(OMPClause *));
967  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
968  sizeof(Stmt *) *
969  numLoopChildren(CollapsedNum, OMPD_distribute));
970  OMPDistributeDirective *Dir = new (Mem)
971  OMPDistributeDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
972  Dir->setClauses(Clauses);
973  Dir->setAssociatedStmt(AssociatedStmt);
975  Dir->setLastIteration(Exprs.LastIteration);
977  Dir->setPreCond(Exprs.PreCond);
978  Dir->setCond(Exprs.Cond);
979  Dir->setInit(Exprs.Init);
980  Dir->setInc(Exprs.Inc);
981  Dir->setIsLastIterVariable(Exprs.IL);
982  Dir->setLowerBoundVariable(Exprs.LB);
983  Dir->setUpperBoundVariable(Exprs.UB);
984  Dir->setStrideVariable(Exprs.ST);
985  Dir->setEnsureUpperBound(Exprs.EUB);
986  Dir->setNextLowerBound(Exprs.NLB);
987  Dir->setNextUpperBound(Exprs.NUB);
988  Dir->setNumIterations(Exprs.NumIterations);
989  Dir->setCounters(Exprs.Counters);
991  Dir->setInits(Exprs.Inits);
992  Dir->setUpdates(Exprs.Updates);
993  Dir->setFinals(Exprs.Finals);
994  Dir->setPreInits(Exprs.PreInits);
995  return Dir;
996 }
997 
999 OMPDistributeDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1000  unsigned CollapsedNum, EmptyShell) {
1001  unsigned Size =
1002  llvm::alignTo(sizeof(OMPDistributeDirective), alignof(OMPClause *));
1003  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1004  sizeof(Stmt *) *
1005  numLoopChildren(CollapsedNum, OMPD_distribute));
1006  return new (Mem) OMPDistributeDirective(CollapsedNum, NumClauses);
1007 }
1008 
1011  SourceLocation EndLoc,
1012  ArrayRef<OMPClause *> Clauses) {
1013  unsigned Size =
1014  llvm::alignTo(sizeof(OMPTargetUpdateDirective), alignof(OMPClause *));
1015  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size());
1017  new (Mem) OMPTargetUpdateDirective(StartLoc, EndLoc, Clauses.size());
1018  Dir->setClauses(Clauses);
1019  return Dir;
1020 }
1021 
1024  EmptyShell) {
1025  unsigned Size =
1026  llvm::alignTo(sizeof(OMPTargetUpdateDirective), alignof(OMPClause *));
1027  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses);
1028  return new (Mem) OMPTargetUpdateDirective(NumClauses);
1029 }
1030 
1032  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1033  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1034  const HelperExprs &Exprs) {
1035  unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForDirective),
1036  alignof(OMPClause *));
1037  void *Mem = C.Allocate(
1038  Size + sizeof(OMPClause *) * Clauses.size() +
1039  sizeof(Stmt *) *
1040  numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for));
1042  new (Mem) OMPDistributeParallelForDirective(StartLoc, EndLoc,
1043  CollapsedNum, Clauses.size());
1044  Dir->setClauses(Clauses);
1045  Dir->setAssociatedStmt(AssociatedStmt);
1047  Dir->setLastIteration(Exprs.LastIteration);
1049  Dir->setPreCond(Exprs.PreCond);
1050  Dir->setCond(Exprs.Cond);
1051  Dir->setInit(Exprs.Init);
1052  Dir->setInc(Exprs.Inc);
1053  Dir->setIsLastIterVariable(Exprs.IL);
1054  Dir->setLowerBoundVariable(Exprs.LB);
1055  Dir->setUpperBoundVariable(Exprs.UB);
1056  Dir->setStrideVariable(Exprs.ST);
1057  Dir->setEnsureUpperBound(Exprs.EUB);
1058  Dir->setNextLowerBound(Exprs.NLB);
1059  Dir->setNextUpperBound(Exprs.NUB);
1060  Dir->setNumIterations(Exprs.NumIterations);
1061  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1062  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1063  Dir->setDistInc(Exprs.DistInc);
1064  Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1065  Dir->setCounters(Exprs.Counters);
1066  Dir->setPrivateCounters(Exprs.PrivateCounters);
1067  Dir->setInits(Exprs.Inits);
1068  Dir->setUpdates(Exprs.Updates);
1069  Dir->setFinals(Exprs.Finals);
1070  Dir->setPreInits(Exprs.PreInits);
1078  return Dir;
1079 }
1080 
1083  unsigned NumClauses,
1084  unsigned CollapsedNum,
1085  EmptyShell) {
1086  unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForDirective),
1087  alignof(OMPClause *));
1088  void *Mem = C.Allocate(
1089  Size + sizeof(OMPClause *) * NumClauses +
1090  sizeof(Stmt *) *
1091  numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for));
1092  return new (Mem) OMPDistributeParallelForDirective(CollapsedNum, NumClauses);
1093 }
1094 
1097  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1098  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1099  const HelperExprs &Exprs) {
1100  unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForSimdDirective),
1101  alignof(OMPClause *));
1102  void *Mem = C.Allocate(
1103  Size + sizeof(OMPClause *) * Clauses.size() +
1104  sizeof(Stmt *) *
1105  numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd));
1106  OMPDistributeParallelForSimdDirective *Dir = new (Mem)
1107  OMPDistributeParallelForSimdDirective(StartLoc, EndLoc, CollapsedNum,
1108  Clauses.size());
1109  Dir->setClauses(Clauses);
1110  Dir->setAssociatedStmt(AssociatedStmt);
1112  Dir->setLastIteration(Exprs.LastIteration);
1114  Dir->setPreCond(Exprs.PreCond);
1115  Dir->setCond(Exprs.Cond);
1116  Dir->setInit(Exprs.Init);
1117  Dir->setInc(Exprs.Inc);
1118  Dir->setIsLastIterVariable(Exprs.IL);
1119  Dir->setLowerBoundVariable(Exprs.LB);
1120  Dir->setUpperBoundVariable(Exprs.UB);
1121  Dir->setStrideVariable(Exprs.ST);
1122  Dir->setEnsureUpperBound(Exprs.EUB);
1123  Dir->setNextLowerBound(Exprs.NLB);
1124  Dir->setNextUpperBound(Exprs.NUB);
1125  Dir->setNumIterations(Exprs.NumIterations);
1126  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1127  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1128  Dir->setDistInc(Exprs.DistInc);
1129  Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1130  Dir->setCounters(Exprs.Counters);
1131  Dir->setPrivateCounters(Exprs.PrivateCounters);
1132  Dir->setInits(Exprs.Inits);
1133  Dir->setUpdates(Exprs.Updates);
1134  Dir->setFinals(Exprs.Finals);
1135  Dir->setPreInits(Exprs.PreInits);
1143  return Dir;
1144 }
1145 
1148  unsigned NumClauses,
1149  unsigned CollapsedNum,
1150  EmptyShell) {
1151  unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForSimdDirective),
1152  alignof(OMPClause *));
1153  void *Mem = C.Allocate(
1154  Size + sizeof(OMPClause *) * NumClauses +
1155  sizeof(Stmt *) *
1156  numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd));
1157  return new (Mem)
1158  OMPDistributeParallelForSimdDirective(CollapsedNum, NumClauses);
1159 }
1160 
1162  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1163  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1164  const HelperExprs &Exprs) {
1165  unsigned Size =
1166  llvm::alignTo(sizeof(OMPDistributeSimdDirective), alignof(OMPClause *));
1167  void *Mem = C.Allocate(
1168  Size + sizeof(OMPClause *) * Clauses.size() +
1169  sizeof(Stmt *) *
1170  numLoopChildren(CollapsedNum, OMPD_distribute_simd));
1172  StartLoc, EndLoc, CollapsedNum, Clauses.size());
1173  Dir->setClauses(Clauses);
1174  Dir->setAssociatedStmt(AssociatedStmt);
1176  Dir->setLastIteration(Exprs.LastIteration);
1178  Dir->setPreCond(Exprs.PreCond);
1179  Dir->setCond(Exprs.Cond);
1180  Dir->setInit(Exprs.Init);
1181  Dir->setInc(Exprs.Inc);
1182  Dir->setIsLastIterVariable(Exprs.IL);
1183  Dir->setLowerBoundVariable(Exprs.LB);
1184  Dir->setUpperBoundVariable(Exprs.UB);
1185  Dir->setStrideVariable(Exprs.ST);
1186  Dir->setEnsureUpperBound(Exprs.EUB);
1187  Dir->setNextLowerBound(Exprs.NLB);
1188  Dir->setNextUpperBound(Exprs.NUB);
1189  Dir->setNumIterations(Exprs.NumIterations);
1190  Dir->setCounters(Exprs.Counters);
1191  Dir->setPrivateCounters(Exprs.PrivateCounters);
1192  Dir->setInits(Exprs.Inits);
1193  Dir->setUpdates(Exprs.Updates);
1194  Dir->setFinals(Exprs.Finals);
1195  Dir->setPreInits(Exprs.PreInits);
1196  return Dir;
1197 }
1198 
1201  unsigned NumClauses,
1202  unsigned CollapsedNum, EmptyShell) {
1203  unsigned Size =
1204  llvm::alignTo(sizeof(OMPDistributeSimdDirective), alignof(OMPClause *));
1205  void *Mem = C.Allocate(
1206  Size + sizeof(OMPClause *) * NumClauses +
1207  sizeof(Stmt *) *
1208  numLoopChildren(CollapsedNum, OMPD_distribute_simd));
1209  return new (Mem) OMPDistributeSimdDirective(CollapsedNum, NumClauses);
1210 }
1211 
1213  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1214  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1215  const HelperExprs &Exprs) {
1216  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForSimdDirective),
1217  alignof(OMPClause *));
1218  void *Mem = C.Allocate(
1219  Size + sizeof(OMPClause *) * Clauses.size() +
1220  sizeof(Stmt *) *
1221  numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd));
1223  new (Mem) OMPTargetParallelForSimdDirective(StartLoc, EndLoc,
1224  CollapsedNum, Clauses.size());
1225  Dir->setClauses(Clauses);
1226  Dir->setAssociatedStmt(AssociatedStmt);
1228  Dir->setLastIteration(Exprs.LastIteration);
1230  Dir->setPreCond(Exprs.PreCond);
1231  Dir->setCond(Exprs.Cond);
1232  Dir->setInit(Exprs.Init);
1233  Dir->setInc(Exprs.Inc);
1234  Dir->setIsLastIterVariable(Exprs.IL);
1235  Dir->setLowerBoundVariable(Exprs.LB);
1236  Dir->setUpperBoundVariable(Exprs.UB);
1237  Dir->setStrideVariable(Exprs.ST);
1238  Dir->setEnsureUpperBound(Exprs.EUB);
1239  Dir->setNextLowerBound(Exprs.NLB);
1240  Dir->setNextUpperBound(Exprs.NUB);
1241  Dir->setNumIterations(Exprs.NumIterations);
1242  Dir->setCounters(Exprs.Counters);
1243  Dir->setPrivateCounters(Exprs.PrivateCounters);
1244  Dir->setInits(Exprs.Inits);
1245  Dir->setUpdates(Exprs.Updates);
1246  Dir->setFinals(Exprs.Finals);
1247  Dir->setPreInits(Exprs.PreInits);
1248  return Dir;
1249 }
1250 
1253  unsigned NumClauses,
1254  unsigned CollapsedNum,
1255  EmptyShell) {
1256  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForSimdDirective),
1257  alignof(OMPClause *));
1258  void *Mem = C.Allocate(
1259  Size + sizeof(OMPClause *) * NumClauses +
1260  sizeof(Stmt *) *
1261  numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd));
1262  return new (Mem) OMPTargetParallelForSimdDirective(CollapsedNum, NumClauses);
1263 }
1264 
1267  SourceLocation EndLoc, unsigned CollapsedNum,
1268  ArrayRef<OMPClause *> Clauses,
1269  Stmt *AssociatedStmt, const HelperExprs &Exprs) {
1270  unsigned Size =
1271  llvm::alignTo(sizeof(OMPTargetSimdDirective), alignof(OMPClause *));
1272  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1273  sizeof(Stmt *) *
1274  numLoopChildren(CollapsedNum, OMPD_target_simd));
1275  OMPTargetSimdDirective *Dir = new (Mem)
1276  OMPTargetSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
1277  Dir->setClauses(Clauses);
1278  Dir->setAssociatedStmt(AssociatedStmt);
1280  Dir->setLastIteration(Exprs.LastIteration);
1282  Dir->setPreCond(Exprs.PreCond);
1283  Dir->setCond(Exprs.Cond);
1284  Dir->setInit(Exprs.Init);
1285  Dir->setInc(Exprs.Inc);
1286  Dir->setCounters(Exprs.Counters);
1287  Dir->setPrivateCounters(Exprs.PrivateCounters);
1288  Dir->setInits(Exprs.Inits);
1289  Dir->setUpdates(Exprs.Updates);
1290  Dir->setFinals(Exprs.Finals);
1291  Dir->setPreInits(Exprs.PreInits);
1292  return Dir;
1293 }
1294 
1296 OMPTargetSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1297  unsigned CollapsedNum, EmptyShell) {
1298  unsigned Size =
1299  llvm::alignTo(sizeof(OMPTargetSimdDirective), alignof(OMPClause *));
1300  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1301  sizeof(Stmt *) *
1302  numLoopChildren(CollapsedNum, OMPD_target_simd));
1303  return new (Mem) OMPTargetSimdDirective(CollapsedNum, NumClauses);
1304 }
1305 
1307  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1308  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1309  const HelperExprs &Exprs) {
1310  unsigned Size =
1311  llvm::alignTo(sizeof(OMPTeamsDistributeDirective), alignof(OMPClause *));
1312  void *Mem = C.Allocate(
1313  Size + sizeof(OMPClause *) * Clauses.size() +
1314  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_teams_distribute));
1316  StartLoc, EndLoc, CollapsedNum, Clauses.size());
1317  Dir->setClauses(Clauses);
1318  Dir->setAssociatedStmt(AssociatedStmt);
1320  Dir->setLastIteration(Exprs.LastIteration);
1322  Dir->setPreCond(Exprs.PreCond);
1323  Dir->setCond(Exprs.Cond);
1324  Dir->setInit(Exprs.Init);
1325  Dir->setInc(Exprs.Inc);
1326  Dir->setIsLastIterVariable(Exprs.IL);
1327  Dir->setLowerBoundVariable(Exprs.LB);
1328  Dir->setUpperBoundVariable(Exprs.UB);
1329  Dir->setStrideVariable(Exprs.ST);
1330  Dir->setEnsureUpperBound(Exprs.EUB);
1331  Dir->setNextLowerBound(Exprs.NLB);
1332  Dir->setNextUpperBound(Exprs.NUB);
1333  Dir->setNumIterations(Exprs.NumIterations);
1334  Dir->setCounters(Exprs.Counters);
1335  Dir->setPrivateCounters(Exprs.PrivateCounters);
1336  Dir->setInits(Exprs.Inits);
1337  Dir->setUpdates(Exprs.Updates);
1338  Dir->setFinals(Exprs.Finals);
1339  Dir->setPreInits(Exprs.PreInits);
1340  return Dir;
1341 }
1342 
1345  unsigned NumClauses,
1346  unsigned CollapsedNum, EmptyShell) {
1347  unsigned Size =
1348  llvm::alignTo(sizeof(OMPTeamsDistributeDirective), alignof(OMPClause *));
1349  void *Mem = C.Allocate(
1350  Size + sizeof(OMPClause *) * NumClauses +
1351  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_teams_distribute));
1352  return new (Mem) OMPTeamsDistributeDirective(CollapsedNum, NumClauses);
1353 }
1354 
1356  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1357  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1358  const HelperExprs &Exprs) {
1359  unsigned Size = llvm::alignTo(sizeof(OMPTeamsDistributeSimdDirective),
1360  alignof(OMPClause *));
1361  void *Mem =
1362  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1363  sizeof(Stmt *) *
1364  numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd));
1366  new (Mem) OMPTeamsDistributeSimdDirective(StartLoc, EndLoc, CollapsedNum,
1367  Clauses.size());
1368  Dir->setClauses(Clauses);
1369  Dir->setAssociatedStmt(AssociatedStmt);
1371  Dir->setLastIteration(Exprs.LastIteration);
1373  Dir->setPreCond(Exprs.PreCond);
1374  Dir->setCond(Exprs.Cond);
1375  Dir->setInit(Exprs.Init);
1376  Dir->setInc(Exprs.Inc);
1377  Dir->setIsLastIterVariable(Exprs.IL);
1378  Dir->setLowerBoundVariable(Exprs.LB);
1379  Dir->setUpperBoundVariable(Exprs.UB);
1380  Dir->setStrideVariable(Exprs.ST);
1381  Dir->setEnsureUpperBound(Exprs.EUB);
1382  Dir->setNextLowerBound(Exprs.NLB);
1383  Dir->setNextUpperBound(Exprs.NUB);
1384  Dir->setNumIterations(Exprs.NumIterations);
1385  Dir->setCounters(Exprs.Counters);
1386  Dir->setPrivateCounters(Exprs.PrivateCounters);
1387  Dir->setInits(Exprs.Inits);
1388  Dir->setUpdates(Exprs.Updates);
1389  Dir->setFinals(Exprs.Finals);
1390  Dir->setPreInits(Exprs.PreInits);
1391  return Dir;
1392 }
1393 
1395  const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
1396  EmptyShell) {
1397  unsigned Size = llvm::alignTo(sizeof(OMPTeamsDistributeSimdDirective),
1398  alignof(OMPClause *));
1399  void *Mem =
1400  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1401  sizeof(Stmt *) *
1402  numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd));
1403  return new (Mem) OMPTeamsDistributeSimdDirective(CollapsedNum, NumClauses);
1404 }
1405 
1408  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1409  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1410  const HelperExprs &Exprs) {
1411  auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForSimdDirective),
1412  alignof(OMPClause *));
1413  void *Mem =
1414  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1415  sizeof(Stmt *) *
1416  numLoopChildren(CollapsedNum,
1417  OMPD_teams_distribute_parallel_for_simd));
1419  OMPTeamsDistributeParallelForSimdDirective(StartLoc, EndLoc, CollapsedNum,
1420  Clauses.size());
1421  Dir->setClauses(Clauses);
1422  Dir->setAssociatedStmt(AssociatedStmt);
1424  Dir->setLastIteration(Exprs.LastIteration);
1426  Dir->setPreCond(Exprs.PreCond);
1427  Dir->setCond(Exprs.Cond);
1428  Dir->setInit(Exprs.Init);
1429  Dir->setInc(Exprs.Inc);
1430  Dir->setIsLastIterVariable(Exprs.IL);
1431  Dir->setLowerBoundVariable(Exprs.LB);
1432  Dir->setUpperBoundVariable(Exprs.UB);
1433  Dir->setStrideVariable(Exprs.ST);
1434  Dir->setEnsureUpperBound(Exprs.EUB);
1435  Dir->setNextLowerBound(Exprs.NLB);
1436  Dir->setNextUpperBound(Exprs.NUB);
1437  Dir->setNumIterations(Exprs.NumIterations);
1438  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1439  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1440  Dir->setDistInc(Exprs.DistInc);
1441  Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1442  Dir->setCounters(Exprs.Counters);
1443  Dir->setPrivateCounters(Exprs.PrivateCounters);
1444  Dir->setInits(Exprs.Inits);
1445  Dir->setUpdates(Exprs.Updates);
1446  Dir->setFinals(Exprs.Finals);
1447  Dir->setPreInits(Exprs.PreInits);
1455  return Dir;
1456 }
1457 
1460  unsigned NumClauses,
1461  unsigned CollapsedNum,
1462  EmptyShell) {
1463  auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForSimdDirective),
1464  alignof(OMPClause *));
1465  void *Mem =
1466  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1467  sizeof(Stmt *) *
1468  numLoopChildren(CollapsedNum,
1469  OMPD_teams_distribute_parallel_for_simd));
1470  return new (Mem)
1471  OMPTeamsDistributeParallelForSimdDirective(CollapsedNum, NumClauses);
1472 }
1473 
1476  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1477  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1478  const HelperExprs &Exprs) {
1479  auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForDirective),
1480  alignof(OMPClause *));
1481  void *Mem = C.Allocate(
1482  Size + sizeof(OMPClause *) * Clauses.size() +
1483  sizeof(Stmt *) *
1484  numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for));
1486  OMPTeamsDistributeParallelForDirective(StartLoc, EndLoc, CollapsedNum,
1487  Clauses.size());
1488  Dir->setClauses(Clauses);
1489  Dir->setAssociatedStmt(AssociatedStmt);
1491  Dir->setLastIteration(Exprs.LastIteration);
1493  Dir->setPreCond(Exprs.PreCond);
1494  Dir->setCond(Exprs.Cond);
1495  Dir->setInit(Exprs.Init);
1496  Dir->setInc(Exprs.Inc);
1497  Dir->setIsLastIterVariable(Exprs.IL);
1498  Dir->setLowerBoundVariable(Exprs.LB);
1499  Dir->setUpperBoundVariable(Exprs.UB);
1500  Dir->setStrideVariable(Exprs.ST);
1501  Dir->setEnsureUpperBound(Exprs.EUB);
1502  Dir->setNextLowerBound(Exprs.NLB);
1503  Dir->setNextUpperBound(Exprs.NUB);
1504  Dir->setNumIterations(Exprs.NumIterations);
1505  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1506  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1507  Dir->setDistInc(Exprs.DistInc);
1508  Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1509  Dir->setCounters(Exprs.Counters);
1510  Dir->setPrivateCounters(Exprs.PrivateCounters);
1511  Dir->setInits(Exprs.Inits);
1512  Dir->setUpdates(Exprs.Updates);
1513  Dir->setFinals(Exprs.Finals);
1514  Dir->setPreInits(Exprs.PreInits);
1522  return Dir;
1523 }
1524 
1527  unsigned NumClauses,
1528  unsigned CollapsedNum,
1529  EmptyShell) {
1530  auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForDirective),
1531  alignof(OMPClause *));
1532  void *Mem = C.Allocate(
1533  Size + sizeof(OMPClause *) * NumClauses +
1534  sizeof(Stmt *) *
1535  numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for));
1536  return new (Mem)
1537  OMPTeamsDistributeParallelForDirective(CollapsedNum, NumClauses);
1538 }
1539 
1541  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1542  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1543  auto Size =
1544  llvm::alignTo(sizeof(OMPTargetTeamsDirective), alignof(OMPClause *));
1545  void *Mem =
1546  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
1548  new (Mem) OMPTargetTeamsDirective(StartLoc, EndLoc, Clauses.size());
1549  Dir->setClauses(Clauses);
1550  Dir->setAssociatedStmt(AssociatedStmt);
1551  return Dir;
1552 }
1553 
1555 OMPTargetTeamsDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
1556  EmptyShell) {
1557  auto Size =
1558  llvm::alignTo(sizeof(OMPTargetTeamsDirective), alignof(OMPClause *));
1559  void *Mem =
1560  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
1561  return new (Mem) OMPTargetTeamsDirective(NumClauses);
1562 }
1563 
1565  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1566  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1567  const HelperExprs &Exprs) {
1568  auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeDirective),
1569  alignof(OMPClause *));
1570  void *Mem = C.Allocate(
1571  Size + sizeof(OMPClause *) * Clauses.size() +
1572  sizeof(Stmt *) *
1573  numLoopChildren(CollapsedNum, OMPD_target_teams_distribute));
1575  new (Mem) OMPTargetTeamsDistributeDirective(StartLoc, EndLoc, CollapsedNum,
1576  Clauses.size());
1577  Dir->setClauses(Clauses);
1578  Dir->setAssociatedStmt(AssociatedStmt);
1580  Dir->setLastIteration(Exprs.LastIteration);
1582  Dir->setPreCond(Exprs.PreCond);
1583  Dir->setCond(Exprs.Cond);
1584  Dir->setInit(Exprs.Init);
1585  Dir->setInc(Exprs.Inc);
1586  Dir->setIsLastIterVariable(Exprs.IL);
1587  Dir->setLowerBoundVariable(Exprs.LB);
1588  Dir->setUpperBoundVariable(Exprs.UB);
1589  Dir->setStrideVariable(Exprs.ST);
1590  Dir->setEnsureUpperBound(Exprs.EUB);
1591  Dir->setNextLowerBound(Exprs.NLB);
1592  Dir->setNextUpperBound(Exprs.NUB);
1593  Dir->setNumIterations(Exprs.NumIterations);
1594  Dir->setCounters(Exprs.Counters);
1595  Dir->setPrivateCounters(Exprs.PrivateCounters);
1596  Dir->setInits(Exprs.Inits);
1597  Dir->setUpdates(Exprs.Updates);
1598  Dir->setFinals(Exprs.Finals);
1599  Dir->setPreInits(Exprs.PreInits);
1600  return Dir;
1601 }
1602 
1605  unsigned NumClauses,
1606  unsigned CollapsedNum,
1607  EmptyShell) {
1608  auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeDirective),
1609  alignof(OMPClause *));
1610  void *Mem = C.Allocate(
1611  Size + sizeof(OMPClause *) * NumClauses +
1612  sizeof(Stmt *) *
1613  numLoopChildren(CollapsedNum, OMPD_target_teams_distribute));
1614  return new (Mem) OMPTargetTeamsDistributeDirective(CollapsedNum, NumClauses);
1615 }
1616 
1619  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1620  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1621  const HelperExprs &Exprs) {
1622  auto Size =
1623  llvm::alignTo(sizeof(OMPTargetTeamsDistributeParallelForDirective),
1624  alignof(OMPClause *));
1625  void *Mem = C.Allocate(
1626  Size + sizeof(OMPClause *) * Clauses.size() +
1627  sizeof(Stmt *) *
1628  numLoopChildren(CollapsedNum,
1629  OMPD_target_teams_distribute_parallel_for));
1632  StartLoc, EndLoc, CollapsedNum, Clauses.size());
1633  Dir->setClauses(Clauses);
1634  Dir->setAssociatedStmt(AssociatedStmt);
1636  Dir->setLastIteration(Exprs.LastIteration);
1638  Dir->setPreCond(Exprs.PreCond);
1639  Dir->setCond(Exprs.Cond);
1640  Dir->setInit(Exprs.Init);
1641  Dir->setInc(Exprs.Inc);
1642  Dir->setIsLastIterVariable(Exprs.IL);
1643  Dir->setLowerBoundVariable(Exprs.LB);
1644  Dir->setUpperBoundVariable(Exprs.UB);
1645  Dir->setStrideVariable(Exprs.ST);
1646  Dir->setEnsureUpperBound(Exprs.EUB);
1647  Dir->setNextLowerBound(Exprs.NLB);
1648  Dir->setNextUpperBound(Exprs.NUB);
1649  Dir->setNumIterations(Exprs.NumIterations);
1650  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1651  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1652  Dir->setDistInc(Exprs.DistInc);
1653  Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1654  Dir->setCounters(Exprs.Counters);
1655  Dir->setPrivateCounters(Exprs.PrivateCounters);
1656  Dir->setInits(Exprs.Inits);
1657  Dir->setUpdates(Exprs.Updates);
1658  Dir->setFinals(Exprs.Finals);
1659  Dir->setPreInits(Exprs.PreInits);
1667  return Dir;
1668 }
1669 
1672  unsigned NumClauses,
1673  unsigned CollapsedNum,
1674  EmptyShell) {
1675  auto Size =
1676  llvm::alignTo(sizeof(OMPTargetTeamsDistributeParallelForDirective),
1677  alignof(OMPClause *));
1678  void *Mem = C.Allocate(
1679  Size + sizeof(OMPClause *) * NumClauses +
1680  sizeof(Stmt *) *
1681  numLoopChildren(CollapsedNum,
1682  OMPD_target_teams_distribute_parallel_for));
1683  return new (Mem)
1684  OMPTargetTeamsDistributeParallelForDirective(CollapsedNum, NumClauses);
1685 }
1686 
1689  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1690  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1691  const HelperExprs &Exprs) {
1692  auto Size =
1694  alignof(OMPClause *));
1695  void *Mem = C.Allocate(
1696  Size + sizeof(OMPClause *) * Clauses.size() +
1697  sizeof(Stmt *) *
1698  numLoopChildren(CollapsedNum,
1699  OMPD_target_teams_distribute_parallel_for_simd));
1702  StartLoc, EndLoc, CollapsedNum, Clauses.size());
1703  Dir->setClauses(Clauses);
1704  Dir->setAssociatedStmt(AssociatedStmt);
1706  Dir->setLastIteration(Exprs.LastIteration);
1708  Dir->setPreCond(Exprs.PreCond);
1709  Dir->setCond(Exprs.Cond);
1710  Dir->setInit(Exprs.Init);
1711  Dir->setInc(Exprs.Inc);
1712  Dir->setIsLastIterVariable(Exprs.IL);
1713  Dir->setLowerBoundVariable(Exprs.LB);
1714  Dir->setUpperBoundVariable(Exprs.UB);
1715  Dir->setStrideVariable(Exprs.ST);
1716  Dir->setEnsureUpperBound(Exprs.EUB);
1717  Dir->setNextLowerBound(Exprs.NLB);
1718  Dir->setNextUpperBound(Exprs.NUB);
1719  Dir->setNumIterations(Exprs.NumIterations);
1720  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1721  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1722  Dir->setDistInc(Exprs.DistInc);
1723  Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1724  Dir->setCounters(Exprs.Counters);
1725  Dir->setPrivateCounters(Exprs.PrivateCounters);
1726  Dir->setInits(Exprs.Inits);
1727  Dir->setUpdates(Exprs.Updates);
1728  Dir->setFinals(Exprs.Finals);
1729  Dir->setPreInits(Exprs.PreInits);
1737  return Dir;
1738 }
1739 
1742  const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
1743  EmptyShell) {
1744  auto Size =
1746  alignof(OMPClause *));
1747  void *Mem = C.Allocate(
1748  Size + sizeof(OMPClause *) * NumClauses +
1749  sizeof(Stmt *) *
1750  numLoopChildren(CollapsedNum,
1751  OMPD_target_teams_distribute_parallel_for_simd));
1753  CollapsedNum, NumClauses);
1754 }
1755 
1758  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1759  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1760  const HelperExprs &Exprs) {
1761  auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeSimdDirective),
1762  alignof(OMPClause *));
1763  void *Mem = C.Allocate(
1764  Size + sizeof(OMPClause *) * Clauses.size() +
1765  sizeof(Stmt *) *
1766  numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd));
1767  OMPTargetTeamsDistributeSimdDirective *Dir = new (Mem)
1768  OMPTargetTeamsDistributeSimdDirective(StartLoc, EndLoc, CollapsedNum,
1769  Clauses.size());
1770  Dir->setClauses(Clauses);
1771  Dir->setAssociatedStmt(AssociatedStmt);
1773  Dir->setLastIteration(Exprs.LastIteration);
1775  Dir->setPreCond(Exprs.PreCond);
1776  Dir->setCond(Exprs.Cond);
1777  Dir->setInit(Exprs.Init);
1778  Dir->setInc(Exprs.Inc);
1779  Dir->setIsLastIterVariable(Exprs.IL);
1780  Dir->setLowerBoundVariable(Exprs.LB);
1781  Dir->setUpperBoundVariable(Exprs.UB);
1782  Dir->setStrideVariable(Exprs.ST);
1783  Dir->setEnsureUpperBound(Exprs.EUB);
1784  Dir->setNextLowerBound(Exprs.NLB);
1785  Dir->setNextUpperBound(Exprs.NUB);
1786  Dir->setNumIterations(Exprs.NumIterations);
1787  Dir->setCounters(Exprs.Counters);
1788  Dir->setPrivateCounters(Exprs.PrivateCounters);
1789  Dir->setInits(Exprs.Inits);
1790  Dir->setUpdates(Exprs.Updates);
1791  Dir->setFinals(Exprs.Finals);
1792  Dir->setPreInits(Exprs.PreInits);
1793  return Dir;
1794 }
1795 
1798  unsigned NumClauses,
1799  unsigned CollapsedNum,
1800  EmptyShell) {
1801  auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeSimdDirective),
1802  alignof(OMPClause *));
1803  void *Mem = C.Allocate(
1804  Size + sizeof(OMPClause *) * NumClauses +
1805  sizeof(Stmt *) *
1806  numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd));
1807  return new (Mem)
1808  OMPTargetTeamsDistributeSimdDirective(CollapsedNum, NumClauses);
1809 }
void setPreInits(Stmt *PreInits)
Definition: StmtOpenMP.h:469
Expr * NLB
Update of LowerBound for statically sheduled 'omp for' loops.
Definition: StmtOpenMP.h:647
Defines the clang::ASTContext interface.
This represents '#pragma omp distribute simd' composite directive.
Definition: StmtOpenMP.h:3155
SmallVector< Expr *, 4 > Finals
Final loop counter values for GodeGen.
Definition: StmtOpenMP.h:675
This represents '#pragma omp master' directive.
Definition: StmtOpenMP.h:1364
Expr * NUB
Update of UpperBound for statically sheduled omp loops for outer loop in combined constructs (e...
Definition: StmtOpenMP.h:614
SmallVector< Expr *, 4 > Updates
Expressions for loop counters update for CodeGen.
Definition: StmtOpenMP.h:673
This represents '#pragma omp task' directive.
Definition: StmtOpenMP.h:1704
void setEnsureUpperBound(Expr *EUB)
Definition: StmtOpenMP.h:500
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:303
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:961
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.
void setCombinedCond(Expr *CombCond)
Definition: StmtOpenMP.h:568
void setCombinedLowerBoundVariable(Expr *CombLB)
Definition: StmtOpenMP.h:548
static OMPTaskwaitDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:519
static OMPTargetParallelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:714
void setHasCancel(bool Has)
Set cancel state.
Definition: StmtOpenMP.h:1291
Stmt - This represents one statement.
Definition: Stmt.h:60
static OMPTaskgroupDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:539
void setLastIteration(Expr *LI)
Definition: StmtOpenMP.h:455
This represents '#pragma omp for simd' directive.
Definition: StmtOpenMP.h:1114
Expr * EUB
EnsureUpperBound – expression UB = min(UB, NumIterations).
Definition: StmtOpenMP.h:645
Expr * DistInc
DistInc - increment expression for distribute loop when found combined with a further loop level (e...
Definition: StmtOpenMP.h:659
static OMPTargetUpdateDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive with a list of Clauses.
This represents '#pragma omp teams distribute parallel for' composite directive.
Definition: StmtOpenMP.h:3566
static OMPSectionDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt, bool HasCancel)
Creates directive.
Definition: StmtOpenMP.cpp:246
void setPrevEnsureUpperBound(Expr *PrevEUB)
Definition: StmtOpenMP.h:543
void setUpperBoundVariable(Expr *UB)
Definition: StmtOpenMP.h:486
void setNumIterations(Expr *NI)
Definition: StmtOpenMP.h:521
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:642
This represents '#pragma omp target teams distribute' combined directive.
Definition: StmtOpenMP.h:3693
static OMPCriticalDirective * Create(const ASTContext &C, const DeclarationNameInfo &Name, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive.
Definition: StmtOpenMP.cpp:310
void setNextLowerBound(Expr *NLB)
Definition: StmtOpenMP.h:507
This represents '#pragma omp parallel for' directive.
Definition: StmtOpenMP.h:1485
This represents '#pragma omp target teams distribute parallel for' combined directive.
Definition: StmtOpenMP.h:3761
void setIsLastIterVariable(Expr *IL)
Definition: StmtOpenMP.h:472
Expr * PrevLB
PreviousLowerBound - local variable passed to runtime in the enclosing schedule or null if that does ...
Definition: StmtOpenMP.h:652
This represents '#pragma omp target exit data' directive.
Definition: StmtOpenMP.h:2380
static OMPTargetTeamsDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
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:913
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:335
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:467
Expr * LastIteration
Loop last iteration number.
Definition: StmtOpenMP.h:623
static OMPTargetExitDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:830
void setFinals(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:51
static OMPTargetTeamsDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTargetDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:689
This represents '#pragma omp parallel' directive.
Definition: StmtOpenMP.h:251
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:128
static OMPTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:951
static OMPTargetParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:762
static OMPFlushDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:607
static OMPTargetExitDataDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:817
This represents '#pragma omp target simd' directive.
Definition: StmtOpenMP.h:3291
This represents '#pragma omp barrier' directive.
Definition: StmtOpenMP.h:1816
This represents '#pragma omp critical' directive.
Definition: StmtOpenMP.h:1411
static OMPCriticalDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:325
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:433
void setCond(Expr *Cond)
Definition: StmtOpenMP.h:464
static OMPTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:901
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:723
This represents '#pragma omp distribute parallel for' composite directive.
Definition: StmtOpenMP.h:3016
This represents '#pragma omp teams distribute parallel for simd' composite directive.
Definition: StmtOpenMP.h:3495
static OMPCancelDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, OpenMPDirectiveKind CancelRegion)
Creates directive.
Definition: StmtOpenMP.cpp:570
static OMPTaskgroupDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive.
Definition: StmtOpenMP.cpp:525
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.
Expr * LB
DistributeLowerBound - used when composing 'omp distribute' with 'omp for' in a same construct...
Definition: StmtOpenMP.h:595
Expr * EUB
DistributeEnsureUpperBound - used when composing 'omp distribute' with 'omp for' in a same construct...
Definition: StmtOpenMP.h:601
static OMPTargetTeamsDistributeParallelForDirective * 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:2635
void setCombinedInit(Expr *CombInit)
Definition: StmtOpenMP.h:563
This represents '#pragma omp teams' directive.
Definition: StmtOpenMP.h:2578
Expr * CalcLastIteration
Calculation of last iteration.
Definition: StmtOpenMP.h:627
This represents '#pragma omp teams distribute simd' combined directive.
Definition: StmtOpenMP.h:3425
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:491
static OMPTargetEnterDataDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:795
Expr * NUB
Update of UpperBound for statically sheduled 'omp for' loops.
Definition: StmtOpenMP.h:649
Expr * Cond
Loop condition.
Definition: StmtOpenMP.h:631
static OMPTargetDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:786
static OMPTeamsDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Expr * PreCond
Loop pre-condition.
Definition: StmtOpenMP.h:629
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:3223
The expressions built for the OpenMP loop CodeGen for the whole collapsed loop nest.
Definition: StmtOpenMP.h:619
static OMPTargetSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp taskgroup' directive.
Definition: StmtOpenMP.h:1904
static OMPTeamsDistributeSimdDirective * 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 OMPSingleDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:282
static OMPTargetTeamsDistributeDirective * 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.
Expr * IterationVarRef
Loop iteration variable.
Definition: StmtOpenMP.h:621
Expr * Init
Distribute loop iteration variable init used when composing 'omp distribute' with 'omp for' in a same...
Definition: StmtOpenMP.h:605
static OMPTeamsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:854
This represents '#pragma omp distribute' directive.
Definition: StmtOpenMP.h:2889
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:673
static OMPTargetTeamsDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
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:105
static unsigned numLoopChildren(unsigned CollapsedNum, OpenMPDirectiveKind Kind)
Children number.
Definition: StmtOpenMP.h:445
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:292
This represents '#pragma omp target teams distribute parallel for simd' combined directive.
Definition: StmtOpenMP.h:3834
This represents '#pragma omp target teams distribute simd' combined directive.
Definition: StmtOpenMP.h:3907
static OMPTeamsDistributeParallelForSimdDirective * 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.
Expr * PrevUB
PreviousUpperBound - local variable passed to runtime in the enclosing schedule or null if that does ...
Definition: StmtOpenMP.h:655
static OMPOrderedDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive.
Definition: StmtOpenMP.cpp:616
This represents '#pragma omp for' directive.
Definition: StmtOpenMP.h:1037
static OMPTargetEnterDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:808
This represents '#pragma omp target teams' directive.
Definition: StmtOpenMP.h:3634
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.
Definition: StmtOpenMP.cpp:999
static OMPParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:422
This represents '#pragma omp cancel' directive.
Definition: StmtOpenMP.h:2693
void setDistInc(Expr *DistInc)
Definition: StmtOpenMP.h:538
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:773
Expr * NLB
Update of LowerBound for statically sheduled omp loops for outer loop in combined constructs (e...
Definition: StmtOpenMP.h:611
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:864
This represents '#pragma omp flush' directive.
Definition: StmtOpenMP.h:1961
This represents '#pragma omp parallel for simd' directive.
Definition: StmtOpenMP.h:1565
Expr * NumIterations
Loop number of iterations.
Definition: StmtOpenMP.h:625
Expr * ST
Stride - local variable passed to runtime.
Definition: StmtOpenMP.h:643
static OMPParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:374
This represents '#pragma omp target enter data' directive.
Definition: StmtOpenMP.h:2321
SmallVector< Expr *, 4 > PrivateCounters
PrivateCounters Loop counters.
Definition: StmtOpenMP.h:669
void setLowerBoundVariable(Expr *LB)
Definition: StmtOpenMP.h:479
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:667
This represents '#pragma omp single' directive.
Definition: StmtOpenMP.h:1309
Encodes a location in the source.
void setPrevLowerBoundVariable(Expr *PrevLB)
Definition: StmtOpenMP.h:528
void setIterationVariable(Expr *IV)
Definition: StmtOpenMP.h:452
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:838
static OMPTargetUpdateDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
void setCombinedNextLowerBound(Expr *CombNLB)
Definition: StmtOpenMP.h:573
unsigned getCollapsedNumber() const
Get number of collapsed loops.
Definition: StmtOpenMP.h:736
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:663
static OMPTeamsDistributeDirective * 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.
This represents '#pragma omp taskwait' directive.
Definition: StmtOpenMP.h:1860
Expr * PrevEUB
PrevEUB - expression similar to EUB but to be used when loop scheduling uses PrevLB and PrevUB (e...
Definition: StmtOpenMP.h:665
This is a basic class for representing single OpenMP clause.
Definition: OpenMPClause.h:33
static OMPOrderedDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:632
This represents '#pragma omp target' directive.
Definition: StmtOpenMP.h:2205
static OMPTeamsDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
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:123
static OMPTeamsDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
DistCombinedHelperExprs DistCombinedFields
Expressions used when combining OpenMP loop pragmas.
Definition: StmtOpenMP.h:680
This represents '#pragma omp ordered' directive.
Definition: StmtOpenMP.h:2016
Expr * LB
LowerBound - local variable passed to runtime.
Definition: StmtOpenMP.h:639
This represents '#pragma omp target update' directive.
Definition: StmtOpenMP.h:2957
Expr * Init
Loop iteration variable init.
Definition: StmtOpenMP.h:633
void setPrivateCounters(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:32
A placeholder type used to construct an empty shell of a type, that will be filled in later (e...
Definition: Stmt.h:308
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:459
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:384
void setPrevUpperBoundVariable(Expr *PrevUB)
Definition: StmtOpenMP.h:533
void setCombinedEnsureUpperBound(Expr *CombEUB)
Definition: StmtOpenMP.h:558
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
StringRef Name
Definition: USRFinder.cpp:123
SmallVector< Expr *, 4 > Inits
Expressions for loop counters inits for CodeGen.
Definition: StmtOpenMP.h:671
void setCombinedUpperBoundVariable(Expr *CombUB)
Definition: StmtOpenMP.h:553
static OMPTargetTeamsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents '#pragma omp section' directive.
Definition: StmtOpenMP.h:1247
This represents '#pragma omp teams distribute' directive.
Definition: StmtOpenMP.h:3357
This represents '#pragma omp simd' directive.
Definition: StmtOpenMP.h:972
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:2071
static OMPForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:209
static OMPBarrierDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:505
This file defines OpenMP AST classes for executable directives and clauses.
Expr * Inc
Loop increment.
Definition: StmtOpenMP.h:635
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:172
static OMPTargetTeamsDistributeSimdDirective * 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 OMPSingleDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:266
static OMPTargetTeamsDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Expr * UB
DistributeUpperBound - used when composing 'omp distribute' with 'omp for' in a same construct...
Definition: StmtOpenMP.h:598
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:13074
static OMPTargetTeamsDistributeParallelForDirective * 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 OMPTaskyieldDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Creates directive.
Definition: StmtOpenMP.cpp:482
Expr * UB
UpperBound - local variable passed to runtime.
Definition: StmtOpenMP.h:641
This represents '#pragma omp target parallel' directive.
Definition: StmtOpenMP.h:2438
void setStrideVariable(Expr *ST)
Definition: StmtOpenMP.h:493
static OMPParallelSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:449
static OMPBarrierDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Creates directive.
Definition: StmtOpenMP.cpp:497
void setUpdates(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:45
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:623
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:221
This represents '#pragma omp taskloop simd' directive.
Definition: StmtOpenMP.h:2823
static OMPSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:236
void setPreCond(Expr *PC)
Definition: StmtOpenMP.h:461
static OMPCancelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:584
static OMPTaskwaitDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Creates directive.
Definition: StmtOpenMP.cpp:511
This represents '#pragma omp sections' directive.
Definition: StmtOpenMP.h:1179
Expr * Cond
Distribute Loop condition used when composing 'omp distribute' with 'omp for' in a same construct...
Definition: StmtOpenMP.h:608
Stmt * PreInits
Init statement for all captured expressions.
Definition: StmtOpenMP.h:677
This represents '#pragma omp target data' directive.
Definition: StmtOpenMP.h:2263
void setNextUpperBound(Expr *NUB)
Definition: StmtOpenMP.h:514
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:699
void setInc(Expr *Inc)
Definition: StmtOpenMP.h:468
static OMPTeamsDistributeParallelForDirective * 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.
Expr * IL
IsLastIteration - local flag variable passed to runtime.
Definition: StmtOpenMP.h:637
This represents '#pragma omp taskyield' directive.
Definition: StmtOpenMP.h:1772
This represents '#pragma omp distribute parallel for simd' composite directive.
Definition: StmtOpenMP.h:3086
static OMPCancellationPointDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, OpenMPDirectiveKind CancelRegion)
Creates directive.
Definition: StmtOpenMP.cpp:549
static OMPFlushDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:594
This represents '#pragma omp parallel sections' directive.
Definition: StmtOpenMP.h:1633
void setCalcLastIteration(Expr *CLI)
Definition: StmtOpenMP.h:458
void setCombinedNextUpperBound(Expr *CombNUB)
Definition: StmtOpenMP.h:578
static OMPTargetSimdDirective * 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 OMPTeamsDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
void setInits(ArrayRef< Expr * > A)
Definition: StmtOpenMP.cpp:39
This represents '#pragma omp target parallel for' directive.
Definition: StmtOpenMP.h:2498
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 OMPTargetTeamsDistributeParallelForSimdDirective * 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 OMPCancellationPointDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:562
This represents '#pragma omp taskloop' directive.
Definition: StmtOpenMP.h:2758