clang  7.0.0
StmtOpenMP.h
Go to the documentation of this file.
1 //===- StmtOpenMP.h - Classes for OpenMP directives ------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 /// \file
10 /// This file defines OpenMP AST classes for executable directives and
11 /// clauses.
12 ///
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CLANG_AST_STMTOPENMP_H
16 #define LLVM_CLANG_AST_STMTOPENMP_H
17 
18 #include "clang/AST/Expr.h"
19 #include "clang/AST/OpenMPClause.h"
20 #include "clang/AST/Stmt.h"
23 
24 namespace clang {
25 
26 //===----------------------------------------------------------------------===//
27 // AST classes for directives.
28 //===----------------------------------------------------------------------===//
29 
30 /// This is a basic class for representing single OpenMP executable
31 /// directive.
32 ///
33 class OMPExecutableDirective : public Stmt {
34  friend class ASTStmtReader;
35  /// Kind of the directive.
37  /// Starting location of the directive (directive keyword).
38  SourceLocation StartLoc;
39  /// Ending location of the directive.
40  SourceLocation EndLoc;
41  /// Numbers of clauses.
42  const unsigned NumClauses;
43  /// Number of child expressions/stmts.
44  const unsigned NumChildren;
45  /// Offset from this to the start of clauses.
46  /// There are NumClauses pointers to clauses, they are followed by
47  /// NumChildren pointers to child stmts/exprs (if the directive type
48  /// requires an associated stmt, then it has to be the first of them).
49  const unsigned ClausesOffset;
50 
51  /// Get the clauses storage.
52  MutableArrayRef<OMPClause *> getClauses() {
53  OMPClause **ClauseStorage = reinterpret_cast<OMPClause **>(
54  reinterpret_cast<char *>(this) + ClausesOffset);
55  return MutableArrayRef<OMPClause *>(ClauseStorage, NumClauses);
56  }
57 
58 protected:
59  /// Build instance of directive of class \a K.
60  ///
61  /// \param SC Statement class.
62  /// \param K Kind of OpenMP directive.
63  /// \param StartLoc Starting location of the directive (directive keyword).
64  /// \param EndLoc Ending location of the directive.
65  ///
66  template <typename T>
68  SourceLocation StartLoc, SourceLocation EndLoc,
69  unsigned NumClauses, unsigned NumChildren)
70  : Stmt(SC), Kind(K), StartLoc(std::move(StartLoc)),
71  EndLoc(std::move(EndLoc)), NumClauses(NumClauses),
72  NumChildren(NumChildren),
73  ClausesOffset(llvm::alignTo(sizeof(T), alignof(OMPClause *))) {}
74 
75  /// Sets the list of variables for this clause.
76  ///
77  /// \param Clauses The list of clauses for the directive.
78  ///
79  void setClauses(ArrayRef<OMPClause *> Clauses);
80 
81  /// Set the associated statement for the directive.
82  ///
83  /// /param S Associated statement.
84  ///
86  assert(hasAssociatedStmt() && "no associated statement.");
87  *child_begin() = S;
88  }
89 
90 public:
91  /// Iterates over a filtered subrange of clauses applied to a
92  /// directive.
93  ///
94  /// This iterator visits only clauses of type SpecificClause.
95  template <typename SpecificClause>
97  : public llvm::iterator_adaptor_base<
98  specific_clause_iterator<SpecificClause>,
99  ArrayRef<OMPClause *>::const_iterator, std::forward_iterator_tag,
100  const SpecificClause *, ptrdiff_t, const SpecificClause *,
101  const SpecificClause *> {
103 
104  void SkipToNextClause() {
105  while (this->I != End && !isa<SpecificClause>(*this->I))
106  ++this->I;
107  }
108 
109  public:
111  : specific_clause_iterator::iterator_adaptor_base(Clauses.begin()),
112  End(Clauses.end()) {
113  SkipToNextClause();
114  }
115 
116  const SpecificClause *operator*() const {
117  return cast<SpecificClause>(*this->I);
118  }
119  const SpecificClause *operator->() const { return **this; }
120 
122  ++this->I;
123  SkipToNextClause();
124  return *this;
125  }
126  };
127 
128  template <typename SpecificClause>
129  static llvm::iterator_range<specific_clause_iterator<SpecificClause>>
133  llvm::makeArrayRef(Clauses.end(), 0))};
134  }
135 
136  template <typename SpecificClause>
137  llvm::iterator_range<specific_clause_iterator<SpecificClause>>
139  return getClausesOfKind<SpecificClause>(clauses());
140  }
141 
142  /// Gets a single clause of the specified kind associated with the
143  /// current directive iff there is only one clause of this kind (and assertion
144  /// is fired if there is more than one clause is associated with the
145  /// directive). Returns nullptr if no clause of this kind is associated with
146  /// the directive.
147  template <typename SpecificClause>
148  const SpecificClause *getSingleClause() const {
149  auto Clauses = getClausesOfKind<SpecificClause>();
150 
151  if (Clauses.begin() != Clauses.end()) {
152  assert(std::next(Clauses.begin()) == Clauses.end() &&
153  "There are at least 2 clauses of the specified kind");
154  return *Clauses.begin();
155  }
156  return nullptr;
157  }
158 
159  /// Returns true if the current directive has one or more clauses of a
160  /// specific kind.
161  template <typename SpecificClause>
162  bool hasClausesOfKind() const {
163  auto Clauses = getClausesOfKind<SpecificClause>();
164  return Clauses.begin() != Clauses.end();
165  }
166 
167  /// Returns starting location of directive kind.
168  SourceLocation getLocStart() const LLVM_READONLY { return getBeginLoc(); }
169  SourceLocation getBeginLoc() const { return StartLoc; }
170  /// Returns ending location of directive.
171  SourceLocation getLocEnd() const LLVM_READONLY { return getEndLoc(); }
172  SourceLocation getEndLoc() const { return EndLoc; }
173 
174  /// Set starting location of directive kind.
175  ///
176  /// \param Loc New starting location of directive.
177  ///
178  void setLocStart(SourceLocation Loc) { StartLoc = Loc; }
179  /// Set ending location of directive.
180  ///
181  /// \param Loc New ending location of directive.
182  ///
183  void setLocEnd(SourceLocation Loc) { EndLoc = Loc; }
184 
185  /// Get number of clauses.
186  unsigned getNumClauses() const { return NumClauses; }
187 
188  /// Returns specified clause.
189  ///
190  /// \param i Number of clause.
191  ///
192  OMPClause *getClause(unsigned i) const { return clauses()[i]; }
193 
194  /// Returns true if directive has associated statement.
195  bool hasAssociatedStmt() const { return NumChildren > 0; }
196 
197  /// Returns statement associated with the directive.
198  const Stmt *getAssociatedStmt() const {
199  assert(hasAssociatedStmt() && "no associated statement.");
200  return *child_begin();
201  }
203  assert(hasAssociatedStmt() && "no associated statement.");
204  return *child_begin();
205  }
206 
207  /// Returns the captured statement associated with the
208  /// component region within the (combined) directive.
209  //
210  // \param RegionKind Component region kind.
213  getOpenMPCaptureRegions(CaptureRegions, getDirectiveKind());
214  assert(std::any_of(
215  CaptureRegions.begin(), CaptureRegions.end(),
216  [=](const OpenMPDirectiveKind K) { return K == RegionKind; }) &&
217  "RegionKind not found in OpenMP CaptureRegions.");
218  auto *CS = cast<CapturedStmt>(getAssociatedStmt());
219  for (auto ThisCaptureRegion : CaptureRegions) {
220  if (ThisCaptureRegion == RegionKind)
221  return CS;
222  CS = cast<CapturedStmt>(CS->getCapturedStmt());
223  }
224  llvm_unreachable("Incorrect RegionKind specified for directive.");
225  }
226 
227  /// Get innermost captured statement for the construct.
229  assert(hasAssociatedStmt() && getAssociatedStmt() &&
230  "Must have associated statement.");
232  getOpenMPCaptureRegions(CaptureRegions, getDirectiveKind());
233  assert(!CaptureRegions.empty() &&
234  "At least one captured statement must be provided.");
235  auto *CS = cast<CapturedStmt>(getAssociatedStmt());
236  for (unsigned Level = CaptureRegions.size(); Level > 1; --Level)
237  CS = cast<CapturedStmt>(CS->getCapturedStmt());
238  return CS;
239  }
240 
242  return const_cast<OMPExecutableDirective *>(this)
244  }
245 
246  OpenMPDirectiveKind getDirectiveKind() const { return Kind; }
247 
248  static bool classof(const Stmt *S) {
249  return S->getStmtClass() >= firstOMPExecutableDirectiveConstant &&
250  S->getStmtClass() <= lastOMPExecutableDirectiveConstant;
251  }
252 
254  if (!hasAssociatedStmt())
256  Stmt **ChildStorage = reinterpret_cast<Stmt **>(getClauses().end());
257  /// Do not mark all the special expression/statements as children, except
258  /// for the associated statement.
259  return child_range(ChildStorage, ChildStorage + 1);
260  }
261 
262  ArrayRef<OMPClause *> clauses() { return getClauses(); }
263 
265  return const_cast<OMPExecutableDirective *>(this)->getClauses();
266  }
267 };
268 
269 /// This represents '#pragma omp parallel' directive.
270 ///
271 /// \code
272 /// #pragma omp parallel private(a,b) reduction(+: c,d)
273 /// \endcode
274 /// In this example directive '#pragma omp parallel' has clauses 'private'
275 /// with the variables 'a' and 'b' and 'reduction' with operator '+' and
276 /// variables 'c' and 'd'.
277 ///
279  friend class ASTStmtReader;
280  /// true if the construct has inner cancel directive.
281  bool HasCancel;
282 
283  /// Build directive with the given start and end location.
284  ///
285  /// \param StartLoc Starting location of the directive (directive keyword).
286  /// \param EndLoc Ending Location of the directive.
287  ///
289  unsigned NumClauses)
290  : OMPExecutableDirective(this, OMPParallelDirectiveClass, OMPD_parallel,
291  StartLoc, EndLoc, NumClauses, 1),
292  HasCancel(false) {}
293 
294  /// Build an empty directive.
295  ///
296  /// \param NumClauses Number of clauses.
297  ///
298  explicit OMPParallelDirective(unsigned NumClauses)
299  : OMPExecutableDirective(this, OMPParallelDirectiveClass, OMPD_parallel,
300  SourceLocation(), SourceLocation(), NumClauses,
301  1),
302  HasCancel(false) {}
303 
304  /// Set cancel state.
305  void setHasCancel(bool Has) { HasCancel = Has; }
306 
307 public:
308  /// Creates directive with a list of \a Clauses.
309  ///
310  /// \param C AST context.
311  /// \param StartLoc Starting location of the directive kind.
312  /// \param EndLoc Ending Location of the directive.
313  /// \param Clauses List of clauses.
314  /// \param AssociatedStmt Statement associated with the directive.
315  /// \param HasCancel true if this directive has inner cancel directive.
316  ///
317  static OMPParallelDirective *
318  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
319  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel);
320 
321  /// Creates an empty directive with the place for \a N clauses.
322  ///
323  /// \param C AST context.
324  /// \param NumClauses Number of clauses.
325  ///
327  unsigned NumClauses, EmptyShell);
328 
329  /// Return true if current directive has inner cancel directive.
330  bool hasCancel() const { return HasCancel; }
331 
332  static bool classof(const Stmt *T) {
333  return T->getStmtClass() == OMPParallelDirectiveClass;
334  }
335 };
336 
337 /// This is a common base class for loop directives ('omp simd', 'omp
338 /// for', 'omp for simd' etc.). It is responsible for the loop code generation.
339 ///
341  friend class ASTStmtReader;
342  /// Number of collapsed loops as specified by 'collapse' clause.
343  unsigned CollapsedNum;
344 
345  /// Offsets to the stored exprs.
346  /// This enumeration contains offsets to all the pointers to children
347  /// expressions stored in OMPLoopDirective.
348  /// The first 9 children are necessary for all the loop directives,
349  /// the next 8 are specific to the worksharing ones, and the next 11 are
350  /// used for combined constructs containing two pragmas associated to loops.
351  /// After the fixed children, three arrays of length CollapsedNum are
352  /// allocated: loop counters, their updates and final values.
353  /// PrevLowerBound and PrevUpperBound are used to communicate blocking
354  /// information in composite constructs which require loop blocking
355  /// DistInc is used to generate the increment expression for the distribute
356  /// loop when combined with a further nested loop
357  /// PrevEnsureUpperBound is used as the EnsureUpperBound expression for the
358  /// for loop when combined with a previous distribute loop in the same pragma
359  /// (e.g. 'distribute parallel for')
360  ///
361  enum {
362  AssociatedStmtOffset = 0,
363  IterationVariableOffset = 1,
364  LastIterationOffset = 2,
365  CalcLastIterationOffset = 3,
366  PreConditionOffset = 4,
367  CondOffset = 5,
368  InitOffset = 6,
369  IncOffset = 7,
370  PreInitsOffset = 8,
371  // The '...End' enumerators do not correspond to child expressions - they
372  // specify the offset to the end (and start of the following counters/
373  // updates/finals arrays).
374  DefaultEnd = 9,
375  // The following 8 exprs are used by worksharing and distribute loops only.
376  IsLastIterVariableOffset = 9,
377  LowerBoundVariableOffset = 10,
378  UpperBoundVariableOffset = 11,
379  StrideVariableOffset = 12,
380  EnsureUpperBoundOffset = 13,
381  NextLowerBoundOffset = 14,
382  NextUpperBoundOffset = 15,
383  NumIterationsOffset = 16,
384  // Offset to the end for worksharing loop directives.
385  WorksharingEnd = 17,
386  PrevLowerBoundVariableOffset = 17,
387  PrevUpperBoundVariableOffset = 18,
388  DistIncOffset = 19,
389  PrevEnsureUpperBoundOffset = 20,
390  CombinedLowerBoundVariableOffset = 21,
391  CombinedUpperBoundVariableOffset = 22,
392  CombinedEnsureUpperBoundOffset = 23,
393  CombinedInitOffset = 24,
394  CombinedConditionOffset = 25,
395  CombinedNextLowerBoundOffset = 26,
396  CombinedNextUpperBoundOffset = 27,
397  // Offset to the end (and start of the following counters/updates/finals
398  // arrays) for combined distribute loop directives.
399  CombinedDistributeEnd = 28,
400  };
401 
402  /// Get the counters storage.
403  MutableArrayRef<Expr *> getCounters() {
404  Expr **Storage = reinterpret_cast<Expr **>(
405  &(*(std::next(child_begin(), getArraysOffset(getDirectiveKind())))));
406  return MutableArrayRef<Expr *>(Storage, CollapsedNum);
407  }
408 
409  /// Get the private counters storage.
410  MutableArrayRef<Expr *> getPrivateCounters() {
411  Expr **Storage = reinterpret_cast<Expr **>(&*std::next(
412  child_begin(), getArraysOffset(getDirectiveKind()) + CollapsedNum));
413  return MutableArrayRef<Expr *>(Storage, CollapsedNum);
414  }
415 
416  /// Get the updates storage.
418  Expr **Storage = reinterpret_cast<Expr **>(
419  &*std::next(child_begin(),
420  getArraysOffset(getDirectiveKind()) + 2 * CollapsedNum));
421  return MutableArrayRef<Expr *>(Storage, CollapsedNum);
422  }
423 
424  /// Get the updates storage.
426  Expr **Storage = reinterpret_cast<Expr **>(
427  &*std::next(child_begin(),
428  getArraysOffset(getDirectiveKind()) + 3 * CollapsedNum));
429  return MutableArrayRef<Expr *>(Storage, CollapsedNum);
430  }
431 
432  /// Get the final counter updates storage.
434  Expr **Storage = reinterpret_cast<Expr **>(
435  &*std::next(child_begin(),
436  getArraysOffset(getDirectiveKind()) + 4 * CollapsedNum));
437  return MutableArrayRef<Expr *>(Storage, CollapsedNum);
438  }
439 
440 protected:
441  /// Build instance of loop directive of class \a Kind.
442  ///
443  /// \param SC Statement class.
444  /// \param Kind Kind of OpenMP directive.
445  /// \param StartLoc Starting location of the directive (directive keyword).
446  /// \param EndLoc Ending location of the directive.
447  /// \param CollapsedNum Number of collapsed loops from 'collapse' clause.
448  /// \param NumClauses Number of clauses.
449  /// \param NumSpecialChildren Number of additional directive-specific stmts.
450  ///
451  template <typename T>
453  SourceLocation StartLoc, SourceLocation EndLoc,
454  unsigned CollapsedNum, unsigned NumClauses,
455  unsigned NumSpecialChildren = 0)
456  : OMPExecutableDirective(That, SC, Kind, StartLoc, EndLoc, NumClauses,
457  numLoopChildren(CollapsedNum, Kind) +
458  NumSpecialChildren),
459  CollapsedNum(CollapsedNum) {}
460 
461  /// Offset to the start of children expression arrays.
464  return CombinedDistributeEnd;
467  return WorksharingEnd;
468  return DefaultEnd;
469  }
470 
471  /// Children number.
472  static unsigned numLoopChildren(unsigned CollapsedNum,
474  return getArraysOffset(Kind) + 5 * CollapsedNum; // Counters,
475  // PrivateCounters, Inits,
476  // Updates and Finals
477  }
478 
480  *std::next(child_begin(), IterationVariableOffset) = IV;
481  }
482  void setLastIteration(Expr *LI) {
483  *std::next(child_begin(), LastIterationOffset) = LI;
484  }
486  *std::next(child_begin(), CalcLastIterationOffset) = CLI;
487  }
488  void setPreCond(Expr *PC) {
489  *std::next(child_begin(), PreConditionOffset) = PC;
490  }
491  void setCond(Expr *Cond) {
492  *std::next(child_begin(), CondOffset) = Cond;
493  }
494  void setInit(Expr *Init) { *std::next(child_begin(), InitOffset) = Init; }
495  void setInc(Expr *Inc) { *std::next(child_begin(), IncOffset) = Inc; }
496  void setPreInits(Stmt *PreInits) {
497  *std::next(child_begin(), PreInitsOffset) = PreInits;
498  }
503  "expected worksharing loop directive");
504  *std::next(child_begin(), IsLastIterVariableOffset) = IL;
505  }
510  "expected worksharing loop directive");
511  *std::next(child_begin(), LowerBoundVariableOffset) = LB;
512  }
517  "expected worksharing loop directive");
518  *std::next(child_begin(), UpperBoundVariableOffset) = UB;
519  }
524  "expected worksharing loop directive");
525  *std::next(child_begin(), StrideVariableOffset) = ST;
526  }
531  "expected worksharing loop directive");
532  *std::next(child_begin(), EnsureUpperBoundOffset) = EUB;
533  }
534  void setNextLowerBound(Expr *NLB) {
538  "expected worksharing loop directive");
539  *std::next(child_begin(), NextLowerBoundOffset) = NLB;
540  }
541  void setNextUpperBound(Expr *NUB) {
545  "expected worksharing loop directive");
546  *std::next(child_begin(), NextUpperBoundOffset) = NUB;
547  }
548  void setNumIterations(Expr *NI) {
552  "expected worksharing loop directive");
553  *std::next(child_begin(), NumIterationsOffset) = NI;
554  }
557  "expected loop bound sharing directive");
558  *std::next(child_begin(), PrevLowerBoundVariableOffset) = PrevLB;
559  }
562  "expected loop bound sharing directive");
563  *std::next(child_begin(), PrevUpperBoundVariableOffset) = PrevUB;
564  }
565  void setDistInc(Expr *DistInc) {
567  "expected loop bound sharing directive");
568  *std::next(child_begin(), DistIncOffset) = DistInc;
569  }
570  void setPrevEnsureUpperBound(Expr *PrevEUB) {
572  "expected loop bound sharing directive");
573  *std::next(child_begin(), PrevEnsureUpperBoundOffset) = PrevEUB;
574  }
577  "expected loop bound sharing directive");
578  *std::next(child_begin(), CombinedLowerBoundVariableOffset) = CombLB;
579  }
582  "expected loop bound sharing directive");
583  *std::next(child_begin(), CombinedUpperBoundVariableOffset) = CombUB;
584  }
587  "expected loop bound sharing directive");
588  *std::next(child_begin(), CombinedEnsureUpperBoundOffset) = CombEUB;
589  }
590  void setCombinedInit(Expr *CombInit) {
592  "expected loop bound sharing directive");
593  *std::next(child_begin(), CombinedInitOffset) = CombInit;
594  }
595  void setCombinedCond(Expr *CombCond) {
597  "expected loop bound sharing directive");
598  *std::next(child_begin(), CombinedConditionOffset) = CombCond;
599  }
602  "expected loop bound sharing directive");
603  *std::next(child_begin(), CombinedNextLowerBoundOffset) = CombNLB;
604  }
607  "expected loop bound sharing directive");
608  *std::next(child_begin(), CombinedNextUpperBoundOffset) = CombNUB;
609  }
610  void setCounters(ArrayRef<Expr *> A);
611  void setPrivateCounters(ArrayRef<Expr *> A);
612  void setInits(ArrayRef<Expr *> A);
614  void setFinals(ArrayRef<Expr *> A);
615 
616 public:
617  /// The expressions built to support OpenMP loops in combined/composite
618  /// pragmas (e.g. pragma omp distribute parallel for)
620  /// DistributeLowerBound - used when composing 'omp distribute' with
621  /// 'omp for' in a same construct.
623  /// DistributeUpperBound - used when composing 'omp distribute' with
624  /// 'omp for' in a same construct.
626  /// DistributeEnsureUpperBound - used when composing 'omp distribute'
627  /// with 'omp for' in a same construct, EUB depends on DistUB
629  /// Distribute loop iteration variable init used when composing 'omp
630  /// distribute'
631  /// with 'omp for' in a same construct
633  /// Distribute Loop condition used when composing 'omp distribute'
634  /// with 'omp for' in a same construct
636  /// Update of LowerBound for statically scheduled omp loops for
637  /// outer loop in combined constructs (e.g. 'distribute parallel for')
639  /// Update of UpperBound for statically scheduled omp loops for
640  /// outer loop in combined constructs (e.g. 'distribute parallel for')
642  };
643 
644  /// The expressions built for the OpenMP loop CodeGen for the
645  /// whole collapsed loop nest.
646  struct HelperExprs {
647  /// Loop iteration variable.
649  /// Loop last iteration number.
651  /// Loop number of iterations.
653  /// Calculation of last iteration.
655  /// Loop pre-condition.
657  /// Loop condition.
659  /// Loop iteration variable init.
661  /// Loop increment.
663  /// IsLastIteration - local flag variable passed to runtime.
665  /// LowerBound - local variable passed to runtime.
667  /// UpperBound - local variable passed to runtime.
669  /// Stride - local variable passed to runtime.
671  /// EnsureUpperBound -- expression UB = min(UB, NumIterations).
673  /// Update of LowerBound for statically scheduled 'omp for' loops.
675  /// Update of UpperBound for statically scheduled 'omp for' loops.
677  /// PreviousLowerBound - local variable passed to runtime in the
678  /// enclosing schedule or null if that does not apply.
680  /// PreviousUpperBound - local variable passed to runtime in the
681  /// enclosing schedule or null if that does not apply.
683  /// DistInc - increment expression for distribute loop when found
684  /// combined with a further loop level (e.g. in 'distribute parallel for')
685  /// expression IV = IV + ST
687  /// PrevEUB - expression similar to EUB but to be used when loop
688  /// scheduling uses PrevLB and PrevUB (e.g. in 'distribute parallel for'
689  /// when ensuring that the UB is either the calculated UB by the runtime or
690  /// the end of the assigned distribute chunk)
691  /// expression UB = min (UB, PrevUB)
693  /// Counters Loop counters.
695  /// PrivateCounters Loop counters.
697  /// Expressions for loop counters inits for CodeGen.
699  /// Expressions for loop counters update for CodeGen.
701  /// Final loop counter values for GodeGen.
703  /// Init statement for all captured expressions.
705 
706  /// Expressions used when combining OpenMP loop pragmas
708 
709  /// Check if all the expressions are built (does not check the
710  /// worksharing ones).
711  bool builtAll() {
712  return IterationVarRef != nullptr && LastIteration != nullptr &&
713  NumIterations != nullptr && PreCond != nullptr &&
714  Cond != nullptr && Init != nullptr && Inc != nullptr;
715  }
716 
717  /// Initialize all the fields to null.
718  /// \param Size Number of elements in the counters/finals/updates arrays.
719  void clear(unsigned Size) {
720  IterationVarRef = nullptr;
721  LastIteration = nullptr;
722  CalcLastIteration = nullptr;
723  PreCond = nullptr;
724  Cond = nullptr;
725  Init = nullptr;
726  Inc = nullptr;
727  IL = nullptr;
728  LB = nullptr;
729  UB = nullptr;
730  ST = nullptr;
731  EUB = nullptr;
732  NLB = nullptr;
733  NUB = nullptr;
734  NumIterations = nullptr;
735  PrevLB = nullptr;
736  PrevUB = nullptr;
737  DistInc = nullptr;
738  PrevEUB = nullptr;
739  Counters.resize(Size);
740  PrivateCounters.resize(Size);
741  Inits.resize(Size);
742  Updates.resize(Size);
743  Finals.resize(Size);
744  for (unsigned i = 0; i < Size; ++i) {
745  Counters[i] = nullptr;
746  PrivateCounters[i] = nullptr;
747  Inits[i] = nullptr;
748  Updates[i] = nullptr;
749  Finals[i] = nullptr;
750  }
751  PreInits = nullptr;
752  DistCombinedFields.LB = nullptr;
753  DistCombinedFields.UB = nullptr;
754  DistCombinedFields.EUB = nullptr;
755  DistCombinedFields.Init = nullptr;
756  DistCombinedFields.Cond = nullptr;
757  DistCombinedFields.NLB = nullptr;
758  DistCombinedFields.NUB = nullptr;
759  }
760  };
761 
762  /// Get number of collapsed loops.
763  unsigned getCollapsedNumber() const { return CollapsedNum; }
764 
766  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
767  *std::next(child_begin(), IterationVariableOffset)));
768  }
770  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
771  *std::next(child_begin(), LastIterationOffset)));
772  }
774  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
775  *std::next(child_begin(), CalcLastIterationOffset)));
776  }
777  Expr *getPreCond() const {
778  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
779  *std::next(child_begin(), PreConditionOffset)));
780  }
781  Expr *getCond() const {
782  return const_cast<Expr *>(
783  reinterpret_cast<const Expr *>(*std::next(child_begin(), CondOffset)));
784  }
785  Expr *getInit() const {
786  return const_cast<Expr *>(
787  reinterpret_cast<const Expr *>(*std::next(child_begin(), InitOffset)));
788  }
789  Expr *getInc() const {
790  return const_cast<Expr *>(
791  reinterpret_cast<const Expr *>(*std::next(child_begin(), IncOffset)));
792  }
793  const Stmt *getPreInits() const {
794  return *std::next(child_begin(), PreInitsOffset);
795  }
796  Stmt *getPreInits() { return *std::next(child_begin(), PreInitsOffset); }
801  "expected worksharing loop directive");
802  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
803  *std::next(child_begin(), IsLastIterVariableOffset)));
804  }
809  "expected worksharing loop directive");
810  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
811  *std::next(child_begin(), LowerBoundVariableOffset)));
812  }
817  "expected worksharing loop directive");
818  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
819  *std::next(child_begin(), UpperBoundVariableOffset)));
820  }
825  "expected worksharing loop directive");
826  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
827  *std::next(child_begin(), StrideVariableOffset)));
828  }
833  "expected worksharing loop directive");
834  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
835  *std::next(child_begin(), EnsureUpperBoundOffset)));
836  }
841  "expected worksharing loop directive");
842  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
843  *std::next(child_begin(), NextLowerBoundOffset)));
844  }
849  "expected worksharing loop directive");
850  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
851  *std::next(child_begin(), NextUpperBoundOffset)));
852  }
857  "expected worksharing loop directive");
858  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
859  *std::next(child_begin(), NumIterationsOffset)));
860  }
863  "expected loop bound sharing directive");
864  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
865  *std::next(child_begin(), PrevLowerBoundVariableOffset)));
866  }
869  "expected loop bound sharing directive");
870  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
871  *std::next(child_begin(), PrevUpperBoundVariableOffset)));
872  }
873  Expr *getDistInc() const {
875  "expected loop bound sharing directive");
876  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
877  *std::next(child_begin(), DistIncOffset)));
878  }
881  "expected loop bound sharing directive");
882  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
883  *std::next(child_begin(), PrevEnsureUpperBoundOffset)));
884  }
887  "expected loop bound sharing directive");
888  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
889  *std::next(child_begin(), CombinedLowerBoundVariableOffset)));
890  }
893  "expected loop bound sharing directive");
894  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
895  *std::next(child_begin(), CombinedUpperBoundVariableOffset)));
896  }
899  "expected loop bound sharing directive");
900  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
901  *std::next(child_begin(), CombinedEnsureUpperBoundOffset)));
902  }
905  "expected loop bound sharing directive");
906  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
907  *std::next(child_begin(), CombinedInitOffset)));
908  }
911  "expected loop bound sharing directive");
912  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
913  *std::next(child_begin(), CombinedConditionOffset)));
914  }
917  "expected loop bound sharing directive");
918  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
919  *std::next(child_begin(), CombinedNextLowerBoundOffset)));
920  }
923  "expected loop bound sharing directive");
924  return const_cast<Expr *>(reinterpret_cast<const Expr *>(
925  *std::next(child_begin(), CombinedNextUpperBoundOffset)));
926  }
927  const Stmt *getBody() const {
928  // This relies on the loop form is already checked by Sema.
929  const Stmt *Body =
931  Body = cast<ForStmt>(Body)->getBody();
932  for (unsigned Cnt = 1; Cnt < CollapsedNum; ++Cnt) {
933  Body = Body->IgnoreContainers();
934  Body = cast<ForStmt>(Body)->getBody();
935  }
936  return Body;
937  }
938 
939  ArrayRef<Expr *> counters() { return getCounters(); }
940 
942  return const_cast<OMPLoopDirective *>(this)->getCounters();
943  }
944 
945  ArrayRef<Expr *> private_counters() { return getPrivateCounters(); }
946 
948  return const_cast<OMPLoopDirective *>(this)->getPrivateCounters();
949  }
950 
952 
954  return const_cast<OMPLoopDirective *>(this)->getInits();
955  }
956 
958 
960  return const_cast<OMPLoopDirective *>(this)->getUpdates();
961  }
962 
964 
966  return const_cast<OMPLoopDirective *>(this)->getFinals();
967  }
968 
969  static bool classof(const Stmt *T) {
970  return T->getStmtClass() == OMPSimdDirectiveClass ||
971  T->getStmtClass() == OMPForDirectiveClass ||
972  T->getStmtClass() == OMPForSimdDirectiveClass ||
973  T->getStmtClass() == OMPParallelForDirectiveClass ||
974  T->getStmtClass() == OMPParallelForSimdDirectiveClass ||
975  T->getStmtClass() == OMPTaskLoopDirectiveClass ||
976  T->getStmtClass() == OMPTaskLoopSimdDirectiveClass ||
977  T->getStmtClass() == OMPDistributeDirectiveClass ||
978  T->getStmtClass() == OMPTargetParallelForDirectiveClass ||
979  T->getStmtClass() == OMPDistributeParallelForDirectiveClass ||
980  T->getStmtClass() == OMPDistributeParallelForSimdDirectiveClass ||
981  T->getStmtClass() == OMPDistributeSimdDirectiveClass ||
982  T->getStmtClass() == OMPTargetParallelForSimdDirectiveClass ||
983  T->getStmtClass() == OMPTargetSimdDirectiveClass ||
984  T->getStmtClass() == OMPTeamsDistributeDirectiveClass ||
985  T->getStmtClass() == OMPTeamsDistributeSimdDirectiveClass ||
986  T->getStmtClass() ==
987  OMPTeamsDistributeParallelForSimdDirectiveClass ||
988  T->getStmtClass() == OMPTeamsDistributeParallelForDirectiveClass ||
989  T->getStmtClass() ==
990  OMPTargetTeamsDistributeParallelForDirectiveClass ||
991  T->getStmtClass() ==
992  OMPTargetTeamsDistributeParallelForSimdDirectiveClass ||
993  T->getStmtClass() == OMPTargetTeamsDistributeDirectiveClass ||
994  T->getStmtClass() == OMPTargetTeamsDistributeSimdDirectiveClass;
995  }
996 };
997 
998 /// This represents '#pragma omp simd' directive.
999 ///
1000 /// \code
1001 /// #pragma omp simd private(a,b) linear(i,j:s) reduction(+:c,d)
1002 /// \endcode
1003 /// In this example directive '#pragma omp simd' has clauses 'private'
1004 /// with the variables 'a' and 'b', 'linear' with variables 'i', 'j' and
1005 /// linear step 's', 'reduction' with operator '+' and variables 'c' and 'd'.
1006 ///
1008  friend class ASTStmtReader;
1009  /// Build directive with the given start and end location.
1010  ///
1011  /// \param StartLoc Starting location of the directive kind.
1012  /// \param EndLoc Ending location of the directive.
1013  /// \param CollapsedNum Number of collapsed nested loops.
1014  /// \param NumClauses Number of clauses.
1015  ///
1017  unsigned CollapsedNum, unsigned NumClauses)
1018  : OMPLoopDirective(this, OMPSimdDirectiveClass, OMPD_simd, StartLoc,
1019  EndLoc, CollapsedNum, NumClauses) {}
1020 
1021  /// Build an empty directive.
1022  ///
1023  /// \param CollapsedNum Number of collapsed nested loops.
1024  /// \param NumClauses Number of clauses.
1025  ///
1026  explicit OMPSimdDirective(unsigned CollapsedNum, unsigned NumClauses)
1027  : OMPLoopDirective(this, OMPSimdDirectiveClass, OMPD_simd,
1028  SourceLocation(), SourceLocation(), CollapsedNum,
1029  NumClauses) {}
1030 
1031 public:
1032  /// Creates directive with a list of \a Clauses.
1033  ///
1034  /// \param C AST context.
1035  /// \param StartLoc Starting location of the directive kind.
1036  /// \param EndLoc Ending Location of the directive.
1037  /// \param CollapsedNum Number of collapsed loops.
1038  /// \param Clauses List of clauses.
1039  /// \param AssociatedStmt Statement, associated with the directive.
1040  /// \param Exprs Helper expressions for CodeGen.
1041  ///
1042  static OMPSimdDirective *Create(const ASTContext &C, SourceLocation StartLoc,
1043  SourceLocation EndLoc, unsigned CollapsedNum,
1044  ArrayRef<OMPClause *> Clauses,
1045  Stmt *AssociatedStmt,
1046  const HelperExprs &Exprs);
1047 
1048  /// Creates an empty directive with the place
1049  /// for \a NumClauses clauses.
1050  ///
1051  /// \param C AST context.
1052  /// \param CollapsedNum Number of collapsed nested loops.
1053  /// \param NumClauses Number of clauses.
1054  ///
1055  static OMPSimdDirective *CreateEmpty(const ASTContext &C, unsigned NumClauses,
1056  unsigned CollapsedNum, EmptyShell);
1057 
1058  static bool classof(const Stmt *T) {
1059  return T->getStmtClass() == OMPSimdDirectiveClass;
1060  }
1061 };
1062 
1063 /// This represents '#pragma omp for' directive.
1064 ///
1065 /// \code
1066 /// #pragma omp for private(a,b) reduction(+:c,d)
1067 /// \endcode
1068 /// In this example directive '#pragma omp for' has clauses 'private' with the
1069 /// variables 'a' and 'b' and 'reduction' with operator '+' and variables 'c'
1070 /// and 'd'.
1071 ///
1073  friend class ASTStmtReader;
1074 
1075  /// true if current directive has inner cancel directive.
1076  bool HasCancel;
1077 
1078  /// Build directive with the given start and end location.
1079  ///
1080  /// \param StartLoc Starting location of the directive kind.
1081  /// \param EndLoc Ending location of the directive.
1082  /// \param CollapsedNum Number of collapsed nested loops.
1083  /// \param NumClauses Number of clauses.
1084  ///
1086  unsigned CollapsedNum, unsigned NumClauses)
1087  : OMPLoopDirective(this, OMPForDirectiveClass, OMPD_for, StartLoc, EndLoc,
1088  CollapsedNum, NumClauses),
1089  HasCancel(false) {}
1090 
1091  /// Build an empty directive.
1092  ///
1093  /// \param CollapsedNum Number of collapsed nested loops.
1094  /// \param NumClauses Number of clauses.
1095  ///
1096  explicit OMPForDirective(unsigned CollapsedNum, unsigned NumClauses)
1097  : OMPLoopDirective(this, OMPForDirectiveClass, OMPD_for, SourceLocation(),
1098  SourceLocation(), CollapsedNum, NumClauses),
1099  HasCancel(false) {}
1100 
1101  /// Set cancel state.
1102  void setHasCancel(bool Has) { HasCancel = Has; }
1103 
1104 public:
1105  /// Creates directive with a list of \a Clauses.
1106  ///
1107  /// \param C AST context.
1108  /// \param StartLoc Starting location of the directive kind.
1109  /// \param EndLoc Ending Location of the directive.
1110  /// \param CollapsedNum Number of collapsed loops.
1111  /// \param Clauses List of clauses.
1112  /// \param AssociatedStmt Statement, associated with the directive.
1113  /// \param Exprs Helper expressions for CodeGen.
1114  /// \param HasCancel true if current directive has inner cancel directive.
1115  ///
1116  static OMPForDirective *Create(const ASTContext &C, SourceLocation StartLoc,
1117  SourceLocation EndLoc, unsigned CollapsedNum,
1118  ArrayRef<OMPClause *> Clauses,
1119  Stmt *AssociatedStmt, const HelperExprs &Exprs,
1120  bool HasCancel);
1121 
1122  /// Creates an empty directive with the place
1123  /// for \a NumClauses clauses.
1124  ///
1125  /// \param C AST context.
1126  /// \param CollapsedNum Number of collapsed nested loops.
1127  /// \param NumClauses Number of clauses.
1128  ///
1129  static OMPForDirective *CreateEmpty(const ASTContext &C, unsigned NumClauses,
1130  unsigned CollapsedNum, EmptyShell);
1131 
1132  /// Return true if current directive has inner cancel directive.
1133  bool hasCancel() const { return HasCancel; }
1134 
1135  static bool classof(const Stmt *T) {
1136  return T->getStmtClass() == OMPForDirectiveClass;
1137  }
1138 };
1139 
1140 /// This represents '#pragma omp for simd' directive.
1141 ///
1142 /// \code
1143 /// #pragma omp for simd private(a,b) linear(i,j:s) reduction(+:c,d)
1144 /// \endcode
1145 /// In this example directive '#pragma omp for simd' has clauses 'private'
1146 /// with the variables 'a' and 'b', 'linear' with variables 'i', 'j' and
1147 /// linear step 's', 'reduction' with operator '+' and variables 'c' and 'd'.
1148 ///
1150  friend class ASTStmtReader;
1151  /// Build directive with the given start and end location.
1152  ///
1153  /// \param StartLoc Starting location of the directive kind.
1154  /// \param EndLoc Ending location of the directive.
1155  /// \param CollapsedNum Number of collapsed nested loops.
1156  /// \param NumClauses Number of clauses.
1157  ///
1159  unsigned CollapsedNum, unsigned NumClauses)
1160  : OMPLoopDirective(this, OMPForSimdDirectiveClass, OMPD_for_simd,
1161  StartLoc, EndLoc, CollapsedNum, NumClauses) {}
1162 
1163  /// Build an empty directive.
1164  ///
1165  /// \param CollapsedNum Number of collapsed nested loops.
1166  /// \param NumClauses Number of clauses.
1167  ///
1168  explicit OMPForSimdDirective(unsigned CollapsedNum, unsigned NumClauses)
1169  : OMPLoopDirective(this, OMPForSimdDirectiveClass, OMPD_for_simd,
1170  SourceLocation(), SourceLocation(), CollapsedNum,
1171  NumClauses) {}
1172 
1173 public:
1174  /// Creates directive with a list of \a Clauses.
1175  ///
1176  /// \param C AST context.
1177  /// \param StartLoc Starting location of the directive kind.
1178  /// \param EndLoc Ending Location of the directive.
1179  /// \param CollapsedNum Number of collapsed loops.
1180  /// \param Clauses List of clauses.
1181  /// \param AssociatedStmt Statement, associated with the directive.
1182  /// \param Exprs Helper expressions for CodeGen.
1183  ///
1184  static OMPForSimdDirective *
1185  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1186  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
1187  Stmt *AssociatedStmt, const HelperExprs &Exprs);
1188 
1189  /// Creates an empty directive with the place
1190  /// for \a NumClauses clauses.
1191  ///
1192  /// \param C AST context.
1193  /// \param CollapsedNum Number of collapsed nested loops.
1194  /// \param NumClauses Number of clauses.
1195  ///
1197  unsigned NumClauses,
1198  unsigned CollapsedNum, EmptyShell);
1199 
1200  static bool classof(const Stmt *T) {
1201  return T->getStmtClass() == OMPForSimdDirectiveClass;
1202  }
1203 };
1204 
1205 /// This represents '#pragma omp sections' directive.
1206 ///
1207 /// \code
1208 /// #pragma omp sections private(a,b) reduction(+:c,d)
1209 /// \endcode
1210 /// In this example directive '#pragma omp sections' has clauses 'private' with
1211 /// the variables 'a' and 'b' and 'reduction' with operator '+' and variables
1212 /// 'c' and 'd'.
1213 ///
1215  friend class ASTStmtReader;
1216 
1217  /// true if current directive has inner cancel directive.
1218  bool HasCancel;
1219 
1220  /// Build directive with the given start and end location.
1221  ///
1222  /// \param StartLoc Starting location of the directive kind.
1223  /// \param EndLoc Ending location of the directive.
1224  /// \param NumClauses Number of clauses.
1225  ///
1227  unsigned NumClauses)
1228  : OMPExecutableDirective(this, OMPSectionsDirectiveClass, OMPD_sections,
1229  StartLoc, EndLoc, NumClauses, 1),
1230  HasCancel(false) {}
1231 
1232  /// Build an empty directive.
1233  ///
1234  /// \param NumClauses Number of clauses.
1235  ///
1236  explicit OMPSectionsDirective(unsigned NumClauses)
1237  : OMPExecutableDirective(this, OMPSectionsDirectiveClass, OMPD_sections,
1238  SourceLocation(), SourceLocation(), NumClauses,
1239  1),
1240  HasCancel(false) {}
1241 
1242  /// Set cancel state.
1243  void setHasCancel(bool Has) { HasCancel = Has; }
1244 
1245 public:
1246  /// Creates directive with a list of \a Clauses.
1247  ///
1248  /// \param C AST context.
1249  /// \param StartLoc Starting location of the directive kind.
1250  /// \param EndLoc Ending Location of the directive.
1251  /// \param Clauses List of clauses.
1252  /// \param AssociatedStmt Statement, associated with the directive.
1253  /// \param HasCancel true if current directive has inner directive.
1254  ///
1255  static OMPSectionsDirective *
1256  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1257  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel);
1258 
1259  /// Creates an empty directive with the place for \a NumClauses
1260  /// clauses.
1261  ///
1262  /// \param C AST context.
1263  /// \param NumClauses Number of clauses.
1264  ///
1266  unsigned NumClauses, EmptyShell);
1267 
1268  /// Return true if current directive has inner cancel directive.
1269  bool hasCancel() const { return HasCancel; }
1270 
1271  static bool classof(const Stmt *T) {
1272  return T->getStmtClass() == OMPSectionsDirectiveClass;
1273  }
1274 };
1275 
1276 /// This represents '#pragma omp section' directive.
1277 ///
1278 /// \code
1279 /// #pragma omp section
1280 /// \endcode
1281 ///
1283  friend class ASTStmtReader;
1284 
1285  /// true if current directive has inner cancel directive.
1286  bool HasCancel;
1287 
1288  /// Build directive with the given start and end location.
1289  ///
1290  /// \param StartLoc Starting location of the directive kind.
1291  /// \param EndLoc Ending location of the directive.
1292  ///
1294  : OMPExecutableDirective(this, OMPSectionDirectiveClass, OMPD_section,
1295  StartLoc, EndLoc, 0, 1),
1296  HasCancel(false) {}
1297 
1298  /// Build an empty directive.
1299  ///
1300  explicit OMPSectionDirective()
1301  : OMPExecutableDirective(this, OMPSectionDirectiveClass, OMPD_section,
1302  SourceLocation(), SourceLocation(), 0, 1),
1303  HasCancel(false) {}
1304 
1305 public:
1306  /// Creates directive.
1307  ///
1308  /// \param C AST context.
1309  /// \param StartLoc Starting location of the directive kind.
1310  /// \param EndLoc Ending Location of the directive.
1311  /// \param AssociatedStmt Statement, associated with the directive.
1312  /// \param HasCancel true if current directive has inner directive.
1313  ///
1314  static OMPSectionDirective *Create(const ASTContext &C,
1315  SourceLocation StartLoc,
1316  SourceLocation EndLoc,
1317  Stmt *AssociatedStmt, bool HasCancel);
1318 
1319  /// Creates an empty directive.
1320  ///
1321  /// \param C AST context.
1322  ///
1324 
1325  /// Set cancel state.
1326  void setHasCancel(bool Has) { HasCancel = Has; }
1327 
1328  /// Return true if current directive has inner cancel directive.
1329  bool hasCancel() const { return HasCancel; }
1330 
1331  static bool classof(const Stmt *T) {
1332  return T->getStmtClass() == OMPSectionDirectiveClass;
1333  }
1334 };
1335 
1336 /// This represents '#pragma omp single' directive.
1337 ///
1338 /// \code
1339 /// #pragma omp single private(a,b) copyprivate(c,d)
1340 /// \endcode
1341 /// In this example directive '#pragma omp single' has clauses 'private' with
1342 /// the variables 'a' and 'b' and 'copyprivate' with variables 'c' and 'd'.
1343 ///
1345  friend class ASTStmtReader;
1346  /// Build directive with the given start and end location.
1347  ///
1348  /// \param StartLoc Starting location of the directive kind.
1349  /// \param EndLoc Ending location of the directive.
1350  /// \param NumClauses Number of clauses.
1351  ///
1353  unsigned NumClauses)
1354  : OMPExecutableDirective(this, OMPSingleDirectiveClass, OMPD_single,
1355  StartLoc, EndLoc, NumClauses, 1) {}
1356 
1357  /// Build an empty directive.
1358  ///
1359  /// \param NumClauses Number of clauses.
1360  ///
1361  explicit OMPSingleDirective(unsigned NumClauses)
1362  : OMPExecutableDirective(this, OMPSingleDirectiveClass, OMPD_single,
1363  SourceLocation(), SourceLocation(), NumClauses,
1364  1) {}
1365 
1366 public:
1367  /// Creates directive with a list of \a Clauses.
1368  ///
1369  /// \param C AST context.
1370  /// \param StartLoc Starting location of the directive kind.
1371  /// \param EndLoc Ending Location of the directive.
1372  /// \param Clauses List of clauses.
1373  /// \param AssociatedStmt Statement, associated with the directive.
1374  ///
1375  static OMPSingleDirective *
1376  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1377  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
1378 
1379  /// Creates an empty directive with the place for \a NumClauses
1380  /// clauses.
1381  ///
1382  /// \param C AST context.
1383  /// \param NumClauses Number of clauses.
1384  ///
1385  static OMPSingleDirective *CreateEmpty(const ASTContext &C,
1386  unsigned NumClauses, EmptyShell);
1387 
1388  static bool classof(const Stmt *T) {
1389  return T->getStmtClass() == OMPSingleDirectiveClass;
1390  }
1391 };
1392 
1393 /// This represents '#pragma omp master' directive.
1394 ///
1395 /// \code
1396 /// #pragma omp master
1397 /// \endcode
1398 ///
1400  friend class ASTStmtReader;
1401  /// Build directive with the given start and end location.
1402  ///
1403  /// \param StartLoc Starting location of the directive kind.
1404  /// \param EndLoc Ending location of the directive.
1405  ///
1407  : OMPExecutableDirective(this, OMPMasterDirectiveClass, OMPD_master,
1408  StartLoc, EndLoc, 0, 1) {}
1409 
1410  /// Build an empty directive.
1411  ///
1412  explicit OMPMasterDirective()
1413  : OMPExecutableDirective(this, OMPMasterDirectiveClass, OMPD_master,
1414  SourceLocation(), SourceLocation(), 0, 1) {}
1415 
1416 public:
1417  /// Creates directive.
1418  ///
1419  /// \param C AST context.
1420  /// \param StartLoc Starting location of the directive kind.
1421  /// \param EndLoc Ending Location of the directive.
1422  /// \param AssociatedStmt Statement, associated with the directive.
1423  ///
1424  static OMPMasterDirective *Create(const ASTContext &C,
1425  SourceLocation StartLoc,
1426  SourceLocation EndLoc,
1427  Stmt *AssociatedStmt);
1428 
1429  /// Creates an empty directive.
1430  ///
1431  /// \param C AST context.
1432  ///
1434 
1435  static bool classof(const Stmt *T) {
1436  return T->getStmtClass() == OMPMasterDirectiveClass;
1437  }
1438 };
1439 
1440 /// This represents '#pragma omp critical' directive.
1441 ///
1442 /// \code
1443 /// #pragma omp critical
1444 /// \endcode
1445 ///
1447  friend class ASTStmtReader;
1448  /// Name of the directive.
1449  DeclarationNameInfo DirName;
1450  /// Build directive with the given start and end location.
1451  ///
1452  /// \param Name Name of the directive.
1453  /// \param StartLoc Starting location of the directive kind.
1454  /// \param EndLoc Ending location of the directive.
1455  /// \param NumClauses Number of clauses.
1456  ///
1458  SourceLocation EndLoc, unsigned NumClauses)
1459  : OMPExecutableDirective(this, OMPCriticalDirectiveClass, OMPD_critical,
1460  StartLoc, EndLoc, NumClauses, 1),
1461  DirName(Name) {}
1462 
1463  /// Build an empty directive.
1464  ///
1465  /// \param NumClauses Number of clauses.
1466  ///
1467  explicit OMPCriticalDirective(unsigned NumClauses)
1468  : OMPExecutableDirective(this, OMPCriticalDirectiveClass, OMPD_critical,
1469  SourceLocation(), SourceLocation(), NumClauses,
1470  1),
1471  DirName() {}
1472 
1473  /// Set name of the directive.
1474  ///
1475  /// \param Name Name of the directive.
1476  ///
1477  void setDirectiveName(const DeclarationNameInfo &Name) { DirName = Name; }
1478 
1479 public:
1480  /// Creates directive.
1481  ///
1482  /// \param C AST context.
1483  /// \param Name Name of the directive.
1484  /// \param StartLoc Starting location of the directive kind.
1485  /// \param EndLoc Ending Location of the directive.
1486  /// \param Clauses List of clauses.
1487  /// \param AssociatedStmt Statement, associated with the directive.
1488  ///
1489  static OMPCriticalDirective *
1490  Create(const ASTContext &C, const DeclarationNameInfo &Name,
1491  SourceLocation StartLoc, SourceLocation EndLoc,
1492  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
1493 
1494  /// Creates an empty directive.
1495  ///
1496  /// \param C AST context.
1497  /// \param NumClauses Number of clauses.
1498  ///
1500  unsigned NumClauses, EmptyShell);
1501 
1502  /// Return name of the directive.
1503  ///
1504  DeclarationNameInfo getDirectiveName() const { return DirName; }
1505 
1506  static bool classof(const Stmt *T) {
1507  return T->getStmtClass() == OMPCriticalDirectiveClass;
1508  }
1509 };
1510 
1511 /// This represents '#pragma omp parallel for' directive.
1512 ///
1513 /// \code
1514 /// #pragma omp parallel for private(a,b) reduction(+:c,d)
1515 /// \endcode
1516 /// In this example directive '#pragma omp parallel for' has clauses 'private'
1517 /// with the variables 'a' and 'b' and 'reduction' with operator '+' and
1518 /// variables 'c' and 'd'.
1519 ///
1521  friend class ASTStmtReader;
1522 
1523  /// true if current region has inner cancel directive.
1524  bool HasCancel;
1525 
1526  /// Build directive with the given start and end location.
1527  ///
1528  /// \param StartLoc Starting location of the directive kind.
1529  /// \param EndLoc Ending location of the directive.
1530  /// \param CollapsedNum Number of collapsed nested loops.
1531  /// \param NumClauses Number of clauses.
1532  ///
1534  unsigned CollapsedNum, unsigned NumClauses)
1535  : OMPLoopDirective(this, OMPParallelForDirectiveClass, OMPD_parallel_for,
1536  StartLoc, EndLoc, CollapsedNum, NumClauses),
1537  HasCancel(false) {}
1538 
1539  /// Build an empty directive.
1540  ///
1541  /// \param CollapsedNum Number of collapsed nested loops.
1542  /// \param NumClauses Number of clauses.
1543  ///
1544  explicit OMPParallelForDirective(unsigned CollapsedNum, unsigned NumClauses)
1545  : OMPLoopDirective(this, OMPParallelForDirectiveClass, OMPD_parallel_for,
1546  SourceLocation(), SourceLocation(), CollapsedNum,
1547  NumClauses),
1548  HasCancel(false) {}
1549 
1550  /// Set cancel state.
1551  void setHasCancel(bool Has) { HasCancel = Has; }
1552 
1553 public:
1554  /// Creates directive with a list of \a Clauses.
1555  ///
1556  /// \param C AST context.
1557  /// \param StartLoc Starting location of the directive kind.
1558  /// \param EndLoc Ending Location of the directive.
1559  /// \param CollapsedNum Number of collapsed loops.
1560  /// \param Clauses List of clauses.
1561  /// \param AssociatedStmt Statement, associated with the directive.
1562  /// \param Exprs Helper expressions for CodeGen.
1563  /// \param HasCancel true if current directive has inner cancel directive.
1564  ///
1565  static OMPParallelForDirective *
1566  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1567  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
1568  Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel);
1569 
1570  /// Creates an empty directive with the place
1571  /// for \a NumClauses clauses.
1572  ///
1573  /// \param C AST context.
1574  /// \param CollapsedNum Number of collapsed nested loops.
1575  /// \param NumClauses Number of clauses.
1576  ///
1578  unsigned NumClauses,
1579  unsigned CollapsedNum,
1580  EmptyShell);
1581 
1582  /// Return true if current directive has inner cancel directive.
1583  bool hasCancel() const { return HasCancel; }
1584 
1585  static bool classof(const Stmt *T) {
1586  return T->getStmtClass() == OMPParallelForDirectiveClass;
1587  }
1588 };
1589 
1590 /// This represents '#pragma omp parallel for simd' directive.
1591 ///
1592 /// \code
1593 /// #pragma omp parallel for simd private(a,b) linear(i,j:s) reduction(+:c,d)
1594 /// \endcode
1595 /// In this example directive '#pragma omp parallel for simd' has clauses
1596 /// 'private' with the variables 'a' and 'b', 'linear' with variables 'i', 'j'
1597 /// and linear step 's', 'reduction' with operator '+' and variables 'c' and
1598 /// 'd'.
1599 ///
1601  friend class ASTStmtReader;
1602  /// Build directive with the given start and end location.
1603  ///
1604  /// \param StartLoc Starting location of the directive kind.
1605  /// \param EndLoc Ending location of the directive.
1606  /// \param CollapsedNum Number of collapsed nested loops.
1607  /// \param NumClauses Number of clauses.
1608  ///
1610  unsigned CollapsedNum, unsigned NumClauses)
1611  : OMPLoopDirective(this, OMPParallelForSimdDirectiveClass,
1612  OMPD_parallel_for_simd, StartLoc, EndLoc, CollapsedNum,
1613  NumClauses) {}
1614 
1615  /// Build an empty directive.
1616  ///
1617  /// \param CollapsedNum Number of collapsed nested loops.
1618  /// \param NumClauses Number of clauses.
1619  ///
1620  explicit OMPParallelForSimdDirective(unsigned CollapsedNum,
1621  unsigned NumClauses)
1622  : OMPLoopDirective(this, OMPParallelForSimdDirectiveClass,
1623  OMPD_parallel_for_simd, SourceLocation(),
1624  SourceLocation(), CollapsedNum, NumClauses) {}
1625 
1626 public:
1627  /// Creates directive with a list of \a Clauses.
1628  ///
1629  /// \param C AST context.
1630  /// \param StartLoc Starting location of the directive kind.
1631  /// \param EndLoc Ending Location of the directive.
1632  /// \param CollapsedNum Number of collapsed loops.
1633  /// \param Clauses List of clauses.
1634  /// \param AssociatedStmt Statement, associated with the directive.
1635  /// \param Exprs Helper expressions for CodeGen.
1636  ///
1638  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1639  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
1640  Stmt *AssociatedStmt, const HelperExprs &Exprs);
1641 
1642  /// Creates an empty directive with the place
1643  /// for \a NumClauses clauses.
1644  ///
1645  /// \param C AST context.
1646  /// \param CollapsedNum Number of collapsed nested loops.
1647  /// \param NumClauses Number of clauses.
1648  ///
1650  unsigned NumClauses,
1651  unsigned CollapsedNum,
1652  EmptyShell);
1653 
1654  static bool classof(const Stmt *T) {
1655  return T->getStmtClass() == OMPParallelForSimdDirectiveClass;
1656  }
1657 };
1658 
1659 /// This represents '#pragma omp parallel sections' directive.
1660 ///
1661 /// \code
1662 /// #pragma omp parallel sections private(a,b) reduction(+:c,d)
1663 /// \endcode
1664 /// In this example directive '#pragma omp parallel sections' has clauses
1665 /// 'private' with the variables 'a' and 'b' and 'reduction' with operator '+'
1666 /// and variables 'c' and 'd'.
1667 ///
1669  friend class ASTStmtReader;
1670 
1671  /// true if current directive has inner cancel directive.
1672  bool HasCancel;
1673 
1674  /// Build directive with the given start and end location.
1675  ///
1676  /// \param StartLoc Starting location of the directive kind.
1677  /// \param EndLoc Ending location of the directive.
1678  /// \param NumClauses Number of clauses.
1679  ///
1681  unsigned NumClauses)
1682  : OMPExecutableDirective(this, OMPParallelSectionsDirectiveClass,
1683  OMPD_parallel_sections, StartLoc, EndLoc,
1684  NumClauses, 1),
1685  HasCancel(false) {}
1686 
1687  /// Build an empty directive.
1688  ///
1689  /// \param NumClauses Number of clauses.
1690  ///
1691  explicit OMPParallelSectionsDirective(unsigned NumClauses)
1692  : OMPExecutableDirective(this, OMPParallelSectionsDirectiveClass,
1693  OMPD_parallel_sections, SourceLocation(),
1694  SourceLocation(), NumClauses, 1),
1695  HasCancel(false) {}
1696 
1697  /// Set cancel state.
1698  void setHasCancel(bool Has) { HasCancel = Has; }
1699 
1700 public:
1701  /// Creates directive with a list of \a Clauses.
1702  ///
1703  /// \param C AST context.
1704  /// \param StartLoc Starting location of the directive kind.
1705  /// \param EndLoc Ending Location of the directive.
1706  /// \param Clauses List of clauses.
1707  /// \param AssociatedStmt Statement, associated with the directive.
1708  /// \param HasCancel true if current directive has inner cancel directive.
1709  ///
1711  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1712  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel);
1713 
1714  /// Creates an empty directive with the place for \a NumClauses
1715  /// clauses.
1716  ///
1717  /// \param C AST context.
1718  /// \param NumClauses Number of clauses.
1719  ///
1721  CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell);
1722 
1723  /// Return true if current directive has inner cancel directive.
1724  bool hasCancel() const { return HasCancel; }
1725 
1726  static bool classof(const Stmt *T) {
1727  return T->getStmtClass() == OMPParallelSectionsDirectiveClass;
1728  }
1729 };
1730 
1731 /// This represents '#pragma omp task' directive.
1732 ///
1733 /// \code
1734 /// #pragma omp task private(a,b) final(d)
1735 /// \endcode
1736 /// In this example directive '#pragma omp task' has clauses 'private' with the
1737 /// variables 'a' and 'b' and 'final' with condition 'd'.
1738 ///
1740  friend class ASTStmtReader;
1741  /// true if this directive has inner cancel directive.
1742  bool HasCancel;
1743 
1744  /// Build directive with the given start and end location.
1745  ///
1746  /// \param StartLoc Starting location of the directive kind.
1747  /// \param EndLoc Ending location of the directive.
1748  /// \param NumClauses Number of clauses.
1749  ///
1751  unsigned NumClauses)
1752  : OMPExecutableDirective(this, OMPTaskDirectiveClass, OMPD_task, StartLoc,
1753  EndLoc, NumClauses, 1),
1754  HasCancel(false) {}
1755 
1756  /// Build an empty directive.
1757  ///
1758  /// \param NumClauses Number of clauses.
1759  ///
1760  explicit OMPTaskDirective(unsigned NumClauses)
1761  : OMPExecutableDirective(this, OMPTaskDirectiveClass, OMPD_task,
1762  SourceLocation(), SourceLocation(), NumClauses,
1763  1),
1764  HasCancel(false) {}
1765 
1766  /// Set cancel state.
1767  void setHasCancel(bool Has) { HasCancel = Has; }
1768 
1769 public:
1770  /// Creates directive with a list of \a Clauses.
1771  ///
1772  /// \param C AST context.
1773  /// \param StartLoc Starting location of the directive kind.
1774  /// \param EndLoc Ending Location of the directive.
1775  /// \param Clauses List of clauses.
1776  /// \param AssociatedStmt Statement, associated with the directive.
1777  /// \param HasCancel true, if current directive has inner cancel directive.
1778  ///
1779  static OMPTaskDirective *Create(const ASTContext &C, SourceLocation StartLoc,
1780  SourceLocation EndLoc,
1781  ArrayRef<OMPClause *> Clauses,
1782  Stmt *AssociatedStmt, bool HasCancel);
1783 
1784  /// Creates an empty directive with the place for \a NumClauses
1785  /// clauses.
1786  ///
1787  /// \param C AST context.
1788  /// \param NumClauses Number of clauses.
1789  ///
1790  static OMPTaskDirective *CreateEmpty(const ASTContext &C, unsigned NumClauses,
1791  EmptyShell);
1792 
1793  /// Return true if current directive has inner cancel directive.
1794  bool hasCancel() const { return HasCancel; }
1795 
1796  static bool classof(const Stmt *T) {
1797  return T->getStmtClass() == OMPTaskDirectiveClass;
1798  }
1799 };
1800 
1801 /// This represents '#pragma omp taskyield' directive.
1802 ///
1803 /// \code
1804 /// #pragma omp taskyield
1805 /// \endcode
1806 ///
1808  friend class ASTStmtReader;
1809  /// Build directive with the given start and end location.
1810  ///
1811  /// \param StartLoc Starting location of the directive kind.
1812  /// \param EndLoc Ending location of the directive.
1813  ///
1815  : OMPExecutableDirective(this, OMPTaskyieldDirectiveClass, OMPD_taskyield,
1816  StartLoc, EndLoc, 0, 0) {}
1817 
1818  /// Build an empty directive.
1819  ///
1820  explicit OMPTaskyieldDirective()
1821  : OMPExecutableDirective(this, OMPTaskyieldDirectiveClass, OMPD_taskyield,
1822  SourceLocation(), SourceLocation(), 0, 0) {}
1823 
1824 public:
1825  /// Creates directive.
1826  ///
1827  /// \param C AST context.
1828  /// \param StartLoc Starting location of the directive kind.
1829  /// \param EndLoc Ending Location of the directive.
1830  ///
1831  static OMPTaskyieldDirective *
1832  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc);
1833 
1834  /// Creates an empty directive.
1835  ///
1836  /// \param C AST context.
1837  ///
1839 
1840  static bool classof(const Stmt *T) {
1841  return T->getStmtClass() == OMPTaskyieldDirectiveClass;
1842  }
1843 };
1844 
1845 /// This represents '#pragma omp barrier' directive.
1846 ///
1847 /// \code
1848 /// #pragma omp barrier
1849 /// \endcode
1850 ///
1852  friend class ASTStmtReader;
1853  /// Build directive with the given start and end location.
1854  ///
1855  /// \param StartLoc Starting location of the directive kind.
1856  /// \param EndLoc Ending location of the directive.
1857  ///
1859  : OMPExecutableDirective(this, OMPBarrierDirectiveClass, OMPD_barrier,
1860  StartLoc, EndLoc, 0, 0) {}
1861 
1862  /// Build an empty directive.
1863  ///
1864  explicit OMPBarrierDirective()
1865  : OMPExecutableDirective(this, OMPBarrierDirectiveClass, OMPD_barrier,
1866  SourceLocation(), SourceLocation(), 0, 0) {}
1867 
1868 public:
1869  /// Creates directive.
1870  ///
1871  /// \param C AST context.
1872  /// \param StartLoc Starting location of the directive kind.
1873  /// \param EndLoc Ending Location of the directive.
1874  ///
1875  static OMPBarrierDirective *
1876  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc);
1877 
1878  /// Creates an empty directive.
1879  ///
1880  /// \param C AST context.
1881  ///
1883 
1884  static bool classof(const Stmt *T) {
1885  return T->getStmtClass() == OMPBarrierDirectiveClass;
1886  }
1887 };
1888 
1889 /// This represents '#pragma omp taskwait' directive.
1890 ///
1891 /// \code
1892 /// #pragma omp taskwait
1893 /// \endcode
1894 ///
1896  friend class ASTStmtReader;
1897  /// Build directive with the given start and end location.
1898  ///
1899  /// \param StartLoc Starting location of the directive kind.
1900  /// \param EndLoc Ending location of the directive.
1901  ///
1903  : OMPExecutableDirective(this, OMPTaskwaitDirectiveClass, OMPD_taskwait,
1904  StartLoc, EndLoc, 0, 0) {}
1905 
1906  /// Build an empty directive.
1907  ///
1908  explicit OMPTaskwaitDirective()
1909  : OMPExecutableDirective(this, OMPTaskwaitDirectiveClass, OMPD_taskwait,
1910  SourceLocation(), SourceLocation(), 0, 0) {}
1911 
1912 public:
1913  /// Creates directive.
1914  ///
1915  /// \param C AST context.
1916  /// \param StartLoc Starting location of the directive kind.
1917  /// \param EndLoc Ending Location of the directive.
1918  ///
1919  static OMPTaskwaitDirective *
1920  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc);
1921 
1922  /// Creates an empty directive.
1923  ///
1924  /// \param C AST context.
1925  ///
1927 
1928  static bool classof(const Stmt *T) {
1929  return T->getStmtClass() == OMPTaskwaitDirectiveClass;
1930  }
1931 };
1932 
1933 /// This represents '#pragma omp taskgroup' directive.
1934 ///
1935 /// \code
1936 /// #pragma omp taskgroup
1937 /// \endcode
1938 ///
1940  friend class ASTStmtReader;
1941  /// Build directive with the given start and end location.
1942  ///
1943  /// \param StartLoc Starting location of the directive kind.
1944  /// \param EndLoc Ending location of the directive.
1945  /// \param NumClauses Number of clauses.
1946  ///
1948  unsigned NumClauses)
1949  : OMPExecutableDirective(this, OMPTaskgroupDirectiveClass, OMPD_taskgroup,
1950  StartLoc, EndLoc, NumClauses, 2) {}
1951 
1952  /// Build an empty directive.
1953  /// \param NumClauses Number of clauses.
1954  ///
1955  explicit OMPTaskgroupDirective(unsigned NumClauses)
1956  : OMPExecutableDirective(this, OMPTaskgroupDirectiveClass, OMPD_taskgroup,
1957  SourceLocation(), SourceLocation(), NumClauses,
1958  2) {}
1959 
1960  /// Sets the task_reduction return variable.
1961  void setReductionRef(Expr *RR) {
1962  *std::next(child_begin(), 1) = RR;
1963  }
1964 
1965 public:
1966  /// Creates directive.
1967  ///
1968  /// \param C AST context.
1969  /// \param StartLoc Starting location of the directive kind.
1970  /// \param EndLoc Ending Location of the directive.
1971  /// \param Clauses List of clauses.
1972  /// \param AssociatedStmt Statement, associated with the directive.
1973  /// \param ReductionRef Reference to the task_reduction return variable.
1974  ///
1975  static OMPTaskgroupDirective *
1976  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1977  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1978  Expr *ReductionRef);
1979 
1980  /// Creates an empty directive.
1981  ///
1982  /// \param C AST context.
1983  /// \param NumClauses Number of clauses.
1984  ///
1986  unsigned NumClauses, EmptyShell);
1987 
1988 
1989  /// Returns reference to the task_reduction return variable.
1990  const Expr *getReductionRef() const {
1991  return static_cast<const Expr *>(*std::next(child_begin(), 1));
1992  }
1994  return static_cast<Expr *>(*std::next(child_begin(), 1));
1995  }
1996 
1997  static bool classof(const Stmt *T) {
1998  return T->getStmtClass() == OMPTaskgroupDirectiveClass;
1999  }
2000 };
2001 
2002 /// This represents '#pragma omp flush' directive.
2003 ///
2004 /// \code
2005 /// #pragma omp flush(a,b)
2006 /// \endcode
2007 /// In this example directive '#pragma omp flush' has 2 arguments- variables 'a'
2008 /// and 'b'.
2009 /// 'omp flush' directive does not have clauses but have an optional list of
2010 /// variables to flush. This list of variables is stored within some fake clause
2011 /// FlushClause.
2013  friend class ASTStmtReader;
2014  /// Build directive with the given start and end location.
2015  ///
2016  /// \param StartLoc Starting location of the directive kind.
2017  /// \param EndLoc Ending location of the directive.
2018  /// \param NumClauses Number of clauses.
2019  ///
2021  unsigned NumClauses)
2022  : OMPExecutableDirective(this, OMPFlushDirectiveClass, OMPD_flush,
2023  StartLoc, EndLoc, NumClauses, 0) {}
2024 
2025  /// Build an empty directive.
2026  ///
2027  /// \param NumClauses Number of clauses.
2028  ///
2029  explicit OMPFlushDirective(unsigned NumClauses)
2030  : OMPExecutableDirective(this, OMPFlushDirectiveClass, OMPD_flush,
2031  SourceLocation(), SourceLocation(), NumClauses,
2032  0) {}
2033 
2034 public:
2035  /// Creates directive with a list of \a Clauses.
2036  ///
2037  /// \param C AST context.
2038  /// \param StartLoc Starting location of the directive kind.
2039  /// \param EndLoc Ending Location of the directive.
2040  /// \param Clauses List of clauses (only single OMPFlushClause clause is
2041  /// allowed).
2042  ///
2043  static OMPFlushDirective *Create(const ASTContext &C, SourceLocation StartLoc,
2044  SourceLocation EndLoc,
2045  ArrayRef<OMPClause *> Clauses);
2046 
2047  /// Creates an empty directive with the place for \a NumClauses
2048  /// clauses.
2049  ///
2050  /// \param C AST context.
2051  /// \param NumClauses Number of clauses.
2052  ///
2053  static OMPFlushDirective *CreateEmpty(const ASTContext &C,
2054  unsigned NumClauses, EmptyShell);
2055 
2056  static bool classof(const Stmt *T) {
2057  return T->getStmtClass() == OMPFlushDirectiveClass;
2058  }
2059 };
2060 
2061 /// This represents '#pragma omp ordered' directive.
2062 ///
2063 /// \code
2064 /// #pragma omp ordered
2065 /// \endcode
2066 ///
2068  friend class ASTStmtReader;
2069  /// Build directive with the given start and end location.
2070  ///
2071  /// \param StartLoc Starting location of the directive kind.
2072  /// \param EndLoc Ending location of the directive.
2073  /// \param NumClauses Number of clauses.
2074  ///
2076  unsigned NumClauses)
2077  : OMPExecutableDirective(this, OMPOrderedDirectiveClass, OMPD_ordered,
2078  StartLoc, EndLoc, NumClauses, 1) {}
2079 
2080  /// Build an empty directive.
2081  ///
2082  /// \param NumClauses Number of clauses.
2083  ///
2084  explicit OMPOrderedDirective(unsigned NumClauses)
2085  : OMPExecutableDirective(this, OMPOrderedDirectiveClass, OMPD_ordered,
2086  SourceLocation(), SourceLocation(), NumClauses,
2087  1) {}
2088 
2089 public:
2090  /// Creates directive.
2091  ///
2092  /// \param C AST context.
2093  /// \param StartLoc Starting location of the directive kind.
2094  /// \param EndLoc Ending Location of the directive.
2095  /// \param Clauses List of clauses.
2096  /// \param AssociatedStmt Statement, associated with the directive.
2097  ///
2098  static OMPOrderedDirective *
2099  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2100  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
2101 
2102  /// Creates an empty directive.
2103  ///
2104  /// \param C AST context.
2105  /// \param NumClauses Number of clauses.
2106  ///
2108  unsigned NumClauses, EmptyShell);
2109 
2110  static bool classof(const Stmt *T) {
2111  return T->getStmtClass() == OMPOrderedDirectiveClass;
2112  }
2113 };
2114 
2115 /// This represents '#pragma omp atomic' directive.
2116 ///
2117 /// \code
2118 /// #pragma omp atomic capture
2119 /// \endcode
2120 /// In this example directive '#pragma omp atomic' has clause 'capture'.
2121 ///
2123  friend class ASTStmtReader;
2124  /// Used for 'atomic update' or 'atomic capture' constructs. They may
2125  /// have atomic expressions of forms
2126  /// \code
2127  /// x = x binop expr;
2128  /// x = expr binop x;
2129  /// \endcode
2130  /// This field is true for the first form of the expression and false for the
2131  /// second. Required for correct codegen of non-associative operations (like
2132  /// << or >>).
2133  bool IsXLHSInRHSPart;
2134  /// Used for 'atomic update' or 'atomic capture' constructs. They may
2135  /// have atomic expressions of forms
2136  /// \code
2137  /// v = x; <update x>;
2138  /// <update x>; v = x;
2139  /// \endcode
2140  /// This field is true for the first(postfix) form of the expression and false
2141  /// otherwise.
2142  bool IsPostfixUpdate;
2143 
2144  /// Build directive with the given start and end location.
2145  ///
2146  /// \param StartLoc Starting location of the directive kind.
2147  /// \param EndLoc Ending location of the directive.
2148  /// \param NumClauses Number of clauses.
2149  ///
2151  unsigned NumClauses)
2152  : OMPExecutableDirective(this, OMPAtomicDirectiveClass, OMPD_atomic,
2153  StartLoc, EndLoc, NumClauses, 5),
2154  IsXLHSInRHSPart(false), IsPostfixUpdate(false) {}
2155 
2156  /// Build an empty directive.
2157  ///
2158  /// \param NumClauses Number of clauses.
2159  ///
2160  explicit OMPAtomicDirective(unsigned NumClauses)
2161  : OMPExecutableDirective(this, OMPAtomicDirectiveClass, OMPD_atomic,
2162  SourceLocation(), SourceLocation(), NumClauses,
2163  5),
2164  IsXLHSInRHSPart(false), IsPostfixUpdate(false) {}
2165 
2166  /// Set 'x' part of the associated expression/statement.
2167  void setX(Expr *X) { *std::next(child_begin()) = X; }
2168  /// Set helper expression of the form
2169  /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
2170  /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
2171  void setUpdateExpr(Expr *UE) { *std::next(child_begin(), 2) = UE; }
2172  /// Set 'v' part of the associated expression/statement.
2173  void setV(Expr *V) { *std::next(child_begin(), 3) = V; }
2174  /// Set 'expr' part of the associated expression/statement.
2175  void setExpr(Expr *E) { *std::next(child_begin(), 4) = E; }
2176 
2177 public:
2178  /// Creates directive with a list of \a Clauses and 'x', 'v' and 'expr'
2179  /// parts of the atomic construct (see Section 2.12.6, atomic Construct, for
2180  /// detailed description of 'x', 'v' and 'expr').
2181  ///
2182  /// \param C AST context.
2183  /// \param StartLoc Starting location of the directive kind.
2184  /// \param EndLoc Ending Location of the directive.
2185  /// \param Clauses List of clauses.
2186  /// \param AssociatedStmt Statement, associated with the directive.
2187  /// \param X 'x' part of the associated expression/statement.
2188  /// \param V 'v' part of the associated expression/statement.
2189  /// \param E 'expr' part of the associated expression/statement.
2190  /// \param UE Helper expression of the form
2191  /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
2192  /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
2193  /// \param IsXLHSInRHSPart true if \a UE has the first form and false if the
2194  /// second.
2195  /// \param IsPostfixUpdate true if original value of 'x' must be stored in
2196  /// 'v', not an updated one.
2197  static OMPAtomicDirective *
2198  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2199  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
2200  Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate);
2201 
2202  /// Creates an empty directive with the place for \a NumClauses
2203  /// clauses.
2204  ///
2205  /// \param C AST context.
2206  /// \param NumClauses Number of clauses.
2207  ///
2208  static OMPAtomicDirective *CreateEmpty(const ASTContext &C,
2209  unsigned NumClauses, EmptyShell);
2210 
2211  /// Get 'x' part of the associated expression/statement.
2212  Expr *getX() { return cast_or_null<Expr>(*std::next(child_begin())); }
2213  const Expr *getX() const {
2214  return cast_or_null<Expr>(*std::next(child_begin()));
2215  }
2216  /// Get helper expression of the form
2217  /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
2218  /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
2220  return cast_or_null<Expr>(*std::next(child_begin(), 2));
2221  }
2222  const Expr *getUpdateExpr() const {
2223  return cast_or_null<Expr>(*std::next(child_begin(), 2));
2224  }
2225  /// Return true if helper update expression has form
2226  /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' and false if it has form
2227  /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
2228  bool isXLHSInRHSPart() const { return IsXLHSInRHSPart; }
2229  /// Return true if 'v' expression must be updated to original value of
2230  /// 'x', false if 'v' must be updated to the new value of 'x'.
2231  bool isPostfixUpdate() const { return IsPostfixUpdate; }
2232  /// Get 'v' part of the associated expression/statement.
2233  Expr *getV() { return cast_or_null<Expr>(*std::next(child_begin(), 3)); }
2234  const Expr *getV() const {
2235  return cast_or_null<Expr>(*std::next(child_begin(), 3));
2236  }
2237  /// Get 'expr' part of the associated expression/statement.
2238  Expr *getExpr() { return cast_or_null<Expr>(*std::next(child_begin(), 4)); }
2239  const Expr *getExpr() const {
2240  return cast_or_null<Expr>(*std::next(child_begin(), 4));
2241  }
2242 
2243  static bool classof(const Stmt *T) {
2244  return T->getStmtClass() == OMPAtomicDirectiveClass;
2245  }
2246 };
2247 
2248 /// This represents '#pragma omp target' directive.
2249 ///
2250 /// \code
2251 /// #pragma omp target if(a)
2252 /// \endcode
2253 /// In this example directive '#pragma omp target' has clause 'if' with
2254 /// condition 'a'.
2255 ///
2257  friend class ASTStmtReader;
2258  /// Build directive with the given start and end location.
2259  ///
2260  /// \param StartLoc Starting location of the directive kind.
2261  /// \param EndLoc Ending location of the directive.
2262  /// \param NumClauses Number of clauses.
2263  ///
2265  unsigned NumClauses)
2266  : OMPExecutableDirective(this, OMPTargetDirectiveClass, OMPD_target,
2267  StartLoc, EndLoc, NumClauses, 1) {}
2268 
2269  /// Build an empty directive.
2270  ///
2271  /// \param NumClauses Number of clauses.
2272  ///
2273  explicit OMPTargetDirective(unsigned NumClauses)
2274  : OMPExecutableDirective(this, OMPTargetDirectiveClass, OMPD_target,
2275  SourceLocation(), SourceLocation(), NumClauses,
2276  1) {}
2277 
2278 public:
2279  /// Creates directive with a list of \a Clauses.
2280  ///
2281  /// \param C AST context.
2282  /// \param StartLoc Starting location of the directive kind.
2283  /// \param EndLoc Ending Location of the directive.
2284  /// \param Clauses List of clauses.
2285  /// \param AssociatedStmt Statement, associated with the directive.
2286  ///
2287  static OMPTargetDirective *
2288  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2289  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
2290 
2291  /// Creates an empty directive with the place for \a NumClauses
2292  /// clauses.
2293  ///
2294  /// \param C AST context.
2295  /// \param NumClauses Number of clauses.
2296  ///
2297  static OMPTargetDirective *CreateEmpty(const ASTContext &C,
2298  unsigned NumClauses, EmptyShell);
2299 
2300  static bool classof(const Stmt *T) {
2301  return T->getStmtClass() == OMPTargetDirectiveClass;
2302  }
2303 };
2304 
2305 /// This represents '#pragma omp target data' directive.
2306 ///
2307 /// \code
2308 /// #pragma omp target data device(0) if(a) map(b[:])
2309 /// \endcode
2310 /// In this example directive '#pragma omp target data' has clauses 'device'
2311 /// with the value '0', 'if' with condition 'a' and 'map' with array
2312 /// section 'b[:]'.
2313 ///
2315  friend class ASTStmtReader;
2316  /// Build directive with the given start and end location.
2317  ///
2318  /// \param StartLoc Starting location of the directive kind.
2319  /// \param EndLoc Ending Location of the directive.
2320  /// \param NumClauses The number of clauses.
2321  ///
2323  unsigned NumClauses)
2324  : OMPExecutableDirective(this, OMPTargetDataDirectiveClass,
2325  OMPD_target_data, StartLoc, EndLoc, NumClauses,
2326  1) {}
2327 
2328  /// Build an empty directive.
2329  ///
2330  /// \param NumClauses Number of clauses.
2331  ///
2332  explicit OMPTargetDataDirective(unsigned NumClauses)
2333  : OMPExecutableDirective(this, OMPTargetDataDirectiveClass,
2334  OMPD_target_data, SourceLocation(),
2335  SourceLocation(), NumClauses, 1) {}
2336 
2337 public:
2338  /// Creates directive with a list of \a Clauses.
2339  ///
2340  /// \param C AST context.
2341  /// \param StartLoc Starting location of the directive kind.
2342  /// \param EndLoc Ending Location of the directive.
2343  /// \param Clauses List of clauses.
2344  /// \param AssociatedStmt Statement, associated with the directive.
2345  ///
2346  static OMPTargetDataDirective *
2347  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2348  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
2349 
2350  /// Creates an empty directive with the place for \a N clauses.
2351  ///
2352  /// \param C AST context.
2353  /// \param N The number of clauses.
2354  ///
2355  static OMPTargetDataDirective *CreateEmpty(const ASTContext &C, unsigned N,
2356  EmptyShell);
2357 
2358  static bool classof(const Stmt *T) {
2359  return T->getStmtClass() == OMPTargetDataDirectiveClass;
2360  }
2361 };
2362 
2363 /// This represents '#pragma omp target enter data' directive.
2364 ///
2365 /// \code
2366 /// #pragma omp target enter data device(0) if(a) map(b[:])
2367 /// \endcode
2368 /// In this example directive '#pragma omp target enter data' has clauses
2369 /// 'device' with the value '0', 'if' with condition 'a' and 'map' with array
2370 /// section 'b[:]'.
2371 ///
2373  friend class ASTStmtReader;
2374  /// Build directive with the given start and end location.
2375  ///
2376  /// \param StartLoc Starting location of the directive kind.
2377  /// \param EndLoc Ending Location of the directive.
2378  /// \param NumClauses The number of clauses.
2379  ///
2381  unsigned NumClauses)
2382  : OMPExecutableDirective(this, OMPTargetEnterDataDirectiveClass,
2383  OMPD_target_enter_data, StartLoc, EndLoc,
2384  NumClauses, /*NumChildren=*/1) {}
2385 
2386  /// Build an empty directive.
2387  ///
2388  /// \param NumClauses Number of clauses.
2389  ///
2390  explicit OMPTargetEnterDataDirective(unsigned NumClauses)
2391  : OMPExecutableDirective(this, OMPTargetEnterDataDirectiveClass,
2392  OMPD_target_enter_data, SourceLocation(),
2393  SourceLocation(), NumClauses,
2394  /*NumChildren=*/1) {}
2395 
2396 public:
2397  /// Creates directive with a list of \a Clauses.
2398  ///
2399  /// \param C AST context.
2400  /// \param StartLoc Starting location of the directive kind.
2401  /// \param EndLoc Ending Location of the directive.
2402  /// \param Clauses List of clauses.
2403  /// \param AssociatedStmt Statement, associated with the directive.
2404  ///
2406  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2407  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
2408 
2409  /// Creates an empty directive with the place for \a N clauses.
2410  ///
2411  /// \param C AST context.
2412  /// \param N The number of clauses.
2413  ///
2415  unsigned N, EmptyShell);
2416 
2417  static bool classof(const Stmt *T) {
2418  return T->getStmtClass() == OMPTargetEnterDataDirectiveClass;
2419  }
2420 };
2421 
2422 /// This represents '#pragma omp target exit data' directive.
2423 ///
2424 /// \code
2425 /// #pragma omp target exit data device(0) if(a) map(b[:])
2426 /// \endcode
2427 /// In this example directive '#pragma omp target exit data' has clauses
2428 /// 'device' with the value '0', 'if' with condition 'a' and 'map' with array
2429 /// section 'b[:]'.
2430 ///
2432  friend class ASTStmtReader;
2433  /// Build directive with the given start and end location.
2434  ///
2435  /// \param StartLoc Starting location of the directive kind.
2436  /// \param EndLoc Ending Location of the directive.
2437  /// \param NumClauses The number of clauses.
2438  ///
2440  unsigned NumClauses)
2441  : OMPExecutableDirective(this, OMPTargetExitDataDirectiveClass,
2442  OMPD_target_exit_data, StartLoc, EndLoc,
2443  NumClauses, /*NumChildren=*/1) {}
2444 
2445  /// Build an empty directive.
2446  ///
2447  /// \param NumClauses Number of clauses.
2448  ///
2449  explicit OMPTargetExitDataDirective(unsigned NumClauses)
2450  : OMPExecutableDirective(this, OMPTargetExitDataDirectiveClass,
2451  OMPD_target_exit_data, SourceLocation(),
2452  SourceLocation(), NumClauses,
2453  /*NumChildren=*/1) {}
2454 
2455 public:
2456  /// Creates directive with a list of \a Clauses.
2457  ///
2458  /// \param C AST context.
2459  /// \param StartLoc Starting location of the directive kind.
2460  /// \param EndLoc Ending Location of the directive.
2461  /// \param Clauses List of clauses.
2462  /// \param AssociatedStmt Statement, associated with the directive.
2463  ///
2465  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2466  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
2467 
2468  /// Creates an empty directive with the place for \a N clauses.
2469  ///
2470  /// \param C AST context.
2471  /// \param N The number of clauses.
2472  ///
2474  unsigned N, EmptyShell);
2475 
2476  static bool classof(const Stmt *T) {
2477  return T->getStmtClass() == OMPTargetExitDataDirectiveClass;
2478  }
2479 };
2480 
2481 /// This represents '#pragma omp target parallel' directive.
2482 ///
2483 /// \code
2484 /// #pragma omp target parallel if(a)
2485 /// \endcode
2486 /// In this example directive '#pragma omp target parallel' has clause 'if' with
2487 /// condition 'a'.
2488 ///
2490  friend class ASTStmtReader;
2491  /// Build directive with the given start and end location.
2492  ///
2493  /// \param StartLoc Starting location of the directive kind.
2494  /// \param EndLoc Ending location of the directive.
2495  /// \param NumClauses Number of clauses.
2496  ///
2498  unsigned NumClauses)
2499  : OMPExecutableDirective(this, OMPTargetParallelDirectiveClass,
2500  OMPD_target_parallel, StartLoc, EndLoc,
2501  NumClauses, /*NumChildren=*/1) {}
2502 
2503  /// Build an empty directive.
2504  ///
2505  /// \param NumClauses Number of clauses.
2506  ///
2507  explicit OMPTargetParallelDirective(unsigned NumClauses)
2508  : OMPExecutableDirective(this, OMPTargetParallelDirectiveClass,
2509  OMPD_target_parallel, SourceLocation(),
2510  SourceLocation(), NumClauses,
2511  /*NumChildren=*/1) {}
2512 
2513 public:
2514  /// Creates directive with a list of \a Clauses.
2515  ///
2516  /// \param C AST context.
2517  /// \param StartLoc Starting location of the directive kind.
2518  /// \param EndLoc Ending Location of the directive.
2519  /// \param Clauses List of clauses.
2520  /// \param AssociatedStmt Statement, associated with the directive.
2521  ///
2523  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2524  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
2525 
2526  /// Creates an empty directive with the place for \a NumClauses
2527  /// clauses.
2528  ///
2529  /// \param C AST context.
2530  /// \param NumClauses Number of clauses.
2531  ///
2533  CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell);
2534 
2535  static bool classof(const Stmt *T) {
2536  return T->getStmtClass() == OMPTargetParallelDirectiveClass;
2537  }
2538 };
2539 
2540 /// This represents '#pragma omp target parallel for' directive.
2541 ///
2542 /// \code
2543 /// #pragma omp target parallel for private(a,b) reduction(+:c,d)
2544 /// \endcode
2545 /// In this example directive '#pragma omp target parallel for' has clauses
2546 /// 'private' with the variables 'a' and 'b' and 'reduction' with operator '+'
2547 /// and variables 'c' and 'd'.
2548 ///
2550  friend class ASTStmtReader;
2551 
2552  /// true if current region has inner cancel directive.
2553  bool HasCancel;
2554 
2555  /// Build directive with the given start and end location.
2556  ///
2557  /// \param StartLoc Starting location of the directive kind.
2558  /// \param EndLoc Ending location of the directive.
2559  /// \param CollapsedNum Number of collapsed nested loops.
2560  /// \param NumClauses Number of clauses.
2561  ///
2563  unsigned CollapsedNum, unsigned NumClauses)
2564  : OMPLoopDirective(this, OMPTargetParallelForDirectiveClass,
2565  OMPD_target_parallel_for, StartLoc, EndLoc,
2566  CollapsedNum, NumClauses),
2567  HasCancel(false) {}
2568 
2569  /// Build an empty directive.
2570  ///
2571  /// \param CollapsedNum Number of collapsed nested loops.
2572  /// \param NumClauses Number of clauses.
2573  ///
2574  explicit OMPTargetParallelForDirective(unsigned CollapsedNum,
2575  unsigned NumClauses)
2576  : OMPLoopDirective(this, OMPTargetParallelForDirectiveClass,
2577  OMPD_target_parallel_for, SourceLocation(),
2578  SourceLocation(), CollapsedNum, NumClauses),
2579  HasCancel(false) {}
2580 
2581  /// Set cancel state.
2582  void setHasCancel(bool Has) { HasCancel = Has; }
2583 
2584 public:
2585  /// Creates directive with a list of \a Clauses.
2586  ///
2587  /// \param C AST context.
2588  /// \param StartLoc Starting location of the directive kind.
2589  /// \param EndLoc Ending Location of the directive.
2590  /// \param CollapsedNum Number of collapsed loops.
2591  /// \param Clauses List of clauses.
2592  /// \param AssociatedStmt Statement, associated with the directive.
2593  /// \param Exprs Helper expressions for CodeGen.
2594  /// \param HasCancel true if current directive has inner cancel directive.
2595  ///
2597  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2598  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
2599  Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel);
2600 
2601  /// Creates an empty directive with the place
2602  /// for \a NumClauses clauses.
2603  ///
2604  /// \param C AST context.
2605  /// \param CollapsedNum Number of collapsed nested loops.
2606  /// \param NumClauses Number of clauses.
2607  ///
2609  unsigned NumClauses,
2610  unsigned CollapsedNum,
2611  EmptyShell);
2612 
2613  /// Return true if current directive has inner cancel directive.
2614  bool hasCancel() const { return HasCancel; }
2615 
2616  static bool classof(const Stmt *T) {
2617  return T->getStmtClass() == OMPTargetParallelForDirectiveClass;
2618  }
2619 };
2620 
2621 /// This represents '#pragma omp teams' directive.
2622 ///
2623 /// \code
2624 /// #pragma omp teams if(a)
2625 /// \endcode
2626 /// In this example directive '#pragma omp teams' has clause 'if' with
2627 /// condition 'a'.
2628 ///
2630  friend class ASTStmtReader;
2631  /// Build directive with the given start and end location.
2632  ///
2633  /// \param StartLoc Starting location of the directive kind.
2634  /// \param EndLoc Ending location of the directive.
2635  /// \param NumClauses Number of clauses.
2636  ///
2638  unsigned NumClauses)
2639  : OMPExecutableDirective(this, OMPTeamsDirectiveClass, OMPD_teams,
2640  StartLoc, EndLoc, NumClauses, 1) {}
2641 
2642  /// Build an empty directive.
2643  ///
2644  /// \param NumClauses Number of clauses.
2645  ///
2646  explicit OMPTeamsDirective(unsigned NumClauses)
2647  : OMPExecutableDirective(this, OMPTeamsDirectiveClass, OMPD_teams,
2648  SourceLocation(), SourceLocation(), NumClauses,
2649  1) {}
2650 
2651 public:
2652  /// Creates directive with a list of \a Clauses.
2653  ///
2654  /// \param C AST context.
2655  /// \param StartLoc Starting location of the directive kind.
2656  /// \param EndLoc Ending Location of the directive.
2657  /// \param Clauses List of clauses.
2658  /// \param AssociatedStmt Statement, associated with the directive.
2659  ///
2660  static OMPTeamsDirective *Create(const ASTContext &C, SourceLocation StartLoc,
2661  SourceLocation EndLoc,
2662  ArrayRef<OMPClause *> Clauses,
2663  Stmt *AssociatedStmt);
2664 
2665  /// Creates an empty directive with the place for \a NumClauses
2666  /// clauses.
2667  ///
2668  /// \param C AST context.
2669  /// \param NumClauses Number of clauses.
2670  ///
2671  static OMPTeamsDirective *CreateEmpty(const ASTContext &C,
2672  unsigned NumClauses, EmptyShell);
2673 
2674  static bool classof(const Stmt *T) {
2675  return T->getStmtClass() == OMPTeamsDirectiveClass;
2676  }
2677 };
2678 
2679 /// This represents '#pragma omp cancellation point' directive.
2680 ///
2681 /// \code
2682 /// #pragma omp cancellation point for
2683 /// \endcode
2684 ///
2685 /// In this example a cancellation point is created for innermost 'for' region.
2687  friend class ASTStmtReader;
2688  OpenMPDirectiveKind CancelRegion;
2689  /// Build directive with the given start and end location.
2690  ///
2691  /// \param StartLoc Starting location of the directive kind.
2692  /// \param EndLoc Ending location of the directive.
2693  ///
2695  : OMPExecutableDirective(this, OMPCancellationPointDirectiveClass,
2696  OMPD_cancellation_point, StartLoc, EndLoc, 0, 0),
2697  CancelRegion(OMPD_unknown) {}
2698 
2699  /// Build an empty directive.
2700  ///
2702  : OMPExecutableDirective(this, OMPCancellationPointDirectiveClass,
2703  OMPD_cancellation_point, SourceLocation(),
2704  SourceLocation(), 0, 0),
2705  CancelRegion(OMPD_unknown) {}
2706 
2707  /// Set cancel region for current cancellation point.
2708  /// \param CR Cancellation region.
2709  void setCancelRegion(OpenMPDirectiveKind CR) { CancelRegion = CR; }
2710 
2711 public:
2712  /// Creates directive.
2713  ///
2714  /// \param C AST context.
2715  /// \param StartLoc Starting location of the directive kind.
2716  /// \param EndLoc Ending Location of the directive.
2717  ///
2719  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2720  OpenMPDirectiveKind CancelRegion);
2721 
2722  /// Creates an empty directive.
2723  ///
2724  /// \param C AST context.
2725  ///
2727  EmptyShell);
2728 
2729  /// Get cancellation region for the current cancellation point.
2730  OpenMPDirectiveKind getCancelRegion() const { return CancelRegion; }
2731 
2732  static bool classof(const Stmt *T) {
2733  return T->getStmtClass() == OMPCancellationPointDirectiveClass;
2734  }
2735 };
2736 
2737 /// This represents '#pragma omp cancel' directive.
2738 ///
2739 /// \code
2740 /// #pragma omp cancel for
2741 /// \endcode
2742 ///
2743 /// In this example a cancel is created for innermost 'for' region.
2745  friend class ASTStmtReader;
2746  OpenMPDirectiveKind CancelRegion;
2747  /// Build directive with the given start and end location.
2748  ///
2749  /// \param StartLoc Starting location of the directive kind.
2750  /// \param EndLoc Ending location of the directive.
2751  /// \param NumClauses Number of clauses.
2752  ///
2754  unsigned NumClauses)
2755  : OMPExecutableDirective(this, OMPCancelDirectiveClass, OMPD_cancel,
2756  StartLoc, EndLoc, NumClauses, 0),
2757  CancelRegion(OMPD_unknown) {}
2758 
2759  /// Build an empty directive.
2760  ///
2761  /// \param NumClauses Number of clauses.
2762  explicit OMPCancelDirective(unsigned NumClauses)
2763  : OMPExecutableDirective(this, OMPCancelDirectiveClass, OMPD_cancel,
2764  SourceLocation(), SourceLocation(), NumClauses,
2765  0),
2766  CancelRegion(OMPD_unknown) {}
2767 
2768  /// Set cancel region for current cancellation point.
2769  /// \param CR Cancellation region.
2770  void setCancelRegion(OpenMPDirectiveKind CR) { CancelRegion = CR; }
2771 
2772 public:
2773  /// Creates directive.
2774  ///
2775  /// \param C AST context.
2776  /// \param StartLoc Starting location of the directive kind.
2777  /// \param EndLoc Ending Location of the directive.
2778  /// \param Clauses List of clauses.
2779  ///
2780  static OMPCancelDirective *
2781  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2782  ArrayRef<OMPClause *> Clauses, OpenMPDirectiveKind CancelRegion);
2783 
2784  /// Creates an empty directive.
2785  ///
2786  /// \param C AST context.
2787  /// \param NumClauses Number of clauses.
2788  ///
2789  static OMPCancelDirective *CreateEmpty(const ASTContext &C,
2790  unsigned NumClauses, EmptyShell);
2791 
2792  /// Get cancellation region for the current cancellation point.
2793  OpenMPDirectiveKind getCancelRegion() const { return CancelRegion; }
2794 
2795  static bool classof(const Stmt *T) {
2796  return T->getStmtClass() == OMPCancelDirectiveClass;
2797  }
2798 };
2799 
2800 /// This represents '#pragma omp taskloop' directive.
2801 ///
2802 /// \code
2803 /// #pragma omp taskloop private(a,b) grainsize(val) num_tasks(num)
2804 /// \endcode
2805 /// In this example directive '#pragma omp taskloop' has clauses 'private'
2806 /// with the variables 'a' and 'b', 'grainsize' with expression 'val' and
2807 /// 'num_tasks' with expression 'num'.
2808 ///
2810  friend class ASTStmtReader;
2811  /// Build directive with the given start and end location.
2812  ///
2813  /// \param StartLoc Starting location of the directive kind.
2814  /// \param EndLoc Ending location of the directive.
2815  /// \param CollapsedNum Number of collapsed nested loops.
2816  /// \param NumClauses Number of clauses.
2817  ///
2819  unsigned CollapsedNum, unsigned NumClauses)
2820  : OMPLoopDirective(this, OMPTaskLoopDirectiveClass, OMPD_taskloop,
2821  StartLoc, EndLoc, CollapsedNum, NumClauses) {}
2822 
2823  /// Build an empty directive.
2824  ///
2825  /// \param CollapsedNum Number of collapsed nested loops.
2826  /// \param NumClauses Number of clauses.
2827  ///
2828  explicit OMPTaskLoopDirective(unsigned CollapsedNum, unsigned NumClauses)
2829  : OMPLoopDirective(this, OMPTaskLoopDirectiveClass, OMPD_taskloop,
2830  SourceLocation(), SourceLocation(), CollapsedNum,
2831  NumClauses) {}
2832 
2833 public:
2834  /// Creates directive with a list of \a Clauses.
2835  ///
2836  /// \param C AST context.
2837  /// \param StartLoc Starting location of the directive kind.
2838  /// \param EndLoc Ending Location of the directive.
2839  /// \param CollapsedNum Number of collapsed loops.
2840  /// \param Clauses List of clauses.
2841  /// \param AssociatedStmt Statement, associated with the directive.
2842  /// \param Exprs Helper expressions for CodeGen.
2843  ///
2844  static OMPTaskLoopDirective *
2845  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2846  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
2847  Stmt *AssociatedStmt, const HelperExprs &Exprs);
2848 
2849  /// Creates an empty directive with the place
2850  /// for \a NumClauses clauses.
2851  ///
2852  /// \param C AST context.
2853  /// \param CollapsedNum Number of collapsed nested loops.
2854  /// \param NumClauses Number of clauses.
2855  ///
2857  unsigned NumClauses,
2858  unsigned CollapsedNum, EmptyShell);
2859 
2860  static bool classof(const Stmt *T) {
2861  return T->getStmtClass() == OMPTaskLoopDirectiveClass;
2862  }
2863 };
2864 
2865 /// This represents '#pragma omp taskloop simd' directive.
2866 ///
2867 /// \code
2868 /// #pragma omp taskloop simd private(a,b) grainsize(val) num_tasks(num)
2869 /// \endcode
2870 /// In this example directive '#pragma omp taskloop simd' has clauses 'private'
2871 /// with the variables 'a' and 'b', 'grainsize' with expression 'val' and
2872 /// 'num_tasks' with expression 'num'.
2873 ///
2875  friend class ASTStmtReader;
2876  /// Build directive with the given start and end location.
2877  ///
2878  /// \param StartLoc Starting location of the directive kind.
2879  /// \param EndLoc Ending location of the directive.
2880  /// \param CollapsedNum Number of collapsed nested loops.
2881  /// \param NumClauses Number of clauses.
2882  ///
2884  unsigned CollapsedNum, unsigned NumClauses)
2885  : OMPLoopDirective(this, OMPTaskLoopSimdDirectiveClass,
2886  OMPD_taskloop_simd, StartLoc, EndLoc, CollapsedNum,
2887  NumClauses) {}
2888 
2889  /// Build an empty directive.
2890  ///
2891  /// \param CollapsedNum Number of collapsed nested loops.
2892  /// \param NumClauses Number of clauses.
2893  ///
2894  explicit OMPTaskLoopSimdDirective(unsigned CollapsedNum, unsigned NumClauses)
2895  : OMPLoopDirective(this, OMPTaskLoopSimdDirectiveClass,
2896  OMPD_taskloop_simd, SourceLocation(), SourceLocation(),
2897  CollapsedNum, NumClauses) {}
2898 
2899 public:
2900  /// Creates directive with a list of \a Clauses.
2901  ///
2902  /// \param C AST context.
2903  /// \param StartLoc Starting location of the directive kind.
2904  /// \param EndLoc Ending Location of the directive.
2905  /// \param CollapsedNum Number of collapsed loops.
2906  /// \param Clauses List of clauses.
2907  /// \param AssociatedStmt Statement, associated with the directive.
2908  /// \param Exprs Helper expressions for CodeGen.
2909  ///
2910  static OMPTaskLoopSimdDirective *
2911  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2912  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
2913  Stmt *AssociatedStmt, const HelperExprs &Exprs);
2914 
2915  /// Creates an empty directive with the place
2916  /// for \a NumClauses clauses.
2917  ///
2918  /// \param C AST context.
2919  /// \param CollapsedNum Number of collapsed nested loops.
2920  /// \param NumClauses Number of clauses.
2921  ///
2923  unsigned NumClauses,
2924  unsigned CollapsedNum,
2925  EmptyShell);
2926 
2927  static bool classof(const Stmt *T) {
2928  return T->getStmtClass() == OMPTaskLoopSimdDirectiveClass;
2929  }
2930 };
2931 
2932 /// This represents '#pragma omp distribute' directive.
2933 ///
2934 /// \code
2935 /// #pragma omp distribute private(a,b)
2936 /// \endcode
2937 /// In this example directive '#pragma omp distribute' has clauses 'private'
2938 /// with the variables 'a' and 'b'
2939 ///
2941  friend class ASTStmtReader;
2942 
2943  /// Build directive with the given start and end location.
2944  ///
2945  /// \param StartLoc Starting location of the directive kind.
2946  /// \param EndLoc Ending location of the directive.
2947  /// \param CollapsedNum Number of collapsed nested loops.
2948  /// \param NumClauses Number of clauses.
2949  ///
2951  unsigned CollapsedNum, unsigned NumClauses)
2952  : OMPLoopDirective(this, OMPDistributeDirectiveClass, OMPD_distribute,
2953  StartLoc, EndLoc, CollapsedNum, NumClauses)
2954  {}
2955 
2956  /// Build an empty directive.
2957  ///
2958  /// \param CollapsedNum Number of collapsed nested loops.
2959  /// \param NumClauses Number of clauses.
2960  ///
2961  explicit OMPDistributeDirective(unsigned CollapsedNum, unsigned NumClauses)
2962  : OMPLoopDirective(this, OMPDistributeDirectiveClass, OMPD_distribute,
2963  SourceLocation(), SourceLocation(), CollapsedNum,
2964  NumClauses)
2965  {}
2966 
2967 public:
2968  /// Creates directive with a list of \a Clauses.
2969  ///
2970  /// \param C AST context.
2971  /// \param StartLoc Starting location of the directive kind.
2972  /// \param EndLoc Ending Location of the directive.
2973  /// \param CollapsedNum Number of collapsed loops.
2974  /// \param Clauses List of clauses.
2975  /// \param AssociatedStmt Statement, associated with the directive.
2976  /// \param Exprs Helper expressions for CodeGen.
2977  ///
2978  static OMPDistributeDirective *
2979  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
2980  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
2981  Stmt *AssociatedStmt, const HelperExprs &Exprs);
2982 
2983  /// Creates an empty directive with the place
2984  /// for \a NumClauses clauses.
2985  ///
2986  /// \param C AST context.
2987  /// \param CollapsedNum Number of collapsed nested loops.
2988  /// \param NumClauses Number of clauses.
2989  ///
2991  unsigned NumClauses,
2992  unsigned CollapsedNum, EmptyShell);
2993 
2994  static bool classof(const Stmt *T) {
2995  return T->getStmtClass() == OMPDistributeDirectiveClass;
2996  }
2997 };
2998 
2999 /// This represents '#pragma omp target update' directive.
3000 ///
3001 /// \code
3002 /// #pragma omp target update to(a) from(b) device(1)
3003 /// \endcode
3004 /// In this example directive '#pragma omp target update' has clause 'to' with
3005 /// argument 'a', clause 'from' with argument 'b' and clause 'device' with
3006 /// argument '1'.
3007 ///
3009  friend class ASTStmtReader;
3010  /// Build directive with the given start and end location.
3011  ///
3012  /// \param StartLoc Starting location of the directive kind.
3013  /// \param EndLoc Ending Location of the directive.
3014  /// \param NumClauses The number of clauses.
3015  ///
3017  unsigned NumClauses)
3018  : OMPExecutableDirective(this, OMPTargetUpdateDirectiveClass,
3019  OMPD_target_update, StartLoc, EndLoc, NumClauses,
3020  1) {}
3021 
3022  /// Build an empty directive.
3023  ///
3024  /// \param NumClauses Number of clauses.
3025  ///
3026  explicit OMPTargetUpdateDirective(unsigned NumClauses)
3027  : OMPExecutableDirective(this, OMPTargetUpdateDirectiveClass,
3028  OMPD_target_update, SourceLocation(),
3029  SourceLocation(), NumClauses, 1) {}
3030 
3031 public:
3032  /// Creates directive with a list of \a Clauses.
3033  ///
3034  /// \param C AST context.
3035  /// \param StartLoc Starting location of the directive kind.
3036  /// \param EndLoc Ending Location of the directive.
3037  /// \param Clauses List of clauses.
3038  /// \param AssociatedStmt Statement, associated with the directive.
3039  ///
3040  static OMPTargetUpdateDirective *
3041  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
3042  ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
3043 
3044  /// Creates an empty directive with the place for \a NumClauses
3045  /// clauses.
3046  ///
3047  /// \param C AST context.
3048  /// \param NumClauses The number of clauses.
3049  ///
3051  unsigned NumClauses, EmptyShell);
3052 
3053  static bool classof(const Stmt *T) {
3054  return T->getStmtClass() == OMPTargetUpdateDirectiveClass;
3055  }
3056 };
3057 
3058 /// This represents '#pragma omp distribute parallel for' composite
3059 /// directive.
3060 ///
3061 /// \code
3062 /// #pragma omp distribute parallel for private(a,b)
3063 /// \endcode
3064 /// In this example directive '#pragma omp distribute parallel for' has clause
3065 /// 'private' with the variables 'a' and 'b'
3066 ///
3068  friend class ASTStmtReader;
3069  /// true if the construct has inner cancel directive.
3070  bool HasCancel = false;
3071 
3072  /// Build directive with the given start and end location.
3073  ///
3074  /// \param StartLoc Starting location of the directive kind.
3075  /// \param EndLoc Ending location of the directive.
3076  /// \param CollapsedNum Number of collapsed nested loops.
3077  /// \param NumClauses Number of clauses.
3078  ///
3080  SourceLocation EndLoc,
3081  unsigned CollapsedNum, unsigned NumClauses)
3082  : OMPLoopDirective(this, OMPDistributeParallelForDirectiveClass,
3083  OMPD_distribute_parallel_for, StartLoc, EndLoc,
3084  CollapsedNum, NumClauses), HasCancel(false) {}
3085 
3086  /// Build an empty directive.
3087  ///
3088  /// \param CollapsedNum Number of collapsed nested loops.
3089  /// \param NumClauses Number of clauses.
3090  ///
3091  explicit OMPDistributeParallelForDirective(unsigned CollapsedNum,
3092  unsigned NumClauses)
3093  : OMPLoopDirective(this, OMPDistributeParallelForDirectiveClass,
3094  OMPD_distribute_parallel_for, SourceLocation(),
3095  SourceLocation(), CollapsedNum, NumClauses),
3096  HasCancel(false) {}
3097 
3098  /// Set cancel state.
3099  void setHasCancel(bool Has) { HasCancel = Has; }
3100 
3101 public:
3102  /// Creates directive with a list of \a Clauses.
3103  ///
3104  /// \param C AST context.
3105  /// \param StartLoc Starting location of the directive kind.
3106  /// \param EndLoc Ending Location of the directive.
3107  /// \param CollapsedNum Number of collapsed loops.
3108  /// \param Clauses List of clauses.
3109  /// \param AssociatedStmt Statement, associated with the directive.
3110  /// \param Exprs Helper expressions for CodeGen.
3111  /// \param HasCancel true if this directive has inner cancel directive.
3112  ///
3114  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
3115  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3116  Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel);
3117 
3118  /// Creates an empty directive with the place
3119  /// for \a NumClauses clauses.
3120  ///
3121  /// \param C AST context.
3122  /// \param CollapsedNum Number of collapsed nested loops.
3123  /// \param NumClauses Number of clauses.
3124  ///
3126  unsigned NumClauses,
3127  unsigned CollapsedNum,
3128  EmptyShell);
3129 
3130  /// Return true if current directive has inner cancel directive.
3131  bool hasCancel() const { return HasCancel; }
3132 
3133  static bool classof(const Stmt *T) {
3134  return T->getStmtClass() == OMPDistributeParallelForDirectiveClass;
3135  }
3136 };
3137 
3138 /// This represents '#pragma omp distribute parallel for simd' composite
3139 /// directive.
3140 ///
3141 /// \code
3142 /// #pragma omp distribute parallel for simd private(x)
3143 /// \endcode
3144 /// In this example directive '#pragma omp distribute parallel for simd' has
3145 /// clause 'private' with the variables 'x'
3146 ///
3148  friend class ASTStmtReader;
3149 
3150  /// Build directive with the given start and end location.
3151  ///
3152  /// \param StartLoc Starting location of the directive kind.
3153  /// \param EndLoc Ending location of the directive.
3154  /// \param CollapsedNum Number of collapsed nested loops.
3155  /// \param NumClauses Number of clauses.
3156  ///
3158  SourceLocation EndLoc,
3159  unsigned CollapsedNum,
3160  unsigned NumClauses)
3161  : OMPLoopDirective(this, OMPDistributeParallelForSimdDirectiveClass,
3162  OMPD_distribute_parallel_for_simd, StartLoc,
3163  EndLoc, CollapsedNum, NumClauses) {}
3164 
3165  /// Build an empty directive.
3166  ///
3167  /// \param CollapsedNum Number of collapsed nested loops.
3168  /// \param NumClauses Number of clauses.
3169  ///
3170  explicit OMPDistributeParallelForSimdDirective(unsigned CollapsedNum,
3171  unsigned NumClauses)
3172  : OMPLoopDirective(this, OMPDistributeParallelForSimdDirectiveClass,
3173  OMPD_distribute_parallel_for_simd,
3174  SourceLocation(), SourceLocation(), CollapsedNum,
3175  NumClauses) {}
3176 
3177 public:
3178  /// Creates directive with a list of \a Clauses.
3179  ///
3180  /// \param C AST context.
3181  /// \param StartLoc Starting location of the directive kind.
3182  /// \param EndLoc Ending Location of the directive.
3183  /// \param CollapsedNum Number of collapsed loops.
3184  /// \param Clauses List of clauses.
3185  /// \param AssociatedStmt Statement, associated with the directive.
3186  /// \param Exprs Helper expressions for CodeGen.
3187  ///
3189  const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
3190  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3191  Stmt *AssociatedStmt, const HelperExprs &Exprs);
3192 
3193  /// Creates an empty directive with the place for \a NumClauses clauses.
3194  ///
3195  /// \param C AST context.
3196  /// \param CollapsedNum Number of collapsed nested loops.
3197  /// \param NumClauses Number of clauses.
3198  ///
3200  const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
3201  EmptyShell);
3202 
3203  static bool classof(const Stmt *T) {
3204  return T->getStmtClass() == OMPDistributeParallelForSimdDirectiveClass;
3205  }
3206 };
3207 
3208 /// This represents '#pragma omp distribute simd' composite directive.
3209 ///
3210 /// \code
3211 /// #pragma omp distribute simd private(x)
3212 /// \endcode
3213 /// In this example directive '#pragma omp distribute simd' has clause
3214 /// 'private' with the variables 'x'
3215 ///
3217  friend class ASTStmtReader;
3218 
3219  /// Build directive with the given start and end location.
3220  ///
3221  /// \param StartLoc Starting location of the directive kind.
3222  /// \param EndLoc Ending location of the directive.
3223  /// \param CollapsedNum Number of collapsed nested loops.
3224  /// \param NumClauses Number of clauses.
3225  ///
3227  unsigned CollapsedNum, unsigned NumClauses)
3228  : OMPLoopDirective(this, OMPDistributeSimdDirectiveClass,
3229  OMPD_distribute_simd, StartLoc, EndLoc, CollapsedNum,
3230  NumClauses) {}
3231 
3232  /// Build an empty directive.
3233  ///
3234  /// \param CollapsedNum Number of collapsed nested loops.
3235  /// \param NumClauses Number of clauses.
3236  ///
3237  explicit OMPDistributeSimdDirective(unsigned CollapsedNum,
3238  unsigned NumClauses)
3239  : OMPLoopDirective(this, OMPDistributeSimdDirectiveClass,
3240  OMPD_distribute_simd, SourceLocation(),
3241  SourceLocation(), CollapsedNum, NumClauses) {}
3242 
3243 public:
3244  /// Creates directive with a list of \a Clauses.
3245  ///
3246  /// \param C AST context.
3247  /// \param StartLoc Starting location of the directive kind.
3248  /// \param EndLoc Ending Location of the directive.
3249  /// \param CollapsedNum Number of collapsed loops.
3250  /// \param Clauses List of clauses.
3251  /// \param AssociatedStmt Statement, associated with the directive.
3252  /// \param Exprs Helper expressions for CodeGen.
3253  ///
3255  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
3256  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3257  Stmt *AssociatedStmt, const HelperExprs &Exprs);
3258 
3259  /// Creates an empty directive with the place for \a NumClauses clauses.
3260  ///
3261  /// \param C AST context.
3262  /// \param CollapsedNum Number of collapsed nested loops.
3263  /// \param NumClauses Number of clauses.
3264  ///
3266  unsigned NumClauses,
3267  unsigned CollapsedNum,
3268  EmptyShell);
3269 
3270  static bool classof(const Stmt *T) {
3271  return T->getStmtClass() == OMPDistributeSimdDirectiveClass;
3272  }
3273 };
3274 
3275 /// This represents '#pragma omp target parallel for simd' directive.
3276 ///
3277 /// \code
3278 /// #pragma omp target parallel for simd private(a) map(b) safelen(c)
3279 /// \endcode
3280 /// In this example directive '#pragma omp target parallel for simd' has clauses
3281 /// 'private' with the variable 'a', 'map' with the variable 'b' and 'safelen'
3282 /// with the variable 'c'.
3283 ///
3285  friend class ASTStmtReader;
3286 
3287  /// Build directive with the given start and end location.
3288  ///
3289  /// \param StartLoc Starting location of the directive kind.
3290  /// \param EndLoc Ending location of the directive.
3291  /// \param CollapsedNum Number of collapsed nested loops.
3292  /// \param NumClauses Number of clauses.
3293  ///
3295  unsigned CollapsedNum, unsigned NumClauses)
3296  : OMPLoopDirective(this, OMPTargetParallelForSimdDirectiveClass,
3297  OMPD_target_parallel_for_simd, StartLoc, EndLoc,
3298  CollapsedNum, NumClauses) {}
3299 
3300  /// Build an empty directive.
3301  ///
3302  /// \param CollapsedNum Number of collapsed nested loops.
3303  /// \param NumClauses Number of clauses.
3304  ///
3305  explicit OMPTargetParallelForSimdDirective(unsigned CollapsedNum,
3306  unsigned NumClauses)
3307  : OMPLoopDirective(this, OMPTargetParallelForSimdDirectiveClass,
3308  OMPD_target_parallel_for_simd, SourceLocation(),
3309  SourceLocation(), CollapsedNum, NumClauses) {}
3310 
3311 public:
3312  /// Creates directive with a list of \a Clauses.
3313  ///
3314  /// \param C AST context.
3315  /// \param StartLoc Starting location of the directive kind.
3316  /// \param EndLoc Ending Location of the directive.
3317  /// \param CollapsedNum Number of collapsed loops.
3318  /// \param Clauses List of clauses.
3319  /// \param AssociatedStmt Statement, associated with the directive.
3320  /// \param Exprs Helper expressions for CodeGen.
3321  ///
3323  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
3324  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3325  Stmt *AssociatedStmt, const HelperExprs &Exprs);
3326 
3327  /// Creates an empty directive with the place for \a NumClauses clauses.
3328  ///
3329  /// \param C AST context.
3330  /// \param CollapsedNum Number of collapsed nested loops.
3331  /// \param NumClauses Number of clauses.
3332  ///
3334  unsigned NumClauses,
3335  unsigned CollapsedNum,
3336  EmptyShell);
3337 
3338  static bool classof(const Stmt *T) {
3339  return T->getStmtClass() == OMPTargetParallelForSimdDirectiveClass;
3340  }
3341 };
3342 
3343 /// This represents '#pragma omp target simd' directive.
3344 ///
3345 /// \code
3346 /// #pragma omp target simd private(a) map(b) safelen(c)
3347 /// \endcode
3348 /// In this example directive '#pragma omp target simd' has clauses 'private'
3349 /// with the variable 'a', 'map' with the variable 'b' and 'safelen' with
3350 /// the variable 'c'.
3351 ///
3353  friend class ASTStmtReader;
3354 
3355  /// Build directive with the given start and end location.
3356  ///
3357  /// \param StartLoc Starting location of the directive kind.
3358  /// \param EndLoc Ending location of the directive.
3359  /// \param CollapsedNum Number of collapsed nested loops.
3360  /// \param NumClauses Number of clauses.
3361  ///
3363  unsigned CollapsedNum, unsigned NumClauses)
3364  : OMPLoopDirective(this, OMPTargetSimdDirectiveClass,
3365  OMPD_target_simd, StartLoc, EndLoc, CollapsedNum,
3366  NumClauses) {}
3367 
3368  /// Build an empty directive.
3369  ///
3370  /// \param CollapsedNum Number of collapsed nested loops.
3371  /// \param NumClauses Number of clauses.
3372  ///
3373  explicit OMPTargetSimdDirective(unsigned CollapsedNum, unsigned NumClauses)
3374  : OMPLoopDirective(this, OMPTargetSimdDirectiveClass, OMPD_target_simd,
3375  SourceLocation(),SourceLocation(), CollapsedNum,
3376  NumClauses) {}
3377 
3378 public:
3379  /// Creates directive with a list of \a Clauses.
3380  ///
3381  /// \param C AST context.
3382  /// \param StartLoc Starting location of the directive kind.
3383  /// \param EndLoc Ending Location of the directive.
3384  /// \param CollapsedNum Number of collapsed loops.
3385  /// \param Clauses List of clauses.
3386  /// \param AssociatedStmt Statement, associated with the directive.
3387  /// \param Exprs Helper expressions for CodeGen.
3388  ///
3389  static OMPTargetSimdDirective *
3390  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
3391  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3392  Stmt *AssociatedStmt, const HelperExprs &Exprs);
3393 
3394  /// Creates an empty directive with the place for \a NumClauses clauses.
3395  ///
3396  /// \param C AST context.
3397  /// \param CollapsedNum Number of collapsed nested loops.
3398  /// \param NumClauses Number of clauses.
3399  ///
3401  unsigned NumClauses,
3402  unsigned CollapsedNum,
3403  EmptyShell);
3404 
3405  static bool classof(const Stmt *T) {
3406  return T->getStmtClass() == OMPTargetSimdDirectiveClass;
3407  }
3408 };
3409 
3410 /// This represents '#pragma omp teams distribute' directive.
3411 ///
3412 /// \code
3413 /// #pragma omp teams distribute private(a,b)
3414 /// \endcode
3415 /// In this example directive '#pragma omp teams distribute' has clauses
3416 /// 'private' with the variables 'a' and 'b'
3417 ///
3419  friend class ASTStmtReader;
3420 
3421  /// Build directive with the given start and end location.
3422  ///
3423  /// \param StartLoc Starting location of the directive kind.
3424  /// \param EndLoc Ending location of the directive.
3425  /// \param CollapsedNum Number of collapsed nested loops.
3426  /// \param NumClauses Number of clauses.
3427  ///
3429  unsigned CollapsedNum, unsigned NumClauses)
3430  : OMPLoopDirective(this, OMPTeamsDistributeDirectiveClass,
3431  OMPD_teams_distribute, StartLoc, EndLoc,
3432  CollapsedNum, NumClauses) {}
3433 
3434  /// Build an empty directive.
3435  ///
3436  /// \param CollapsedNum Number of collapsed nested loops.
3437  /// \param NumClauses Number of clauses.
3438  ///
3439  explicit OMPTeamsDistributeDirective(unsigned CollapsedNum,
3440  unsigned NumClauses)
3441  : OMPLoopDirective(this, OMPTeamsDistributeDirectiveClass,
3442  OMPD_teams_distribute, SourceLocation(),
3443  SourceLocation(), CollapsedNum, NumClauses) {}
3444 
3445 public:
3446  /// Creates directive with a list of \a Clauses.
3447  ///
3448  /// \param C AST context.
3449  /// \param StartLoc Starting location of the directive kind.
3450  /// \param EndLoc Ending Location of the directive.
3451  /// \param CollapsedNum Number of collapsed loops.
3452  /// \param Clauses List of clauses.
3453  /// \param AssociatedStmt Statement, associated with the directive.
3454  /// \param Exprs Helper expressions for CodeGen.
3455  ///
3457  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
3458  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3459  Stmt *AssociatedStmt, const HelperExprs &Exprs);
3460 
3461  /// Creates an empty directive with the place for \a NumClauses clauses.
3462  ///
3463  /// \param C AST context.
3464  /// \param CollapsedNum Number of collapsed nested loops.
3465  /// \param NumClauses Number of clauses.
3466  ///
3468  unsigned NumClauses,
3469  unsigned CollapsedNum,
3470  EmptyShell);
3471 
3472  static bool classof(const Stmt *T) {
3473  return T->getStmtClass() == OMPTeamsDistributeDirectiveClass;
3474  }
3475 };
3476 
3477 /// This represents '#pragma omp teams distribute simd'
3478 /// combined directive.
3479 ///
3480 /// \code
3481 /// #pragma omp teams distribute simd private(a,b)
3482 /// \endcode
3483 /// In this example directive '#pragma omp teams distribute simd'
3484 /// has clause 'private' with the variables 'a' and 'b'
3485 ///
3487  friend class ASTStmtReader;
3488 
3489  /// Build directive with the given start and end location.
3490  ///
3491  /// \param StartLoc Starting location of the directive kind.
3492  /// \param EndLoc Ending location of the directive.
3493  /// \param CollapsedNum Number of collapsed nested loops.
3494  /// \param NumClauses Number of clauses.
3495  ///
3497  SourceLocation EndLoc, unsigned CollapsedNum,
3498  unsigned NumClauses)
3499  : OMPLoopDirective(this, OMPTeamsDistributeSimdDirectiveClass,
3500  OMPD_teams_distribute_simd, StartLoc, EndLoc,
3501  CollapsedNum, NumClauses) {}
3502 
3503  /// Build an empty directive.
3504  ///
3505  /// \param CollapsedNum Number of collapsed nested loops.
3506  /// \param NumClauses Number of clauses.
3507  ///
3508  explicit OMPTeamsDistributeSimdDirective(unsigned CollapsedNum,
3509  unsigned NumClauses)
3510  : OMPLoopDirective(this, OMPTeamsDistributeSimdDirectiveClass,
3511  OMPD_teams_distribute_simd, SourceLocation(),
3512  SourceLocation(), CollapsedNum, NumClauses) {}
3513 
3514 public:
3515  /// Creates directive with a list of \a Clauses.
3516  ///
3517  /// \param C AST context.
3518  /// \param StartLoc Starting location of the directive kind.
3519  /// \param EndLoc Ending Location of the directive.
3520  /// \param CollapsedNum Number of collapsed loops.
3521  /// \param Clauses List of clauses.
3522  /// \param AssociatedStmt Statement, associated with the directive.
3523  /// \param Exprs Helper expressions for CodeGen.
3524  ///
3526  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
3527  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3528  Stmt *AssociatedStmt, const HelperExprs &Exprs);
3529 
3530  /// Creates an empty directive with the place
3531  /// for \a NumClauses clauses.
3532  ///
3533  /// \param C AST context.
3534  /// \param CollapsedNum Number of collapsed nested loops.
3535  /// \param NumClauses Number of clauses.
3536  ///
3538  unsigned NumClauses,
3539  unsigned CollapsedNum,
3540  EmptyShell);
3541 
3542  static bool classof(const Stmt *T) {
3543  return T->getStmtClass() == OMPTeamsDistributeSimdDirectiveClass;
3544  }
3545 };
3546 
3547 /// This represents '#pragma omp teams distribute parallel for simd' composite
3548 /// directive.
3549 ///
3550 /// \code
3551 /// #pragma omp teams distribute parallel for simd private(x)
3552 /// \endcode
3553 /// In this example directive '#pragma omp teams distribute parallel for simd'
3554 /// has clause 'private' with the variables 'x'
3555 ///
3557  : public OMPLoopDirective {
3558  friend class ASTStmtReader;
3559 
3560  /// Build directive with the given start and end location.
3561  ///
3562  /// \param StartLoc Starting location of the directive kind.
3563  /// \param EndLoc Ending location of the directive.
3564  /// \param CollapsedNum Number of collapsed nested loops.
3565  /// \param NumClauses Number of clauses.
3566  ///
3568  SourceLocation EndLoc,
3569  unsigned CollapsedNum,
3570  unsigned NumClauses)
3571  : OMPLoopDirective(this, OMPTeamsDistributeParallelForSimdDirectiveClass,
3572  OMPD_teams_distribute_parallel_for_simd, StartLoc,
3573  EndLoc, CollapsedNum, NumClauses) {}
3574 
3575  /// Build an empty directive.
3576  ///
3577  /// \param CollapsedNum Number of collapsed nested loops.
3578  /// \param NumClauses Number of clauses.
3579  ///
3580  explicit OMPTeamsDistributeParallelForSimdDirective(unsigned CollapsedNum,
3581  unsigned NumClauses)
3582  : OMPLoopDirective(this, OMPTeamsDistributeParallelForSimdDirectiveClass,
3583  OMPD_teams_distribute_parallel_for_simd,
3584  SourceLocation(), SourceLocation(), CollapsedNum,
3585  NumClauses) {}
3586 
3587 public:
3588  /// Creates directive with a list of \a Clauses.
3589  ///
3590  /// \param C AST context.
3591  /// \param StartLoc Starting location of the directive kind.
3592  /// \param EndLoc Ending Location of the directive.
3593  /// \param CollapsedNum Number of collapsed loops.
3594  /// \param Clauses List of clauses.
3595  /// \param AssociatedStmt Statement, associated with the directive.
3596  /// \param Exprs Helper expressions for CodeGen.
3597  ///
3599  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
3600  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3601  Stmt *AssociatedStmt, const HelperExprs &Exprs);
3602 
3603  /// Creates an empty directive with the place for \a NumClauses clauses.
3604  ///
3605  /// \param C AST context.
3606  /// \param CollapsedNum Number of collapsed nested loops.
3607  /// \param NumClauses Number of clauses.
3608  ///
3610  CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
3611  EmptyShell);
3612 
3613  static bool classof(const Stmt *T) {
3614  return T->getStmtClass() == OMPTeamsDistributeParallelForSimdDirectiveClass;
3615  }
3616 };
3617 
3618 /// This represents '#pragma omp teams distribute parallel for' composite
3619 /// directive.
3620 ///
3621 /// \code
3622 /// #pragma omp teams distribute parallel for private(x)
3623 /// \endcode
3624 /// In this example directive '#pragma omp teams distribute parallel for'
3625 /// has clause 'private' with the variables 'x'
3626 ///
3628  friend class ASTStmtReader;
3629  /// true if the construct has inner cancel directive.
3630  bool HasCancel = false;
3631 
3632  /// Build directive with the given start and end location.
3633  ///
3634  /// \param StartLoc Starting location of the directive kind.
3635  /// \param EndLoc Ending location of the directive.
3636  /// \param CollapsedNum Number of collapsed nested loops.
3637  /// \param NumClauses Number of clauses.
3638  ///
3640  SourceLocation EndLoc,
3641  unsigned CollapsedNum,
3642  unsigned NumClauses)
3643  : OMPLoopDirective(this, OMPTeamsDistributeParallelForDirectiveClass,
3644  OMPD_teams_distribute_parallel_for, StartLoc, EndLoc,
3645  CollapsedNum, NumClauses), HasCancel(false) {}
3646 
3647  /// Build an empty directive.
3648  ///
3649  /// \param CollapsedNum Number of collapsed nested loops.
3650  /// \param NumClauses Number of clauses.
3651  ///
3652  explicit OMPTeamsDistributeParallelForDirective(unsigned CollapsedNum,
3653  unsigned NumClauses)
3654  : OMPLoopDirective(this, OMPTeamsDistributeParallelForDirectiveClass,
3655  OMPD_teams_distribute_parallel_for, SourceLocation(),
3656  SourceLocation(), CollapsedNum, NumClauses),
3657  HasCancel(false) {}
3658 
3659  /// Set cancel state.
3660  void setHasCancel(bool Has) { HasCancel = Has; }
3661 
3662 public:
3663  /// Creates directive with a list of \a Clauses.
3664  ///
3665  /// \param C AST context.
3666  /// \param StartLoc Starting location of the directive kind.
3667  /// \param EndLoc Ending Location of the directive.
3668  /// \param CollapsedNum Number of collapsed loops.
3669  /// \param Clauses List of clauses.
3670  /// \param AssociatedStmt Statement, associated with the directive.
3671  /// \param Exprs Helper expressions for CodeGen.
3672  /// \param HasCancel true if this directive has inner cancel directive.
3673  ///
3675  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
3676  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3677  Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel);
3678 
3679  /// Creates an empty directive with the place for \a NumClauses clauses.
3680  ///
3681  /// \param C AST context.
3682  /// \param CollapsedNum Number of collapsed nested loops.
3683  /// \param NumClauses Number of clauses.
3684  ///
3686  CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
3687  EmptyShell);
3688 
3689  /// Return true if current directive has inner cancel directive.
3690  bool hasCancel() const { return HasCancel; }
3691 
3692  static bool classof(const Stmt *T) {
3693  return T->getStmtClass() == OMPTeamsDistributeParallelForDirectiveClass;
3694  }
3695 };
3696 
3697 /// This represents '#pragma omp target teams' directive.
3698 ///
3699 /// \code
3700 /// #pragma omp target teams if(a>0)
3701 /// \endcode
3702 /// In this example directive '#pragma omp target teams' has clause 'if' with
3703 /// condition 'a>0'.
3704 ///
3706  friend class ASTStmtReader;
3707  /// Build directive with the given start and end location.
3708  ///
3709  /// \param StartLoc Starting location of the directive kind.
3710  /// \param EndLoc Ending location of the directive.
3711  /// \param NumClauses Number of clauses.
3712  ///
3714  unsigned NumClauses)
3715  : OMPExecutableDirective(this, OMPTargetTeamsDirectiveClass,
3716  OMPD_target_teams, StartLoc, EndLoc, NumClauses,
3717  1) {}
3718 
3719  /// Build an empty directive.
3720  ///
3721  /// \param NumClauses Number of clauses.
3722  ///
3723  explicit OMPTargetTeamsDirective(unsigned NumClauses)
3724  : OMPExecutableDirective(this, OMPTargetTeamsDirectiveClass,
3725  OMPD_target_teams, SourceLocation(),
3726  SourceLocation(), NumClauses, 1) {}
3727 
3728 public:
3729  /// Creates directive with a list of \a Clauses.
3730  ///
3731  /// \param C AST context.
3732  /// \param StartLoc Starting location of the directive kind.
3733  /// \param EndLoc Ending Location of the directive.
3734  /// \param Clauses List of clauses.
3735  /// \param AssociatedStmt Statement, associated with the directive.
3736  ///
3737  static OMPTargetTeamsDirective *Create(const ASTContext &C,
3738  SourceLocation StartLoc,
3739  SourceLocation EndLoc,
3740  ArrayRef<OMPClause *> Clauses,
3741  Stmt *AssociatedStmt);
3742 
3743  /// Creates an empty directive with the place for \a NumClauses clauses.
3744  ///
3745  /// \param C AST context.
3746  /// \param NumClauses Number of clauses.
3747  ///
3749  unsigned NumClauses, EmptyShell);
3750 
3751  static bool classof(const Stmt *T) {
3752  return T->getStmtClass() == OMPTargetTeamsDirectiveClass;
3753  }
3754 };
3755 
3756 /// This represents '#pragma omp target teams distribute' combined directive.
3757 ///
3758 /// \code
3759 /// #pragma omp target teams distribute private(x)
3760 /// \endcode
3761 /// In this example directive '#pragma omp target teams distribute' has clause
3762 /// 'private' with the variables 'x'
3763 ///
3765  friend class ASTStmtReader;
3766 
3767  /// Build directive with the given start and end location.
3768  ///
3769  /// \param StartLoc Starting location of the directive kind.
3770  /// \param EndLoc Ending location of the directive.
3771  /// \param CollapsedNum Number of collapsed nested loops.
3772  /// \param NumClauses Number of clauses.
3773  ///
3775  SourceLocation EndLoc,
3776  unsigned CollapsedNum, unsigned NumClauses)
3777  : OMPLoopDirective(this, OMPTargetTeamsDistributeDirectiveClass,
3778  OMPD_target_teams_distribute, StartLoc, EndLoc,
3779  CollapsedNum, NumClauses) {}
3780 
3781  /// Build an empty directive.
3782  ///
3783  /// \param CollapsedNum Number of collapsed nested loops.
3784  /// \param NumClauses Number of clauses.
3785  ///
3786  explicit OMPTargetTeamsDistributeDirective(unsigned CollapsedNum,
3787  unsigned NumClauses)
3788  : OMPLoopDirective(this, OMPTargetTeamsDistributeDirectiveClass,
3789  OMPD_target_teams_distribute, SourceLocation(),
3790  SourceLocation(), CollapsedNum, NumClauses) {}
3791 
3792 public:
3793  /// Creates directive with a list of \a Clauses.
3794  ///
3795  /// \param C AST context.
3796  /// \param StartLoc Starting location of the directive kind.
3797  /// \param EndLoc Ending Location of the directive.
3798  /// \param CollapsedNum Number of collapsed loops.
3799  /// \param Clauses List of clauses.
3800  /// \param AssociatedStmt Statement, associated with the directive.
3801  /// \param Exprs Helper expressions for CodeGen.
3802  ///
3804  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
3805  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3806  Stmt *AssociatedStmt, const HelperExprs &Exprs);
3807 
3808  /// Creates an empty directive with the place for \a NumClauses clauses.
3809  ///
3810  /// \param C AST context.
3811  /// \param CollapsedNum Number of collapsed nested loops.
3812  /// \param NumClauses Number of clauses.
3813  ///
3815  CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
3816  EmptyShell);
3817 
3818  static bool classof(const Stmt *T) {
3819  return T->getStmtClass() == OMPTargetTeamsDistributeDirectiveClass;
3820  }
3821 };
3822 
3823 /// This represents '#pragma omp target teams distribute parallel for' combined
3824 /// directive.
3825 ///
3826 /// \code
3827 /// #pragma omp target teams distribute parallel for private(x)
3828 /// \endcode
3829 /// In this example directive '#pragma omp target teams distribute parallel
3830 /// for' has clause 'private' with the variables 'x'
3831 ///
3833  : public OMPLoopDirective {
3834  friend class ASTStmtReader;
3835  /// true if the construct has inner cancel directive.
3836  bool HasCancel = false;
3837 
3838  /// Build directive with the given start and end location.
3839  ///
3840  /// \param StartLoc Starting location of the directive kind.
3841  /// \param EndLoc Ending location of the directive.
3842  /// \param CollapsedNum Number of collapsed nested loops.
3843  /// \param NumClauses Number of clauses.
3844  ///
3846  SourceLocation EndLoc,
3847  unsigned CollapsedNum,
3848  unsigned NumClauses)
3849  : OMPLoopDirective(this,
3850  OMPTargetTeamsDistributeParallelForDirectiveClass,
3851  OMPD_target_teams_distribute_parallel_for, StartLoc,
3852  EndLoc, CollapsedNum, NumClauses),
3853  HasCancel(false) {}
3854 
3855  /// Build an empty directive.
3856  ///
3857  /// \param CollapsedNum Number of collapsed nested loops.
3858  /// \param NumClauses Number of clauses.
3859  ///
3860  explicit OMPTargetTeamsDistributeParallelForDirective(unsigned CollapsedNum,
3861  unsigned NumClauses)
3862  : OMPLoopDirective(
3863  this, OMPTargetTeamsDistributeParallelForDirectiveClass,
3864  OMPD_target_teams_distribute_parallel_for, SourceLocation(),
3865  SourceLocation(), CollapsedNum, NumClauses),
3866  HasCancel(false) {}
3867 
3868  /// Set cancel state.
3869  void setHasCancel(bool Has) { HasCancel = Has; }
3870 
3871 public:
3872  /// Creates directive with a list of \a Clauses.
3873  ///
3874  /// \param C AST context.
3875  /// \param StartLoc Starting location of the directive kind.
3876  /// \param EndLoc Ending Location of the directive.
3877  /// \param CollapsedNum Number of collapsed loops.
3878  /// \param Clauses List of clauses.
3879  /// \param AssociatedStmt Statement, associated with the directive.
3880  /// \param Exprs Helper expressions for CodeGen.
3881  /// \param HasCancel true if this directive has inner cancel directive.
3882  ///
3884  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
3885  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3886  Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel);
3887 
3888  /// Creates an empty directive with the place for \a NumClauses clauses.
3889  ///
3890  /// \param C AST context.
3891  /// \param CollapsedNum Number of collapsed nested loops.
3892  /// \param NumClauses Number of clauses.
3893  ///
3895  CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
3896  EmptyShell);
3897 
3898  /// Return true if current directive has inner cancel directive.
3899  bool hasCancel() const { return HasCancel; }
3900 
3901  static bool classof(const Stmt *T) {
3902  return T->getStmtClass() ==
3903  OMPTargetTeamsDistributeParallelForDirectiveClass;
3904  }
3905 };
3906 
3907 /// This represents '#pragma omp target teams distribute parallel for simd'
3908 /// combined directive.
3909 ///
3910 /// \code
3911 /// #pragma omp target teams distribute parallel for simd private(x)
3912 /// \endcode
3913 /// In this example directive '#pragma omp target teams distribute parallel
3914 /// for simd' has clause 'private' with the variables 'x'
3915 ///
3917  : public OMPLoopDirective {
3918  friend class ASTStmtReader;
3919 
3920  /// Build directive with the given start and end location.
3921  ///
3922  /// \param StartLoc Starting location of the directive kind.
3923  /// \param EndLoc Ending location of the directive.
3924  /// \param CollapsedNum Number of collapsed nested loops.
3925  /// \param NumClauses Number of clauses.
3926  ///
3928  SourceLocation EndLoc,
3929  unsigned CollapsedNum,
3930  unsigned NumClauses)
3931  : OMPLoopDirective(this,
3932  OMPTargetTeamsDistributeParallelForSimdDirectiveClass,
3933  OMPD_target_teams_distribute_parallel_for_simd,
3934  StartLoc, EndLoc, CollapsedNum, NumClauses) {}
3935 
3936  /// Build an empty directive.
3937  ///
3938  /// \param CollapsedNum Number of collapsed nested loops.
3939  /// \param NumClauses Number of clauses.
3940  ///
3942  unsigned CollapsedNum, unsigned NumClauses)
3943  : OMPLoopDirective(
3944  this, OMPTargetTeamsDistributeParallelForSimdDirectiveClass,
3945  OMPD_target_teams_distribute_parallel_for_simd, SourceLocation(),
3946  SourceLocation(), CollapsedNum, NumClauses) {}
3947 
3948 public:
3949  /// Creates directive with a list of \a Clauses.
3950  ///
3951  /// \param C AST context.
3952  /// \param StartLoc Starting location of the directive kind.
3953  /// \param EndLoc Ending Location of the directive.
3954  /// \param CollapsedNum Number of collapsed loops.
3955  /// \param Clauses List of clauses.
3956  /// \param AssociatedStmt Statement, associated with the directive.
3957  /// \param Exprs Helper expressions for CodeGen.
3958  ///
3960  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
3961  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
3962  Stmt *AssociatedStmt, const HelperExprs &Exprs);
3963 
3964  /// Creates an empty directive with the place for \a NumClauses clauses.
3965  ///
3966  /// \param C AST context.
3967  /// \param CollapsedNum Number of collapsed nested loops.
3968  /// \param NumClauses Number of clauses.
3969  ///
3971  CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
3972  EmptyShell);
3973 
3974  static bool classof(const Stmt *T) {
3975  return T->getStmtClass() ==
3976  OMPTargetTeamsDistributeParallelForSimdDirectiveClass;
3977  }
3978 };
3979 
3980 /// This represents '#pragma omp target teams distribute simd' combined
3981 /// directive.
3982 ///
3983 /// \code
3984 /// #pragma omp target teams distribute simd private(x)
3985 /// \endcode
3986 /// In this example directive '#pragma omp target teams distribute simd'
3987 /// has clause 'private' with the variables 'x'
3988 ///
3990  friend class ASTStmtReader;
3991 
3992  /// Build directive with the given start and end location.
3993  ///
3994  /// \param StartLoc Starting location of the directive kind.
3995  /// \param EndLoc Ending location of the directive.
3996  /// \param CollapsedNum Number of collapsed nested loops.
3997  /// \param NumClauses Number of clauses.
3998  ///
4000  SourceLocation EndLoc,
4001  unsigned CollapsedNum,
4002  unsigned NumClauses)
4003  : OMPLoopDirective(this, OMPTargetTeamsDistributeSimdDirectiveClass,
4004  OMPD_target_teams_distribute_simd, StartLoc, EndLoc,
4005  CollapsedNum, NumClauses) {}
4006 
4007  /// Build an empty directive.
4008  ///
4009  /// \param CollapsedNum Number of collapsed nested loops.
4010  /// \param NumClauses Number of clauses.
4011  ///
4012  explicit OMPTargetTeamsDistributeSimdDirective(unsigned CollapsedNum,
4013  unsigned NumClauses)
4014  : OMPLoopDirective(this, OMPTargetTeamsDistributeSimdDirectiveClass,
4015  OMPD_target_teams_distribute_simd, SourceLocation(),
4016  SourceLocation(), CollapsedNum, NumClauses) {}
4017 
4018 public:
4019  /// Creates directive with a list of \a Clauses.
4020  ///
4021  /// \param C AST context.
4022  /// \param StartLoc Starting location of the directive kind.
4023  /// \param EndLoc Ending Location of the directive.
4024  /// \param CollapsedNum Number of collapsed loops.
4025  /// \param Clauses List of clauses.
4026  /// \param AssociatedStmt Statement, associated with the directive.
4027  /// \param Exprs Helper expressions for CodeGen.
4028  ///
4030  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
4031  unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
4032  Stmt *AssociatedStmt, const HelperExprs &Exprs);
4033 
4034  /// Creates an empty directive with the place for \a NumClauses clauses.
4035  ///
4036  /// \param C AST context.
4037  /// \param CollapsedNum Number of collapsed nested loops.
4038  /// \param NumClauses Number of clauses.
4039  ///
4041  CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
4042  EmptyShell);
4043 
4044  static bool classof(const Stmt *T) {
4045  return T->getStmtClass() == OMPTargetTeamsDistributeSimdDirectiveClass;
4046  }
4047 };
4048 
4049 } // end namespace clang
4050 
4051 #endif
void setPreInits(Stmt *PreInits)
Definition: StmtOpenMP.h:496
child_iterator child_begin()
Definition: Stmt.h:468
Expr * NLB
Update of LowerBound for statically scheduled &#39;omp for&#39; loops.
Definition: StmtOpenMP.h:674
bool hasCancel() const
Return true if current directive has inner cancel directive.
Definition: StmtOpenMP.h:330
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:2110
This represents &#39;#pragma omp distribute simd&#39; composite directive.
Definition: StmtOpenMP.h:3216
Expr * getNextUpperBound() const
Definition: StmtOpenMP.h:845
SmallVector< Expr *, 4 > Finals
Final loop counter values for GodeGen.
Definition: StmtOpenMP.h:702
This represents &#39;#pragma omp master&#39; directive.
Definition: StmtOpenMP.h:1399
Expr * NUB
Update of UpperBound for statically scheduled omp loops for outer loop in combined constructs (e...
Definition: StmtOpenMP.h:641
SmallVector< Expr *, 4 > Updates
Expressions for loop counters update for CodeGen.
Definition: StmtOpenMP.h:700
This represents &#39;#pragma omp task&#39; directive.
Definition: StmtOpenMP.h:1739
void setEnsureUpperBound(Expr *EUB)
Definition: StmtOpenMP.h:527
Expr * getUpperBoundVariable() const
Definition: StmtOpenMP.h:813
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:1388
ArrayRef< Expr * > inits() const
Definition: StmtOpenMP.h:953
ArrayRef< OMPClause * > clauses()
Definition: StmtOpenMP.h:262
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:969
OMPLoopDirective(const T *That, StmtClass SC, OpenMPDirectiveKind Kind, SourceLocation StartLoc, SourceLocation EndLoc, unsigned CollapsedNum, unsigned NumClauses, unsigned NumSpecialChildren=0)
Build instance of loop directive of class Kind.
Definition: StmtOpenMP.h:452
void setCombinedCond(Expr *CombCond)
Definition: StmtOpenMP.h:595
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:2417
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:30
const Expr * getV() const
Definition: StmtOpenMP.h:2234
void setCombinedLowerBoundVariable(Expr *CombLB)
Definition: StmtOpenMP.h:575
void setHasCancel(bool Has)
Set cancel state.
Definition: StmtOpenMP.h:1326
Stmt - This represents one statement.
Definition: Stmt.h:66
void setLastIteration(Expr *LI)
Definition: StmtOpenMP.h:482
Expr * getLowerBoundVariable() const
Definition: StmtOpenMP.h:805
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:3053
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:2300
This represents &#39;#pragma omp for simd&#39; directive.
Definition: StmtOpenMP.h:1149
Expr * EUB
EnsureUpperBound – expression UB = min(UB, NumIterations).
Definition: StmtOpenMP.h:672
Expr * DistInc
DistInc - increment expression for distribute loop when found combined with a further loop level (e...
Definition: StmtOpenMP.h:686
This represents &#39;#pragma omp teams distribute parallel for&#39; composite directive.
Definition: StmtOpenMP.h:3627
SourceLocation getBeginLoc() const
Definition: StmtOpenMP.h:169
void setPrevEnsureUpperBound(Expr *PrevEUB)
Definition: StmtOpenMP.h:570
CapturedStmt * getInnermostCapturedStmt()
Get innermost captured statement for the construct.
Definition: StmtOpenMP.h:228
void setUpperBoundVariable(Expr *UB)
Definition: StmtOpenMP.h:513
void setNumIterations(Expr *NI)
Definition: StmtOpenMP.h:548
This represents &#39;#pragma omp target teams distribute&#39; combined directive.
Definition: StmtOpenMP.h:3764
void setNextLowerBound(Expr *NLB)
Definition: StmtOpenMP.h:534
llvm::iterator_range< child_iterator > child_range
Definition: Stmt.h:458
This represents &#39;#pragma omp parallel for&#39; directive.
Definition: StmtOpenMP.h:1520
This represents &#39;#pragma omp target teams distribute parallel for&#39; combined directive.
Definition: StmtOpenMP.h:3832
Expr * getCombinedEnsureUpperBound() const
Definition: StmtOpenMP.h:897
void setIsLastIterVariable(Expr *IL)
Definition: StmtOpenMP.h:499
Expr * PrevLB
PreviousLowerBound - local variable passed to runtime in the enclosing schedule or null if that does ...
Definition: StmtOpenMP.h:679
SourceLocation getEndLoc() const
Definition: StmtOpenMP.h:172
bool hasCancel() const
Return true if current directive has inner cancel directive.
Definition: StmtOpenMP.h:1724
This represents &#39;#pragma omp target exit data&#39; directive.
Definition: StmtOpenMP.h:2431
bool hasCancel() const
Return true if current directive has inner cancel directive.
Definition: StmtOpenMP.h:2614
const Stmt * getBody() const
Definition: StmtOpenMP.h:927
Expr * getCombinedUpperBoundVariable() const
Definition: StmtOpenMP.h:891
void setUpdates(ArrayRef< Expr *> UL)
Sets the list of update expressions for linear variables.
Expr * getCalcLastIteration() const
Definition: StmtOpenMP.h:773
void setInit(Expr *Init)
Definition: StmtOpenMP.h:494
The expressions built to support OpenMP loops in combined/composite pragmas (e.g. ...
Definition: StmtOpenMP.h:619
bool isXLHSInRHSPart() const
Return true if helper update expression has form &#39;OpaqueValueExpr(x) binop OpaqueValueExpr(expr)&#39; and...
Definition: StmtOpenMP.h:2228
const Expr * getUpdateExpr() const
Definition: StmtOpenMP.h:2222
ArrayRef< Expr * > finals() const
Definition: StmtOpenMP.h:965
Expr * LastIteration
Loop last iteration number.
Definition: StmtOpenMP.h:650
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:1796
This represents &#39;#pragma omp parallel&#39; directive.
Definition: StmtOpenMP.h:278
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:3270
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:150
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:2616
Expr * getEnsureUpperBound() const
Definition: StmtOpenMP.h:829
const CapturedStmt * getCapturedStmt(OpenMPDirectiveKind RegionKind) const
Returns the captured statement associated with the component region within the (combined) directive...
Definition: StmtOpenMP.h:211
Definition: Format.h:2031
Expr * getInc() const
Definition: StmtOpenMP.h:789
ArrayRef< Expr * > updates()
Definition: StmtOpenMP.h:957
This represents &#39;#pragma omp target simd&#39; directive.
Definition: StmtOpenMP.h:3352
static unsigned getArraysOffset(OpenMPDirectiveKind Kind)
Offset to the start of children expression arrays.
Definition: StmtOpenMP.h:462
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:1840
Defines some OpenMP-specific enums and functions.
OpenMPDirectiveKind getDirectiveKind() const
Definition: StmtOpenMP.h:246
This represents &#39;#pragma omp barrier&#39; directive.
Definition: StmtOpenMP.h:1851
This is a common base class for loop directives (&#39;omp simd&#39;, &#39;omp for&#39;, &#39;omp for simd&#39; etc...
Definition: StmtOpenMP.h:340
This represents &#39;#pragma omp critical&#39; directive.
Definition: StmtOpenMP.h:1446
OpenMPDirectiveKind getCancelRegion() const
Get cancellation region for the current cancellation point.
Definition: StmtOpenMP.h:2730
void setCond(Expr *Cond)
Definition: StmtOpenMP.h:491
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:3405
This represents &#39;#pragma omp distribute parallel for&#39; composite directive.
Definition: StmtOpenMP.h:3067
This represents &#39;#pragma omp teams distribute parallel for simd&#39; composite directive.
Definition: StmtOpenMP.h:3556
ArrayRef< Expr * > finals()
Definition: StmtOpenMP.h:963
Expr * getIsLastIterVariable() const
Definition: StmtOpenMP.h:797
Expr * LB
DistributeLowerBound - used when composing &#39;omp distribute&#39; with &#39;omp for&#39; in a same construct...
Definition: StmtOpenMP.h:622
Expr * EUB
DistributeEnsureUpperBound - used when composing &#39;omp distribute&#39; with &#39;omp for&#39; in a same construct...
Definition: StmtOpenMP.h:628
Expr * getX()
Get &#39;x&#39; part of the associated expression/statement.
Definition: StmtOpenMP.h:2212
Expr * getIterationVariable() const
Definition: StmtOpenMP.h:765
bool hasCancel() const
Return true if current directive has inner cancel directive.
Definition: StmtOpenMP.h:3131
SourceLocation getLocStart() const LLVM_READONLY
Returns starting location of directive kind.
Definition: StmtOpenMP.h:168
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:3472
static bool classof(const Stmt *S)
Definition: StmtOpenMP.h:248
This represents &#39;#pragma omp cancellation point&#39; directive.
Definition: StmtOpenMP.h:2686
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:1997
void setCombinedInit(Expr *CombInit)
Definition: StmtOpenMP.h:590
MutableArrayRef< Expr * > getFinals()
Sets the list of final update expressions for linear variables.
This represents &#39;#pragma omp teams&#39; directive.
Definition: StmtOpenMP.h:2629
Expr * getInit() const
Definition: StmtOpenMP.h:785
Expr * CalcLastIteration
Calculation of last iteration.
Definition: StmtOpenMP.h:654
This represents &#39;#pragma omp teams distribute simd&#39; combined directive.
Definition: StmtOpenMP.h:3486
bool isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a worksharing directive.
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:2535
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:332
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:1271
StmtClass
Definition: Stmt.h:68
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:1726
void setFinals(ArrayRef< Expr *> FL)
Sets the list of final update expressions for linear variables.
Expr * NUB
Update of UpperBound for statically scheduled &#39;omp for&#39; loops.
Definition: StmtOpenMP.h:676
Expr * Cond
Loop condition.
Definition: StmtOpenMP.h:658
Expr * PreCond
Loop pre-condition.
Definition: StmtOpenMP.h:656
This represents &#39;#pragma omp target parallel for simd&#39; directive.
Definition: StmtOpenMP.h:3284
ArrayRef< Expr * > private_counters()
Definition: StmtOpenMP.h:945
The expressions built for the OpenMP loop CodeGen for the whole collapsed loop nest.
Definition: StmtOpenMP.h:646
bool hasCancel() const
Return true if current directive has inner cancel directive.
Definition: StmtOpenMP.h:1329
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:1585
This represents &#39;#pragma omp taskgroup&#39; directive.
Definition: StmtOpenMP.h:1939
Expr * getCombinedLowerBoundVariable() const
Definition: StmtOpenMP.h:885
Expr * IterationVarRef
Loop iteration variable.
Definition: StmtOpenMP.h:648
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:632
This represents &#39;#pragma omp distribute&#39; directive.
Definition: StmtOpenMP.h:2940
const Stmt * getAssociatedStmt() const
Returns statement associated with the directive.
Definition: StmtOpenMP.h:198
bool hasCancel() const
Return true if current directive has inner cancel directive.
Definition: StmtOpenMP.h:1583
bool hasCancel() const
Return true if current directive has inner cancel directive.
Definition: StmtOpenMP.h:3690
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:2860
Expr - This represents one expression.
Definition: Expr.h:106
MutableArrayRef< Expr * > getUpdates()
Sets the list of update expressions for linear variables.
static unsigned numLoopChildren(unsigned CollapsedNum, OpenMPDirectiveKind Kind)
Children number.
Definition: StmtOpenMP.h:472
Stmt * IgnoreContainers(bool IgnoreCaptured=false)
Skip no-op (attributed, compound) container stmts and skip captured stmt at the top, if IgnoreCaptured is true.
Definition: Stmt.cpp:133
ArrayRef< OMPClause * > clauses() const
Definition: StmtOpenMP.h:264
bool hasCancel() const
Return true if current directive has inner cancel directive.
Definition: StmtOpenMP.h:1133
This represents &#39;#pragma omp target teams distribute parallel for simd&#39; combined directive.
Definition: StmtOpenMP.h:3916
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:1884
static llvm::iterator_range< specific_clause_iterator< SpecificClause > > getClausesOfKind(ArrayRef< OMPClause *> Clauses)
Definition: StmtOpenMP.h:130
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:2994
This represents &#39;#pragma omp target teams distribute simd&#39; combined directive.
Definition: StmtOpenMP.h:3989
bool builtAll()
Check if all the expressions are built (does not check the worksharing ones).
Definition: StmtOpenMP.h:711
unsigned getNumClauses() const
Get number of clauses.
Definition: StmtOpenMP.h:186
Expr * getDistInc() const
Definition: StmtOpenMP.h:873
Expr * getNextLowerBound() const
Definition: StmtOpenMP.h:837
Expr * PrevUB
PreviousUpperBound - local variable passed to runtime in the enclosing schedule or null if that does ...
Definition: StmtOpenMP.h:682
Expr * getPrevEnsureUpperBound() const
Definition: StmtOpenMP.h:879
This represents &#39;#pragma omp for&#39; directive.
Definition: StmtOpenMP.h:1072
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:2795
ArrayRef< Expr * > counters() const
Definition: StmtOpenMP.h:941
static OMPLinearClause * CreateEmpty(const ASTContext &C, unsigned NumVars)
Creates an empty clause with the place for NumVars variables.
This represents &#39;#pragma omp target teams&#39; directive.
Definition: StmtOpenMP.h:3705
void setAssociatedStmt(Stmt *S)
Set the associated statement for the directive.
Definition: StmtOpenMP.h:85
bool isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a taskloop directive.
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:1135
StmtIterator child_iterator
Child Iterators: All subclasses must implement &#39;children&#39; to permit easy iteration over the substatem...
Definition: Stmt.h:455
This represents &#39;#pragma omp cancel&#39; directive.
Definition: StmtOpenMP.h:2744
void setDistInc(Expr *DistInc)
Definition: StmtOpenMP.h:565
Expr * NLB
Update of LowerBound for statically scheduled omp loops for outer loop in combined constructs (e...
Definition: StmtOpenMP.h:638
void setClauses(ArrayRef< OMPClause *> Clauses)
Sets the list of variables for this clause.
Definition: StmtOpenMP.cpp:20
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:2476
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:2056
This file defines OpenMP AST classes for clauses.
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:2243
This represents &#39;#pragma omp flush&#39; directive.
Definition: StmtOpenMP.h:2012
bool hasClausesOfKind() const
Returns true if the current directive has one or more clauses of a specific kind. ...
Definition: StmtOpenMP.h:162
This represents &#39;#pragma omp parallel for simd&#39; directive.
Definition: StmtOpenMP.h:1600
Expr * NumIterations
Loop number of iterations.
Definition: StmtOpenMP.h:652
void setLocStart(SourceLocation Loc)
Set starting location of directive kind.
Definition: StmtOpenMP.h:178
Expr * ST
Stride - local variable passed to runtime.
Definition: StmtOpenMP.h:670
Expr * getLastIteration() const
Definition: StmtOpenMP.h:769
const SpecificClause * getSingleClause() const
Gets a single clause of the specified kind associated with the current directive iff there is only on...
Definition: StmtOpenMP.h:148
bool isPostfixUpdate() const
Return true if &#39;v&#39; expression must be updated to original value of &#39;x&#39;, false if &#39;v&#39; must be updated ...
Definition: StmtOpenMP.h:2231
This represents &#39;#pragma omp target enter data&#39; directive.
Definition: StmtOpenMP.h:2372
SmallVector< Expr *, 4 > PrivateCounters
PrivateCounters Loop counters.
Definition: StmtOpenMP.h:696
void setLowerBoundVariable(Expr *LB)
Definition: StmtOpenMP.h:506
Expr * getStrideVariable() const
Definition: StmtOpenMP.h:821
ArrayRef< Expr * > updates() const
Definition: StmtOpenMP.h:959
const Stmt * getPreInits() const
Definition: StmtOpenMP.h:793
#define false
Definition: stdbool.h:33
Kind
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:2732
This captures a statement into a function.
Definition: Stmt.h:2125
SmallVector< Expr *, 4 > Counters
Counters Loop counters.
Definition: StmtOpenMP.h:694
specific_clause_iterator(ArrayRef< OMPClause *> Clauses)
Definition: StmtOpenMP.h:110
This represents &#39;#pragma omp single&#39; directive.
Definition: StmtOpenMP.h:1344
Encodes a location in the source.
void setPrevLowerBoundVariable(Expr *PrevLB)
Definition: StmtOpenMP.h:555
void setIterationVariable(Expr *IV)
Definition: StmtOpenMP.h:479
MutableArrayRef< Expr * > getInits()
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:33
void setCombinedNextLowerBound(Expr *CombNLB)
Definition: StmtOpenMP.h:600
OMPClause * getClause(unsigned i) const
Returns specified clause.
Definition: StmtOpenMP.h:192
Expr * getExpr()
Get &#39;expr&#39; part of the associated expression/statement.
Definition: StmtOpenMP.h:2238
OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:23
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:2674
DeclarationNameInfo getDirectiveName() const
Return name of the directive.
Definition: StmtOpenMP.h:1504
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:1331
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:1928
This represents &#39;#pragma omp taskwait&#39; directive.
Definition: StmtOpenMP.h:1895
Expr * PrevEUB
PrevEUB - expression similar to EUB but to be used when loop scheduling uses PrevLB and PrevUB (e...
Definition: StmtOpenMP.h:692
This is a basic class for representing single OpenMP clause.
Definition: OpenMPClause.h:51
bool isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind)
Checks if the specified directive kind is one of the composite or combined directives that need loop ...
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:3751
llvm::iterator_range< specific_clause_iterator< SpecificClause > > getClausesOfKind() const
Definition: StmtOpenMP.h:138
Stmt * getCapturedStmt()
Retrieve the statement being captured.
Definition: Stmt.h:2226
This represents &#39;#pragma omp target&#39; directive.
Definition: StmtOpenMP.h:2256
bool hasCancel() const
Return true if current directive has inner cancel directive.
Definition: StmtOpenMP.h:1794
Expr * getV()
Get &#39;v&#39; part of the associated expression/statement.
Definition: StmtOpenMP.h:2233
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:1506
DistCombinedHelperExprs DistCombinedFields
Expressions used when combining OpenMP loop pragmas.
Definition: StmtOpenMP.h:707
This represents &#39;#pragma omp ordered&#39; directive.
Definition: StmtOpenMP.h:2067
Expr * LB
LowerBound - local variable passed to runtime.
Definition: StmtOpenMP.h:666
void clear(unsigned Size)
Initialize all the fields to null.
Definition: StmtOpenMP.h:719
This represents &#39;#pragma omp target update&#39; directive.
Definition: StmtOpenMP.h:3008
Expr * Init
Loop iteration variable init.
Definition: StmtOpenMP.h:660
A placeholder type used to construct an empty shell of a type, that will be filled in later (e...
Definition: Stmt.h:338
ArrayRef< Expr * > private_counters() const
Definition: StmtOpenMP.h:947
#define alignof
Definition: stdalign.h:29
void setPrevUpperBoundVariable(Expr *PrevUB)
Definition: StmtOpenMP.h:560
void setCombinedEnsureUpperBound(Expr *CombEUB)
Definition: StmtOpenMP.h:585
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:3338
Dataflow Directional Tag Classes.
Expr * getPrevUpperBoundVariable() const
Definition: StmtOpenMP.h:867
const CapturedStmt * getInnermostCapturedStmt() const
Definition: StmtOpenMP.h:241
SmallVector< Expr *, 4 > Inits
Expressions for loop counters inits for CodeGen.
Definition: StmtOpenMP.h:698
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:2927
void setCombinedUpperBoundVariable(Expr *CombUB)
Definition: StmtOpenMP.h:580
Expr * getCond() const
Definition: StmtOpenMP.h:781
This represents &#39;#pragma omp section&#39; directive.
Definition: StmtOpenMP.h:1282
This represents &#39;#pragma omp teams distribute&#39; directive.
Definition: StmtOpenMP.h:3418
bool hasCancel() const
Return true if current directive has inner cancel directive.
Definition: StmtOpenMP.h:3899
This represents &#39;#pragma omp simd&#39; directive.
Definition: StmtOpenMP.h:1007
StmtClass getStmtClass() const
Definition: Stmt.h:391
const Expr * getReductionRef() const
Returns reference to the task_reduction return variable.
Definition: StmtOpenMP.h:1990
Expr * getUpdateExpr()
Get helper expression of the form &#39;OpaqueValueExpr(x) binop OpaqueValueExpr(expr)&#39; or &#39;OpaqueValueExp...
Definition: StmtOpenMP.h:2219
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:3818
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
This represents &#39;#pragma omp atomic&#39; directive.
Definition: StmtOpenMP.h:2122
Expr * getCombinedInit() const
Definition: StmtOpenMP.h:903
unsigned getCollapsedNumber() const
Get number of collapsed loops.
Definition: StmtOpenMP.h:763
Expr * getCombinedNextLowerBound() const
Definition: StmtOpenMP.h:915
ArrayRef< Expr * > counters()
Definition: StmtOpenMP.h:939
Expr * getCombinedNextUpperBound() const
Definition: StmtOpenMP.h:921
Iterates over a filtered subrange of clauses applied to a directive.
Definition: StmtOpenMP.h:96
void getOpenMPCaptureRegions(llvm::SmallVectorImpl< OpenMPDirectiveKind > &CaptureRegions, OpenMPDirectiveKind DKind)
Return the captured regions of an OpenMP directive.
bool isOpenMPDistributeDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a distribute directive.
ArrayRef< Expr * > inits()
Definition: StmtOpenMP.h:951
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:2358
Expr * Inc
Loop increment.
Definition: StmtOpenMP.h:662
const Expr * getExpr() const
Definition: StmtOpenMP.h:2239
Expr * getNumIterations() const
Definition: StmtOpenMP.h:853
bool hasAssociatedStmt() const
Returns true if directive has associated statement.
Definition: StmtOpenMP.h:195
Expr * getPrevLowerBoundVariable() const
Definition: StmtOpenMP.h:861
Expr * UB
DistributeUpperBound - used when composing &#39;omp distribute&#39; with &#39;omp for&#39; in a same construct...
Definition: StmtOpenMP.h:625
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:13820
Expr * UB
UpperBound - local variable passed to runtime.
Definition: StmtOpenMP.h:668
Defines the clang::SourceLocation class and associated facilities.
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:1654
This represents &#39;#pragma omp target parallel&#39; directive.
Definition: StmtOpenMP.h:2489
void setStrideVariable(Expr *ST)
Definition: StmtOpenMP.h:520
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:1058
Expr * getCombinedCond() const
Definition: StmtOpenMP.h:909
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:1435
This represents &#39;#pragma omp taskloop simd&#39; directive.
Definition: StmtOpenMP.h:2874
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:3133
Expr * getPreCond() const
Definition: StmtOpenMP.h:777
void setPreCond(Expr *PC)
Definition: StmtOpenMP.h:488
OMPExecutableDirective(const T *, StmtClass SC, OpenMPDirectiveKind K, SourceLocation StartLoc, SourceLocation EndLoc, unsigned NumClauses, unsigned NumChildren)
Build instance of directive of class K.
Definition: StmtOpenMP.h:67
This represents &#39;#pragma omp sections&#39; directive.
Definition: StmtOpenMP.h:1214
Expr * Cond
Distribute Loop condition used when composing &#39;omp distribute&#39; with &#39;omp for&#39; in a same construct...
Definition: StmtOpenMP.h:635
Stmt * PreInits
Init statement for all captured expressions.
Definition: StmtOpenMP.h:704
void setInits(ArrayRef< Expr *> IL)
Sets the list of the initial values for linear variables.
This represents &#39;#pragma omp target data&#39; directive.
Definition: StmtOpenMP.h:2314
OpenMPDirectiveKind getCancelRegion() const
Get cancellation region for the current cancellation point.
Definition: StmtOpenMP.h:2793
void setNextUpperBound(Expr *NUB)
Definition: StmtOpenMP.h:541
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:3542
const Expr * getX() const
Definition: StmtOpenMP.h:2213
void setInc(Expr *Inc)
Definition: StmtOpenMP.h:495
Expr * IL
IsLastIteration - local flag variable passed to runtime.
Definition: StmtOpenMP.h:664
SourceLocation getLocEnd() const LLVM_READONLY
Returns ending location of directive.
Definition: StmtOpenMP.h:171
This represents &#39;#pragma omp taskyield&#39; directive.
Definition: StmtOpenMP.h:1807
This represents &#39;#pragma omp distribute parallel for simd&#39; composite directive.
Definition: StmtOpenMP.h:3147
This represents &#39;#pragma omp parallel sections&#39; directive.
Definition: StmtOpenMP.h:1668
void setCalcLastIteration(Expr *CLI)
Definition: StmtOpenMP.h:485
void setCombinedNextUpperBound(Expr *CombNUB)
Definition: StmtOpenMP.h:605
bool hasCancel() const
Return true if current directive has inner cancel directive.
Definition: StmtOpenMP.h:1269
void setLocEnd(SourceLocation Loc)
Set ending location of directive.
Definition: StmtOpenMP.h:183
static bool classof(const Stmt *T)
Definition: StmtOpenMP.h:1200
This represents &#39;#pragma omp target parallel for&#39; directive.
Definition: StmtOpenMP.h:2549
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> PL, ArrayRef< Expr *> IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
This represents &#39;#pragma omp taskloop&#39; directive.
Definition: StmtOpenMP.h:2809