contrib/llvm/tools/clang/include/clang/AST/StmtOpenMP.h

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