clang  10.0.0svn
StmtOpenMP.cpp
Go to the documentation of this file.
1 //===--- StmtOpenMP.cpp - Classes for OpenMP directives -------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the subclesses of Stmt class declared in StmtOpenMP.h
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/AST/StmtOpenMP.h"
14 
15 #include "clang/AST/ASTContext.h"
16 
17 using namespace clang;
18 
20  assert(Clauses.size() == getNumClauses() &&
21  "Number of clauses is not the same as the preallocated buffer");
22  std::copy(Clauses.begin(), Clauses.end(), getClauses().begin());
23 }
24 
26  // Special case: 'omp target enter data', 'omp target exit data',
27  // 'omp target update' are stand-alone directives, but for implementation
28  // reasons they have empty synthetic structured block, to simplify codegen.
29  if (isa<OMPTargetEnterDataDirective>(this) ||
30  isa<OMPTargetExitDataDirective>(this) ||
31  isa<OMPTargetUpdateDirective>(this))
32  return true;
33  return !hasAssociatedStmt() || !getAssociatedStmt();
34 }
35 
37  assert(!isStandaloneDirective() &&
38  "Standalone Executable Directives don't have Structured Blocks.");
39  if (auto *LD = dyn_cast<OMPLoopDirective>(this))
40  return LD->getBody();
42 }
43 
45  assert(A.size() == getCollapsedNumber() &&
46  "Number of loop counters is not the same as the collapsed number");
47  std::copy(A.begin(), A.end(), getCounters().begin());
48 }
49 
51  assert(A.size() == getCollapsedNumber() && "Number of loop private counters "
52  "is not the same as the collapsed "
53  "number");
54  std::copy(A.begin(), A.end(), getPrivateCounters().begin());
55 }
56 
58  assert(A.size() == getCollapsedNumber() &&
59  "Number of counter inits is not the same as the collapsed number");
60  std::copy(A.begin(), A.end(), getInits().begin());
61 }
62 
64  assert(A.size() == getCollapsedNumber() &&
65  "Number of counter updates is not the same as the collapsed number");
66  std::copy(A.begin(), A.end(), getUpdates().begin());
67 }
68 
70  assert(A.size() == getCollapsedNumber() &&
71  "Number of counter finals is not the same as the collapsed number");
72  std::copy(A.begin(), A.end(), getFinals().begin());
73 }
74 
76  assert(
77  A.size() == getCollapsedNumber() &&
78  "Number of dependent counters is not the same as the collapsed number");
79  llvm::copy(A, getDependentCounters().begin());
80 }
81 
83  assert(A.size() == getCollapsedNumber() &&
84  "Number of dependent inits is not the same as the collapsed number");
85  llvm::copy(A, getDependentInits().begin());
86 }
87 
89  assert(A.size() == getCollapsedNumber() &&
90  "Number of finals conditions is not the same as the collapsed number");
91  llvm::copy(A, getFinalsConditions().begin());
92 }
93 
95  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
96  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
97  unsigned Size =
98  llvm::alignTo(sizeof(OMPParallelDirective), alignof(OMPClause *));
99  void *Mem =
100  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
101  OMPParallelDirective *Dir =
102  new (Mem) OMPParallelDirective(StartLoc, EndLoc, Clauses.size());
103  Dir->setClauses(Clauses);
104  Dir->setAssociatedStmt(AssociatedStmt);
105  Dir->setHasCancel(HasCancel);
106  return Dir;
107 }
108 
110  unsigned NumClauses,
111  EmptyShell) {
112  unsigned Size =
113  llvm::alignTo(sizeof(OMPParallelDirective), alignof(OMPClause *));
114  void *Mem =
115  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
116  return new (Mem) OMPParallelDirective(NumClauses);
117 }
118 
121  SourceLocation EndLoc, unsigned CollapsedNum,
122  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
123  const HelperExprs &Exprs) {
124  unsigned Size = llvm::alignTo(sizeof(OMPSimdDirective), alignof(OMPClause *));
125  void *Mem =
126  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
127  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
128  OMPSimdDirective *Dir = new (Mem)
129  OMPSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
130  Dir->setClauses(Clauses);
131  Dir->setAssociatedStmt(AssociatedStmt);
133  Dir->setLastIteration(Exprs.LastIteration);
135  Dir->setPreCond(Exprs.PreCond);
136  Dir->setCond(Exprs.Cond);
137  Dir->setInit(Exprs.Init);
138  Dir->setInc(Exprs.Inc);
139  Dir->setCounters(Exprs.Counters);
141  Dir->setInits(Exprs.Inits);
142  Dir->setUpdates(Exprs.Updates);
143  Dir->setFinals(Exprs.Finals);
145  Dir->setDependentInits(Exprs.DependentInits);
147  Dir->setPreInits(Exprs.PreInits);
148  return Dir;
149 }
150 
152  unsigned NumClauses,
153  unsigned CollapsedNum,
154  EmptyShell) {
155  unsigned Size = llvm::alignTo(sizeof(OMPSimdDirective), alignof(OMPClause *));
156  void *Mem =
157  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
158  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
159  return new (Mem) OMPSimdDirective(CollapsedNum, NumClauses);
160 }
161 
164  SourceLocation EndLoc, unsigned CollapsedNum,
165  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
166  const HelperExprs &Exprs, bool HasCancel) {
167  unsigned Size = llvm::alignTo(sizeof(OMPForDirective), alignof(OMPClause *));
168  void *Mem =
169  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
170  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
171  OMPForDirective *Dir =
172  new (Mem) OMPForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
173  Dir->setClauses(Clauses);
174  Dir->setAssociatedStmt(AssociatedStmt);
176  Dir->setLastIteration(Exprs.LastIteration);
178  Dir->setPreCond(Exprs.PreCond);
179  Dir->setCond(Exprs.Cond);
180  Dir->setInit(Exprs.Init);
181  Dir->setInc(Exprs.Inc);
182  Dir->setIsLastIterVariable(Exprs.IL);
183  Dir->setLowerBoundVariable(Exprs.LB);
184  Dir->setUpperBoundVariable(Exprs.UB);
185  Dir->setStrideVariable(Exprs.ST);
186  Dir->setEnsureUpperBound(Exprs.EUB);
187  Dir->setNextLowerBound(Exprs.NLB);
188  Dir->setNextUpperBound(Exprs.NUB);
189  Dir->setNumIterations(Exprs.NumIterations);
190  Dir->setCounters(Exprs.Counters);
192  Dir->setInits(Exprs.Inits);
193  Dir->setUpdates(Exprs.Updates);
194  Dir->setFinals(Exprs.Finals);
196  Dir->setDependentInits(Exprs.DependentInits);
198  Dir->setPreInits(Exprs.PreInits);
199  Dir->setHasCancel(HasCancel);
200  return Dir;
201 }
202 
204  unsigned NumClauses,
205  unsigned CollapsedNum,
206  EmptyShell) {
207  unsigned Size = llvm::alignTo(sizeof(OMPForDirective), alignof(OMPClause *));
208  void *Mem =
209  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
210  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
211  return new (Mem) OMPForDirective(CollapsedNum, NumClauses);
212 }
213 
216  SourceLocation EndLoc, unsigned CollapsedNum,
217  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
218  const HelperExprs &Exprs) {
219  unsigned Size =
220  llvm::alignTo(sizeof(OMPForSimdDirective), alignof(OMPClause *));
221  void *Mem =
222  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
223  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
224  OMPForSimdDirective *Dir = new (Mem)
225  OMPForSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
226  Dir->setClauses(Clauses);
227  Dir->setAssociatedStmt(AssociatedStmt);
229  Dir->setLastIteration(Exprs.LastIteration);
231  Dir->setPreCond(Exprs.PreCond);
232  Dir->setCond(Exprs.Cond);
233  Dir->setInit(Exprs.Init);
234  Dir->setInc(Exprs.Inc);
235  Dir->setIsLastIterVariable(Exprs.IL);
236  Dir->setLowerBoundVariable(Exprs.LB);
237  Dir->setUpperBoundVariable(Exprs.UB);
238  Dir->setStrideVariable(Exprs.ST);
239  Dir->setEnsureUpperBound(Exprs.EUB);
240  Dir->setNextLowerBound(Exprs.NLB);
241  Dir->setNextUpperBound(Exprs.NUB);
242  Dir->setNumIterations(Exprs.NumIterations);
243  Dir->setCounters(Exprs.Counters);
245  Dir->setInits(Exprs.Inits);
246  Dir->setUpdates(Exprs.Updates);
247  Dir->setFinals(Exprs.Finals);
249  Dir->setDependentInits(Exprs.DependentInits);
251  Dir->setPreInits(Exprs.PreInits);
252  return Dir;
253 }
254 
256  unsigned NumClauses,
257  unsigned CollapsedNum,
258  EmptyShell) {
259  unsigned Size =
260  llvm::alignTo(sizeof(OMPForSimdDirective), alignof(OMPClause *));
261  void *Mem =
262  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
263  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
264  return new (Mem) OMPForSimdDirective(CollapsedNum, NumClauses);
265 }
266 
268  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
269  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
270  unsigned Size =
271  llvm::alignTo(sizeof(OMPSectionsDirective), alignof(OMPClause *));
272  void *Mem =
273  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
274  OMPSectionsDirective *Dir =
275  new (Mem) OMPSectionsDirective(StartLoc, EndLoc, Clauses.size());
276  Dir->setClauses(Clauses);
277  Dir->setAssociatedStmt(AssociatedStmt);
278  Dir->setHasCancel(HasCancel);
279  return Dir;
280 }
281 
283  unsigned NumClauses,
284  EmptyShell) {
285  unsigned Size =
286  llvm::alignTo(sizeof(OMPSectionsDirective), alignof(OMPClause *));
287  void *Mem =
288  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
289  return new (Mem) OMPSectionsDirective(NumClauses);
290 }
291 
293  SourceLocation StartLoc,
294  SourceLocation EndLoc,
295  Stmt *AssociatedStmt,
296  bool HasCancel) {
297  unsigned Size = llvm::alignTo(sizeof(OMPSectionDirective), alignof(Stmt *));
298  void *Mem = C.Allocate(Size + sizeof(Stmt *));
299  OMPSectionDirective *Dir = new (Mem) OMPSectionDirective(StartLoc, EndLoc);
300  Dir->setAssociatedStmt(AssociatedStmt);
301  Dir->setHasCancel(HasCancel);
302  return Dir;
303 }
304 
306  EmptyShell) {
307  unsigned Size = llvm::alignTo(sizeof(OMPSectionDirective), alignof(Stmt *));
308  void *Mem = C.Allocate(Size + sizeof(Stmt *));
309  return new (Mem) OMPSectionDirective();
310 }
311 
313  SourceLocation StartLoc,
314  SourceLocation EndLoc,
315  ArrayRef<OMPClause *> Clauses,
316  Stmt *AssociatedStmt) {
317  unsigned Size =
318  llvm::alignTo(sizeof(OMPSingleDirective), alignof(OMPClause *));
319  void *Mem =
320  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
321  OMPSingleDirective *Dir =
322  new (Mem) OMPSingleDirective(StartLoc, EndLoc, Clauses.size());
323  Dir->setClauses(Clauses);
324  Dir->setAssociatedStmt(AssociatedStmt);
325  return Dir;
326 }
327 
329  unsigned NumClauses,
330  EmptyShell) {
331  unsigned Size =
332  llvm::alignTo(sizeof(OMPSingleDirective), alignof(OMPClause *));
333  void *Mem =
334  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
335  return new (Mem) OMPSingleDirective(NumClauses);
336 }
337 
339  SourceLocation StartLoc,
340  SourceLocation EndLoc,
341  Stmt *AssociatedStmt) {
342  unsigned Size = llvm::alignTo(sizeof(OMPMasterDirective), alignof(Stmt *));
343  void *Mem = C.Allocate(Size + sizeof(Stmt *));
344  OMPMasterDirective *Dir = new (Mem) OMPMasterDirective(StartLoc, EndLoc);
345  Dir->setAssociatedStmt(AssociatedStmt);
346  return Dir;
347 }
348 
350  EmptyShell) {
351  unsigned Size = llvm::alignTo(sizeof(OMPMasterDirective), alignof(Stmt *));
352  void *Mem = C.Allocate(Size + sizeof(Stmt *));
353  return new (Mem) OMPMasterDirective();
354 }
355 
357  const ASTContext &C, const DeclarationNameInfo &Name,
358  SourceLocation StartLoc, SourceLocation EndLoc,
359  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
360  unsigned Size =
361  llvm::alignTo(sizeof(OMPCriticalDirective), alignof(OMPClause *));
362  void *Mem =
363  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
364  OMPCriticalDirective *Dir =
365  new (Mem) OMPCriticalDirective(Name, StartLoc, EndLoc, Clauses.size());
366  Dir->setClauses(Clauses);
367  Dir->setAssociatedStmt(AssociatedStmt);
368  return Dir;
369 }
370 
372  unsigned NumClauses,
373  EmptyShell) {
374  unsigned Size =
375  llvm::alignTo(sizeof(OMPCriticalDirective), alignof(OMPClause *));
376  void *Mem =
377  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
378  return new (Mem) OMPCriticalDirective(NumClauses);
379 }
380 
382  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
383  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
384  const HelperExprs &Exprs, bool HasCancel) {
385  unsigned Size =
386  llvm::alignTo(sizeof(OMPParallelForDirective), alignof(OMPClause *));
387  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
388  sizeof(Stmt *) *
389  numLoopChildren(CollapsedNum, OMPD_parallel_for));
390  OMPParallelForDirective *Dir = new (Mem)
391  OMPParallelForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
392  Dir->setClauses(Clauses);
393  Dir->setAssociatedStmt(AssociatedStmt);
395  Dir->setLastIteration(Exprs.LastIteration);
397  Dir->setPreCond(Exprs.PreCond);
398  Dir->setCond(Exprs.Cond);
399  Dir->setInit(Exprs.Init);
400  Dir->setInc(Exprs.Inc);
401  Dir->setIsLastIterVariable(Exprs.IL);
402  Dir->setLowerBoundVariable(Exprs.LB);
403  Dir->setUpperBoundVariable(Exprs.UB);
404  Dir->setStrideVariable(Exprs.ST);
405  Dir->setEnsureUpperBound(Exprs.EUB);
406  Dir->setNextLowerBound(Exprs.NLB);
407  Dir->setNextUpperBound(Exprs.NUB);
408  Dir->setNumIterations(Exprs.NumIterations);
409  Dir->setCounters(Exprs.Counters);
411  Dir->setInits(Exprs.Inits);
412  Dir->setUpdates(Exprs.Updates);
413  Dir->setFinals(Exprs.Finals);
415  Dir->setDependentInits(Exprs.DependentInits);
417  Dir->setPreInits(Exprs.PreInits);
418  Dir->setHasCancel(HasCancel);
419  return Dir;
420 }
421 
424  unsigned CollapsedNum, EmptyShell) {
425  unsigned Size =
426  llvm::alignTo(sizeof(OMPParallelForDirective), alignof(OMPClause *));
427  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
428  sizeof(Stmt *) *
429  numLoopChildren(CollapsedNum, OMPD_parallel_for));
430  return new (Mem) OMPParallelForDirective(CollapsedNum, NumClauses);
431 }
432 
434  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
435  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
436  const HelperExprs &Exprs) {
437  unsigned Size =
438  llvm::alignTo(sizeof(OMPParallelForSimdDirective), alignof(OMPClause *));
439  void *Mem = C.Allocate(
440  Size + sizeof(OMPClause *) * Clauses.size() +
441  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
443  StartLoc, EndLoc, CollapsedNum, Clauses.size());
444  Dir->setClauses(Clauses);
445  Dir->setAssociatedStmt(AssociatedStmt);
447  Dir->setLastIteration(Exprs.LastIteration);
449  Dir->setPreCond(Exprs.PreCond);
450  Dir->setCond(Exprs.Cond);
451  Dir->setInit(Exprs.Init);
452  Dir->setInc(Exprs.Inc);
453  Dir->setIsLastIterVariable(Exprs.IL);
454  Dir->setLowerBoundVariable(Exprs.LB);
455  Dir->setUpperBoundVariable(Exprs.UB);
456  Dir->setStrideVariable(Exprs.ST);
457  Dir->setEnsureUpperBound(Exprs.EUB);
458  Dir->setNextLowerBound(Exprs.NLB);
459  Dir->setNextUpperBound(Exprs.NUB);
460  Dir->setNumIterations(Exprs.NumIterations);
461  Dir->setCounters(Exprs.Counters);
463  Dir->setInits(Exprs.Inits);
464  Dir->setUpdates(Exprs.Updates);
465  Dir->setFinals(Exprs.Finals);
467  Dir->setDependentInits(Exprs.DependentInits);
469  Dir->setPreInits(Exprs.PreInits);
470  return Dir;
471 }
472 
475  unsigned NumClauses,
476  unsigned CollapsedNum, EmptyShell) {
477  unsigned Size =
478  llvm::alignTo(sizeof(OMPParallelForSimdDirective), alignof(OMPClause *));
479  void *Mem = C.Allocate(
480  Size + sizeof(OMPClause *) * NumClauses +
481  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
482  return new (Mem) OMPParallelForSimdDirective(CollapsedNum, NumClauses);
483 }
484 
486  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
487  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
488  unsigned Size =
489  llvm::alignTo(sizeof(OMPParallelSectionsDirective), alignof(OMPClause *));
490  void *Mem =
491  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
493  new (Mem) OMPParallelSectionsDirective(StartLoc, EndLoc, Clauses.size());
494  Dir->setClauses(Clauses);
495  Dir->setAssociatedStmt(AssociatedStmt);
496  Dir->setHasCancel(HasCancel);
497  return Dir;
498 }
499 
502  unsigned NumClauses, EmptyShell) {
503  unsigned Size =
504  llvm::alignTo(sizeof(OMPParallelSectionsDirective), alignof(OMPClause *));
505  void *Mem =
506  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
507  return new (Mem) OMPParallelSectionsDirective(NumClauses);
508 }
509 
512  SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
513  Stmt *AssociatedStmt, bool HasCancel) {
514  unsigned Size = llvm::alignTo(sizeof(OMPTaskDirective), alignof(OMPClause *));
515  void *Mem =
516  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
517  OMPTaskDirective *Dir =
518  new (Mem) OMPTaskDirective(StartLoc, EndLoc, Clauses.size());
519  Dir->setClauses(Clauses);
520  Dir->setAssociatedStmt(AssociatedStmt);
521  Dir->setHasCancel(HasCancel);
522  return Dir;
523 }
524 
526  unsigned NumClauses,
527  EmptyShell) {
528  unsigned Size = llvm::alignTo(sizeof(OMPTaskDirective), alignof(OMPClause *));
529  void *Mem =
530  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
531  return new (Mem) OMPTaskDirective(NumClauses);
532 }
533 
535  SourceLocation StartLoc,
536  SourceLocation EndLoc) {
537  void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
538  OMPTaskyieldDirective *Dir =
539  new (Mem) OMPTaskyieldDirective(StartLoc, EndLoc);
540  return Dir;
541 }
542 
544  EmptyShell) {
545  void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
546  return new (Mem) OMPTaskyieldDirective();
547 }
548 
550  SourceLocation StartLoc,
551  SourceLocation EndLoc) {
552  void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
553  OMPBarrierDirective *Dir = new (Mem) OMPBarrierDirective(StartLoc, EndLoc);
554  return Dir;
555 }
556 
558  EmptyShell) {
559  void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
560  return new (Mem) OMPBarrierDirective();
561 }
562 
564  SourceLocation StartLoc,
565  SourceLocation EndLoc) {
566  void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
567  OMPTaskwaitDirective *Dir = new (Mem) OMPTaskwaitDirective(StartLoc, EndLoc);
568  return Dir;
569 }
570 
572  EmptyShell) {
573  void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
574  return new (Mem) OMPTaskwaitDirective();
575 }
576 
578  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
579  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *ReductionRef) {
580  unsigned Size = llvm::alignTo(sizeof(OMPTaskgroupDirective) +
581  sizeof(OMPClause *) * Clauses.size(),
582  alignof(Stmt *));
583  void *Mem = C.Allocate(Size + sizeof(Stmt *) + sizeof(Expr *));
584  OMPTaskgroupDirective *Dir =
585  new (Mem) OMPTaskgroupDirective(StartLoc, EndLoc, Clauses.size());
586  Dir->setAssociatedStmt(AssociatedStmt);
587  Dir->setReductionRef(ReductionRef);
588  Dir->setClauses(Clauses);
589  return Dir;
590 }
591 
593  unsigned NumClauses,
594  EmptyShell) {
595  unsigned Size = llvm::alignTo(sizeof(OMPTaskgroupDirective) +
596  sizeof(OMPClause *) * NumClauses,
597  alignof(Stmt *));
598  void *Mem = C.Allocate(Size + sizeof(Stmt *) + sizeof(Expr *));
599  return new (Mem) OMPTaskgroupDirective(NumClauses);
600 }
601 
603  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
604  OpenMPDirectiveKind CancelRegion) {
605  unsigned Size =
606  llvm::alignTo(sizeof(OMPCancellationPointDirective), alignof(Stmt *));
607  void *Mem = C.Allocate(Size);
609  new (Mem) OMPCancellationPointDirective(StartLoc, EndLoc);
610  Dir->setCancelRegion(CancelRegion);
611  return Dir;
612 }
613 
616  unsigned Size =
617  llvm::alignTo(sizeof(OMPCancellationPointDirective), alignof(Stmt *));
618  void *Mem = C.Allocate(Size);
619  return new (Mem) OMPCancellationPointDirective();
620 }
621 
624  SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
625  OpenMPDirectiveKind CancelRegion) {
626  unsigned Size = llvm::alignTo(sizeof(OMPCancelDirective) +
627  sizeof(OMPClause *) * Clauses.size(),
628  alignof(Stmt *));
629  void *Mem = C.Allocate(Size);
630  OMPCancelDirective *Dir =
631  new (Mem) OMPCancelDirective(StartLoc, EndLoc, Clauses.size());
632  Dir->setClauses(Clauses);
633  Dir->setCancelRegion(CancelRegion);
634  return Dir;
635 }
636 
638  unsigned NumClauses,
639  EmptyShell) {
640  unsigned Size = llvm::alignTo(sizeof(OMPCancelDirective) +
641  sizeof(OMPClause *) * NumClauses,
642  alignof(Stmt *));
643  void *Mem = C.Allocate(Size);
644  return new (Mem) OMPCancelDirective(NumClauses);
645 }
646 
648  SourceLocation StartLoc,
649  SourceLocation EndLoc,
650  ArrayRef<OMPClause *> Clauses) {
651  unsigned Size =
652  llvm::alignTo(sizeof(OMPFlushDirective), alignof(OMPClause *));
653  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size());
654  OMPFlushDirective *Dir =
655  new (Mem) OMPFlushDirective(StartLoc, EndLoc, Clauses.size());
656  Dir->setClauses(Clauses);
657  return Dir;
658 }
659 
661  unsigned NumClauses,
662  EmptyShell) {
663  unsigned Size =
664  llvm::alignTo(sizeof(OMPFlushDirective), alignof(OMPClause *));
665  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses);
666  return new (Mem) OMPFlushDirective(NumClauses);
667 }
668 
670  SourceLocation StartLoc,
671  SourceLocation EndLoc,
672  ArrayRef<OMPClause *> Clauses,
673  Stmt *AssociatedStmt) {
674  unsigned Size =
675  llvm::alignTo(sizeof(OMPOrderedDirective), alignof(OMPClause *));
676  void *Mem =
677  C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * Clauses.size());
678  OMPOrderedDirective *Dir =
679  new (Mem) OMPOrderedDirective(StartLoc, EndLoc, Clauses.size());
680  Dir->setClauses(Clauses);
681  Dir->setAssociatedStmt(AssociatedStmt);
682  return Dir;
683 }
684 
686  unsigned NumClauses,
687  EmptyShell) {
688  unsigned Size =
689  llvm::alignTo(sizeof(OMPOrderedDirective), alignof(OMPClause *));
690  void *Mem =
691  C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * NumClauses);
692  return new (Mem) OMPOrderedDirective(NumClauses);
693 }
694 
696  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
697  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
698  Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {
699  unsigned Size =
700  llvm::alignTo(sizeof(OMPAtomicDirective), alignof(OMPClause *));
701  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
702  5 * sizeof(Stmt *));
703  OMPAtomicDirective *Dir =
704  new (Mem) OMPAtomicDirective(StartLoc, EndLoc, Clauses.size());
705  Dir->setClauses(Clauses);
706  Dir->setAssociatedStmt(AssociatedStmt);
707  Dir->setX(X);
708  Dir->setV(V);
709  Dir->setExpr(E);
710  Dir->setUpdateExpr(UE);
711  Dir->IsXLHSInRHSPart = IsXLHSInRHSPart;
712  Dir->IsPostfixUpdate = IsPostfixUpdate;
713  return Dir;
714 }
715 
717  unsigned NumClauses,
718  EmptyShell) {
719  unsigned Size =
720  llvm::alignTo(sizeof(OMPAtomicDirective), alignof(OMPClause *));
721  void *Mem =
722  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 5 * sizeof(Stmt *));
723  return new (Mem) OMPAtomicDirective(NumClauses);
724 }
725 
727  SourceLocation StartLoc,
728  SourceLocation EndLoc,
729  ArrayRef<OMPClause *> Clauses,
730  Stmt *AssociatedStmt) {
731  unsigned Size =
732  llvm::alignTo(sizeof(OMPTargetDirective), alignof(OMPClause *));
733  void *Mem =
734  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
735  OMPTargetDirective *Dir =
736  new (Mem) OMPTargetDirective(StartLoc, EndLoc, Clauses.size());
737  Dir->setClauses(Clauses);
738  Dir->setAssociatedStmt(AssociatedStmt);
739  return Dir;
740 }
741 
743  unsigned NumClauses,
744  EmptyShell) {
745  unsigned Size =
746  llvm::alignTo(sizeof(OMPTargetDirective), alignof(OMPClause *));
747  void *Mem =
748  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
749  return new (Mem) OMPTargetDirective(NumClauses);
750 }
751 
753  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
754  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
755  unsigned Size =
756  llvm::alignTo(sizeof(OMPTargetParallelDirective), alignof(OMPClause *));
757  void *Mem =
758  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
760  new (Mem) OMPTargetParallelDirective(StartLoc, EndLoc, Clauses.size());
761  Dir->setClauses(Clauses);
762  Dir->setAssociatedStmt(AssociatedStmt);
763  return Dir;
764 }
765 
768  unsigned NumClauses, EmptyShell) {
769  unsigned Size =
770  llvm::alignTo(sizeof(OMPTargetParallelDirective), alignof(OMPClause *));
771  void *Mem =
772  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
773  return new (Mem) OMPTargetParallelDirective(NumClauses);
774 }
775 
777  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
778  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
779  const HelperExprs &Exprs, bool HasCancel) {
780  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForDirective),
781  alignof(OMPClause *));
782  void *Mem = C.Allocate(
783  Size + sizeof(OMPClause *) * Clauses.size() +
784  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_parallel_for));
786  StartLoc, EndLoc, CollapsedNum, Clauses.size());
787  Dir->setClauses(Clauses);
788  Dir->setAssociatedStmt(AssociatedStmt);
790  Dir->setLastIteration(Exprs.LastIteration);
792  Dir->setPreCond(Exprs.PreCond);
793  Dir->setCond(Exprs.Cond);
794  Dir->setInit(Exprs.Init);
795  Dir->setInc(Exprs.Inc);
796  Dir->setIsLastIterVariable(Exprs.IL);
797  Dir->setLowerBoundVariable(Exprs.LB);
798  Dir->setUpperBoundVariable(Exprs.UB);
799  Dir->setStrideVariable(Exprs.ST);
800  Dir->setEnsureUpperBound(Exprs.EUB);
801  Dir->setNextLowerBound(Exprs.NLB);
802  Dir->setNextUpperBound(Exprs.NUB);
803  Dir->setNumIterations(Exprs.NumIterations);
804  Dir->setCounters(Exprs.Counters);
806  Dir->setInits(Exprs.Inits);
807  Dir->setUpdates(Exprs.Updates);
808  Dir->setFinals(Exprs.Finals);
810  Dir->setDependentInits(Exprs.DependentInits);
812  Dir->setPreInits(Exprs.PreInits);
813  Dir->setHasCancel(HasCancel);
814  return Dir;
815 }
816 
819  unsigned NumClauses,
820  unsigned CollapsedNum, EmptyShell) {
821  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForDirective),
822  alignof(OMPClause *));
823  void *Mem = C.Allocate(
824  Size + sizeof(OMPClause *) * NumClauses +
825  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_parallel_for));
826  return new (Mem) OMPTargetParallelForDirective(CollapsedNum, NumClauses);
827 }
828 
830  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
831  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
832  void *Mem = C.Allocate(
833  llvm::alignTo(sizeof(OMPTargetDataDirective), alignof(OMPClause *)) +
834  sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
836  new (Mem) OMPTargetDataDirective(StartLoc, EndLoc, Clauses.size());
837  Dir->setClauses(Clauses);
838  Dir->setAssociatedStmt(AssociatedStmt);
839  return Dir;
840 }
841 
843  unsigned N,
844  EmptyShell) {
845  void *Mem = C.Allocate(
846  llvm::alignTo(sizeof(OMPTargetDataDirective), alignof(OMPClause *)) +
847  sizeof(OMPClause *) * N + sizeof(Stmt *));
848  return new (Mem) OMPTargetDataDirective(N);
849 }
850 
852  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
853  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
854  void *Mem = C.Allocate(
855  llvm::alignTo(sizeof(OMPTargetEnterDataDirective), alignof(OMPClause *)) +
856  sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
858  new (Mem) OMPTargetEnterDataDirective(StartLoc, EndLoc, Clauses.size());
859  Dir->setClauses(Clauses);
860  Dir->setAssociatedStmt(AssociatedStmt);
861  return Dir;
862 }
863 
866  EmptyShell) {
867  void *Mem = C.Allocate(
868  llvm::alignTo(sizeof(OMPTargetEnterDataDirective), alignof(OMPClause *)) +
869  sizeof(OMPClause *) * N + sizeof(Stmt *));
870  return new (Mem) OMPTargetEnterDataDirective(N);
871 }
872 
874  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
875  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
876  void *Mem = C.Allocate(
877  llvm::alignTo(sizeof(OMPTargetExitDataDirective), alignof(OMPClause *)) +
878  sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
880  new (Mem) OMPTargetExitDataDirective(StartLoc, EndLoc, Clauses.size());
881  Dir->setClauses(Clauses);
882  Dir->setAssociatedStmt(AssociatedStmt);
883  return Dir;
884 }
885 
888  EmptyShell) {
889  void *Mem = C.Allocate(
890  llvm::alignTo(sizeof(OMPTargetExitDataDirective), alignof(OMPClause *)) +
891  sizeof(OMPClause *) * N + sizeof(Stmt *));
892  return new (Mem) OMPTargetExitDataDirective(N);
893 }
894 
896  SourceLocation StartLoc,
897  SourceLocation EndLoc,
898  ArrayRef<OMPClause *> Clauses,
899  Stmt *AssociatedStmt) {
900  unsigned Size =
901  llvm::alignTo(sizeof(OMPTeamsDirective), alignof(OMPClause *));
902  void *Mem =
903  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
904  OMPTeamsDirective *Dir =
905  new (Mem) OMPTeamsDirective(StartLoc, EndLoc, Clauses.size());
906  Dir->setClauses(Clauses);
907  Dir->setAssociatedStmt(AssociatedStmt);
908  return Dir;
909 }
910 
912  unsigned NumClauses,
913  EmptyShell) {
914  unsigned Size =
915  llvm::alignTo(sizeof(OMPTeamsDirective), alignof(OMPClause *));
916  void *Mem =
917  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
918  return new (Mem) OMPTeamsDirective(NumClauses);
919 }
920 
922  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
923  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
924  const HelperExprs &Exprs) {
925  unsigned Size =
926  llvm::alignTo(sizeof(OMPTaskLoopDirective), alignof(OMPClause *));
927  void *Mem =
928  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
929  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
930  OMPTaskLoopDirective *Dir = new (Mem)
931  OMPTaskLoopDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
932  Dir->setClauses(Clauses);
933  Dir->setAssociatedStmt(AssociatedStmt);
935  Dir->setLastIteration(Exprs.LastIteration);
937  Dir->setPreCond(Exprs.PreCond);
938  Dir->setCond(Exprs.Cond);
939  Dir->setInit(Exprs.Init);
940  Dir->setInc(Exprs.Inc);
941  Dir->setIsLastIterVariable(Exprs.IL);
942  Dir->setLowerBoundVariable(Exprs.LB);
943  Dir->setUpperBoundVariable(Exprs.UB);
944  Dir->setStrideVariable(Exprs.ST);
945  Dir->setEnsureUpperBound(Exprs.EUB);
946  Dir->setNextLowerBound(Exprs.NLB);
947  Dir->setNextUpperBound(Exprs.NUB);
948  Dir->setNumIterations(Exprs.NumIterations);
949  Dir->setCounters(Exprs.Counters);
951  Dir->setInits(Exprs.Inits);
952  Dir->setUpdates(Exprs.Updates);
953  Dir->setFinals(Exprs.Finals);
955  Dir->setDependentInits(Exprs.DependentInits);
957  Dir->setPreInits(Exprs.PreInits);
958  return Dir;
959 }
960 
962  unsigned NumClauses,
963  unsigned CollapsedNum,
964  EmptyShell) {
965  unsigned Size =
966  llvm::alignTo(sizeof(OMPTaskLoopDirective), alignof(OMPClause *));
967  void *Mem =
968  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
969  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
970  return new (Mem) OMPTaskLoopDirective(CollapsedNum, NumClauses);
971 }
972 
974  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
975  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
976  const HelperExprs &Exprs) {
977  unsigned Size =
978  llvm::alignTo(sizeof(OMPTaskLoopSimdDirective), alignof(OMPClause *));
979  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
980  sizeof(Stmt *) *
981  numLoopChildren(CollapsedNum, OMPD_taskloop_simd));
982  OMPTaskLoopSimdDirective *Dir = new (Mem)
983  OMPTaskLoopSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
984  Dir->setClauses(Clauses);
985  Dir->setAssociatedStmt(AssociatedStmt);
987  Dir->setLastIteration(Exprs.LastIteration);
989  Dir->setPreCond(Exprs.PreCond);
990  Dir->setCond(Exprs.Cond);
991  Dir->setInit(Exprs.Init);
992  Dir->setInc(Exprs.Inc);
993  Dir->setIsLastIterVariable(Exprs.IL);
994  Dir->setLowerBoundVariable(Exprs.LB);
995  Dir->setUpperBoundVariable(Exprs.UB);
996  Dir->setStrideVariable(Exprs.ST);
997  Dir->setEnsureUpperBound(Exprs.EUB);
998  Dir->setNextLowerBound(Exprs.NLB);
999  Dir->setNextUpperBound(Exprs.NUB);
1000  Dir->setNumIterations(Exprs.NumIterations);
1001  Dir->setCounters(Exprs.Counters);
1002  Dir->setPrivateCounters(Exprs.PrivateCounters);
1003  Dir->setInits(Exprs.Inits);
1004  Dir->setUpdates(Exprs.Updates);
1005  Dir->setFinals(Exprs.Finals);
1007  Dir->setDependentInits(Exprs.DependentInits);
1009  Dir->setPreInits(Exprs.PreInits);
1010  return Dir;
1011 }
1012 
1015  unsigned CollapsedNum, EmptyShell) {
1016  unsigned Size =
1017  llvm::alignTo(sizeof(OMPTaskLoopSimdDirective), alignof(OMPClause *));
1018  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1019  sizeof(Stmt *) *
1020  numLoopChildren(CollapsedNum, OMPD_taskloop_simd));
1021  return new (Mem) OMPTaskLoopSimdDirective(CollapsedNum, NumClauses);
1022 }
1023 
1025  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1026  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1027  const HelperExprs &Exprs) {
1028  unsigned Size =
1029  llvm::alignTo(sizeof(OMPMasterTaskLoopDirective), alignof(OMPClause *));
1030  void *Mem = C.Allocate(
1031  Size + sizeof(OMPClause *) * Clauses.size() +
1032  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_master_taskloop));
1034  StartLoc, EndLoc, CollapsedNum, Clauses.size());
1035  Dir->setClauses(Clauses);
1036  Dir->setAssociatedStmt(AssociatedStmt);
1038  Dir->setLastIteration(Exprs.LastIteration);
1040  Dir->setPreCond(Exprs.PreCond);
1041  Dir->setCond(Exprs.Cond);
1042  Dir->setInit(Exprs.Init);
1043  Dir->setInc(Exprs.Inc);
1044  Dir->setIsLastIterVariable(Exprs.IL);
1045  Dir->setLowerBoundVariable(Exprs.LB);
1046  Dir->setUpperBoundVariable(Exprs.UB);
1047  Dir->setStrideVariable(Exprs.ST);
1048  Dir->setEnsureUpperBound(Exprs.EUB);
1049  Dir->setNextLowerBound(Exprs.NLB);
1050  Dir->setNextUpperBound(Exprs.NUB);
1051  Dir->setNumIterations(Exprs.NumIterations);
1052  Dir->setCounters(Exprs.Counters);
1053  Dir->setPrivateCounters(Exprs.PrivateCounters);
1054  Dir->setInits(Exprs.Inits);
1055  Dir->setUpdates(Exprs.Updates);
1056  Dir->setFinals(Exprs.Finals);
1058  Dir->setDependentInits(Exprs.DependentInits);
1060  Dir->setPreInits(Exprs.PreInits);
1061  return Dir;
1062 }
1063 
1066  unsigned NumClauses,
1067  unsigned CollapsedNum, EmptyShell) {
1068  unsigned Size =
1069  llvm::alignTo(sizeof(OMPMasterTaskLoopDirective), alignof(OMPClause *));
1070  void *Mem = C.Allocate(
1071  Size + sizeof(OMPClause *) * NumClauses +
1072  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_master_taskloop));
1073  return new (Mem) OMPMasterTaskLoopDirective(CollapsedNum, NumClauses);
1074 }
1075 
1077  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1078  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1079  const HelperExprs &Exprs) {
1080  unsigned Size = llvm::alignTo(sizeof(OMPMasterTaskLoopSimdDirective),
1081  alignof(OMPClause *));
1082  void *Mem =
1083  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1084  sizeof(Stmt *) *
1085  numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd));
1086  auto *Dir = new (Mem) OMPMasterTaskLoopSimdDirective(
1087  StartLoc, EndLoc, CollapsedNum, Clauses.size());
1088  Dir->setClauses(Clauses);
1089  Dir->setAssociatedStmt(AssociatedStmt);
1090  Dir->setIterationVariable(Exprs.IterationVarRef);
1091  Dir->setLastIteration(Exprs.LastIteration);
1092  Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1093  Dir->setPreCond(Exprs.PreCond);
1094  Dir->setCond(Exprs.Cond);
1095  Dir->setInit(Exprs.Init);
1096  Dir->setInc(Exprs.Inc);
1097  Dir->setIsLastIterVariable(Exprs.IL);
1098  Dir->setLowerBoundVariable(Exprs.LB);
1099  Dir->setUpperBoundVariable(Exprs.UB);
1100  Dir->setStrideVariable(Exprs.ST);
1101  Dir->setEnsureUpperBound(Exprs.EUB);
1102  Dir->setNextLowerBound(Exprs.NLB);
1103  Dir->setNextUpperBound(Exprs.NUB);
1104  Dir->setNumIterations(Exprs.NumIterations);
1105  Dir->setCounters(Exprs.Counters);
1106  Dir->setPrivateCounters(Exprs.PrivateCounters);
1107  Dir->setInits(Exprs.Inits);
1108  Dir->setUpdates(Exprs.Updates);
1109  Dir->setFinals(Exprs.Finals);
1110  Dir->setDependentCounters(Exprs.DependentCounters);
1111  Dir->setDependentInits(Exprs.DependentInits);
1112  Dir->setFinalsConditions(Exprs.FinalsConditions);
1113  Dir->setPreInits(Exprs.PreInits);
1114  return Dir;
1115 }
1116 
1119  unsigned NumClauses,
1120  unsigned CollapsedNum, EmptyShell) {
1121  unsigned Size = llvm::alignTo(sizeof(OMPMasterTaskLoopSimdDirective),
1122  alignof(OMPClause *));
1123  void *Mem =
1124  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1125  sizeof(Stmt *) *
1126  numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd));
1127  return new (Mem) OMPMasterTaskLoopSimdDirective(CollapsedNum, NumClauses);
1128 }
1129 
1131  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1132  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1133  const HelperExprs &Exprs) {
1134  unsigned Size = llvm::alignTo(sizeof(OMPParallelMasterTaskLoopDirective),
1135  alignof(OMPClause *));
1136  void *Mem = C.Allocate(
1137  Size + sizeof(OMPClause *) * Clauses.size() +
1138  sizeof(Stmt *) *
1139  numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop));
1140  auto *Dir = new (Mem) OMPParallelMasterTaskLoopDirective(
1141  StartLoc, EndLoc, CollapsedNum, Clauses.size());
1142  Dir->setClauses(Clauses);
1143  Dir->setAssociatedStmt(AssociatedStmt);
1144  Dir->setIterationVariable(Exprs.IterationVarRef);
1145  Dir->setLastIteration(Exprs.LastIteration);
1146  Dir->setCalcLastIteration(Exprs.CalcLastIteration);
1147  Dir->setPreCond(Exprs.PreCond);
1148  Dir->setCond(Exprs.Cond);
1149  Dir->setInit(Exprs.Init);
1150  Dir->setInc(Exprs.Inc);
1151  Dir->setIsLastIterVariable(Exprs.IL);
1152  Dir->setLowerBoundVariable(Exprs.LB);
1153  Dir->setUpperBoundVariable(Exprs.UB);
1154  Dir->setStrideVariable(Exprs.ST);
1155  Dir->setEnsureUpperBound(Exprs.EUB);
1156  Dir->setNextLowerBound(Exprs.NLB);
1157  Dir->setNextUpperBound(Exprs.NUB);
1158  Dir->setNumIterations(Exprs.NumIterations);
1159  Dir->setCounters(Exprs.Counters);
1160  Dir->setPrivateCounters(Exprs.PrivateCounters);
1161  Dir->setInits(Exprs.Inits);
1162  Dir->setUpdates(Exprs.Updates);
1163  Dir->setFinals(Exprs.Finals);
1164  Dir->setDependentCounters(Exprs.DependentCounters);
1165  Dir->setDependentInits(Exprs.DependentInits);
1166  Dir->setFinalsConditions(Exprs.FinalsConditions);
1167  Dir->setPreInits(Exprs.PreInits);
1168  return Dir;
1169 }
1170 
1173  unsigned NumClauses,
1174  unsigned CollapsedNum,
1175  EmptyShell) {
1176  unsigned Size = llvm::alignTo(sizeof(OMPParallelMasterTaskLoopDirective),
1177  alignof(OMPClause *));
1178  void *Mem = C.Allocate(
1179  Size + sizeof(OMPClause *) * NumClauses +
1180  sizeof(Stmt *) *
1181  numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop));
1182  return new (Mem) OMPParallelMasterTaskLoopDirective(CollapsedNum, NumClauses);
1183 }
1184 
1186  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1187  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1188  const HelperExprs &Exprs) {
1189  unsigned Size =
1190  llvm::alignTo(sizeof(OMPDistributeDirective), alignof(OMPClause *));
1191  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1192  sizeof(Stmt *) *
1193  numLoopChildren(CollapsedNum, OMPD_distribute));
1194  OMPDistributeDirective *Dir = new (Mem)
1195  OMPDistributeDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
1196  Dir->setClauses(Clauses);
1197  Dir->setAssociatedStmt(AssociatedStmt);
1199  Dir->setLastIteration(Exprs.LastIteration);
1201  Dir->setPreCond(Exprs.PreCond);
1202  Dir->setCond(Exprs.Cond);
1203  Dir->setInit(Exprs.Init);
1204  Dir->setInc(Exprs.Inc);
1205  Dir->setIsLastIterVariable(Exprs.IL);
1206  Dir->setLowerBoundVariable(Exprs.LB);
1207  Dir->setUpperBoundVariable(Exprs.UB);
1208  Dir->setStrideVariable(Exprs.ST);
1209  Dir->setEnsureUpperBound(Exprs.EUB);
1210  Dir->setNextLowerBound(Exprs.NLB);
1211  Dir->setNextUpperBound(Exprs.NUB);
1212  Dir->setNumIterations(Exprs.NumIterations);
1213  Dir->setCounters(Exprs.Counters);
1214  Dir->setPrivateCounters(Exprs.PrivateCounters);
1215  Dir->setInits(Exprs.Inits);
1216  Dir->setUpdates(Exprs.Updates);
1217  Dir->setFinals(Exprs.Finals);
1219  Dir->setDependentInits(Exprs.DependentInits);
1221  Dir->setPreInits(Exprs.PreInits);
1222  return Dir;
1223 }
1224 
1227  unsigned CollapsedNum, EmptyShell) {
1228  unsigned Size =
1229  llvm::alignTo(sizeof(OMPDistributeDirective), alignof(OMPClause *));
1230  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1231  sizeof(Stmt *) *
1232  numLoopChildren(CollapsedNum, OMPD_distribute));
1233  return new (Mem) OMPDistributeDirective(CollapsedNum, NumClauses);
1234 }
1235 
1237  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1238  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1239  unsigned Size =
1240  llvm::alignTo(sizeof(OMPTargetUpdateDirective), alignof(OMPClause *));
1241  void *Mem =
1242  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
1244  new (Mem) OMPTargetUpdateDirective(StartLoc, EndLoc, Clauses.size());
1245  Dir->setClauses(Clauses);
1246  Dir->setAssociatedStmt(AssociatedStmt);
1247  return Dir;
1248 }
1249 
1252  EmptyShell) {
1253  unsigned Size =
1254  llvm::alignTo(sizeof(OMPTargetUpdateDirective), alignof(OMPClause *));
1255  void *Mem =
1256  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
1257  return new (Mem) OMPTargetUpdateDirective(NumClauses);
1258 }
1259 
1261  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1262  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1263  const HelperExprs &Exprs, bool HasCancel) {
1264  unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForDirective),
1265  alignof(OMPClause *));
1266  void *Mem = C.Allocate(
1267  Size + sizeof(OMPClause *) * Clauses.size() +
1268  sizeof(Stmt *) *
1269  numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for));
1271  new (Mem) OMPDistributeParallelForDirective(StartLoc, EndLoc,
1272  CollapsedNum, Clauses.size());
1273  Dir->setClauses(Clauses);
1274  Dir->setAssociatedStmt(AssociatedStmt);
1276  Dir->setLastIteration(Exprs.LastIteration);
1278  Dir->setPreCond(Exprs.PreCond);
1279  Dir->setCond(Exprs.Cond);
1280  Dir->setInit(Exprs.Init);
1281  Dir->setInc(Exprs.Inc);
1282  Dir->setIsLastIterVariable(Exprs.IL);
1283  Dir->setLowerBoundVariable(Exprs.LB);
1284  Dir->setUpperBoundVariable(Exprs.UB);
1285  Dir->setStrideVariable(Exprs.ST);
1286  Dir->setEnsureUpperBound(Exprs.EUB);
1287  Dir->setNextLowerBound(Exprs.NLB);
1288  Dir->setNextUpperBound(Exprs.NUB);
1289  Dir->setNumIterations(Exprs.NumIterations);
1290  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1291  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1292  Dir->setDistInc(Exprs.DistInc);
1293  Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1294  Dir->setCounters(Exprs.Counters);
1295  Dir->setPrivateCounters(Exprs.PrivateCounters);
1296  Dir->setInits(Exprs.Inits);
1297  Dir->setUpdates(Exprs.Updates);
1298  Dir->setFinals(Exprs.Finals);
1300  Dir->setDependentInits(Exprs.DependentInits);
1302  Dir->setPreInits(Exprs.PreInits);
1312  Dir->HasCancel = HasCancel;
1313  return Dir;
1314 }
1315 
1318  unsigned NumClauses,
1319  unsigned CollapsedNum,
1320  EmptyShell) {
1321  unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForDirective),
1322  alignof(OMPClause *));
1323  void *Mem = C.Allocate(
1324  Size + sizeof(OMPClause *) * NumClauses +
1325  sizeof(Stmt *) *
1326  numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for));
1327  return new (Mem) OMPDistributeParallelForDirective(CollapsedNum, NumClauses);
1328 }
1329 
1332  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1333  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1334  const HelperExprs &Exprs) {
1335  unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForSimdDirective),
1336  alignof(OMPClause *));
1337  void *Mem = C.Allocate(
1338  Size + sizeof(OMPClause *) * Clauses.size() +
1339  sizeof(Stmt *) *
1340  numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd));
1341  OMPDistributeParallelForSimdDirective *Dir = new (Mem)
1342  OMPDistributeParallelForSimdDirective(StartLoc, EndLoc, CollapsedNum,
1343  Clauses.size());
1344  Dir->setClauses(Clauses);
1345  Dir->setAssociatedStmt(AssociatedStmt);
1347  Dir->setLastIteration(Exprs.LastIteration);
1349  Dir->setPreCond(Exprs.PreCond);
1350  Dir->setCond(Exprs.Cond);
1351  Dir->setInit(Exprs.Init);
1352  Dir->setInc(Exprs.Inc);
1353  Dir->setIsLastIterVariable(Exprs.IL);
1354  Dir->setLowerBoundVariable(Exprs.LB);
1355  Dir->setUpperBoundVariable(Exprs.UB);
1356  Dir->setStrideVariable(Exprs.ST);
1357  Dir->setEnsureUpperBound(Exprs.EUB);
1358  Dir->setNextLowerBound(Exprs.NLB);
1359  Dir->setNextUpperBound(Exprs.NUB);
1360  Dir->setNumIterations(Exprs.NumIterations);
1361  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1362  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1363  Dir->setDistInc(Exprs.DistInc);
1364  Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1365  Dir->setCounters(Exprs.Counters);
1366  Dir->setPrivateCounters(Exprs.PrivateCounters);
1367  Dir->setInits(Exprs.Inits);
1368  Dir->setUpdates(Exprs.Updates);
1369  Dir->setFinals(Exprs.Finals);
1371  Dir->setDependentInits(Exprs.DependentInits);
1373  Dir->setPreInits(Exprs.PreInits);
1383  return Dir;
1384 }
1385 
1388  unsigned NumClauses,
1389  unsigned CollapsedNum,
1390  EmptyShell) {
1391  unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForSimdDirective),
1392  alignof(OMPClause *));
1393  void *Mem = C.Allocate(
1394  Size + sizeof(OMPClause *) * NumClauses +
1395  sizeof(Stmt *) *
1396  numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd));
1397  return new (Mem)
1398  OMPDistributeParallelForSimdDirective(CollapsedNum, NumClauses);
1399 }
1400 
1402  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1403  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1404  const HelperExprs &Exprs) {
1405  unsigned Size =
1406  llvm::alignTo(sizeof(OMPDistributeSimdDirective), alignof(OMPClause *));
1407  void *Mem = C.Allocate(
1408  Size + sizeof(OMPClause *) * Clauses.size() +
1409  sizeof(Stmt *) *
1410  numLoopChildren(CollapsedNum, OMPD_distribute_simd));
1412  StartLoc, EndLoc, CollapsedNum, Clauses.size());
1413  Dir->setClauses(Clauses);
1414  Dir->setAssociatedStmt(AssociatedStmt);
1416  Dir->setLastIteration(Exprs.LastIteration);
1418  Dir->setPreCond(Exprs.PreCond);
1419  Dir->setCond(Exprs.Cond);
1420  Dir->setInit(Exprs.Init);
1421  Dir->setInc(Exprs.Inc);
1422  Dir->setIsLastIterVariable(Exprs.IL);
1423  Dir->setLowerBoundVariable(Exprs.LB);
1424  Dir->setUpperBoundVariable(Exprs.UB);
1425  Dir->setStrideVariable(Exprs.ST);
1426  Dir->setEnsureUpperBound(Exprs.EUB);
1427  Dir->setNextLowerBound(Exprs.NLB);
1428  Dir->setNextUpperBound(Exprs.NUB);
1429  Dir->setNumIterations(Exprs.NumIterations);
1430  Dir->setCounters(Exprs.Counters);
1431  Dir->setPrivateCounters(Exprs.PrivateCounters);
1432  Dir->setInits(Exprs.Inits);
1433  Dir->setUpdates(Exprs.Updates);
1434  Dir->setFinals(Exprs.Finals);
1436  Dir->setDependentInits(Exprs.DependentInits);
1438  Dir->setPreInits(Exprs.PreInits);
1439  return Dir;
1440 }
1441 
1444  unsigned NumClauses,
1445  unsigned CollapsedNum, EmptyShell) {
1446  unsigned Size =
1447  llvm::alignTo(sizeof(OMPDistributeSimdDirective), alignof(OMPClause *));
1448  void *Mem = C.Allocate(
1449  Size + sizeof(OMPClause *) * NumClauses +
1450  sizeof(Stmt *) *
1451  numLoopChildren(CollapsedNum, OMPD_distribute_simd));
1452  return new (Mem) OMPDistributeSimdDirective(CollapsedNum, NumClauses);
1453 }
1454 
1456  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1457  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1458  const HelperExprs &Exprs) {
1459  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForSimdDirective),
1460  alignof(OMPClause *));
1461  void *Mem = C.Allocate(
1462  Size + sizeof(OMPClause *) * Clauses.size() +
1463  sizeof(Stmt *) *
1464  numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd));
1466  new (Mem) OMPTargetParallelForSimdDirective(StartLoc, EndLoc,
1467  CollapsedNum, Clauses.size());
1468  Dir->setClauses(Clauses);
1469  Dir->setAssociatedStmt(AssociatedStmt);
1471  Dir->setLastIteration(Exprs.LastIteration);
1473  Dir->setPreCond(Exprs.PreCond);
1474  Dir->setCond(Exprs.Cond);
1475  Dir->setInit(Exprs.Init);
1476  Dir->setInc(Exprs.Inc);
1477  Dir->setIsLastIterVariable(Exprs.IL);
1478  Dir->setLowerBoundVariable(Exprs.LB);
1479  Dir->setUpperBoundVariable(Exprs.UB);
1480  Dir->setStrideVariable(Exprs.ST);
1481  Dir->setEnsureUpperBound(Exprs.EUB);
1482  Dir->setNextLowerBound(Exprs.NLB);
1483  Dir->setNextUpperBound(Exprs.NUB);
1484  Dir->setNumIterations(Exprs.NumIterations);
1485  Dir->setCounters(Exprs.Counters);
1486  Dir->setPrivateCounters(Exprs.PrivateCounters);
1487  Dir->setInits(Exprs.Inits);
1488  Dir->setUpdates(Exprs.Updates);
1489  Dir->setFinals(Exprs.Finals);
1491  Dir->setDependentInits(Exprs.DependentInits);
1493  Dir->setPreInits(Exprs.PreInits);
1494  return Dir;
1495 }
1496 
1499  unsigned NumClauses,
1500  unsigned CollapsedNum,
1501  EmptyShell) {
1502  unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForSimdDirective),
1503  alignof(OMPClause *));
1504  void *Mem = C.Allocate(
1505  Size + sizeof(OMPClause *) * NumClauses +
1506  sizeof(Stmt *) *
1507  numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd));
1508  return new (Mem) OMPTargetParallelForSimdDirective(CollapsedNum, NumClauses);
1509 }
1510 
1513  SourceLocation EndLoc, unsigned CollapsedNum,
1514  ArrayRef<OMPClause *> Clauses,
1515  Stmt *AssociatedStmt, const HelperExprs &Exprs) {
1516  unsigned Size =
1517  llvm::alignTo(sizeof(OMPTargetSimdDirective), alignof(OMPClause *));
1518  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1519  sizeof(Stmt *) *
1520  numLoopChildren(CollapsedNum, OMPD_target_simd));
1521  OMPTargetSimdDirective *Dir = new (Mem)
1522  OMPTargetSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
1523  Dir->setClauses(Clauses);
1524  Dir->setAssociatedStmt(AssociatedStmt);
1526  Dir->setLastIteration(Exprs.LastIteration);
1528  Dir->setPreCond(Exprs.PreCond);
1529  Dir->setCond(Exprs.Cond);
1530  Dir->setInit(Exprs.Init);
1531  Dir->setInc(Exprs.Inc);
1532  Dir->setCounters(Exprs.Counters);
1533  Dir->setPrivateCounters(Exprs.PrivateCounters);
1534  Dir->setInits(Exprs.Inits);
1535  Dir->setUpdates(Exprs.Updates);
1536  Dir->setFinals(Exprs.Finals);
1538  Dir->setDependentInits(Exprs.DependentInits);
1540  Dir->setPreInits(Exprs.PreInits);
1541  return Dir;
1542 }
1543 
1546  unsigned CollapsedNum, EmptyShell) {
1547  unsigned Size =
1548  llvm::alignTo(sizeof(OMPTargetSimdDirective), alignof(OMPClause *));
1549  void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1550  sizeof(Stmt *) *
1551  numLoopChildren(CollapsedNum, OMPD_target_simd));
1552  return new (Mem) OMPTargetSimdDirective(CollapsedNum, NumClauses);
1553 }
1554 
1556  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1557  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1558  const HelperExprs &Exprs) {
1559  unsigned Size =
1560  llvm::alignTo(sizeof(OMPTeamsDistributeDirective), alignof(OMPClause *));
1561  void *Mem = C.Allocate(
1562  Size + sizeof(OMPClause *) * Clauses.size() +
1563  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_teams_distribute));
1565  StartLoc, EndLoc, CollapsedNum, Clauses.size());
1566  Dir->setClauses(Clauses);
1567  Dir->setAssociatedStmt(AssociatedStmt);
1569  Dir->setLastIteration(Exprs.LastIteration);
1571  Dir->setPreCond(Exprs.PreCond);
1572  Dir->setCond(Exprs.Cond);
1573  Dir->setInit(Exprs.Init);
1574  Dir->setInc(Exprs.Inc);
1575  Dir->setIsLastIterVariable(Exprs.IL);
1576  Dir->setLowerBoundVariable(Exprs.LB);
1577  Dir->setUpperBoundVariable(Exprs.UB);
1578  Dir->setStrideVariable(Exprs.ST);
1579  Dir->setEnsureUpperBound(Exprs.EUB);
1580  Dir->setNextLowerBound(Exprs.NLB);
1581  Dir->setNextUpperBound(Exprs.NUB);
1582  Dir->setNumIterations(Exprs.NumIterations);
1583  Dir->setCounters(Exprs.Counters);
1584  Dir->setPrivateCounters(Exprs.PrivateCounters);
1585  Dir->setInits(Exprs.Inits);
1586  Dir->setUpdates(Exprs.Updates);
1587  Dir->setFinals(Exprs.Finals);
1589  Dir->setDependentInits(Exprs.DependentInits);
1591  Dir->setPreInits(Exprs.PreInits);
1592  return Dir;
1593 }
1594 
1597  unsigned NumClauses,
1598  unsigned CollapsedNum, EmptyShell) {
1599  unsigned Size =
1600  llvm::alignTo(sizeof(OMPTeamsDistributeDirective), alignof(OMPClause *));
1601  void *Mem = C.Allocate(
1602  Size + sizeof(OMPClause *) * NumClauses +
1603  sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_teams_distribute));
1604  return new (Mem) OMPTeamsDistributeDirective(CollapsedNum, NumClauses);
1605 }
1606 
1608  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1609  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1610  const HelperExprs &Exprs) {
1611  unsigned Size = llvm::alignTo(sizeof(OMPTeamsDistributeSimdDirective),
1612  alignof(OMPClause *));
1613  void *Mem =
1614  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1615  sizeof(Stmt *) *
1616  numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd));
1618  new (Mem) OMPTeamsDistributeSimdDirective(StartLoc, EndLoc, CollapsedNum,
1619  Clauses.size());
1620  Dir->setClauses(Clauses);
1621  Dir->setAssociatedStmt(AssociatedStmt);
1623  Dir->setLastIteration(Exprs.LastIteration);
1625  Dir->setPreCond(Exprs.PreCond);
1626  Dir->setCond(Exprs.Cond);
1627  Dir->setInit(Exprs.Init);
1628  Dir->setInc(Exprs.Inc);
1629  Dir->setIsLastIterVariable(Exprs.IL);
1630  Dir->setLowerBoundVariable(Exprs.LB);
1631  Dir->setUpperBoundVariable(Exprs.UB);
1632  Dir->setStrideVariable(Exprs.ST);
1633  Dir->setEnsureUpperBound(Exprs.EUB);
1634  Dir->setNextLowerBound(Exprs.NLB);
1635  Dir->setNextUpperBound(Exprs.NUB);
1636  Dir->setNumIterations(Exprs.NumIterations);
1637  Dir->setCounters(Exprs.Counters);
1638  Dir->setPrivateCounters(Exprs.PrivateCounters);
1639  Dir->setInits(Exprs.Inits);
1640  Dir->setUpdates(Exprs.Updates);
1641  Dir->setFinals(Exprs.Finals);
1643  Dir->setDependentInits(Exprs.DependentInits);
1645  Dir->setPreInits(Exprs.PreInits);
1646  return Dir;
1647 }
1648 
1650  const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
1651  EmptyShell) {
1652  unsigned Size = llvm::alignTo(sizeof(OMPTeamsDistributeSimdDirective),
1653  alignof(OMPClause *));
1654  void *Mem =
1655  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1656  sizeof(Stmt *) *
1657  numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd));
1658  return new (Mem) OMPTeamsDistributeSimdDirective(CollapsedNum, NumClauses);
1659 }
1660 
1663  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1664  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1665  const HelperExprs &Exprs) {
1666  auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForSimdDirective),
1667  alignof(OMPClause *));
1668  void *Mem =
1669  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
1670  sizeof(Stmt *) *
1671  numLoopChildren(CollapsedNum,
1672  OMPD_teams_distribute_parallel_for_simd));
1674  OMPTeamsDistributeParallelForSimdDirective(StartLoc, EndLoc, CollapsedNum,
1675  Clauses.size());
1676  Dir->setClauses(Clauses);
1677  Dir->setAssociatedStmt(AssociatedStmt);
1679  Dir->setLastIteration(Exprs.LastIteration);
1681  Dir->setPreCond(Exprs.PreCond);
1682  Dir->setCond(Exprs.Cond);
1683  Dir->setInit(Exprs.Init);
1684  Dir->setInc(Exprs.Inc);
1685  Dir->setIsLastIterVariable(Exprs.IL);
1686  Dir->setLowerBoundVariable(Exprs.LB);
1687  Dir->setUpperBoundVariable(Exprs.UB);
1688  Dir->setStrideVariable(Exprs.ST);
1689  Dir->setEnsureUpperBound(Exprs.EUB);
1690  Dir->setNextLowerBound(Exprs.NLB);
1691  Dir->setNextUpperBound(Exprs.NUB);
1692  Dir->setNumIterations(Exprs.NumIterations);
1693  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1694  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1695  Dir->setDistInc(Exprs.DistInc);
1696  Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1697  Dir->setCounters(Exprs.Counters);
1698  Dir->setPrivateCounters(Exprs.PrivateCounters);
1699  Dir->setInits(Exprs.Inits);
1700  Dir->setUpdates(Exprs.Updates);
1701  Dir->setFinals(Exprs.Finals);
1703  Dir->setDependentInits(Exprs.DependentInits);
1705  Dir->setPreInits(Exprs.PreInits);
1715  return Dir;
1716 }
1717 
1720  unsigned NumClauses,
1721  unsigned CollapsedNum,
1722  EmptyShell) {
1723  auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForSimdDirective),
1724  alignof(OMPClause *));
1725  void *Mem =
1726  C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
1727  sizeof(Stmt *) *
1728  numLoopChildren(CollapsedNum,
1729  OMPD_teams_distribute_parallel_for_simd));
1730  return new (Mem)
1731  OMPTeamsDistributeParallelForSimdDirective(CollapsedNum, NumClauses);
1732 }
1733 
1736  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1737  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1738  const HelperExprs &Exprs, bool HasCancel) {
1739  auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForDirective),
1740  alignof(OMPClause *));
1741  void *Mem = C.Allocate(
1742  Size + sizeof(OMPClause *) * Clauses.size() +
1743  sizeof(Stmt *) *
1744  numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for));
1746  OMPTeamsDistributeParallelForDirective(StartLoc, EndLoc, CollapsedNum,
1747  Clauses.size());
1748  Dir->setClauses(Clauses);
1749  Dir->setAssociatedStmt(AssociatedStmt);
1751  Dir->setLastIteration(Exprs.LastIteration);
1753  Dir->setPreCond(Exprs.PreCond);
1754  Dir->setCond(Exprs.Cond);
1755  Dir->setInit(Exprs.Init);
1756  Dir->setInc(Exprs.Inc);
1757  Dir->setIsLastIterVariable(Exprs.IL);
1758  Dir->setLowerBoundVariable(Exprs.LB);
1759  Dir->setUpperBoundVariable(Exprs.UB);
1760  Dir->setStrideVariable(Exprs.ST);
1761  Dir->setEnsureUpperBound(Exprs.EUB);
1762  Dir->setNextLowerBound(Exprs.NLB);
1763  Dir->setNextUpperBound(Exprs.NUB);
1764  Dir->setNumIterations(Exprs.NumIterations);
1765  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1766  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1767  Dir->setDistInc(Exprs.DistInc);
1768  Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1769  Dir->setCounters(Exprs.Counters);
1770  Dir->setPrivateCounters(Exprs.PrivateCounters);
1771  Dir->setInits(Exprs.Inits);
1772  Dir->setUpdates(Exprs.Updates);
1773  Dir->setFinals(Exprs.Finals);
1775  Dir->setDependentInits(Exprs.DependentInits);
1777  Dir->setPreInits(Exprs.PreInits);
1787  Dir->HasCancel = HasCancel;
1788  return Dir;
1789 }
1790 
1793  unsigned NumClauses,
1794  unsigned CollapsedNum,
1795  EmptyShell) {
1796  auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForDirective),
1797  alignof(OMPClause *));
1798  void *Mem = C.Allocate(
1799  Size + sizeof(OMPClause *) * NumClauses +
1800  sizeof(Stmt *) *
1801  numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for));
1802  return new (Mem)
1803  OMPTeamsDistributeParallelForDirective(CollapsedNum, NumClauses);
1804 }
1805 
1807  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1808  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1809  auto Size =
1810  llvm::alignTo(sizeof(OMPTargetTeamsDirective), alignof(OMPClause *));
1811  void *Mem =
1812  C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
1814  new (Mem) OMPTargetTeamsDirective(StartLoc, EndLoc, Clauses.size());
1815  Dir->setClauses(Clauses);
1816  Dir->setAssociatedStmt(AssociatedStmt);
1817  return Dir;
1818 }
1819 
1822  EmptyShell) {
1823  auto Size =
1824  llvm::alignTo(sizeof(OMPTargetTeamsDirective), alignof(OMPClause *));
1825  void *Mem =
1826  C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
1827  return new (Mem) OMPTargetTeamsDirective(NumClauses);
1828 }
1829 
1831  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1832  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1833  const HelperExprs &Exprs) {
1834  auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeDirective),
1835  alignof(OMPClause *));
1836  void *Mem = C.Allocate(
1837  Size + sizeof(OMPClause *) * Clauses.size() +
1838  sizeof(Stmt *) *
1839  numLoopChildren(CollapsedNum, OMPD_target_teams_distribute));
1841  new (Mem) OMPTargetTeamsDistributeDirective(StartLoc, EndLoc, CollapsedNum,
1842  Clauses.size());
1843  Dir->setClauses(Clauses);
1844  Dir->setAssociatedStmt(AssociatedStmt);
1846  Dir->setLastIteration(Exprs.LastIteration);
1848  Dir->setPreCond(Exprs.PreCond);
1849  Dir->setCond(Exprs.Cond);
1850  Dir->setInit(Exprs.Init);
1851  Dir->setInc(Exprs.Inc);
1852  Dir->setIsLastIterVariable(Exprs.IL);
1853  Dir->setLowerBoundVariable(Exprs.LB);
1854  Dir->setUpperBoundVariable(Exprs.UB);
1855  Dir->setStrideVariable(Exprs.ST);
1856  Dir->setEnsureUpperBound(Exprs.EUB);
1857  Dir->setNextLowerBound(Exprs.NLB);
1858  Dir->setNextUpperBound(Exprs.NUB);
1859  Dir->setNumIterations(Exprs.NumIterations);
1860  Dir->setCounters(Exprs.Counters);
1861  Dir->setPrivateCounters(Exprs.PrivateCounters);
1862  Dir->setInits(Exprs.Inits);
1863  Dir->setUpdates(Exprs.Updates);
1864  Dir->setFinals(Exprs.Finals);
1866  Dir->setDependentInits(Exprs.DependentInits);
1868  Dir->setPreInits(Exprs.PreInits);
1869  return Dir;
1870 }
1871 
1874  unsigned NumClauses,
1875  unsigned CollapsedNum,
1876  EmptyShell) {
1877  auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeDirective),
1878  alignof(OMPClause *));
1879  void *Mem = C.Allocate(
1880  Size + sizeof(OMPClause *) * NumClauses +
1881  sizeof(Stmt *) *
1882  numLoopChildren(CollapsedNum, OMPD_target_teams_distribute));
1883  return new (Mem) OMPTargetTeamsDistributeDirective(CollapsedNum, NumClauses);
1884 }
1885 
1888  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1889  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1890  const HelperExprs &Exprs, bool HasCancel) {
1891  auto Size =
1892  llvm::alignTo(sizeof(OMPTargetTeamsDistributeParallelForDirective),
1893  alignof(OMPClause *));
1894  void *Mem = C.Allocate(
1895  Size + sizeof(OMPClause *) * Clauses.size() +
1896  sizeof(Stmt *) *
1897  numLoopChildren(CollapsedNum,
1898  OMPD_target_teams_distribute_parallel_for));
1901  StartLoc, EndLoc, CollapsedNum, Clauses.size());
1902  Dir->setClauses(Clauses);
1903  Dir->setAssociatedStmt(AssociatedStmt);
1905  Dir->setLastIteration(Exprs.LastIteration);
1907  Dir->setPreCond(Exprs.PreCond);
1908  Dir->setCond(Exprs.Cond);
1909  Dir->setInit(Exprs.Init);
1910  Dir->setInc(Exprs.Inc);
1911  Dir->setIsLastIterVariable(Exprs.IL);
1912  Dir->setLowerBoundVariable(Exprs.LB);
1913  Dir->setUpperBoundVariable(Exprs.UB);
1914  Dir->setStrideVariable(Exprs.ST);
1915  Dir->setEnsureUpperBound(Exprs.EUB);
1916  Dir->setNextLowerBound(Exprs.NLB);
1917  Dir->setNextUpperBound(Exprs.NUB);
1918  Dir->setNumIterations(Exprs.NumIterations);
1919  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1920  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1921  Dir->setDistInc(Exprs.DistInc);
1922  Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1923  Dir->setCounters(Exprs.Counters);
1924  Dir->setPrivateCounters(Exprs.PrivateCounters);
1925  Dir->setInits(Exprs.Inits);
1926  Dir->setUpdates(Exprs.Updates);
1927  Dir->setFinals(Exprs.Finals);
1929  Dir->setDependentInits(Exprs.DependentInits);
1931  Dir->setPreInits(Exprs.PreInits);
1941  Dir->HasCancel = HasCancel;
1942  return Dir;
1943 }
1944 
1947  unsigned NumClauses,
1948  unsigned CollapsedNum,
1949  EmptyShell) {
1950  auto Size =
1951  llvm::alignTo(sizeof(OMPTargetTeamsDistributeParallelForDirective),
1952  alignof(OMPClause *));
1953  void *Mem = C.Allocate(
1954  Size + sizeof(OMPClause *) * NumClauses +
1955  sizeof(Stmt *) *
1956  numLoopChildren(CollapsedNum,
1957  OMPD_target_teams_distribute_parallel_for));
1958  return new (Mem)
1959  OMPTargetTeamsDistributeParallelForDirective(CollapsedNum, NumClauses);
1960 }
1961 
1964  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1965  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1966  const HelperExprs &Exprs) {
1967  auto Size =
1969  alignof(OMPClause *));
1970  void *Mem = C.Allocate(
1971  Size + sizeof(OMPClause *) * Clauses.size() +
1972  sizeof(Stmt *) *
1973  numLoopChildren(CollapsedNum,
1974  OMPD_target_teams_distribute_parallel_for_simd));
1977  StartLoc, EndLoc, CollapsedNum, Clauses.size());
1978  Dir->setClauses(Clauses);
1979  Dir->setAssociatedStmt(AssociatedStmt);
1981  Dir->setLastIteration(Exprs.LastIteration);
1983  Dir->setPreCond(Exprs.PreCond);
1984  Dir->setCond(Exprs.Cond);
1985  Dir->setInit(Exprs.Init);
1986  Dir->setInc(Exprs.Inc);
1987  Dir->setIsLastIterVariable(Exprs.IL);
1988  Dir->setLowerBoundVariable(Exprs.LB);
1989  Dir->setUpperBoundVariable(Exprs.UB);
1990  Dir->setStrideVariable(Exprs.ST);
1991  Dir->setEnsureUpperBound(Exprs.EUB);
1992  Dir->setNextLowerBound(Exprs.NLB);
1993  Dir->setNextUpperBound(Exprs.NUB);
1994  Dir->setNumIterations(Exprs.NumIterations);
1995  Dir->setPrevLowerBoundVariable(Exprs.PrevLB);
1996  Dir->setPrevUpperBoundVariable(Exprs.PrevUB);
1997  Dir->setDistInc(Exprs.DistInc);
1998  Dir->setPrevEnsureUpperBound(Exprs.PrevEUB);
1999  Dir->setCounters(Exprs.Counters);
2000  Dir->setPrivateCounters(Exprs.PrivateCounters);
2001  Dir->setInits(Exprs.Inits);
2002  Dir->setUpdates(Exprs.Updates);
2003  Dir->setFinals(Exprs.Finals);
2005  Dir->setDependentInits(Exprs.DependentInits);
2007  Dir->setPreInits(Exprs.PreInits);
2017  return Dir;
2018 }
2019 
2022  const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
2023  EmptyShell) {
2024  auto Size =
2026  alignof(OMPClause *));
2027  void *Mem = C.Allocate(
2028  Size + sizeof(OMPClause *) * NumClauses +
2029  sizeof(Stmt *) *
2030  numLoopChildren(CollapsedNum,
2031  OMPD_target_teams_distribute_parallel_for_simd));
2033  CollapsedNum, NumClauses);
2034 }
2035 
2038  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2039  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2040  const HelperExprs &Exprs) {
2041  auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeSimdDirective),
2042  alignof(OMPClause *));
2043  void *Mem = C.Allocate(
2044  Size + sizeof(OMPClause *) * Clauses.size() +
2045  sizeof(Stmt *) *
2046  numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd));
2047  OMPTargetTeamsDistributeSimdDirective *Dir = new (Mem)
2048  OMPTargetTeamsDistributeSimdDirective(StartLoc, EndLoc, CollapsedNum,
2049  Clauses.size());
2050  Dir->setClauses(Clauses);
2051  Dir->setAssociatedStmt(AssociatedStmt);
2053  Dir->setLastIteration(Exprs.LastIteration);
2055  Dir->setPreCond(Exprs.PreCond);
2056  Dir->setCond(Exprs.Cond);
2057  Dir->setInit(Exprs.Init);
2058  Dir->setInc(Exprs.Inc);
2059  Dir->setIsLastIterVariable(Exprs.IL);
2060  Dir->setLowerBoundVariable(Exprs.LB);
2061  Dir->setUpperBoundVariable(Exprs.UB);
2062  Dir->setStrideVariable(Exprs.ST);
2063  Dir->setEnsureUpperBound(Exprs.EUB);
2064  Dir->setNextLowerBound(Exprs.NLB);
2065  Dir->setNextUpperBound(Exprs.NUB);
2066  Dir->setNumIterations(Exprs.NumIterations);
2067  Dir->setCounters(Exprs.Counters);
2068  Dir->setPrivateCounters(Exprs.PrivateCounters);
2069  Dir->setInits(Exprs.Inits);
2070  Dir->setUpdates(Exprs.Updates);
2071  Dir->setFinals(Exprs.Finals);
2073  Dir->setDependentInits(Exprs.DependentInits);
2075  Dir->setPreInits(Exprs.PreInits);
2076  return Dir;
2077 }
2078 
2081  unsigned NumClauses,
2082  unsigned CollapsedNum,
2083  EmptyShell) {
2084  auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeSimdDirective),
2085  alignof(OMPClause *));
2086  void *Mem = C.Allocate(
2087  Size + sizeof(OMPClause *) * NumClauses +
2088  sizeof(Stmt *) *
2089  numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd));
2090  return new (Mem)
2091  OMPTargetTeamsDistributeSimdDirective(CollapsedNum, NumClauses);
2092 }
void setPreInits(Stmt *PreInits)
Definition: StmtOpenMP.h:604
void setCombinedParForInDistCond(Expr *CombParForInDistCond)
Definition: StmtOpenMP.h:723
Expr * NLB
Update of LowerBound for statically scheduled &#39;omp for&#39; loops.
Definition: StmtOpenMP.h:803
Defines the clang::ASTContext interface.
This represents &#39;#pragma omp distribute simd&#39; composite directive.
Definition: StmtOpenMP.h:3614
SmallVector< Expr *, 4 > Finals
Final loop counter values for GodeGen.
Definition: StmtOpenMP.h:831
This represents &#39;#pragma omp master&#39; directive.
Definition: StmtOpenMP.h:1592
Expr * NUB
Update of UpperBound for statically scheduled omp loops for outer loop in combined constructs (e...
Definition: StmtOpenMP.h:763
SmallVector< Expr *, 4 > Updates
Expressions for loop counters update for CodeGen.
Definition: StmtOpenMP.h:829
This represents &#39;#pragma omp task&#39; directive.
Definition: StmtOpenMP.h:1932
void setEnsureUpperBound(Expr *EUB)
Definition: StmtOpenMP.h:635
static OMPMasterTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPMasterDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:349
static OMPDistributeParallelForDirective * 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.
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 &#39;x&#39;, &#39;v&#39; and &#39;expr&#39; parts of the atomic construct (see S...
Definition: StmtOpenMP.cpp:695
static OMPParallelMasterTaskLoopDirective * 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:703
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:895
void setCombinedLowerBoundVariable(Expr *CombLB)
Definition: StmtOpenMP.h:683
static OMPTaskwaitDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:571
static OMPTargetParallelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:767
void setHasCancel(bool Has)
Set cancel state.
Definition: StmtOpenMP.h:1519
Stmt - This represents one statement.
Definition: Stmt.h:66
static OMPTaskgroupDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:592
void setLastIteration(Expr *LI)
Definition: StmtOpenMP.h:590
bool isStandaloneDirective() const
Returns whether or not this is a Standalone directive.
Definition: StmtOpenMP.cpp:25
static OMPTaskgroupDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *ReductionRef)
Creates directive.
Definition: StmtOpenMP.cpp:577
void setPrivateCounters(ArrayRef< Expr *> A)
Definition: StmtOpenMP.cpp:50
static OMPTargetTeamsDistributeParallelForDirective * 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.
This represents &#39;#pragma omp for simd&#39; directive.
Definition: StmtOpenMP.h:1342
Expr * EUB
EnsureUpperBound – expression UB = min(UB, NumIterations).
Definition: StmtOpenMP.h:801
Expr * DistInc
DistInc - increment expression for distribute loop when found combined with a further loop level (e...
Definition: StmtOpenMP.h:815
This represents &#39;#pragma omp teams distribute parallel for&#39; composite directive.
Definition: StmtOpenMP.h:4025
static OMPSectionDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt, bool HasCancel)
Creates directive.
Definition: StmtOpenMP.cpp:292
void setPrevEnsureUpperBound(Expr *PrevEUB)
Definition: StmtOpenMP.h:678
CapturedStmt * getInnermostCapturedStmt()
Get innermost captured statement for the construct.
Definition: StmtOpenMP.h:283
void setUpperBoundVariable(Expr *UB)
Definition: StmtOpenMP.h:621
void setNumIterations(Expr *NI)
Definition: StmtOpenMP.h:656
This represents &#39;#pragma omp target teams distribute&#39; combined directive.
Definition: StmtOpenMP.h:4162
void setNextLowerBound(Expr *NLB)
Definition: StmtOpenMP.h:642
static OMPMasterTaskLoopDirective * 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 &#39;#pragma omp parallel for&#39; directive.
Definition: StmtOpenMP.h:1713
This represents &#39;#pragma omp target teams distribute parallel for&#39; combined directive.
Definition: StmtOpenMP.h:4230
static OMPTeamsDistributeParallelForDirective * 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.
void setDependentInits(ArrayRef< Expr *> A)
Definition: StmtOpenMP.cpp:82
void setIsLastIterVariable(Expr *IL)
Definition: StmtOpenMP.h:607
Expr * PrevLB
PreviousLowerBound - local variable passed to runtime in the enclosing schedule or null if that does ...
Definition: StmtOpenMP.h:808
This represents &#39;#pragma omp target exit data&#39; directive.
Definition: StmtOpenMP.h:2624
static OMPTargetTeamsDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
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.
static OMPParallelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:109
void setCombinedDistCond(Expr *CombDistCond)
Definition: StmtOpenMP.h:718
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.
void setInit(Expr *Init)
Definition: StmtOpenMP.h:602
static OMPMasterTaskLoopSimdDirective * 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 * LastIteration
Loop last iteration number.
Definition: StmtOpenMP.h:779
static OMPTargetExitDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:887
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 OMPTargetTeamsDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
const Stmt * getStructuredBlock() const
Returns the AST node representing OpenMP structured-block of this OpenMP executable directive...
Definition: StmtOpenMP.cpp:36
static OMPTargetDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:742
This represents &#39;#pragma omp parallel&#39; directive.
Definition: StmtOpenMP.h:357
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:160
static OMPTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPTargetEnterDataDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause *> Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:851
static OMPTargetParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:818
static OMPTargetUpdateDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause *> Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
static OMPFlushDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:660
This represents &#39;#pragma omp target simd&#39; directive.
Definition: StmtOpenMP.h:3750
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:511
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.
This represents &#39;#pragma omp barrier&#39; directive.
Definition: StmtOpenMP.h:2044
This represents &#39;#pragma omp critical&#39; directive.
Definition: StmtOpenMP.h:1639
static OMPCriticalDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:371
void setCond(Expr *Cond)
Definition: StmtOpenMP.h:599
static OMPTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:961
This represents &#39;#pragma omp distribute parallel for&#39; composite directive.
Definition: StmtOpenMP.h:3465
This represents &#39;#pragma omp teams distribute parallel for simd&#39; composite directive.
Definition: StmtOpenMP.h:3954
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 &#39;omp distribute&#39; with &#39;omp for&#39; in a same construct...
Definition: StmtOpenMP.h:744
Expr * EUB
DistributeEnsureUpperBound - used when composing &#39;omp distribute&#39; with &#39;omp for&#39; in a same construct...
Definition: StmtOpenMP.h:750
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 OMPTargetTeamsDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
static OMPParallelMasterTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents &#39;#pragma omp cancellation point&#39; directive.
Definition: StmtOpenMP.h:2879
void setCombinedInit(Expr *CombInit)
Definition: StmtOpenMP.h:698
MutableArrayRef< Expr * > getFinals()
Sets the list of final update expressions for linear variables.
This represents &#39;#pragma omp teams&#39; directive.
Definition: StmtOpenMP.h:2822
static OMPFlushDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause *> Clauses)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:647
Expr * CalcLastIteration
Calculation of last iteration.
Definition: StmtOpenMP.h:783
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.
This represents &#39;#pragma omp teams distribute simd&#39; combined directive.
Definition: StmtOpenMP.h:3884
static OMPTargetParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
SmallVector< Expr *, 4 > FinalsConditions
List of final conditions required for the generation of the non-rectangular loops.
Definition: StmtOpenMP.h:840
static OMPTaskyieldDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:543
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:433
Expr * NUB
Update of UpperBound for statically scheduled &#39;omp for&#39; loops.
Definition: StmtOpenMP.h:805
Expr * Cond
Loop condition.
Definition: StmtOpenMP.h:787
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 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:776
static OMPTargetDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:842
static OMPTeamsDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
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:752
Expr * PreCond
Loop pre-condition.
Definition: StmtOpenMP.h:785
This represents &#39;#pragma omp target parallel for simd&#39; directive.
Definition: StmtOpenMP.h:3682
void setDependentCounters(ArrayRef< Expr *> A)
Definition: StmtOpenMP.cpp:75
The expressions built for the OpenMP loop CodeGen for the whole collapsed loop nest.
Definition: StmtOpenMP.h:775
static OMPTargetSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents &#39;#pragma omp taskgroup&#39; directive.
Definition: StmtOpenMP.h:2132
static OMPSingleDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:328
static OMPCriticalDirective * Create(const ASTContext &C, const DeclarationNameInfo &Name, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause *> Clauses, Stmt *AssociatedStmt)
Creates directive.
Definition: StmtOpenMP.cpp:356
Expr * DistCond
Distribute Loop condition used when composing &#39;omp distribute&#39; with &#39;omp for&#39; in a same construct whe...
Definition: StmtOpenMP.h:766
Expr * IterationVarRef
Loop iteration variable.
Definition: StmtOpenMP.h:777
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.
Expr * Init
Distribute loop iteration variable init used when composing &#39;omp distribute&#39; with &#39;omp for&#39; in a same...
Definition: StmtOpenMP.h:754
static OMPTeamsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:911
This represents &#39;#pragma omp distribute&#39; directive.
Definition: StmtOpenMP.h:3338
void setInits(ArrayRef< Expr *> A)
Definition: StmtOpenMP.cpp:57
const Stmt * getAssociatedStmt() const
Returns statement associated with the directive.
Definition: StmtOpenMP.h:253
static OMPSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:151
This represents one expression.
Definition: Expr.h:108
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.
MutableArrayRef< Expr * > getUpdates()
Sets the list of update expressions for linear variables.
SmallVector< Expr *, 4 > DependentInits
List of initializers required for the generation of the non-rectangular loops.
Definition: StmtOpenMP.h:837
This represents &#39;#pragma omp master taskloop&#39; directive.
Definition: StmtOpenMP.h:3134
static OMPMasterTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
#define V(N, I)
Definition: ASTContext.h:2921
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:338
This represents &#39;#pragma omp target teams distribute parallel for simd&#39; combined directive.
Definition: StmtOpenMP.h:4314
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 OMPTargetDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause *> Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:726
This represents &#39;#pragma omp target teams distribute simd&#39; combined directive.
Definition: StmtOpenMP.h:4387
unsigned getNumClauses() const
Get number of clauses.
Definition: StmtOpenMP.h:241
Expr * PrevUB
PreviousUpperBound - local variable passed to runtime in the enclosing schedule or null if that does ...
Definition: StmtOpenMP.h:811
static OMPOrderedDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause *> Clauses, Stmt *AssociatedStmt)
Creates directive.
Definition: StmtOpenMP.cpp:669
This represents &#39;#pragma omp for&#39; directive.
Definition: StmtOpenMP.h:1265
static OMPTargetEnterDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:865
This represents &#39;#pragma omp target teams&#39; directive.
Definition: StmtOpenMP.h:4103
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.
Expr * ParForInDistCond
&#39;omp parallel for&#39; loop condition used when composed with &#39;omp distribute&#39; in the same construct and ...
Definition: StmtOpenMP.h:770
static OMPParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:474
This represents &#39;#pragma omp cancel&#39; directive.
Definition: StmtOpenMP.h:2937
void setDistInc(Expr *DistInc)
Definition: StmtOpenMP.h:673
Expr * NLB
Update of LowerBound for statically scheduled omp loops for outer loop in combined constructs (e...
Definition: StmtOpenMP.h:760
static OMPDistributeParallelForDirective * 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:19
This represents &#39;#pragma omp flush&#39; directive.
Definition: StmtOpenMP.h:2205
This represents &#39;#pragma omp parallel for simd&#39; directive.
Definition: StmtOpenMP.h:1793
Expr * NumIterations
Loop number of iterations.
Definition: StmtOpenMP.h:781
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:163
Expr * ST
Stride - local variable passed to runtime.
Definition: StmtOpenMP.h:799
This represents &#39;#pragma omp parallel master taskloop&#39; directive.
Definition: StmtOpenMP.h:3270
static OMPParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:423
This represents &#39;#pragma omp target enter data&#39; directive.
Definition: StmtOpenMP.h:2565
void setUpdates(ArrayRef< Expr *> A)
Definition: StmtOpenMP.cpp:63
SmallVector< Expr *, 4 > PrivateCounters
PrivateCounters Loop counters.
Definition: StmtOpenMP.h:825
void setLowerBoundVariable(Expr *LB)
Definition: StmtOpenMP.h:614
This represents &#39;#pragma omp master taskloop simd&#39; directive.
Definition: StmtOpenMP.h:3202
static OMPSectionDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:305
SmallVector< Expr *, 4 > Counters
Counters Loop counters.
Definition: StmtOpenMP.h:823
This represents &#39;#pragma omp single&#39; directive.
Definition: StmtOpenMP.h:1537
Encodes a location in the source.
void setPrevLowerBoundVariable(Expr *PrevLB)
Definition: StmtOpenMP.h:663
void setIterationVariable(Expr *IV)
Definition: StmtOpenMP.h:587
MutableArrayRef< Expr * > getInits()
static OMPTaskDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:525
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:708
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:381
OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:22
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:94
static OMPTargetExitDataDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause *> Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
Definition: StmtOpenMP.cpp:873
static OMPAtomicDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:716
This represents &#39;#pragma omp taskwait&#39; directive.
Definition: StmtOpenMP.h:2088
Expr * PrevEUB
PrevEUB - expression similar to EUB but to be used when loop scheduling uses PrevLB and PrevUB (e...
Definition: StmtOpenMP.h:821
This is a basic class for representing single OpenMP clause.
Definition: OpenMPClause.h:50
void setFinalsConditions(ArrayRef< Expr *> A)
Definition: StmtOpenMP.cpp:88
static OMPOrderedDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:685
Stmt * getCapturedStmt()
Retrieve the statement being captured.
Definition: Stmt.h:3461
This represents &#39;#pragma omp target&#39; directive.
Definition: StmtOpenMP.h:2449
static OMPTeamsDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
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:845
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:215
This represents &#39;#pragma omp ordered&#39; directive.
Definition: StmtOpenMP.h:2260
Expr * LB
LowerBound - local variable passed to runtime.
Definition: StmtOpenMP.h:795
This represents &#39;#pragma omp target update&#39; directive.
Definition: StmtOpenMP.h:3406
Expr * Init
Loop iteration variable init.
Definition: StmtOpenMP.h:789
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:312
A placeholder type used to construct an empty shell of a type, that will be filled in later (e...
Definition: Stmt.h:1044
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:685
void setPrevUpperBoundVariable(Expr *PrevUB)
Definition: StmtOpenMP.h:668
void setCombinedEnsureUpperBound(Expr *CombEUB)
Definition: StmtOpenMP.h:693
static OMPForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:203
void setCounters(ArrayRef< Expr *> A)
Definition: StmtOpenMP.cpp:44
Dataflow Directional Tag Classes.
SmallVector< Expr *, 4 > Inits
Expressions for loop counters inits for CodeGen.
Definition: StmtOpenMP.h:827
void setCombinedUpperBoundVariable(Expr *CombUB)
Definition: StmtOpenMP.h:688
static OMPTargetTeamsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents &#39;#pragma omp section&#39; directive.
Definition: StmtOpenMP.h:1475
SmallVector< Expr *, 4 > DependentCounters
List of counters required for the generation of the non-rectangular loops.
Definition: StmtOpenMP.h:834
This represents &#39;#pragma omp teams distribute&#39; directive.
Definition: StmtOpenMP.h:3816
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:485
This represents &#39;#pragma omp simd&#39; directive.
Definition: StmtOpenMP.h:1200
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
This represents &#39;#pragma omp atomic&#39; directive.
Definition: StmtOpenMP.h:2315
static OMPForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:255
static OMPBarrierDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:557
This file defines OpenMP AST classes for executable directives and clauses.
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:267
Expr * Inc
Loop increment.
Definition: StmtOpenMP.h:791
bool hasAssociatedStmt() const
Returns true if directive has associated statement.
Definition: StmtOpenMP.h:250
static OMPTargetTeamsDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause *> Clauses, Stmt *AssociatedStmt)
Creates directive with a list of Clauses.
static OMPTargetTeamsDistributeParallelForSimdDirective * 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:921
Expr * UB
DistributeUpperBound - used when composing &#39;omp distribute&#39; with &#39;omp for&#39; in a same construct...
Definition: StmtOpenMP.h:747
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:14652
static OMPTaskyieldDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Creates directive.
Definition: StmtOpenMP.cpp:534
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:829
Expr * UB
UpperBound - local variable passed to runtime.
Definition: StmtOpenMP.h:797
This represents &#39;#pragma omp target parallel&#39; directive.
Definition: StmtOpenMP.h:2682
void setStrideVariable(Expr *ST)
Definition: StmtOpenMP.h:628
static OMPParallelSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:501
static OMPBarrierDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Creates directive.
Definition: StmtOpenMP.cpp:549
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:120
This represents &#39;#pragma omp taskloop simd&#39; directive.
Definition: StmtOpenMP.h:3067
static OMPSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:282
void setPreCond(Expr *PC)
Definition: StmtOpenMP.h:596
static OMPCancelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:637
static OMPTaskwaitDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc)
Creates directive.
Definition: StmtOpenMP.cpp:563
This represents &#39;#pragma omp sections&#39; directive.
Definition: StmtOpenMP.h:1407
Expr * Cond
Distribute Loop condition used when composing &#39;omp distribute&#39; with &#39;omp for&#39; in a same construct...
Definition: StmtOpenMP.h:757
Stmt * PreInits
Init statement for all captured expressions.
Definition: StmtOpenMP.h:842
This represents &#39;#pragma omp target data&#39; directive.
Definition: StmtOpenMP.h:2507
void setNextUpperBound(Expr *NUB)
Definition: StmtOpenMP.h:649
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.
void setInc(Expr *Inc)
Definition: StmtOpenMP.h:603
static OMPCancelDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause *> Clauses, OpenMPDirectiveKind CancelRegion)
Creates directive.
Definition: StmtOpenMP.cpp:623
Expr * IL
IsLastIteration - local flag variable passed to runtime.
Definition: StmtOpenMP.h:793
This represents &#39;#pragma omp taskyield&#39; directive.
Definition: StmtOpenMP.h:2000
This represents &#39;#pragma omp distribute parallel for simd&#39; composite directive.
Definition: StmtOpenMP.h:3545
static OMPCancellationPointDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, OpenMPDirectiveKind CancelRegion)
Creates directive.
Definition: StmtOpenMP.cpp:602
This represents &#39;#pragma omp parallel sections&#39; directive.
Definition: StmtOpenMP.h:1861
void setCalcLastIteration(Expr *CLI)
Definition: StmtOpenMP.h:593
void setCombinedNextUpperBound(Expr *CombNUB)
Definition: StmtOpenMP.h:713
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:973
void setFinals(ArrayRef< Expr *> A)
Definition: StmtOpenMP.cpp:69
static OMPTeamsDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
This represents &#39;#pragma omp target parallel for&#39; directive.
Definition: StmtOpenMP.h:2742
static OMPCancellationPointDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:615
This represents &#39;#pragma omp taskloop&#39; directive.
Definition: StmtOpenMP.h:3002