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::RoundUpToAlignment(sizeof(T),
  74                                                llvm::alignOf<OMPClause *>())) {}
  75
  76   /// \brief Sets the list of variables for this clause.
  77   ///
  78   /// \param Clauses The list of clauses for the directive.
  79   ///
  80   void setClauses(ArrayRef<OMPClause *> Clauses);
  81
  82   /// \brief Set the associated statement for the directive.
  83   ///
  84   /// /param S Associated statement.
  85   ///
  86   void setAssociatedStmt(Stmt *S) {
  87     assert(hasAssociatedStmt() && "no associated statement.");
  88     *child_begin() = S;
  89   }
  90
  91 public:
  92   /// \brief Iterates over a filtered subrange of clauses applied to a
  93   /// directive.
  94   ///
  95   /// This iterator visits only those declarations that meet some run-time
  96   /// criteria.
  97   template <class FilterPredicate> class filtered_clause_iterator {
  98   protected:
  99     ArrayRef<OMPClause *>::const_iterator Current;
 100     ArrayRef<OMPClause *>::const_iterator End;
 101     FilterPredicate Pred;
 102     void SkipToNextClause() {
 103       while (Current != End && !Pred(*Current))
 104         ++Current;
 105     }
 106
 107   public:
 108     typedef const OMPClause *value_type;
 109     filtered_clause_iterator() : Current(), End() {}
 110     filtered_clause_iterator(ArrayRef<OMPClause *> Arr, FilterPredicate Pred)
 111         : Current(Arr.begin()), End(Arr.end()), Pred(std::move(Pred)) {
 112       SkipToNextClause();
 113     }
 114     value_type operator*() const { return *Current; }
 115     value_type operator->() const { return *Current; }
 116     filtered_clause_iterator &operator++() {
 117       ++Current;
 118       SkipToNextClause();
 119       return *this;
 120     }
 121
 122     filtered_clause_iterator operator++(int) {
 123       filtered_clause_iterator tmp(*this);
 124       ++(*this);
 125       return tmp;
 126     }
 127
 128     bool operator!() { return Current == End; }
 129     explicit operator bool() { return Current != End; }
 130     bool empty() const { return Current == End; }
 131   };
 132
 133   template <typename Fn>
 134   filtered_clause_iterator<Fn> getFilteredClauses(Fn &&fn) const {
 135     return filtered_clause_iterator<Fn>(clauses(), std::move(fn));
 136   }
 137   struct ClauseKindFilter {
 138     OpenMPClauseKind Kind;
 139     bool operator()(const OMPClause *clause) const {
 140       return clause->getClauseKind() == Kind;
 141     }
 142   };
 143   filtered_clause_iterator<ClauseKindFilter>
 144   getClausesOfKind(OpenMPClauseKind Kind) const {
 145     return getFilteredClauses(ClauseKindFilter{Kind});
 146   }
 147
 148   /// \brief Gets a single clause of the specified kind \a K associated with the
 149   /// current directive iff there is only one clause of this kind (and assertion
 150   /// is fired if there is more than one clause is associated with the
 151   /// directive). Returns nullptr if no clause of kind \a K is associated with
 152   /// the directive.
 153   const OMPClause *getSingleClause(OpenMPClauseKind K) const;
 154
 155   /// \brief Returns starting location of directive kind.
 156   SourceLocation getLocStart() const { return StartLoc; }
 157   /// \brief Returns ending location of directive.
 158   SourceLocation getLocEnd() const { return EndLoc; }
 159
 160   /// \brief Set starting location of directive kind.
 161   ///
 162   /// \param Loc New starting location of directive.
 163   ///
 164   void setLocStart(SourceLocation Loc) { StartLoc = Loc; }
 165   /// \brief Set ending location of directive.
 166   ///
 167   /// \param Loc New ending location of directive.
 168   ///
 169   void setLocEnd(SourceLocation Loc) { EndLoc = Loc; }
 170
 171   /// \brief Get number of clauses.
 172   unsigned getNumClauses() const { return NumClauses; }
 173
 174   /// \brief Returns specified clause.
 175   ///
 176   /// \param i Number of clause.
 177   ///
 178   OMPClause *getClause(unsigned i) const { return clauses()[i]; }
 179
 180   /// \brief Returns true if directive has associated statement.
 181   bool hasAssociatedStmt() const { return NumChildren > 0; }
 182
 183   /// \brief Returns statement associated with the directive.
 184   Stmt *getAssociatedStmt() const {
 185     assert(hasAssociatedStmt() && "no associated statement.");
 186     return const_cast<Stmt *>(*child_begin());
 187   }
 188
 189   OpenMPDirectiveKind getDirectiveKind() const { return Kind; }
 190
 191   static bool classof(const Stmt *S) {
 192     return S->getStmtClass() >= firstOMPExecutableDirectiveConstant &&
 193            S->getStmtClass() <= lastOMPExecutableDirectiveConstant;
 194   }
 195
 196   child_range children() {
 197     if (!hasAssociatedStmt())
 198       return child_range();
 199     Stmt **ChildStorage = reinterpret_cast<Stmt **>(getClauses().end());
 200     return child_range(ChildStorage, ChildStorage + NumChildren);
 201   }
 202
 203   ArrayRef<OMPClause *> clauses() { return getClauses(); }
 204
 205   ArrayRef<OMPClause *> clauses() const {
 206     return const_cast<OMPExecutableDirective *>(this)->getClauses();
 207   }
 208 };
 209
 210 /// \brief This represents '#pragma omp parallel' directive.
 211 ///
 212 /// \code
 213 /// #pragma omp parallel private(a,b) reduction(+: c,d)
 214 /// \endcode
 215 /// In this example directive '#pragma omp parallel' has clauses 'private'
 216 /// with the variables 'a' and 'b' and 'reduction' with operator '+' and
 217 /// variables 'c' and 'd'.
 218 ///
 219 class OMPParallelDirective : public OMPExecutableDirective {
 220   /// \brief Build directive with the given start and end location.
 221   ///
 222   /// \param StartLoc Starting location of the directive (directive keyword).
 223   /// \param EndLoc Ending Location of the directive.
 224   ///
 225   OMPParallelDirective(SourceLocation StartLoc, SourceLocation EndLoc,
 226                        unsigned NumClauses)
 227       : OMPExecutableDirective(this, OMPParallelDirectiveClass, OMPD_parallel,
 228                                StartLoc, EndLoc, NumClauses, 1) {}
 229
 230   /// \brief Build an empty directive.
 231   ///
 232   /// \param NumClauses Number of clauses.
 233   ///
 234   explicit OMPParallelDirective(unsigned NumClauses)
 235       : OMPExecutableDirective(this, OMPParallelDirectiveClass, OMPD_parallel,
 236                                SourceLocation(), SourceLocation(), NumClauses,
 237                                1) {}
 238
 239 public:
 240   /// \brief Creates directive with a list of \a Clauses.
 241   ///
 242   /// \param C AST context.
 243   /// \param StartLoc Starting location of the directive kind.
 244   /// \param EndLoc Ending Location of the directive.
 245   /// \param Clauses List of clauses.
 246   /// \param AssociatedStmt Statement associated with the directive.
 247   ///
 248   static OMPParallelDirective *
 249   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
 250          ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
 251
 252   /// \brief Creates an empty directive with the place for \a N clauses.
 253   ///
 254   /// \param C AST context.
 255   /// \param NumClauses Number of clauses.
 256   ///
 257   static OMPParallelDirective *CreateEmpty(const ASTContext &C,
 258                                            unsigned NumClauses, EmptyShell);
 259
 260   static bool classof(const Stmt *T) {
 261     return T->getStmtClass() == OMPParallelDirectiveClass;
 262   }
 263 };
 264
 265 /// \brief This is a common base class for loop directives ('omp simd', 'omp
 266 /// for', 'omp for simd' etc.). It is responsible for the loop code generation.
 267 ///
 268 class OMPLoopDirective : public OMPExecutableDirective {
 269   friend class ASTStmtReader;
 270   /// \brief Number of collapsed loops as specified by 'collapse' clause.
 271   unsigned CollapsedNum;
 272
 273   /// \brief Offsets to the stored exprs.
 274   /// This enumeration contains offsets to all the pointers to children
 275   /// expressions stored in OMPLoopDirective.
 276   /// The first 9 children are nesessary for all the loop directives, and
 277   /// the next 7 are specific to the worksharing ones.
 278   /// After the fixed children, three arrays of length CollapsedNum are
 279   /// allocated: loop counters, their updates and final values.
 280   ///
 281   enum {
 282     AssociatedStmtOffset = 0,
 283     IterationVariableOffset = 1,
 284     LastIterationOffset = 2,
 285     CalcLastIterationOffset = 3,
 286     PreConditionOffset = 4,
 287     CondOffset = 5,
 288     InitOffset = 6,
 289     IncOffset = 7,
 290     // The '...End' enumerators do not correspond to child expressions - they
 291     // specify the offset to the end (and start of the following counters/
 292     // updates/finals arrays).
 293     DefaultEnd = 8,
 294     // The following 7 exprs are used by worksharing loops only.
 295     IsLastIterVariableOffset = 8,
 296     LowerBoundVariableOffset = 9,
 297     UpperBoundVariableOffset = 10,
 298     StrideVariableOffset = 11,
 299     EnsureUpperBoundOffset = 12,
 300     NextLowerBoundOffset = 13,
 301     NextUpperBoundOffset = 14,
 302     // Offset to the end (and start of the following counters/updates/finals
 303     // arrays) for worksharing loop directives.
 304     WorksharingEnd = 15,
 305   };
 306
 307   /// \brief Get the counters storage.
 308   MutableArrayRef<Expr *> getCounters() {
 309     Expr **Storage = reinterpret_cast<Expr **>(
 310         &(*(std::next(child_begin(), getArraysOffset(getDirectiveKind())))));
 311     return MutableArrayRef<Expr *>(Storage, CollapsedNum);
 312   }
 313
 314   /// \brief Get the updates storage.
 315   MutableArrayRef<Expr *> getInits() {
 316     Expr **Storage = reinterpret_cast<Expr **>(
 317         &*std::next(child_begin(),
 318                     getArraysOffset(getDirectiveKind()) + CollapsedNum));
 319     return MutableArrayRef<Expr *>(Storage, CollapsedNum);
 320   }
 321
 322   /// \brief Get the updates storage.
 323   MutableArrayRef<Expr *> getUpdates() {
 324     Expr **Storage = reinterpret_cast<Expr **>(
 325         &*std::next(child_begin(),
 326                     getArraysOffset(getDirectiveKind()) + 2 * CollapsedNum));
 327     return MutableArrayRef<Expr *>(Storage, CollapsedNum);
 328   }
 329
 330   /// \brief Get the final counter updates storage.
 331   MutableArrayRef<Expr *> getFinals() {
 332     Expr **Storage = reinterpret_cast<Expr **>(
 333         &*std::next(child_begin(),
 334                     getArraysOffset(getDirectiveKind()) + 3 * CollapsedNum));
 335     return MutableArrayRef<Expr *>(Storage, CollapsedNum);
 336   }
 337
 338 protected:
 339   /// \brief Build instance of loop directive of class \a Kind.
 340   ///
 341   /// \param SC Statement class.
 342   /// \param Kind Kind of OpenMP directive.
 343   /// \param StartLoc Starting location of the directive (directive keyword).
 344   /// \param EndLoc Ending location of the directive.
 345   /// \param CollapsedNum Number of collapsed loops from 'collapse' clause.
 346   /// \param NumClauses Number of clauses.
 347   /// \param NumSpecialChildren Number of additional directive-specific stmts.
 348   ///
 349   template <typename T>
 350   OMPLoopDirective(const T *That, StmtClass SC, OpenMPDirectiveKind Kind,
 351                    SourceLocation StartLoc, SourceLocation EndLoc,
 352                    unsigned CollapsedNum, unsigned NumClauses,
 353                    unsigned NumSpecialChildren = 0)
 354       : OMPExecutableDirective(That, SC, Kind, StartLoc, EndLoc, NumClauses,
 355                                numLoopChildren(CollapsedNum, Kind) +
 356                                    NumSpecialChildren),
 357         CollapsedNum(CollapsedNum) {}
 358
 359   /// \brief Offset to the start of children expression arrays.
 360   static unsigned getArraysOffset(OpenMPDirectiveKind Kind) {
 361     return isOpenMPWorksharingDirective(Kind) ? WorksharingEnd
 362                                               : DefaultEnd;
 363   }
 364
 365   /// \brief Children number.
 366   static unsigned numLoopChildren(unsigned CollapsedNum,
 367                                   OpenMPDirectiveKind Kind) {
 368     return getArraysOffset(Kind) +
 369            4 * CollapsedNum; // Counters, Inits, Updates and Finals
 370   }
 371
 372   void setIterationVariable(Expr *IV) {
 373     *std::next(child_begin(), IterationVariableOffset) = IV;
 374   }
 375   void setLastIteration(Expr *LI) {
 376     *std::next(child_begin(), LastIterationOffset) = LI;
 377   }
 378   void setCalcLastIteration(Expr *CLI) {
 379     *std::next(child_begin(), CalcLastIterationOffset) = CLI;
 380   }
 381   void setPreCond(Expr *PC) {
 382     *std::next(child_begin(), PreConditionOffset) = PC;
 383   }
 384   void setCond(Expr *Cond) {
 385     *std::next(child_begin(), CondOffset) = Cond;
 386   }
 387   void setInit(Expr *Init) { *std::next(child_begin(), InitOffset) = Init; }
 388   void setInc(Expr *Inc) { *std::next(child_begin(), IncOffset) = Inc; }
 389   void setIsLastIterVariable(Expr *IL) {
 390     assert(isOpenMPWorksharingDirective(getDirectiveKind()) &&
 391            "expected worksharing loop directive");
 392     *std::next(child_begin(), IsLastIterVariableOffset) = IL;
 393   }
 394   void setLowerBoundVariable(Expr *LB) {
 395     assert(isOpenMPWorksharingDirective(getDirectiveKind()) &&
 396            "expected worksharing loop directive");
 397     *std::next(child_begin(), LowerBoundVariableOffset) = LB;
 398   }
 399   void setUpperBoundVariable(Expr *UB) {
 400     assert(isOpenMPWorksharingDirective(getDirectiveKind()) &&
 401            "expected worksharing loop directive");
 402     *std::next(child_begin(), UpperBoundVariableOffset) = UB;
 403   }
 404   void setStrideVariable(Expr *ST) {
 405     assert(isOpenMPWorksharingDirective(getDirectiveKind()) &&
 406            "expected worksharing loop directive");
 407     *std::next(child_begin(), StrideVariableOffset) = ST;
 408   }
 409   void setEnsureUpperBound(Expr *EUB) {
 410     assert(isOpenMPWorksharingDirective(getDirectiveKind()) &&
 411            "expected worksharing loop directive");
 412     *std::next(child_begin(), EnsureUpperBoundOffset) = EUB;
 413   }
 414   void setNextLowerBound(Expr *NLB) {
 415     assert(isOpenMPWorksharingDirective(getDirectiveKind()) &&
 416            "expected worksharing loop directive");
 417     *std::next(child_begin(), NextLowerBoundOffset) = NLB;
 418   }
 419   void setNextUpperBound(Expr *NUB) {
 420     assert(isOpenMPWorksharingDirective(getDirectiveKind()) &&
 421            "expected worksharing loop directive");
 422     *std::next(child_begin(), NextUpperBoundOffset) = NUB;
 423   }
 424   void setCounters(ArrayRef<Expr *> A);
 425   void setInits(ArrayRef<Expr *> A);
 426   void setUpdates(ArrayRef<Expr *> A);
 427   void setFinals(ArrayRef<Expr *> A);
 428
 429 public:
 430   /// \brief The expressions built for the OpenMP loop CodeGen for the
 431   /// whole collapsed loop nest.
 432   struct HelperExprs {
 433     /// \brief Loop iteration variable.
 434     Expr *IterationVarRef;
 435     /// \brief Loop last iteration number.
 436     Expr *LastIteration;
 437     /// \brief Loop number of iterations.
 438     Expr *NumIterations;
 439     /// \brief Calculation of last iteration.
 440     Expr *CalcLastIteration;
 441     /// \brief Loop pre-condition.
 442     Expr *PreCond;
 443     /// \brief Loop condition.
 444     Expr *Cond;
 445     /// \brief Loop iteration variable init.
 446     Expr *Init;
 447     /// \brief Loop increment.
 448     Expr *Inc;
 449     /// \brief IsLastIteration - local flag variable passed to runtime.
 450     Expr *IL;
 451     /// \brief LowerBound - local variable passed to runtime.
 452     Expr *LB;
 453     /// \brief UpperBound - local variable passed to runtime.
 454     Expr *UB;
 455     /// \brief Stride - local variable passed to runtime.
 456     Expr *ST;
 457     /// \brief EnsureUpperBound -- expression LB = min(LB, NumIterations).
 458     Expr *EUB;
 459     /// \brief Update of LowerBound for statically sheduled 'omp for' loops.
 460     Expr *NLB;
 461     /// \brief Update of UpperBound for statically sheduled 'omp for' loops.
 462     Expr *NUB;
 463     /// \brief Counters Loop counters.
 464     SmallVector<Expr *, 4> Counters;
 465     /// \brief Expressions for loop counters inits for CodeGen.
 466     SmallVector<Expr *, 4> Inits;
 467     /// \brief Expressions for loop counters update for CodeGen.
 468     SmallVector<Expr *, 4> Updates;
 469     /// \brief Final loop counter values for GodeGen.
 470     SmallVector<Expr *, 4> Finals;
 471
 472     /// \brief Check if all the expressions are built (does not check the
 473     /// worksharing ones).
 474     bool builtAll() {
 475       return IterationVarRef != nullptr && LastIteration != nullptr &&
 476              NumIterations != nullptr && PreCond != nullptr &&
 477              Cond != nullptr && Init != nullptr && Inc != nullptr;
 478     }
 479
 480     /// \brief Initialize all the fields to null.
 481     /// \param Size Number of elements in the counters/finals/updates arrays.
 482     void clear(unsigned Size) {
 483       IterationVarRef = nullptr;
 484       LastIteration = nullptr;
 485       CalcLastIteration = nullptr;
 486       PreCond = nullptr;
 487       Cond = nullptr;
 488       Init = nullptr;
 489       Inc = nullptr;
 490       IL = nullptr;
 491       LB = nullptr;
 492       UB = nullptr;
 493       ST = nullptr;
 494       EUB = nullptr;
 495       NLB = nullptr;
 496       NUB = nullptr;
 497       Counters.resize(Size);
 498       Inits.resize(Size);
 499       Updates.resize(Size);
 500       Finals.resize(Size);
 501       for (unsigned i = 0; i < Size; ++i) {
 502         Counters[i] = nullptr;
 503         Inits[i] = nullptr;
 504         Updates[i] = nullptr;
 505         Finals[i] = nullptr;
 506       }
 507     }
 508   };
 509
 510   /// \brief Get number of collapsed loops.
 511   unsigned getCollapsedNumber() const { return CollapsedNum; }
 512
 513   Expr *getIterationVariable() const {
 514     return const_cast<Expr *>(reinterpret_cast<const Expr *>(
 515         *std::next(child_begin(), IterationVariableOffset)));
 516   }
 517   Expr *getLastIteration() const {
 518     return const_cast<Expr *>(reinterpret_cast<const Expr *>(
 519         *std::next(child_begin(), LastIterationOffset)));
 520   }
 521   Expr *getCalcLastIteration() const {
 522     return const_cast<Expr *>(reinterpret_cast<const Expr *>(
 523         *std::next(child_begin(), CalcLastIterationOffset)));
 524   }
 525   Expr *getPreCond() const {
 526     return const_cast<Expr *>(reinterpret_cast<const Expr *>(
 527         *std::next(child_begin(), PreConditionOffset)));
 528   }
 529   Expr *getCond() const {
 530     return const_cast<Expr *>(
 531         reinterpret_cast<const Expr *>(*std::next(child_begin(), CondOffset)));
 532   }
 533   Expr *getInit() const {
 534     return const_cast<Expr *>(
 535         reinterpret_cast<const Expr *>(*std::next(child_begin(), InitOffset)));
 536   }
 537   Expr *getInc() const {
 538     return const_cast<Expr *>(
 539         reinterpret_cast<const Expr *>(*std::next(child_begin(), IncOffset)));
 540   }
 541   Expr *getIsLastIterVariable() const {
 542     assert(isOpenMPWorksharingDirective(getDirectiveKind()) &&
 543            "expected worksharing loop directive");
 544     return const_cast<Expr *>(reinterpret_cast<const Expr *>(
 545         *std::next(child_begin(), IsLastIterVariableOffset)));
 546   }
 547   Expr *getLowerBoundVariable() const {
 548     assert(isOpenMPWorksharingDirective(getDirectiveKind()) &&
 549            "expected worksharing loop directive");
 550     return const_cast<Expr *>(reinterpret_cast<const Expr *>(
 551         *std::next(child_begin(), LowerBoundVariableOffset)));
 552   }
 553   Expr *getUpperBoundVariable() const {
 554     assert(isOpenMPWorksharingDirective(getDirectiveKind()) &&
 555            "expected worksharing loop directive");
 556     return const_cast<Expr *>(reinterpret_cast<const Expr *>(
 557         *std::next(child_begin(), UpperBoundVariableOffset)));
 558   }
 559   Expr *getStrideVariable() const {
 560     assert(isOpenMPWorksharingDirective(getDirectiveKind()) &&
 561            "expected worksharing loop directive");
 562     return const_cast<Expr *>(reinterpret_cast<const Expr *>(
 563         *std::next(child_begin(), StrideVariableOffset)));
 564   }
 565   Expr *getEnsureUpperBound() const {
 566     assert(isOpenMPWorksharingDirective(getDirectiveKind()) &&
 567            "expected worksharing loop directive");
 568     return const_cast<Expr *>(reinterpret_cast<const Expr *>(
 569         *std::next(child_begin(), EnsureUpperBoundOffset)));
 570   }
 571   Expr *getNextLowerBound() const {
 572     assert(isOpenMPWorksharingDirective(getDirectiveKind()) &&
 573            "expected worksharing loop directive");
 574     return const_cast<Expr *>(reinterpret_cast<const Expr *>(
 575         *std::next(child_begin(), NextLowerBoundOffset)));
 576   }
 577   Expr *getNextUpperBound() const {
 578     assert(isOpenMPWorksharingDirective(getDirectiveKind()) &&
 579            "expected worksharing loop directive");
 580     return const_cast<Expr *>(reinterpret_cast<const Expr *>(
 581         *std::next(child_begin(), NextUpperBoundOffset)));
 582   }
 583   const Stmt *getBody() const {
 584     // This relies on the loop form is already checked by Sema.
 585     Stmt *Body = getAssociatedStmt()->IgnoreContainers(true);
 586     Body = cast<ForStmt>(Body)->getBody();
 587     for (unsigned Cnt = 1; Cnt < CollapsedNum; ++Cnt) {
 588       Body = Body->IgnoreContainers();
 589       Body = cast<ForStmt>(Body)->getBody();
 590     }
 591     return Body;
 592   }
 593
 594   ArrayRef<Expr *> counters() { return getCounters(); }
 595
 596   ArrayRef<Expr *> counters() const {
 597     return const_cast<OMPLoopDirective *>(this)->getCounters();
 598   }
 599
 600   ArrayRef<Expr *> inits() { return getInits(); }
 601
 602   ArrayRef<Expr *> inits() const {
 603     return const_cast<OMPLoopDirective *>(this)->getInits();
 604   }
 605
 606   ArrayRef<Expr *> updates() { return getUpdates(); }
 607
 608   ArrayRef<Expr *> updates() const {
 609     return const_cast<OMPLoopDirective *>(this)->getUpdates();
 610   }
 611
 612   ArrayRef<Expr *> finals() { return getFinals(); }
 613
 614   ArrayRef<Expr *> finals() const {
 615     return const_cast<OMPLoopDirective *>(this)->getFinals();
 616   }
 617
 618   static bool classof(const Stmt *T) {
 619     return T->getStmtClass() == OMPSimdDirectiveClass ||
 620            T->getStmtClass() == OMPForDirectiveClass ||
 621            T->getStmtClass() == OMPForSimdDirectiveClass ||
 622            T->getStmtClass() == OMPParallelForDirectiveClass ||
 623            T->getStmtClass() == OMPParallelForSimdDirectiveClass;
 624   }
 625 };
 626
 627 /// \brief This represents '#pragma omp simd' directive.
 628 ///
 629 /// \code
 630 /// #pragma omp simd private(a,b) linear(i,j:s) reduction(+:c,d)
 631 /// \endcode
 632 /// In this example directive '#pragma omp simd' has clauses 'private'
 633 /// with the variables 'a' and 'b', 'linear' with variables 'i', 'j' and
 634 /// linear step 's', 'reduction' with operator '+' and variables 'c' and 'd'.
 635 ///
 636 class OMPSimdDirective : public OMPLoopDirective {
 637   friend class ASTStmtReader;
 638   /// \brief Build directive with the given start and end location.
 639   ///
 640   /// \param StartLoc Starting location of the directive kind.
 641   /// \param EndLoc Ending location of the directive.
 642   /// \param CollapsedNum Number of collapsed nested loops.
 643   /// \param NumClauses Number of clauses.
 644   ///
 645   OMPSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
 646                    unsigned CollapsedNum, unsigned NumClauses)
 647       : OMPLoopDirective(this, OMPSimdDirectiveClass, OMPD_simd, StartLoc,
 648                          EndLoc, CollapsedNum, NumClauses) {}
 649
 650   /// \brief Build an empty directive.
 651   ///
 652   /// \param CollapsedNum Number of collapsed nested loops.
 653   /// \param NumClauses Number of clauses.
 654   ///
 655   explicit OMPSimdDirective(unsigned CollapsedNum, unsigned NumClauses)
 656       : OMPLoopDirective(this, OMPSimdDirectiveClass, OMPD_simd,
 657                          SourceLocation(), SourceLocation(), CollapsedNum,
 658                          NumClauses) {}
 659
 660 public:
 661   /// \brief Creates directive with a list of \a Clauses.
 662   ///
 663   /// \param C AST context.
 664   /// \param StartLoc Starting location of the directive kind.
 665   /// \param EndLoc Ending Location of the directive.
 666   /// \param CollapsedNum Number of collapsed loops.
 667   /// \param Clauses List of clauses.
 668   /// \param AssociatedStmt Statement, associated with the directive.
 669   /// \param Exprs Helper expressions for CodeGen.
 670   ///
 671   static OMPSimdDirective *Create(const ASTContext &C, SourceLocation StartLoc,
 672                                   SourceLocation EndLoc, unsigned CollapsedNum,
 673                                   ArrayRef<OMPClause *> Clauses,
 674                                   Stmt *AssociatedStmt,
 675                                   const HelperExprs &Exprs);
 676
 677   /// \brief Creates an empty directive with the place
 678   /// for \a NumClauses clauses.
 679   ///
 680   /// \param C AST context.
 681   /// \param CollapsedNum Number of collapsed nested loops.
 682   /// \param NumClauses Number of clauses.
 683   ///
 684   static OMPSimdDirective *CreateEmpty(const ASTContext &C, unsigned NumClauses,
 685                                        unsigned CollapsedNum, EmptyShell);
 686
 687   static bool classof(const Stmt *T) {
 688     return T->getStmtClass() == OMPSimdDirectiveClass;
 689   }
 690 };
 691
 692 /// \brief This represents '#pragma omp for' directive.
 693 ///
 694 /// \code
 695 /// #pragma omp for private(a,b) reduction(+:c,d)
 696 /// \endcode
 697 /// In this example directive '#pragma omp for' has clauses 'private' with the
 698 /// variables 'a' and 'b' and 'reduction' with operator '+' and variables 'c'
 699 /// and 'd'.
 700 ///
 701 class OMPForDirective : public OMPLoopDirective {
 702   friend class ASTStmtReader;
 703   /// \brief Build directive with the given start and end location.
 704   ///
 705   /// \param StartLoc Starting location of the directive kind.
 706   /// \param EndLoc Ending location of the directive.
 707   /// \param CollapsedNum Number of collapsed nested loops.
 708   /// \param NumClauses Number of clauses.
 709   ///
 710   OMPForDirective(SourceLocation StartLoc, SourceLocation EndLoc,
 711                   unsigned CollapsedNum, unsigned NumClauses)
 712       : OMPLoopDirective(this, OMPForDirectiveClass, OMPD_for, StartLoc, EndLoc,
 713                          CollapsedNum, NumClauses) {}
 714
 715   /// \brief Build an empty directive.
 716   ///
 717   /// \param CollapsedNum Number of collapsed nested loops.
 718   /// \param NumClauses Number of clauses.
 719   ///
 720   explicit OMPForDirective(unsigned CollapsedNum, unsigned NumClauses)
 721       : OMPLoopDirective(this, OMPForDirectiveClass, OMPD_for, SourceLocation(),
 722                          SourceLocation(), CollapsedNum, NumClauses) {}
 723
 724 public:
 725   /// \brief Creates directive with a list of \a Clauses.
 726   ///
 727   /// \param C AST context.
 728   /// \param StartLoc Starting location of the directive kind.
 729   /// \param EndLoc Ending Location of the directive.
 730   /// \param CollapsedNum Number of collapsed loops.
 731   /// \param Clauses List of clauses.
 732   /// \param AssociatedStmt Statement, associated with the directive.
 733   /// \param Exprs Helper expressions for CodeGen.
 734   ///
 735   static OMPForDirective *Create(const ASTContext &C, SourceLocation StartLoc,
 736                                  SourceLocation EndLoc, unsigned CollapsedNum,
 737                                  ArrayRef<OMPClause *> Clauses,
 738                                  Stmt *AssociatedStmt,
 739                                  const HelperExprs &Exprs);
 740
 741   /// \brief Creates an empty directive with the place
 742   /// for \a NumClauses clauses.
 743   ///
 744   /// \param C AST context.
 745   /// \param CollapsedNum Number of collapsed nested loops.
 746   /// \param NumClauses Number of clauses.
 747   ///
 748   static OMPForDirective *CreateEmpty(const ASTContext &C, unsigned NumClauses,
 749                                       unsigned CollapsedNum, EmptyShell);
 750
 751   static bool classof(const Stmt *T) {
 752     return T->getStmtClass() == OMPForDirectiveClass;
 753   }
 754 };
 755
 756 /// \brief This represents '#pragma omp for simd' directive.
 757 ///
 758 /// \code
 759 /// #pragma omp for simd private(a,b) linear(i,j:s) reduction(+:c,d)
 760 /// \endcode
 761 /// In this example directive '#pragma omp for simd' has clauses 'private'
 762 /// with the variables 'a' and 'b', 'linear' with variables 'i', 'j' and
 763 /// linear step 's', 'reduction' with operator '+' and variables 'c' and 'd'.
 764 ///
 765 class OMPForSimdDirective : public OMPLoopDirective {
 766   friend class ASTStmtReader;
 767   /// \brief Build directive with the given start and end location.
 768   ///
 769   /// \param StartLoc Starting location of the directive kind.
 770   /// \param EndLoc Ending location of the directive.
 771   /// \param CollapsedNum Number of collapsed nested loops.
 772   /// \param NumClauses Number of clauses.
 773   ///
 774   OMPForSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
 775                       unsigned CollapsedNum, unsigned NumClauses)
 776       : OMPLoopDirective(this, OMPForSimdDirectiveClass, OMPD_for_simd,
 777                          StartLoc, EndLoc, CollapsedNum, NumClauses) {}
 778
 779   /// \brief Build an empty directive.
 780   ///
 781   /// \param CollapsedNum Number of collapsed nested loops.
 782   /// \param NumClauses Number of clauses.
 783   ///
 784   explicit OMPForSimdDirective(unsigned CollapsedNum, unsigned NumClauses)
 785       : OMPLoopDirective(this, OMPForSimdDirectiveClass, OMPD_for_simd,
 786                          SourceLocation(), SourceLocation(), CollapsedNum,
 787                          NumClauses) {}
 788
 789 public:
 790   /// \brief Creates directive with a list of \a Clauses.
 791   ///
 792   /// \param C AST context.
 793   /// \param StartLoc Starting location of the directive kind.
 794   /// \param EndLoc Ending Location of the directive.
 795   /// \param CollapsedNum Number of collapsed loops.
 796   /// \param Clauses List of clauses.
 797   /// \param AssociatedStmt Statement, associated with the directive.
 798   /// \param Exprs Helper expressions for CodeGen.
 799   ///
 800   static OMPForSimdDirective *
 801   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
 802          unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
 803          Stmt *AssociatedStmt, const HelperExprs &Exprs);
 804
 805   /// \brief Creates an empty directive with the place
 806   /// for \a NumClauses clauses.
 807   ///
 808   /// \param C AST context.
 809   /// \param CollapsedNum Number of collapsed nested loops.
 810   /// \param NumClauses Number of clauses.
 811   ///
 812   static OMPForSimdDirective *CreateEmpty(const ASTContext &C,
 813                                           unsigned NumClauses,
 814                                           unsigned CollapsedNum, EmptyShell);
 815
 816   static bool classof(const Stmt *T) {
 817     return T->getStmtClass() == OMPForSimdDirectiveClass;
 818   }
 819 };
 820
 821 /// \brief This represents '#pragma omp sections' directive.
 822 ///
 823 /// \code
 824 /// #pragma omp sections private(a,b) reduction(+:c,d)
 825 /// \endcode
 826 /// In this example directive '#pragma omp sections' has clauses 'private' with
 827 /// the variables 'a' and 'b' and 'reduction' with operator '+' and variables
 828 /// 'c' and 'd'.
 829 ///
 830 class OMPSectionsDirective : public OMPExecutableDirective {
 831   friend class ASTStmtReader;
 832   /// \brief Build directive with the given start and end location.
 833   ///
 834   /// \param StartLoc Starting location of the directive kind.
 835   /// \param EndLoc Ending location of the directive.
 836   /// \param NumClauses Number of clauses.
 837   ///
 838   OMPSectionsDirective(SourceLocation StartLoc, SourceLocation EndLoc,
 839                        unsigned NumClauses)
 840       : OMPExecutableDirective(this, OMPSectionsDirectiveClass, OMPD_sections,
 841                                StartLoc, EndLoc, NumClauses, 1) {}
 842
 843   /// \brief Build an empty directive.
 844   ///
 845   /// \param NumClauses Number of clauses.
 846   ///
 847   explicit OMPSectionsDirective(unsigned NumClauses)
 848       : OMPExecutableDirective(this, OMPSectionsDirectiveClass, OMPD_sections,
 849                                SourceLocation(), SourceLocation(), NumClauses,
 850                                1) {}
 851
 852 public:
 853   /// \brief Creates directive with a list of \a Clauses.
 854   ///
 855   /// \param C AST context.
 856   /// \param StartLoc Starting location of the directive kind.
 857   /// \param EndLoc Ending Location of the directive.
 858   /// \param Clauses List of clauses.
 859   /// \param AssociatedStmt Statement, associated with the directive.
 860   ///
 861   static OMPSectionsDirective *
 862   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
 863          ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
 864
 865   /// \brief Creates an empty directive with the place for \a NumClauses
 866   /// clauses.
 867   ///
 868   /// \param C AST context.
 869   /// \param NumClauses Number of clauses.
 870   ///
 871   static OMPSectionsDirective *CreateEmpty(const ASTContext &C,
 872                                            unsigned NumClauses, EmptyShell);
 873
 874   static bool classof(const Stmt *T) {
 875     return T->getStmtClass() == OMPSectionsDirectiveClass;
 876   }
 877 };
 878
 879 /// \brief This represents '#pragma omp section' directive.
 880 ///
 881 /// \code
 882 /// #pragma omp section
 883 /// \endcode
 884 ///
 885 class OMPSectionDirective : public OMPExecutableDirective {
 886   friend class ASTStmtReader;
 887   /// \brief Build directive with the given start and end location.
 888   ///
 889   /// \param StartLoc Starting location of the directive kind.
 890   /// \param EndLoc Ending location of the directive.
 891   ///
 892   OMPSectionDirective(SourceLocation StartLoc, SourceLocation EndLoc)
 893       : OMPExecutableDirective(this, OMPSectionDirectiveClass, OMPD_section,
 894                                StartLoc, EndLoc, 0, 1) {}
 895
 896   /// \brief Build an empty directive.
 897   ///
 898   explicit OMPSectionDirective()
 899       : OMPExecutableDirective(this, OMPSectionDirectiveClass, OMPD_section,
 900                                SourceLocation(), SourceLocation(), 0, 1) {}
 901
 902 public:
 903   /// \brief Creates directive.
 904   ///
 905   /// \param C AST context.
 906   /// \param StartLoc Starting location of the directive kind.
 907   /// \param EndLoc Ending Location of the directive.
 908   /// \param AssociatedStmt Statement, associated with the directive.
 909   ///
 910   static OMPSectionDirective *Create(const ASTContext &C,
 911                                      SourceLocation StartLoc,
 912                                      SourceLocation EndLoc,
 913                                      Stmt *AssociatedStmt);
 914
 915   /// \brief Creates an empty directive.
 916   ///
 917   /// \param C AST context.
 918   ///
 919   static OMPSectionDirective *CreateEmpty(const ASTContext &C, EmptyShell);
 920
 921   static bool classof(const Stmt *T) {
 922     return T->getStmtClass() == OMPSectionDirectiveClass;
 923   }
 924 };
 925
 926 /// \brief This represents '#pragma omp single' directive.
 927 ///
 928 /// \code
 929 /// #pragma omp single private(a,b) copyprivate(c,d)
 930 /// \endcode
 931 /// In this example directive '#pragma omp single' has clauses 'private' with
 932 /// the variables 'a' and 'b' and 'copyprivate' with variables 'c' and 'd'.
 933 ///
 934 class OMPSingleDirective : public OMPExecutableDirective {
 935   friend class ASTStmtReader;
 936   /// \brief Build directive with the given start and end location.
 937   ///
 938   /// \param StartLoc Starting location of the directive kind.
 939   /// \param EndLoc Ending location of the directive.
 940   /// \param NumClauses Number of clauses.
 941   ///
 942   OMPSingleDirective(SourceLocation StartLoc, SourceLocation EndLoc,
 943                      unsigned NumClauses)
 944       : OMPExecutableDirective(this, OMPSingleDirectiveClass, OMPD_single,
 945                                StartLoc, EndLoc, NumClauses, 1) {}
 946
 947   /// \brief Build an empty directive.
 948   ///
 949   /// \param NumClauses Number of clauses.
 950   ///
 951   explicit OMPSingleDirective(unsigned NumClauses)
 952       : OMPExecutableDirective(this, OMPSingleDirectiveClass, OMPD_single,
 953                                SourceLocation(), SourceLocation(), NumClauses,
 954                                1) {}
 955
 956 public:
 957   /// \brief Creates directive with a list of \a Clauses.
 958   ///
 959   /// \param C AST context.
 960   /// \param StartLoc Starting location of the directive kind.
 961   /// \param EndLoc Ending Location of the directive.
 962   /// \param Clauses List of clauses.
 963   /// \param AssociatedStmt Statement, associated with the directive.
 964   ///
 965   static OMPSingleDirective *
 966   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
 967          ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
 968
 969   /// \brief Creates an empty directive with the place for \a NumClauses
 970   /// clauses.
 971   ///
 972   /// \param C AST context.
 973   /// \param NumClauses Number of clauses.
 974   ///
 975   static OMPSingleDirective *CreateEmpty(const ASTContext &C,
 976                                          unsigned NumClauses, EmptyShell);
 977
 978   static bool classof(const Stmt *T) {
 979     return T->getStmtClass() == OMPSingleDirectiveClass;
 980   }
 981 };
 982
 983 /// \brief This represents '#pragma omp master' directive.
 984 ///
 985 /// \code
 986 /// #pragma omp master
 987 /// \endcode
 988 ///
 989 class OMPMasterDirective : public OMPExecutableDirective {
 990   friend class ASTStmtReader;
 991   /// \brief Build directive with the given start and end location.
 992   ///
 993   /// \param StartLoc Starting location of the directive kind.
 994   /// \param EndLoc Ending location of the directive.
 995   ///
 996   OMPMasterDirective(SourceLocation StartLoc, SourceLocation EndLoc)
 997       : OMPExecutableDirective(this, OMPMasterDirectiveClass, OMPD_master,
 998                                StartLoc, EndLoc, 0, 1) {}
 999
1000   /// \brief Build an empty directive.
1001   ///
1002   explicit OMPMasterDirective()
1003       : OMPExecutableDirective(this, OMPMasterDirectiveClass, OMPD_master,
1004                                SourceLocation(), SourceLocation(), 0, 1) {}
1005
1006 public:
1007   /// \brief Creates directive.
1008   ///
1009   /// \param C AST context.
1010   /// \param StartLoc Starting location of the directive kind.
1011   /// \param EndLoc Ending Location of the directive.
1012   /// \param AssociatedStmt Statement, associated with the directive.
1013   ///
1014   static OMPMasterDirective *Create(const ASTContext &C,
1015                                     SourceLocation StartLoc,
1016                                     SourceLocation EndLoc,
1017                                     Stmt *AssociatedStmt);
1018
1019   /// \brief Creates an empty directive.
1020   ///
1021   /// \param C AST context.
1022   ///
1023   static OMPMasterDirective *CreateEmpty(const ASTContext &C, EmptyShell);
1024
1025   static bool classof(const Stmt *T) {
1026     return T->getStmtClass() == OMPMasterDirectiveClass;
1027   }
1028 };
1029
1030 /// \brief This represents '#pragma omp critical' directive.
1031 ///
1032 /// \code
1033 /// #pragma omp critical
1034 /// \endcode
1035 ///
1036 class OMPCriticalDirective : public OMPExecutableDirective {
1037   friend class ASTStmtReader;
1038   /// \brief Name of the directive.
1039   DeclarationNameInfo DirName;
1040   /// \brief Build directive with the given start and end location.
1041   ///
1042   /// \param Name Name of the directive.
1043   /// \param StartLoc Starting location of the directive kind.
1044   /// \param EndLoc Ending location of the directive.
1045   ///
1046   OMPCriticalDirective(const DeclarationNameInfo &Name, SourceLocation StartLoc,
1047                        SourceLocation EndLoc)
1048       : OMPExecutableDirective(this, OMPCriticalDirectiveClass, OMPD_critical,
1049                                StartLoc, EndLoc, 0, 1),
1050         DirName(Name) {}
1051
1052   /// \brief Build an empty directive.
1053   ///
1054   explicit OMPCriticalDirective()
1055       : OMPExecutableDirective(this, OMPCriticalDirectiveClass, OMPD_critical,
1056                                SourceLocation(), SourceLocation(), 0, 1),
1057         DirName() {}
1058
1059   /// \brief Set name of the directive.
1060   ///
1061   /// \param Name Name of the directive.
1062   ///
1063   void setDirectiveName(const DeclarationNameInfo &Name) { DirName = Name; }
1064
1065 public:
1066   /// \brief Creates directive.
1067   ///
1068   /// \param C AST context.
1069   /// \param Name Name of the directive.
1070   /// \param StartLoc Starting location of the directive kind.
1071   /// \param EndLoc Ending Location of the directive.
1072   /// \param AssociatedStmt Statement, associated with the directive.
1073   ///
1074   static OMPCriticalDirective *
1075   Create(const ASTContext &C, const DeclarationNameInfo &Name,
1076          SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt);
1077
1078   /// \brief Creates an empty directive.
1079   ///
1080   /// \param C AST context.
1081   ///
1082   static OMPCriticalDirective *CreateEmpty(const ASTContext &C, EmptyShell);
1083
1084   /// \brief Return name of the directive.
1085   ///
1086   DeclarationNameInfo getDirectiveName() const { return DirName; }
1087
1088   static bool classof(const Stmt *T) {
1089     return T->getStmtClass() == OMPCriticalDirectiveClass;
1090   }
1091 };
1092
1093 /// \brief This represents '#pragma omp parallel for' directive.
1094 ///
1095 /// \code
1096 /// #pragma omp parallel for private(a,b) reduction(+:c,d)
1097 /// \endcode
1098 /// In this example directive '#pragma omp parallel for' has clauses 'private'
1099 /// with the variables 'a' and 'b' and 'reduction' with operator '+' and
1100 /// variables 'c' and 'd'.
1101 ///
1102 class OMPParallelForDirective : public OMPLoopDirective {
1103   friend class ASTStmtReader;
1104   /// \brief Build directive with the given start and end location.
1105   ///
1106   /// \param StartLoc Starting location of the directive kind.
1107   /// \param EndLoc Ending location of the directive.
1108   /// \param CollapsedNum Number of collapsed nested loops.
1109   /// \param NumClauses Number of clauses.
1110   ///
1111   OMPParallelForDirective(SourceLocation StartLoc, SourceLocation EndLoc,
1112                           unsigned CollapsedNum, unsigned NumClauses)
1113       : OMPLoopDirective(this, OMPParallelForDirectiveClass, OMPD_parallel_for,
1114                          StartLoc, EndLoc, CollapsedNum, NumClauses) {}
1115
1116   /// \brief Build an empty directive.
1117   ///
1118   /// \param CollapsedNum Number of collapsed nested loops.
1119   /// \param NumClauses Number of clauses.
1120   ///
1121   explicit OMPParallelForDirective(unsigned CollapsedNum, unsigned NumClauses)
1122       : OMPLoopDirective(this, OMPParallelForDirectiveClass, OMPD_parallel_for,
1123                          SourceLocation(), SourceLocation(), CollapsedNum,
1124                          NumClauses) {}
1125
1126 public:
1127   /// \brief Creates directive with a list of \a Clauses.
1128   ///
1129   /// \param C AST context.
1130   /// \param StartLoc Starting location of the directive kind.
1131   /// \param EndLoc Ending Location of the directive.
1132   /// \param CollapsedNum Number of collapsed loops.
1133   /// \param Clauses List of clauses.
1134   /// \param AssociatedStmt Statement, associated with the directive.
1135   /// \param Exprs Helper expressions for CodeGen.
1136   ///
1137   static OMPParallelForDirective *
1138   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1139          unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
1140          Stmt *AssociatedStmt, const HelperExprs &Exprs);
1141
1142   /// \brief Creates an empty directive with the place
1143   /// for \a NumClauses clauses.
1144   ///
1145   /// \param C AST context.
1146   /// \param CollapsedNum Number of collapsed nested loops.
1147   /// \param NumClauses Number of clauses.
1148   ///
1149   static OMPParallelForDirective *CreateEmpty(const ASTContext &C,
1150                                               unsigned NumClauses,
1151                                               unsigned CollapsedNum,
1152                                               EmptyShell);
1153
1154   static bool classof(const Stmt *T) {
1155     return T->getStmtClass() == OMPParallelForDirectiveClass;
1156   }
1157 };
1158
1159 /// \brief This represents '#pragma omp parallel for simd' directive.
1160 ///
1161 /// \code
1162 /// #pragma omp parallel for simd private(a,b) linear(i,j:s) reduction(+:c,d)
1163 /// \endcode
1164 /// In this example directive '#pragma omp parallel for simd' has clauses
1165 /// 'private' with the variables 'a' and 'b', 'linear' with variables 'i', 'j'
1166 /// and linear step 's', 'reduction' with operator '+' and variables 'c' and
1167 /// 'd'.
1168 ///
1169 class OMPParallelForSimdDirective : public OMPLoopDirective {
1170   friend class ASTStmtReader;
1171   /// \brief Build directive with the given start and end location.
1172   ///
1173   /// \param StartLoc Starting location of the directive kind.
1174   /// \param EndLoc Ending location of the directive.
1175   /// \param CollapsedNum Number of collapsed nested loops.
1176   /// \param NumClauses Number of clauses.
1177   ///
1178   OMPParallelForSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
1179                               unsigned CollapsedNum, unsigned NumClauses)
1180       : OMPLoopDirective(this, OMPParallelForSimdDirectiveClass,
1181                          OMPD_parallel_for_simd, StartLoc, EndLoc, CollapsedNum,
1182                          NumClauses) {}
1183
1184   /// \brief Build an empty directive.
1185   ///
1186   /// \param CollapsedNum Number of collapsed nested loops.
1187   /// \param NumClauses Number of clauses.
1188   ///
1189   explicit OMPParallelForSimdDirective(unsigned CollapsedNum,
1190                                        unsigned NumClauses)
1191       : OMPLoopDirective(this, OMPParallelForSimdDirectiveClass,
1192                          OMPD_parallel_for_simd, SourceLocation(),
1193                          SourceLocation(), CollapsedNum, NumClauses) {}
1194
1195 public:
1196   /// \brief Creates directive with a list of \a Clauses.
1197   ///
1198   /// \param C AST context.
1199   /// \param StartLoc Starting location of the directive kind.
1200   /// \param EndLoc Ending Location of the directive.
1201   /// \param CollapsedNum Number of collapsed loops.
1202   /// \param Clauses List of clauses.
1203   /// \param AssociatedStmt Statement, associated with the directive.
1204   /// \param Exprs Helper expressions for CodeGen.
1205   ///
1206   static OMPParallelForSimdDirective *
1207   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1208          unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
1209          Stmt *AssociatedStmt, const HelperExprs &Exprs);
1210
1211   /// \brief Creates an empty directive with the place
1212   /// for \a NumClauses clauses.
1213   ///
1214   /// \param C AST context.
1215   /// \param CollapsedNum Number of collapsed nested loops.
1216   /// \param NumClauses Number of clauses.
1217   ///
1218   static OMPParallelForSimdDirective *CreateEmpty(const ASTContext &C,
1219                                                   unsigned NumClauses,
1220                                                   unsigned CollapsedNum,
1221                                                   EmptyShell);
1222
1223   static bool classof(const Stmt *T) {
1224     return T->getStmtClass() == OMPParallelForSimdDirectiveClass;
1225   }
1226 };
1227
1228 /// \brief This represents '#pragma omp parallel sections' directive.
1229 ///
1230 /// \code
1231 /// #pragma omp parallel sections private(a,b) reduction(+:c,d)
1232 /// \endcode
1233 /// In this example directive '#pragma omp parallel sections' has clauses
1234 /// 'private' with the variables 'a' and 'b' and 'reduction' with operator '+'
1235 /// and variables 'c' and 'd'.
1236 ///
1237 class OMPParallelSectionsDirective : public OMPExecutableDirective {
1238   friend class ASTStmtReader;
1239   /// \brief Build directive with the given start and end location.
1240   ///
1241   /// \param StartLoc Starting location of the directive kind.
1242   /// \param EndLoc Ending location of the directive.
1243   /// \param NumClauses Number of clauses.
1244   ///
1245   OMPParallelSectionsDirective(SourceLocation StartLoc, SourceLocation EndLoc,
1246                                unsigned NumClauses)
1247       : OMPExecutableDirective(this, OMPParallelSectionsDirectiveClass,
1248                                OMPD_parallel_sections, StartLoc, EndLoc,
1249                                NumClauses, 1) {}
1250
1251   /// \brief Build an empty directive.
1252   ///
1253   /// \param NumClauses Number of clauses.
1254   ///
1255   explicit OMPParallelSectionsDirective(unsigned NumClauses)
1256       : OMPExecutableDirective(this, OMPParallelSectionsDirectiveClass,
1257                                OMPD_parallel_sections, SourceLocation(),
1258                                SourceLocation(), NumClauses, 1) {}
1259
1260 public:
1261   /// \brief Creates directive with a list of \a Clauses.
1262   ///
1263   /// \param C AST context.
1264   /// \param StartLoc Starting location of the directive kind.
1265   /// \param EndLoc Ending Location of the directive.
1266   /// \param Clauses List of clauses.
1267   /// \param AssociatedStmt Statement, associated with the directive.
1268   ///
1269   static OMPParallelSectionsDirective *
1270   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1271          ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
1272
1273   /// \brief Creates an empty directive with the place for \a NumClauses
1274   /// clauses.
1275   ///
1276   /// \param C AST context.
1277   /// \param NumClauses Number of clauses.
1278   ///
1279   static OMPParallelSectionsDirective *
1280   CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell);
1281
1282   static bool classof(const Stmt *T) {
1283     return T->getStmtClass() == OMPParallelSectionsDirectiveClass;
1284   }
1285 };
1286
1287 /// \brief This represents '#pragma omp task' directive.
1288 ///
1289 /// \code
1290 /// #pragma omp task private(a,b) final(d)
1291 /// \endcode
1292 /// In this example directive '#pragma omp task' has clauses 'private' with the
1293 /// variables 'a' and 'b' and 'final' with condition 'd'.
1294 ///
1295 class OMPTaskDirective : public OMPExecutableDirective {
1296   friend class ASTStmtReader;
1297   /// \brief Build directive with the given start and end location.
1298   ///
1299   /// \param StartLoc Starting location of the directive kind.
1300   /// \param EndLoc Ending location of the directive.
1301   /// \param NumClauses Number of clauses.
1302   ///
1303   OMPTaskDirective(SourceLocation StartLoc, SourceLocation EndLoc,
1304                    unsigned NumClauses)
1305       : OMPExecutableDirective(this, OMPTaskDirectiveClass, OMPD_task, StartLoc,
1306                                EndLoc, NumClauses, 1) {}
1307
1308   /// \brief Build an empty directive.
1309   ///
1310   /// \param NumClauses Number of clauses.
1311   ///
1312   explicit OMPTaskDirective(unsigned NumClauses)
1313       : OMPExecutableDirective(this, OMPTaskDirectiveClass, OMPD_task,
1314                                SourceLocation(), SourceLocation(), NumClauses,
1315                                1) {}
1316
1317 public:
1318   /// \brief Creates directive with a list of \a Clauses.
1319   ///
1320   /// \param C AST context.
1321   /// \param StartLoc Starting location of the directive kind.
1322   /// \param EndLoc Ending Location of the directive.
1323   /// \param Clauses List of clauses.
1324   /// \param AssociatedStmt Statement, associated with the directive.
1325   ///
1326   static OMPTaskDirective *Create(const ASTContext &C, SourceLocation StartLoc,
1327                                   SourceLocation EndLoc,
1328                                   ArrayRef<OMPClause *> Clauses,
1329                                   Stmt *AssociatedStmt);
1330
1331   /// \brief Creates an empty directive with the place for \a NumClauses
1332   /// clauses.
1333   ///
1334   /// \param C AST context.
1335   /// \param NumClauses Number of clauses.
1336   ///
1337   static OMPTaskDirective *CreateEmpty(const ASTContext &C, unsigned NumClauses,
1338                                        EmptyShell);
1339
1340   static bool classof(const Stmt *T) {
1341     return T->getStmtClass() == OMPTaskDirectiveClass;
1342   }
1343 };
1344
1345 /// \brief This represents '#pragma omp taskyield' directive.
1346 ///
1347 /// \code
1348 /// #pragma omp taskyield
1349 /// \endcode
1350 ///
1351 class OMPTaskyieldDirective : public OMPExecutableDirective {
1352   friend class ASTStmtReader;
1353   /// \brief Build directive with the given start and end location.
1354   ///
1355   /// \param StartLoc Starting location of the directive kind.
1356   /// \param EndLoc Ending location of the directive.
1357   ///
1358   OMPTaskyieldDirective(SourceLocation StartLoc, SourceLocation EndLoc)
1359       : OMPExecutableDirective(this, OMPTaskyieldDirectiveClass, OMPD_taskyield,
1360                                StartLoc, EndLoc, 0, 0) {}
1361
1362   /// \brief Build an empty directive.
1363   ///
1364   explicit OMPTaskyieldDirective()
1365       : OMPExecutableDirective(this, OMPTaskyieldDirectiveClass, OMPD_taskyield,
1366                                SourceLocation(), SourceLocation(), 0, 0) {}
1367
1368 public:
1369   /// \brief Creates directive.
1370   ///
1371   /// \param C AST context.
1372   /// \param StartLoc Starting location of the directive kind.
1373   /// \param EndLoc Ending Location of the directive.
1374   ///
1375   static OMPTaskyieldDirective *
1376   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc);
1377
1378   /// \brief Creates an empty directive.
1379   ///
1380   /// \param C AST context.
1381   ///
1382   static OMPTaskyieldDirective *CreateEmpty(const ASTContext &C, EmptyShell);
1383
1384   static bool classof(const Stmt *T) {
1385     return T->getStmtClass() == OMPTaskyieldDirectiveClass;
1386   }
1387 };
1388
1389 /// \brief This represents '#pragma omp barrier' directive.
1390 ///
1391 /// \code
1392 /// #pragma omp barrier
1393 /// \endcode
1394 ///
1395 class OMPBarrierDirective : public OMPExecutableDirective {
1396   friend class ASTStmtReader;
1397   /// \brief Build directive with the given start and end location.
1398   ///
1399   /// \param StartLoc Starting location of the directive kind.
1400   /// \param EndLoc Ending location of the directive.
1401   ///
1402   OMPBarrierDirective(SourceLocation StartLoc, SourceLocation EndLoc)
1403       : OMPExecutableDirective(this, OMPBarrierDirectiveClass, OMPD_barrier,
1404                                StartLoc, EndLoc, 0, 0) {}
1405
1406   /// \brief Build an empty directive.
1407   ///
1408   explicit OMPBarrierDirective()
1409       : OMPExecutableDirective(this, OMPBarrierDirectiveClass, OMPD_barrier,
1410                                SourceLocation(), SourceLocation(), 0, 0) {}
1411
1412 public:
1413   /// \brief Creates directive.
1414   ///
1415   /// \param C AST context.
1416   /// \param StartLoc Starting location of the directive kind.
1417   /// \param EndLoc Ending Location of the directive.
1418   ///
1419   static OMPBarrierDirective *
1420   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc);
1421
1422   /// \brief Creates an empty directive.
1423   ///
1424   /// \param C AST context.
1425   ///
1426   static OMPBarrierDirective *CreateEmpty(const ASTContext &C, EmptyShell);
1427
1428   static bool classof(const Stmt *T) {
1429     return T->getStmtClass() == OMPBarrierDirectiveClass;
1430   }
1431 };
1432
1433 /// \brief This represents '#pragma omp taskwait' directive.
1434 ///
1435 /// \code
1436 /// #pragma omp taskwait
1437 /// \endcode
1438 ///
1439 class OMPTaskwaitDirective : public OMPExecutableDirective {
1440   friend class ASTStmtReader;
1441   /// \brief Build directive with the given start and end location.
1442   ///
1443   /// \param StartLoc Starting location of the directive kind.
1444   /// \param EndLoc Ending location of the directive.
1445   ///
1446   OMPTaskwaitDirective(SourceLocation StartLoc, SourceLocation EndLoc)
1447       : OMPExecutableDirective(this, OMPTaskwaitDirectiveClass, OMPD_taskwait,
1448                                StartLoc, EndLoc, 0, 0) {}
1449
1450   /// \brief Build an empty directive.
1451   ///
1452   explicit OMPTaskwaitDirective()
1453       : OMPExecutableDirective(this, OMPTaskwaitDirectiveClass, OMPD_taskwait,
1454                                SourceLocation(), SourceLocation(), 0, 0) {}
1455
1456 public:
1457   /// \brief Creates directive.
1458   ///
1459   /// \param C AST context.
1460   /// \param StartLoc Starting location of the directive kind.
1461   /// \param EndLoc Ending Location of the directive.
1462   ///
1463   static OMPTaskwaitDirective *
1464   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc);
1465
1466   /// \brief Creates an empty directive.
1467   ///
1468   /// \param C AST context.
1469   ///
1470   static OMPTaskwaitDirective *CreateEmpty(const ASTContext &C, EmptyShell);
1471
1472   static bool classof(const Stmt *T) {
1473     return T->getStmtClass() == OMPTaskwaitDirectiveClass;
1474   }
1475 };
1476
1477 /// \brief This represents '#pragma omp taskgroup' directive.
1478 ///
1479 /// \code
1480 /// #pragma omp taskgroup
1481 /// \endcode
1482 ///
1483 class OMPTaskgroupDirective : public OMPExecutableDirective {
1484   friend class ASTStmtReader;
1485   /// \brief Build directive with the given start and end location.
1486   ///
1487   /// \param StartLoc Starting location of the directive kind.
1488   /// \param EndLoc Ending location of the directive.
1489   ///
1490   OMPTaskgroupDirective(SourceLocation StartLoc, SourceLocation EndLoc)
1491       : OMPExecutableDirective(this, OMPTaskgroupDirectiveClass, OMPD_taskgroup,
1492                                StartLoc, EndLoc, 0, 1) {}
1493
1494   /// \brief Build an empty directive.
1495   ///
1496   explicit OMPTaskgroupDirective()
1497       : OMPExecutableDirective(this, OMPTaskgroupDirectiveClass, OMPD_taskgroup,
1498                                SourceLocation(), SourceLocation(), 0, 1) {}
1499
1500 public:
1501   /// \brief Creates directive.
1502   ///
1503   /// \param C AST context.
1504   /// \param StartLoc Starting location of the directive kind.
1505   /// \param EndLoc Ending Location of the directive.
1506   /// \param AssociatedStmt Statement, associated with the directive.
1507   ///
1508   static OMPTaskgroupDirective *Create(const ASTContext &C,
1509                                        SourceLocation StartLoc,
1510                                        SourceLocation EndLoc,
1511                                        Stmt *AssociatedStmt);
1512
1513   /// \brief Creates an empty directive.
1514   ///
1515   /// \param C AST context.
1516   ///
1517   static OMPTaskgroupDirective *CreateEmpty(const ASTContext &C, EmptyShell);
1518
1519   static bool classof(const Stmt *T) {
1520     return T->getStmtClass() == OMPTaskgroupDirectiveClass;
1521   }
1522 };
1523
1524 /// \brief This represents '#pragma omp flush' directive.
1525 ///
1526 /// \code
1527 /// #pragma omp flush(a,b)
1528 /// \endcode
1529 /// In this example directive '#pragma omp flush' has 2 arguments- variables 'a'
1530 /// and 'b'.
1531 /// 'omp flush' directive does not have clauses but have an optional list of
1532 /// variables to flush. This list of variables is stored within some fake clause
1533 /// FlushClause.
1534 class OMPFlushDirective : public OMPExecutableDirective {
1535   friend class ASTStmtReader;
1536   /// \brief Build directive with the given start and end location.
1537   ///
1538   /// \param StartLoc Starting location of the directive kind.
1539   /// \param EndLoc Ending location of the directive.
1540   /// \param NumClauses Number of clauses.
1541   ///
1542   OMPFlushDirective(SourceLocation StartLoc, SourceLocation EndLoc,
1543                     unsigned NumClauses)
1544       : OMPExecutableDirective(this, OMPFlushDirectiveClass, OMPD_flush,
1545                                StartLoc, EndLoc, NumClauses, 0) {}
1546
1547   /// \brief Build an empty directive.
1548   ///
1549   /// \param NumClauses Number of clauses.
1550   ///
1551   explicit OMPFlushDirective(unsigned NumClauses)
1552       : OMPExecutableDirective(this, OMPFlushDirectiveClass, OMPD_flush,
1553                                SourceLocation(), SourceLocation(), NumClauses,
1554                                0) {}
1555
1556 public:
1557   /// \brief Creates directive with a list of \a Clauses.
1558   ///
1559   /// \param C AST context.
1560   /// \param StartLoc Starting location of the directive kind.
1561   /// \param EndLoc Ending Location of the directive.
1562   /// \param Clauses List of clauses (only single OMPFlushClause clause is
1563   /// allowed).
1564   ///
1565   static OMPFlushDirective *Create(const ASTContext &C, SourceLocation StartLoc,
1566                                    SourceLocation EndLoc,
1567                                    ArrayRef<OMPClause *> Clauses);
1568
1569   /// \brief Creates an empty directive with the place for \a NumClauses
1570   /// clauses.
1571   ///
1572   /// \param C AST context.
1573   /// \param NumClauses Number of clauses.
1574   ///
1575   static OMPFlushDirective *CreateEmpty(const ASTContext &C,
1576                                         unsigned NumClauses, EmptyShell);
1577
1578   static bool classof(const Stmt *T) {
1579     return T->getStmtClass() == OMPFlushDirectiveClass;
1580   }
1581 };
1582
1583 /// \brief This represents '#pragma omp ordered' directive.
1584 ///
1585 /// \code
1586 /// #pragma omp ordered
1587 /// \endcode
1588 ///
1589 class OMPOrderedDirective : public OMPExecutableDirective {
1590   friend class ASTStmtReader;
1591   /// \brief Build directive with the given start and end location.
1592   ///
1593   /// \param StartLoc Starting location of the directive kind.
1594   /// \param EndLoc Ending location of the directive.
1595   ///
1596   OMPOrderedDirective(SourceLocation StartLoc, SourceLocation EndLoc)
1597       : OMPExecutableDirective(this, OMPOrderedDirectiveClass, OMPD_ordered,
1598                                StartLoc, EndLoc, 0, 1) {}
1599
1600   /// \brief Build an empty directive.
1601   ///
1602   explicit OMPOrderedDirective()
1603       : OMPExecutableDirective(this, OMPOrderedDirectiveClass, OMPD_ordered,
1604                                SourceLocation(), SourceLocation(), 0, 1) {}
1605
1606 public:
1607   /// \brief Creates directive.
1608   ///
1609   /// \param C AST context.
1610   /// \param StartLoc Starting location of the directive kind.
1611   /// \param EndLoc Ending Location of the directive.
1612   /// \param AssociatedStmt Statement, associated with the directive.
1613   ///
1614   static OMPOrderedDirective *Create(const ASTContext &C,
1615                                      SourceLocation StartLoc,
1616                                      SourceLocation EndLoc,
1617                                      Stmt *AssociatedStmt);
1618
1619   /// \brief Creates an empty directive.
1620   ///
1621   /// \param C AST context.
1622   ///
1623   static OMPOrderedDirective *CreateEmpty(const ASTContext &C, EmptyShell);
1624
1625   static bool classof(const Stmt *T) {
1626     return T->getStmtClass() == OMPOrderedDirectiveClass;
1627   }
1628 };
1629
1630 /// \brief This represents '#pragma omp atomic' directive.
1631 ///
1632 /// \code
1633 /// #pragma omp atomic capture
1634 /// \endcode
1635 /// In this example directive '#pragma omp atomic' has clause 'capture'.
1636 ///
1637 class OMPAtomicDirective : public OMPExecutableDirective {
1638   friend class ASTStmtReader;
1639   /// \brief Used for 'atomic update' or 'atomic capture' constructs. They may
1640   /// have atomic expressions of forms
1641   /// \code
1642   /// x = x binop expr;
1643   /// x = expr binop x;
1644   /// \endcode
1645   /// This field is true for the first form of the expression and false for the
1646   /// second. Required for correct codegen of non-associative operations (like
1647   /// << or >>).
1648   bool IsXLHSInRHSPart;
1649   /// \brief Used for 'atomic update' or 'atomic capture' constructs. They may
1650   /// have atomic expressions of forms
1651   /// \code
1652   /// v = x; <update x>;
1653   /// <update x>; v = x;
1654   /// \endcode
1655   /// This field is true for the first(postfix) form of the expression and false
1656   /// otherwise.
1657   bool IsPostfixUpdate;
1658
1659   /// \brief Build directive with the given start and end location.
1660   ///
1661   /// \param StartLoc Starting location of the directive kind.
1662   /// \param EndLoc Ending location of the directive.
1663   /// \param NumClauses Number of clauses.
1664   ///
1665   OMPAtomicDirective(SourceLocation StartLoc, SourceLocation EndLoc,
1666                      unsigned NumClauses)
1667       : OMPExecutableDirective(this, OMPAtomicDirectiveClass, OMPD_atomic,
1668                                StartLoc, EndLoc, NumClauses, 5),
1669         IsXLHSInRHSPart(false), IsPostfixUpdate(false) {}
1670
1671   /// \brief Build an empty directive.
1672   ///
1673   /// \param NumClauses Number of clauses.
1674   ///
1675   explicit OMPAtomicDirective(unsigned NumClauses)
1676       : OMPExecutableDirective(this, OMPAtomicDirectiveClass, OMPD_atomic,
1677                                SourceLocation(), SourceLocation(), NumClauses,
1678                                5),
1679         IsXLHSInRHSPart(false), IsPostfixUpdate(false) {}
1680
1681   /// \brief Set 'x' part of the associated expression/statement.
1682   void setX(Expr *X) { *std::next(child_begin()) = X; }
1683   /// \brief Set helper expression of the form
1684   /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
1685   /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
1686   void setUpdateExpr(Expr *UE) { *std::next(child_begin(), 2) = UE; }
1687   /// \brief Set 'v' part of the associated expression/statement.
1688   void setV(Expr *V) { *std::next(child_begin(), 3) = V; }
1689   /// \brief Set 'expr' part of the associated expression/statement.
1690   void setExpr(Expr *E) { *std::next(child_begin(), 4) = E; }
1691
1692 public:
1693   /// \brief Creates directive with a list of \a Clauses and 'x', 'v' and 'expr'
1694   /// parts of the atomic construct (see Section 2.12.6, atomic Construct, for
1695   /// detailed description of 'x', 'v' and 'expr').
1696   ///
1697   /// \param C AST context.
1698   /// \param StartLoc Starting location of the directive kind.
1699   /// \param EndLoc Ending Location of the directive.
1700   /// \param Clauses List of clauses.
1701   /// \param AssociatedStmt Statement, associated with the directive.
1702   /// \param X 'x' part of the associated expression/statement.
1703   /// \param V 'v' part of the associated expression/statement.
1704   /// \param E 'expr' part of the associated expression/statement.
1705   /// \param UE Helper expression of the form
1706   /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
1707   /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
1708   /// \param IsXLHSInRHSPart true if \a UE has the first form and false if the
1709   /// second.
1710   /// \param IsPostfixUpdate true if original value of 'x' must be stored in
1711   /// 'v', not an updated one.
1712   static OMPAtomicDirective *
1713   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1714          ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
1715          Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate);
1716
1717   /// \brief Creates an empty directive with the place for \a NumClauses
1718   /// clauses.
1719   ///
1720   /// \param C AST context.
1721   /// \param NumClauses Number of clauses.
1722   ///
1723   static OMPAtomicDirective *CreateEmpty(const ASTContext &C,
1724                                          unsigned NumClauses, EmptyShell);
1725
1726   /// \brief Get 'x' part of the associated expression/statement.
1727   Expr *getX() { return cast_or_null<Expr>(*std::next(child_begin())); }
1728   const Expr *getX() const {
1729     return cast_or_null<Expr>(*std::next(child_begin()));
1730   }
1731   /// \brief Get helper expression of the form
1732   /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
1733   /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
1734   Expr *getUpdateExpr() {
1735     return cast_or_null<Expr>(*std::next(child_begin(), 2));
1736   }
1737   const Expr *getUpdateExpr() const {
1738     return cast_or_null<Expr>(*std::next(child_begin(), 2));
1739   }
1740   /// \brief Return true if helper update expression has form
1741   /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' and false if it has form
1742   /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
1743   bool isXLHSInRHSPart() const { return IsXLHSInRHSPart; }
1744   /// \brief Return true if 'v' expression must be updated to original value of
1745   /// 'x', false if 'v' must be updated to the new value of 'x'.
1746   bool isPostfixUpdate() const { return IsPostfixUpdate; }
1747   /// \brief Get 'v' part of the associated expression/statement.
1748   Expr *getV() { return cast_or_null<Expr>(*std::next(child_begin(), 3)); }
1749   const Expr *getV() const {
1750     return cast_or_null<Expr>(*std::next(child_begin(), 3));
1751   }
1752   /// \brief Get 'expr' part of the associated expression/statement.
1753   Expr *getExpr() { return cast_or_null<Expr>(*std::next(child_begin(), 4)); }
1754   const Expr *getExpr() const {
1755     return cast_or_null<Expr>(*std::next(child_begin(), 4));
1756   }
1757
1758   static bool classof(const Stmt *T) {
1759     return T->getStmtClass() == OMPAtomicDirectiveClass;
1760   }
1761 };
1762
1763 /// \brief This represents '#pragma omp target' directive.
1764 ///
1765 /// \code
1766 /// #pragma omp target if(a)
1767 /// \endcode
1768 /// In this example directive '#pragma omp target' has clause 'if' with
1769 /// condition 'a'.
1770 ///
1771 class OMPTargetDirective : public OMPExecutableDirective {
1772   friend class ASTStmtReader;
1773   /// \brief Build directive with the given start and end location.
1774   ///
1775   /// \param StartLoc Starting location of the directive kind.
1776   /// \param EndLoc Ending location of the directive.
1777   /// \param NumClauses Number of clauses.
1778   ///
1779   OMPTargetDirective(SourceLocation StartLoc, SourceLocation EndLoc,
1780                      unsigned NumClauses)
1781       : OMPExecutableDirective(this, OMPTargetDirectiveClass, OMPD_target,
1782                                StartLoc, EndLoc, NumClauses, 1) {}
1783
1784   /// \brief Build an empty directive.
1785   ///
1786   /// \param NumClauses Number of clauses.
1787   ///
1788   explicit OMPTargetDirective(unsigned NumClauses)
1789       : OMPExecutableDirective(this, OMPTargetDirectiveClass, OMPD_target,
1790                                SourceLocation(), SourceLocation(), NumClauses,
1791                                1) {}
1792
1793 public:
1794   /// \brief Creates directive with a list of \a Clauses.
1795   ///
1796   /// \param C AST context.
1797   /// \param StartLoc Starting location of the directive kind.
1798   /// \param EndLoc Ending Location of the directive.
1799   /// \param Clauses List of clauses.
1800   /// \param AssociatedStmt Statement, associated with the directive.
1801   ///
1802   static OMPTargetDirective *
1803   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1804          ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
1805
1806   /// \brief Creates an empty directive with the place for \a NumClauses
1807   /// clauses.
1808   ///
1809   /// \param C AST context.
1810   /// \param NumClauses Number of clauses.
1811   ///
1812   static OMPTargetDirective *CreateEmpty(const ASTContext &C,
1813                                          unsigned NumClauses, EmptyShell);
1814
1815   static bool classof(const Stmt *T) {
1816     return T->getStmtClass() == OMPTargetDirectiveClass;
1817   }
1818 };
1819
1820 /// \brief This represents '#pragma omp teams' directive.
1821 ///
1822 /// \code
1823 /// #pragma omp teams if(a)
1824 /// \endcode
1825 /// In this example directive '#pragma omp teams' has clause 'if' with
1826 /// condition 'a'.
1827 ///
1828 class OMPTeamsDirective : public OMPExecutableDirective {
1829   friend class ASTStmtReader;
1830   /// \brief Build directive with the given start and end location.
1831   ///
1832   /// \param StartLoc Starting location of the directive kind.
1833   /// \param EndLoc Ending location of the directive.
1834   /// \param NumClauses Number of clauses.
1835   ///
1836   OMPTeamsDirective(SourceLocation StartLoc, SourceLocation EndLoc,
1837                     unsigned NumClauses)
1838       : OMPExecutableDirective(this, OMPTeamsDirectiveClass, OMPD_teams,
1839                                StartLoc, EndLoc, NumClauses, 1) {}
1840
1841   /// \brief Build an empty directive.
1842   ///
1843   /// \param NumClauses Number of clauses.
1844   ///
1845   explicit OMPTeamsDirective(unsigned NumClauses)
1846       : OMPExecutableDirective(this, OMPTeamsDirectiveClass, OMPD_teams,
1847                                SourceLocation(), SourceLocation(), NumClauses,
1848                                1) {}
1849
1850 public:
1851   /// \brief Creates directive with a list of \a Clauses.
1852   ///
1853   /// \param C AST context.
1854   /// \param StartLoc Starting location of the directive kind.
1855   /// \param EndLoc Ending Location of the directive.
1856   /// \param Clauses List of clauses.
1857   /// \param AssociatedStmt Statement, associated with the directive.
1858   ///
1859   static OMPTeamsDirective *Create(const ASTContext &C, SourceLocation StartLoc,
1860                                    SourceLocation EndLoc,
1861                                    ArrayRef<OMPClause *> Clauses,
1862                                    Stmt *AssociatedStmt);
1863
1864   /// \brief Creates an empty directive with the place for \a NumClauses
1865   /// clauses.
1866   ///
1867   /// \param C AST context.
1868   /// \param NumClauses Number of clauses.
1869   ///
1870   static OMPTeamsDirective *CreateEmpty(const ASTContext &C,
1871                                         unsigned NumClauses, EmptyShell);
1872
1873   static bool classof(const Stmt *T) {
1874     return T->getStmtClass() == OMPTeamsDirectiveClass;
1875   }
1876 };
1877
1878 /// \brief This represents '#pragma omp cancellation point' directive.
1879 ///
1880 /// \code
1881 /// #pragma omp cancellation point for
1882 /// \endcode
1883 ///
1884 /// In this example a cancellation point is created for innermost 'for' region.
1885 class OMPCancellationPointDirective : public OMPExecutableDirective {
1886   friend class ASTStmtReader;
1887   OpenMPDirectiveKind CancelRegion;
1888   /// \brief Build directive with the given start and end location.
1889   ///
1890   /// \param StartLoc Starting location of the directive kind.
1891   /// \param EndLoc Ending location of the directive.
1892   ///
1893   OMPCancellationPointDirective(SourceLocation StartLoc, SourceLocation EndLoc)
1894       : OMPExecutableDirective(this, OMPCancellationPointDirectiveClass,
1895                                OMPD_cancellation_point, StartLoc, EndLoc, 0, 0),
1896         CancelRegion(OMPD_unknown) {}
1897
1898   /// \brief Build an empty directive.
1899   ///
1900   explicit OMPCancellationPointDirective()
1901       : OMPExecutableDirective(this, OMPCancellationPointDirectiveClass,
1902                                OMPD_cancellation_point, SourceLocation(),
1903                                SourceLocation(), 0, 0),
1904         CancelRegion(OMPD_unknown) {}
1905
1906   /// \brief Set cancel region for current cancellation point.
1907   /// \param CR Cancellation region.
1908   void setCancelRegion(OpenMPDirectiveKind CR) { CancelRegion = CR; }
1909
1910 public:
1911   /// \brief Creates directive.
1912   ///
1913   /// \param C AST context.
1914   /// \param StartLoc Starting location of the directive kind.
1915   /// \param EndLoc Ending Location of the directive.
1916   ///
1917   static OMPCancellationPointDirective *
1918   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
1919          OpenMPDirectiveKind CancelRegion);
1920
1921   /// \brief Creates an empty directive.
1922   ///
1923   /// \param C AST context.
1924   ///
1925   static OMPCancellationPointDirective *CreateEmpty(const ASTContext &C,
1926                                                     EmptyShell);
1927
1928   /// \brief Get cancellation region for the current cancellation point.
1929   OpenMPDirectiveKind getCancelRegion() const { return CancelRegion; }
1930
1931   static bool classof(const Stmt *T) {
1932     return T->getStmtClass() == OMPCancellationPointDirectiveClass;
1933   }
1934 };
1935
1936 /// \brief This represents '#pragma omp cancel' directive.
1937 ///
1938 /// \code
1939 /// #pragma omp cancel for
1940 /// \endcode
1941 ///
1942 /// In this example a cancel is created for innermost 'for' region.
1943 class OMPCancelDirective : public OMPExecutableDirective {
1944   friend class ASTStmtReader;
1945   OpenMPDirectiveKind CancelRegion;
1946   /// \brief Build directive with the given start and end location.
1947   ///
1948   /// \param StartLoc Starting location of the directive kind.
1949   /// \param EndLoc Ending location of the directive.
1950   ///
1951   OMPCancelDirective(SourceLocation StartLoc, SourceLocation EndLoc)
1952       : OMPExecutableDirective(this, OMPCancelDirectiveClass, OMPD_cancel,
1953                                StartLoc, EndLoc, 0, 0),
1954         CancelRegion(OMPD_unknown) {}
1955
1956   /// \brief Build an empty directive.
1957   ///
1958   explicit OMPCancelDirective()
1959       : OMPExecutableDirective(this, OMPCancelDirectiveClass, OMPD_cancel,
1960                                SourceLocation(), SourceLocation(), 0, 0),
1961         CancelRegion(OMPD_unknown) {}
1962
1963   /// \brief Set cancel region for current cancellation point.
1964   /// \param CR Cancellation region.
1965   void setCancelRegion(OpenMPDirectiveKind CR) { CancelRegion = CR; }
1966
1967 public:
1968   /// \brief Creates directive.
1969   ///
1970   /// \param C AST context.
1971   /// \param StartLoc Starting location of the directive kind.
1972   /// \param EndLoc Ending Location of the directive.
1973   ///
1974   static OMPCancelDirective *Create(const ASTContext &C,
1975                                     SourceLocation StartLoc,
1976                                     SourceLocation EndLoc,
1977                                     OpenMPDirectiveKind CancelRegion);
1978
1979   /// \brief Creates an empty directive.
1980   ///
1981   /// \param C AST context.
1982   ///
1983   static OMPCancelDirective *CreateEmpty(const ASTContext &C, EmptyShell);
1984
1985   /// \brief Get cancellation region for the current cancellation point.
1986   OpenMPDirectiveKind getCancelRegion() const { return CancelRegion; }
1987
1988   static bool classof(const Stmt *T) {
1989     return T->getStmtClass() == OMPCancelDirectiveClass;
1990   }
1991 };
1992
1993 } // end namespace clang
1994
1995 #endif