clang/include/clang/AST/OpenMPClause.h

   1 //===- OpenMPClause.h - Classes for OpenMP clauses --------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 /// \file
  10 /// This file defines OpenMP AST classes for clauses.
  11 /// There are clauses for executable directives, clauses for declarative
  12 /// directives and clauses which can be used in both kinds of directives.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef LLVM_CLANG_AST_OPENMPCLAUSE_H
  17 #define LLVM_CLANG_AST_OPENMPCLAUSE_H
  18
  19 #include "clang/AST/Decl.h"
  20 #include "clang/AST/DeclarationName.h"
  21 #include "clang/AST/Expr.h"
  22 #include "clang/AST/NestedNameSpecifier.h"
  23 #include "clang/AST/Stmt.h"
  24 #include "clang/AST/StmtIterator.h"
  25 #include "clang/Basic/LLVM.h"
  26 #include "clang/Basic/OpenMPKinds.h"
  27 #include "clang/Basic/SourceLocation.h"
  28 #include "llvm/ADT/ArrayRef.h"
  29 #include "llvm/ADT/MapVector.h"
  30 #include "llvm/ADT/SmallVector.h"
  31 #include "llvm/ADT/iterator.h"
  32 #include "llvm/ADT/iterator_range.h"
  33 #include "llvm/Frontend/OpenMP/OMPConstants.h"
  34 #include "llvm/Frontend/OpenMP/OMPContext.h"
  35 #include "llvm/Support/Casting.h"
  36 #include "llvm/Support/Compiler.h"
  37 #include "llvm/Support/TrailingObjects.h"
  38 #include <cassert>
  39 #include <cstddef>
  40 #include <iterator>
  41 #include <utility>
  42
  43 namespace clang {
  44
  45 class ASTContext;
  46
  47 //===----------------------------------------------------------------------===//
  48 // AST classes for clauses.
  49 //===----------------------------------------------------------------------===//
  50
  51 /// This is a basic class for representing single OpenMP clause.
  52 class OMPClause {
  53   /// Starting location of the clause (the clause keyword).
  54   SourceLocation StartLoc;
  55
  56   /// Ending location of the clause.
  57   SourceLocation EndLoc;
  58
  59   /// Kind of the clause.
  60   OpenMPClauseKind Kind;
  61
  62 protected:
  63   OMPClause(OpenMPClauseKind K, SourceLocation StartLoc, SourceLocation EndLoc)
  64       : StartLoc(StartLoc), EndLoc(EndLoc), Kind(K) {}
  65
  66 public:
  67   /// Returns the starting location of the clause.
  68   SourceLocation getBeginLoc() const { return StartLoc; }
  69
  70   /// Returns the ending location of the clause.
  71   SourceLocation getEndLoc() const { return EndLoc; }
  72
  73   /// Sets the starting location of the clause.
  74   void setLocStart(SourceLocation Loc) { StartLoc = Loc; }
  75
  76   /// Sets the ending location of the clause.
  77   void setLocEnd(SourceLocation Loc) { EndLoc = Loc; }
  78
  79   /// Returns kind of OpenMP clause (private, shared, reduction, etc.).
  80   OpenMPClauseKind getClauseKind() const { return Kind; }
  81
  82   bool isImplicit() const { return StartLoc.isInvalid(); }
  83
  84   using child_iterator = StmtIterator;
  85   using const_child_iterator = ConstStmtIterator;
  86   using child_range = llvm::iterator_range<child_iterator>;
  87   using const_child_range = llvm::iterator_range<const_child_iterator>;
  88
  89   child_range children();
  90   const_child_range children() const {
  91     auto Children = const_cast<OMPClause *>(this)->children();
  92     return const_child_range(Children.begin(), Children.end());
  93   }
  94
  95   /// Get the iterator range for the expressions used in the clauses. Used
  96   /// expressions include only the children that must be evaluated at the
  97   /// runtime before entering the construct.
  98   child_range used_children();
  99   const_child_range used_children() const {
 100     auto Children = const_cast<OMPClause *>(this)->children();
 101     return const_child_range(Children.begin(), Children.end());
 102   }
 103
 104   static bool classof(const OMPClause *) { return true; }
 105 };
 106
 107 /// Class that handles pre-initialization statement for some clauses, like
 108 /// 'shedule', 'firstprivate' etc.
 109 class OMPClauseWithPreInit {
 110   friend class OMPClauseReader;
 111
 112   /// Pre-initialization statement for the clause.
 113   Stmt *PreInit = nullptr;
 114
 115   /// Region that captures the associated stmt.
 116   OpenMPDirectiveKind CaptureRegion = llvm::omp::OMPD_unknown;
 117
 118 protected:
 119   OMPClauseWithPreInit(const OMPClause *This) {
 120     assert(get(This) && "get is not tuned for pre-init.");
 121   }
 122
 123   /// Set pre-initialization statement for the clause.
 124   void
 125   setPreInitStmt(Stmt *S,
 126                  OpenMPDirectiveKind ThisRegion = llvm::omp::OMPD_unknown) {
 127     PreInit = S;
 128     CaptureRegion = ThisRegion;
 129   }
 130
 131 public:
 132   /// Get pre-initialization statement for the clause.
 133   const Stmt *getPreInitStmt() const { return PreInit; }
 134
 135   /// Get pre-initialization statement for the clause.
 136   Stmt *getPreInitStmt() { return PreInit; }
 137
 138   /// Get capture region for the stmt in the clause.
 139   OpenMPDirectiveKind getCaptureRegion() const { return CaptureRegion; }
 140
 141   static OMPClauseWithPreInit *get(OMPClause *C);
 142   static const OMPClauseWithPreInit *get(const OMPClause *C);
 143 };
 144
 145 /// Class that handles post-update expression for some clauses, like
 146 /// 'lastprivate', 'reduction' etc.
 147 class OMPClauseWithPostUpdate : public OMPClauseWithPreInit {
 148   friend class OMPClauseReader;
 149
 150   /// Post-update expression for the clause.
 151   Expr *PostUpdate = nullptr;
 152
 153 protected:
 154   OMPClauseWithPostUpdate(const OMPClause *This) : OMPClauseWithPreInit(This) {
 155     assert(get(This) && "get is not tuned for post-update.");
 156   }
 157
 158   /// Set pre-initialization statement for the clause.
 159   void setPostUpdateExpr(Expr *S) { PostUpdate = S; }
 160
 161 public:
 162   /// Get post-update expression for the clause.
 163   const Expr *getPostUpdateExpr() const { return PostUpdate; }
 164
 165   /// Get post-update expression for the clause.
 166   Expr *getPostUpdateExpr() { return PostUpdate; }
 167
 168   static OMPClauseWithPostUpdate *get(OMPClause *C);
 169   static const OMPClauseWithPostUpdate *get(const OMPClause *C);
 170 };
 171
 172 /// This structure contains most locations needed for by an OMPVarListClause.
 173 struct OMPVarListLocTy {
 174   /// Starting location of the clause (the clause keyword).
 175   SourceLocation StartLoc;
 176   /// Location of '('.
 177   SourceLocation LParenLoc;
 178   /// Ending location of the clause.
 179   SourceLocation EndLoc;
 180   OMPVarListLocTy() = default;
 181   OMPVarListLocTy(SourceLocation StartLoc, SourceLocation LParenLoc,
 182                   SourceLocation EndLoc)
 183       : StartLoc(StartLoc), LParenLoc(LParenLoc), EndLoc(EndLoc) {}
 184 };
 185
 186 /// This represents clauses with the list of variables like 'private',
 187 /// 'firstprivate', 'copyin', 'shared', or 'reduction' clauses in the
 188 /// '#pragma omp ...' directives.
 189 template <class T> class OMPVarListClause : public OMPClause {
 190   friend class OMPClauseReader;
 191
 192   /// Location of '('.
 193   SourceLocation LParenLoc;
 194
 195   /// Number of variables in the list.
 196   unsigned NumVars;
 197
 198 protected:
 199   /// Build a clause with \a N variables
 200   ///
 201   /// \param K Kind of the clause.
 202   /// \param StartLoc Starting location of the clause (the clause keyword).
 203   /// \param LParenLoc Location of '('.
 204   /// \param EndLoc Ending location of the clause.
 205   /// \param N Number of the variables in the clause.
 206   OMPVarListClause(OpenMPClauseKind K, SourceLocation StartLoc,
 207                    SourceLocation LParenLoc, SourceLocation EndLoc, unsigned N)
 208       : OMPClause(K, StartLoc, EndLoc), LParenLoc(LParenLoc), NumVars(N) {}
 209
 210   /// Fetches list of variables associated with this clause.
 211   MutableArrayRef<Expr *> getVarRefs() {
 212     return MutableArrayRef<Expr *>(
 213         static_cast<T *>(this)->template getTrailingObjects<Expr *>(), NumVars);
 214   }
 215
 216   /// Sets the list of variables for this clause.
 217   void setVarRefs(ArrayRef<Expr *> VL) {
 218     assert(VL.size() == NumVars &&
 219            "Number of variables is not the same as the preallocated buffer");
 220     std::copy(VL.begin(), VL.end(),
 221               static_cast<T *>(this)->template getTrailingObjects<Expr *>());
 222   }
 223
 224 public:
 225   using varlist_iterator = MutableArrayRef<Expr *>::iterator;
 226   using varlist_const_iterator = ArrayRef<const Expr *>::iterator;
 227   using varlist_range = llvm::iterator_range<varlist_iterator>;
 228   using varlist_const_range = llvm::iterator_range<varlist_const_iterator>;
 229
 230   unsigned varlist_size() const { return NumVars; }
 231   bool varlist_empty() const { return NumVars == 0; }
 232
 233   varlist_range varlists() {
 234     return varlist_range(varlist_begin(), varlist_end());
 235   }
 236   varlist_const_range varlists() const {
 237     return varlist_const_range(varlist_begin(), varlist_end());
 238   }
 239
 240   varlist_iterator varlist_begin() { return getVarRefs().begin(); }
 241   varlist_iterator varlist_end() { return getVarRefs().end(); }
 242   varlist_const_iterator varlist_begin() const { return getVarRefs().begin(); }
 243   varlist_const_iterator varlist_end() const { return getVarRefs().end(); }
 244
 245   /// Sets the location of '('.
 246   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 247
 248   /// Returns the location of '('.
 249   SourceLocation getLParenLoc() const { return LParenLoc; }
 250
 251   /// Fetches list of all variables in the clause.
 252   ArrayRef<const Expr *> getVarRefs() const {
 253     return llvm::makeArrayRef(
 254         static_cast<const T *>(this)->template getTrailingObjects<Expr *>(),
 255         NumVars);
 256   }
 257 };
 258
 259 /// This represents 'allocator' clause in the '#pragma omp ...'
 260 /// directive.
 261 ///
 262 /// \code
 263 /// #pragma omp allocate(a) allocator(omp_default_mem_alloc)
 264 /// \endcode
 265 /// In this example directive '#pragma omp allocate' has simple 'allocator'
 266 /// clause with the allocator 'omp_default_mem_alloc'.
 267 class OMPAllocatorClause : public OMPClause {
 268   friend class OMPClauseReader;
 269
 270   /// Location of '('.
 271   SourceLocation LParenLoc;
 272
 273   /// Expression with the allocator.
 274   Stmt *Allocator = nullptr;
 275
 276   /// Set allocator.
 277   void setAllocator(Expr *A) { Allocator = A; }
 278
 279 public:
 280   /// Build 'allocator' clause with the given allocator.
 281   ///
 282   /// \param A Allocator.
 283   /// \param StartLoc Starting location of the clause.
 284   /// \param LParenLoc Location of '('.
 285   /// \param EndLoc Ending location of the clause.
 286   OMPAllocatorClause(Expr *A, SourceLocation StartLoc, SourceLocation LParenLoc,
 287                      SourceLocation EndLoc)
 288       : OMPClause(OMPC_allocator, StartLoc, EndLoc), LParenLoc(LParenLoc),
 289         Allocator(A) {}
 290
 291   /// Build an empty clause.
 292   OMPAllocatorClause()
 293       : OMPClause(OMPC_allocator, SourceLocation(), SourceLocation()) {}
 294
 295   /// Sets the location of '('.
 296   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 297
 298   /// Returns the location of '('.
 299   SourceLocation getLParenLoc() const { return LParenLoc; }
 300
 301   /// Returns allocator.
 302   Expr *getAllocator() const { return cast_or_null<Expr>(Allocator); }
 303
 304   child_range children() { return child_range(&Allocator, &Allocator + 1); }
 305
 306   const_child_range children() const {
 307     return const_child_range(&Allocator, &Allocator + 1);
 308   }
 309
 310   child_range used_children() {
 311     return child_range(child_iterator(), child_iterator());
 312   }
 313   const_child_range used_children() const {
 314     return const_child_range(const_child_iterator(), const_child_iterator());
 315   }
 316
 317   static bool classof(const OMPClause *T) {
 318     return T->getClauseKind() == OMPC_allocator;
 319   }
 320 };
 321
 322 /// This represents clause 'allocate' in the '#pragma omp ...' directives.
 323 ///
 324 /// \code
 325 /// #pragma omp parallel private(a) allocate(omp_default_mem_alloc :a)
 326 /// \endcode
 327 /// In this example directive '#pragma omp parallel' has clause 'private'
 328 /// and clause 'allocate' for the variable 'a'.
 329 class OMPAllocateClause final
 330     : public OMPVarListClause<OMPAllocateClause>,
 331       private llvm::TrailingObjects<OMPAllocateClause, Expr *> {
 332   friend class OMPClauseReader;
 333   friend OMPVarListClause;
 334   friend TrailingObjects;
 335
 336   /// Allocator specified in the clause, or 'nullptr' if the default one is
 337   /// used.
 338   Expr *Allocator = nullptr;
 339   /// Position of the ':' delimiter in the clause;
 340   SourceLocation ColonLoc;
 341
 342   /// Build clause with number of variables \a N.
 343   ///
 344   /// \param StartLoc Starting location of the clause.
 345   /// \param LParenLoc Location of '('.
 346   /// \param Allocator Allocator expression.
 347   /// \param ColonLoc Location of ':' delimiter.
 348   /// \param EndLoc Ending location of the clause.
 349   /// \param N Number of the variables in the clause.
 350   OMPAllocateClause(SourceLocation StartLoc, SourceLocation LParenLoc,
 351                     Expr *Allocator, SourceLocation ColonLoc,
 352                     SourceLocation EndLoc, unsigned N)
 353       : OMPVarListClause<OMPAllocateClause>(OMPC_allocate, StartLoc, LParenLoc,
 354                                             EndLoc, N),
 355         Allocator(Allocator), ColonLoc(ColonLoc) {}
 356
 357   /// Build an empty clause.
 358   ///
 359   /// \param N Number of variables.
 360   explicit OMPAllocateClause(unsigned N)
 361       : OMPVarListClause<OMPAllocateClause>(OMPC_allocate, SourceLocation(),
 362                                             SourceLocation(), SourceLocation(),
 363                                             N) {}
 364
 365   /// Sets location of ':' symbol in clause.
 366   void setColonLoc(SourceLocation CL) { ColonLoc = CL; }
 367
 368   void setAllocator(Expr *A) { Allocator = A; }
 369
 370 public:
 371   /// Creates clause with a list of variables \a VL.
 372   ///
 373   /// \param C AST context.
 374   /// \param StartLoc Starting location of the clause.
 375   /// \param LParenLoc Location of '('.
 376   /// \param Allocator Allocator expression.
 377   /// \param ColonLoc Location of ':' delimiter.
 378   /// \param EndLoc Ending location of the clause.
 379   /// \param VL List of references to the variables.
 380   static OMPAllocateClause *Create(const ASTContext &C, SourceLocation StartLoc,
 381                                    SourceLocation LParenLoc, Expr *Allocator,
 382                                    SourceLocation ColonLoc,
 383                                    SourceLocation EndLoc, ArrayRef<Expr *> VL);
 384
 385   /// Returns the allocator expression or nullptr, if no allocator is specified.
 386   Expr *getAllocator() const { return Allocator; }
 387
 388   /// Returns the location of the ':' delimiter.
 389   SourceLocation getColonLoc() const { return ColonLoc; }
 390
 391   /// Creates an empty clause with the place for \a N variables.
 392   ///
 393   /// \param C AST context.
 394   /// \param N The number of variables.
 395   static OMPAllocateClause *CreateEmpty(const ASTContext &C, unsigned N);
 396
 397   child_range children() {
 398     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
 399                        reinterpret_cast<Stmt **>(varlist_end()));
 400   }
 401
 402   const_child_range children() const {
 403     auto Children = const_cast<OMPAllocateClause *>(this)->children();
 404     return const_child_range(Children.begin(), Children.end());
 405   }
 406
 407   child_range used_children() {
 408     return child_range(child_iterator(), child_iterator());
 409   }
 410   const_child_range used_children() const {
 411     return const_child_range(const_child_iterator(), const_child_iterator());
 412   }
 413
 414   static bool classof(const OMPClause *T) {
 415     return T->getClauseKind() == OMPC_allocate;
 416   }
 417 };
 418
 419 /// This represents 'if' clause in the '#pragma omp ...' directive.
 420 ///
 421 /// \code
 422 /// #pragma omp parallel if(parallel:a > 5)
 423 /// \endcode
 424 /// In this example directive '#pragma omp parallel' has simple 'if' clause with
 425 /// condition 'a > 5' and directive name modifier 'parallel'.
 426 class OMPIfClause : public OMPClause, public OMPClauseWithPreInit {
 427   friend class OMPClauseReader;
 428
 429   /// Location of '('.
 430   SourceLocation LParenLoc;
 431
 432   /// Condition of the 'if' clause.
 433   Stmt *Condition = nullptr;
 434
 435   /// Location of ':' (if any).
 436   SourceLocation ColonLoc;
 437
 438   /// Directive name modifier for the clause.
 439   OpenMPDirectiveKind NameModifier = llvm::omp::OMPD_unknown;
 440
 441   /// Name modifier location.
 442   SourceLocation NameModifierLoc;
 443
 444   /// Set condition.
 445   void setCondition(Expr *Cond) { Condition = Cond; }
 446
 447   /// Set directive name modifier for the clause.
 448   void setNameModifier(OpenMPDirectiveKind NM) { NameModifier = NM; }
 449
 450   /// Set location of directive name modifier for the clause.
 451   void setNameModifierLoc(SourceLocation Loc) { NameModifierLoc = Loc; }
 452
 453   /// Set location of ':'.
 454   void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; }
 455
 456 public:
 457   /// Build 'if' clause with condition \a Cond.
 458   ///
 459   /// \param NameModifier [OpenMP 4.1] Directive name modifier of clause.
 460   /// \param Cond Condition of the clause.
 461   /// \param HelperCond Helper condition for the clause.
 462   /// \param CaptureRegion Innermost OpenMP region where expressions in this
 463   /// clause must be captured.
 464   /// \param StartLoc Starting location of the clause.
 465   /// \param LParenLoc Location of '('.
 466   /// \param NameModifierLoc Location of directive name modifier.
 467   /// \param ColonLoc [OpenMP 4.1] Location of ':'.
 468   /// \param EndLoc Ending location of the clause.
 469   OMPIfClause(OpenMPDirectiveKind NameModifier, Expr *Cond, Stmt *HelperCond,
 470               OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc,
 471               SourceLocation LParenLoc, SourceLocation NameModifierLoc,
 472               SourceLocation ColonLoc, SourceLocation EndLoc)
 473       : OMPClause(OMPC_if, StartLoc, EndLoc), OMPClauseWithPreInit(this),
 474         LParenLoc(LParenLoc), Condition(Cond), ColonLoc(ColonLoc),
 475         NameModifier(NameModifier), NameModifierLoc(NameModifierLoc) {
 476     setPreInitStmt(HelperCond, CaptureRegion);
 477   }
 478
 479   /// Build an empty clause.
 480   OMPIfClause()
 481       : OMPClause(OMPC_if, SourceLocation(), SourceLocation()),
 482         OMPClauseWithPreInit(this) {}
 483
 484   /// Sets the location of '('.
 485   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 486
 487   /// Returns the location of '('.
 488   SourceLocation getLParenLoc() const { return LParenLoc; }
 489
 490   /// Return the location of ':'.
 491   SourceLocation getColonLoc() const { return ColonLoc; }
 492
 493   /// Returns condition.
 494   Expr *getCondition() const { return cast_or_null<Expr>(Condition); }
 495
 496   /// Return directive name modifier associated with the clause.
 497   OpenMPDirectiveKind getNameModifier() const { return NameModifier; }
 498
 499   /// Return the location of directive name modifier.
 500   SourceLocation getNameModifierLoc() const { return NameModifierLoc; }
 501
 502   child_range children() { return child_range(&Condition, &Condition + 1); }
 503
 504   const_child_range children() const {
 505     return const_child_range(&Condition, &Condition + 1);
 506   }
 507
 508   child_range used_children();
 509   const_child_range used_children() const {
 510     auto Children = const_cast<OMPIfClause *>(this)->used_children();
 511     return const_child_range(Children.begin(), Children.end());
 512   }
 513
 514   static bool classof(const OMPClause *T) {
 515     return T->getClauseKind() == OMPC_if;
 516   }
 517 };
 518
 519 /// This represents 'final' clause in the '#pragma omp ...' directive.
 520 ///
 521 /// \code
 522 /// #pragma omp task final(a > 5)
 523 /// \endcode
 524 /// In this example directive '#pragma omp task' has simple 'final'
 525 /// clause with condition 'a > 5'.
 526 class OMPFinalClause : public OMPClause, public OMPClauseWithPreInit {
 527   friend class OMPClauseReader;
 528
 529   /// Location of '('.
 530   SourceLocation LParenLoc;
 531
 532   /// Condition of the 'if' clause.
 533   Stmt *Condition = nullptr;
 534
 535   /// Set condition.
 536   void setCondition(Expr *Cond) { Condition = Cond; }
 537
 538 public:
 539   /// Build 'final' clause with condition \a Cond.
 540   ///
 541   /// \param Cond Condition of the clause.
 542   /// \param HelperCond Helper condition for the construct.
 543   /// \param CaptureRegion Innermost OpenMP region where expressions in this
 544   /// clause must be captured.
 545   /// \param StartLoc Starting location of the clause.
 546   /// \param LParenLoc Location of '('.
 547   /// \param EndLoc Ending location of the clause.
 548   OMPFinalClause(Expr *Cond, Stmt *HelperCond,
 549                  OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc,
 550                  SourceLocation LParenLoc, SourceLocation EndLoc)
 551       : OMPClause(OMPC_final, StartLoc, EndLoc), OMPClauseWithPreInit(this),
 552         LParenLoc(LParenLoc), Condition(Cond) {
 553     setPreInitStmt(HelperCond, CaptureRegion);
 554   }
 555
 556   /// Build an empty clause.
 557   OMPFinalClause()
 558       : OMPClause(OMPC_final, SourceLocation(), SourceLocation()),
 559         OMPClauseWithPreInit(this) {}
 560
 561   /// Sets the location of '('.
 562   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 563
 564   /// Returns the location of '('.
 565   SourceLocation getLParenLoc() const { return LParenLoc; }
 566
 567   /// Returns condition.
 568   Expr *getCondition() const { return cast_or_null<Expr>(Condition); }
 569
 570   child_range children() { return child_range(&Condition, &Condition + 1); }
 571
 572   const_child_range children() const {
 573     return const_child_range(&Condition, &Condition + 1);
 574   }
 575
 576   child_range used_children();
 577   const_child_range used_children() const {
 578     auto Children = const_cast<OMPFinalClause *>(this)->used_children();
 579     return const_child_range(Children.begin(), Children.end());
 580   }
 581
 582   static bool classof(const OMPClause *T) {
 583     return T->getClauseKind() == OMPC_final;
 584   }
 585 };
 586
 587 /// This represents 'num_threads' clause in the '#pragma omp ...'
 588 /// directive.
 589 ///
 590 /// \code
 591 /// #pragma omp parallel num_threads(6)
 592 /// \endcode
 593 /// In this example directive '#pragma omp parallel' has simple 'num_threads'
 594 /// clause with number of threads '6'.
 595 class OMPNumThreadsClause : public OMPClause, public OMPClauseWithPreInit {
 596   friend class OMPClauseReader;
 597
 598   /// Location of '('.
 599   SourceLocation LParenLoc;
 600
 601   /// Condition of the 'num_threads' clause.
 602   Stmt *NumThreads = nullptr;
 603
 604   /// Set condition.
 605   void setNumThreads(Expr *NThreads) { NumThreads = NThreads; }
 606
 607 public:
 608   /// Build 'num_threads' clause with condition \a NumThreads.
 609   ///
 610   /// \param NumThreads Number of threads for the construct.
 611   /// \param HelperNumThreads Helper Number of threads for the construct.
 612   /// \param CaptureRegion Innermost OpenMP region where expressions in this
 613   /// clause must be captured.
 614   /// \param StartLoc Starting location of the clause.
 615   /// \param LParenLoc Location of '('.
 616   /// \param EndLoc Ending location of the clause.
 617   OMPNumThreadsClause(Expr *NumThreads, Stmt *HelperNumThreads,
 618                       OpenMPDirectiveKind CaptureRegion,
 619                       SourceLocation StartLoc, SourceLocation LParenLoc,
 620                       SourceLocation EndLoc)
 621       : OMPClause(OMPC_num_threads, StartLoc, EndLoc),
 622         OMPClauseWithPreInit(this), LParenLoc(LParenLoc),
 623         NumThreads(NumThreads) {
 624     setPreInitStmt(HelperNumThreads, CaptureRegion);
 625   }
 626
 627   /// Build an empty clause.
 628   OMPNumThreadsClause()
 629       : OMPClause(OMPC_num_threads, SourceLocation(), SourceLocation()),
 630         OMPClauseWithPreInit(this) {}
 631
 632   /// Sets the location of '('.
 633   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 634
 635   /// Returns the location of '('.
 636   SourceLocation getLParenLoc() const { return LParenLoc; }
 637
 638   /// Returns number of threads.
 639   Expr *getNumThreads() const { return cast_or_null<Expr>(NumThreads); }
 640
 641   child_range children() { return child_range(&NumThreads, &NumThreads + 1); }
 642
 643   const_child_range children() const {
 644     return const_child_range(&NumThreads, &NumThreads + 1);
 645   }
 646
 647   child_range used_children() {
 648     return child_range(child_iterator(), child_iterator());
 649   }
 650   const_child_range used_children() const {
 651     return const_child_range(const_child_iterator(), const_child_iterator());
 652   }
 653
 654   static bool classof(const OMPClause *T) {
 655     return T->getClauseKind() == OMPC_num_threads;
 656   }
 657 };
 658
 659 /// This represents 'safelen' clause in the '#pragma omp ...'
 660 /// directive.
 661 ///
 662 /// \code
 663 /// #pragma omp simd safelen(4)
 664 /// \endcode
 665 /// In this example directive '#pragma omp simd' has clause 'safelen'
 666 /// with single expression '4'.
 667 /// If the safelen clause is used then no two iterations executed
 668 /// concurrently with SIMD instructions can have a greater distance
 669 /// in the logical iteration space than its value. The parameter of
 670 /// the safelen clause must be a constant positive integer expression.
 671 class OMPSafelenClause : public OMPClause {
 672   friend class OMPClauseReader;
 673
 674   /// Location of '('.
 675   SourceLocation LParenLoc;
 676
 677   /// Safe iteration space distance.
 678   Stmt *Safelen = nullptr;
 679
 680   /// Set safelen.
 681   void setSafelen(Expr *Len) { Safelen = Len; }
 682
 683 public:
 684   /// Build 'safelen' clause.
 685   ///
 686   /// \param Len Expression associated with this clause.
 687   /// \param StartLoc Starting location of the clause.
 688   /// \param EndLoc Ending location of the clause.
 689   OMPSafelenClause(Expr *Len, SourceLocation StartLoc, SourceLocation LParenLoc,
 690                    SourceLocation EndLoc)
 691       : OMPClause(OMPC_safelen, StartLoc, EndLoc), LParenLoc(LParenLoc),
 692         Safelen(Len) {}
 693
 694   /// Build an empty clause.
 695   explicit OMPSafelenClause()
 696       : OMPClause(OMPC_safelen, SourceLocation(), SourceLocation()) {}
 697
 698   /// Sets the location of '('.
 699   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 700
 701   /// Returns the location of '('.
 702   SourceLocation getLParenLoc() const { return LParenLoc; }
 703
 704   /// Return safe iteration space distance.
 705   Expr *getSafelen() const { return cast_or_null<Expr>(Safelen); }
 706
 707   child_range children() { return child_range(&Safelen, &Safelen + 1); }
 708
 709   const_child_range children() const {
 710     return const_child_range(&Safelen, &Safelen + 1);
 711   }
 712
 713   child_range used_children() {
 714     return child_range(child_iterator(), child_iterator());
 715   }
 716   const_child_range used_children() const {
 717     return const_child_range(const_child_iterator(), const_child_iterator());
 718   }
 719
 720   static bool classof(const OMPClause *T) {
 721     return T->getClauseKind() == OMPC_safelen;
 722   }
 723 };
 724
 725 /// This represents 'simdlen' clause in the '#pragma omp ...'
 726 /// directive.
 727 ///
 728 /// \code
 729 /// #pragma omp simd simdlen(4)
 730 /// \endcode
 731 /// In this example directive '#pragma omp simd' has clause 'simdlen'
 732 /// with single expression '4'.
 733 /// If the 'simdlen' clause is used then it specifies the preferred number of
 734 /// iterations to be executed concurrently. The parameter of the 'simdlen'
 735 /// clause must be a constant positive integer expression.
 736 class OMPSimdlenClause : public OMPClause {
 737   friend class OMPClauseReader;
 738
 739   /// Location of '('.
 740   SourceLocation LParenLoc;
 741
 742   /// Safe iteration space distance.
 743   Stmt *Simdlen = nullptr;
 744
 745   /// Set simdlen.
 746   void setSimdlen(Expr *Len) { Simdlen = Len; }
 747
 748 public:
 749   /// Build 'simdlen' clause.
 750   ///
 751   /// \param Len Expression associated with this clause.
 752   /// \param StartLoc Starting location of the clause.
 753   /// \param EndLoc Ending location of the clause.
 754   OMPSimdlenClause(Expr *Len, SourceLocation StartLoc, SourceLocation LParenLoc,
 755                    SourceLocation EndLoc)
 756       : OMPClause(OMPC_simdlen, StartLoc, EndLoc), LParenLoc(LParenLoc),
 757         Simdlen(Len) {}
 758
 759   /// Build an empty clause.
 760   explicit OMPSimdlenClause()
 761       : OMPClause(OMPC_simdlen, SourceLocation(), SourceLocation()) {}
 762
 763   /// Sets the location of '('.
 764   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 765
 766   /// Returns the location of '('.
 767   SourceLocation getLParenLoc() const { return LParenLoc; }
 768
 769   /// Return safe iteration space distance.
 770   Expr *getSimdlen() const { return cast_or_null<Expr>(Simdlen); }
 771
 772   child_range children() { return child_range(&Simdlen, &Simdlen + 1); }
 773
 774   const_child_range children() const {
 775     return const_child_range(&Simdlen, &Simdlen + 1);
 776   }
 777
 778   child_range used_children() {
 779     return child_range(child_iterator(), child_iterator());
 780   }
 781   const_child_range used_children() const {
 782     return const_child_range(const_child_iterator(), const_child_iterator());
 783   }
 784
 785   static bool classof(const OMPClause *T) {
 786     return T->getClauseKind() == OMPC_simdlen;
 787   }
 788 };
 789
 790 /// This represents 'collapse' clause in the '#pragma omp ...'
 791 /// directive.
 792 ///
 793 /// \code
 794 /// #pragma omp simd collapse(3)
 795 /// \endcode
 796 /// In this example directive '#pragma omp simd' has clause 'collapse'
 797 /// with single expression '3'.
 798 /// The parameter must be a constant positive integer expression, it specifies
 799 /// the number of nested loops that should be collapsed into a single iteration
 800 /// space.
 801 class OMPCollapseClause : public OMPClause {
 802   friend class OMPClauseReader;
 803
 804   /// Location of '('.
 805   SourceLocation LParenLoc;
 806
 807   /// Number of for-loops.
 808   Stmt *NumForLoops = nullptr;
 809
 810   /// Set the number of associated for-loops.
 811   void setNumForLoops(Expr *Num) { NumForLoops = Num; }
 812
 813 public:
 814   /// Build 'collapse' clause.
 815   ///
 816   /// \param Num Expression associated with this clause.
 817   /// \param StartLoc Starting location of the clause.
 818   /// \param LParenLoc Location of '('.
 819   /// \param EndLoc Ending location of the clause.
 820   OMPCollapseClause(Expr *Num, SourceLocation StartLoc,
 821                     SourceLocation LParenLoc, SourceLocation EndLoc)
 822       : OMPClause(OMPC_collapse, StartLoc, EndLoc), LParenLoc(LParenLoc),
 823         NumForLoops(Num) {}
 824
 825   /// Build an empty clause.
 826   explicit OMPCollapseClause()
 827       : OMPClause(OMPC_collapse, SourceLocation(), SourceLocation()) {}
 828
 829   /// Sets the location of '('.
 830   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 831
 832   /// Returns the location of '('.
 833   SourceLocation getLParenLoc() const { return LParenLoc; }
 834
 835   /// Return the number of associated for-loops.
 836   Expr *getNumForLoops() const { return cast_or_null<Expr>(NumForLoops); }
 837
 838   child_range children() { return child_range(&NumForLoops, &NumForLoops + 1); }
 839
 840   const_child_range children() const {
 841     return const_child_range(&NumForLoops, &NumForLoops + 1);
 842   }
 843
 844   child_range used_children() {
 845     return child_range(child_iterator(), child_iterator());
 846   }
 847   const_child_range used_children() const {
 848     return const_child_range(const_child_iterator(), const_child_iterator());
 849   }
 850
 851   static bool classof(const OMPClause *T) {
 852     return T->getClauseKind() == OMPC_collapse;
 853   }
 854 };
 855
 856 /// This represents 'default' clause in the '#pragma omp ...' directive.
 857 ///
 858 /// \code
 859 /// #pragma omp parallel default(shared)
 860 /// \endcode
 861 /// In this example directive '#pragma omp parallel' has simple 'default'
 862 /// clause with kind 'shared'.
 863 class OMPDefaultClause : public OMPClause {
 864   friend class OMPClauseReader;
 865
 866   /// Location of '('.
 867   SourceLocation LParenLoc;
 868
 869   /// A kind of the 'default' clause.
 870   llvm::omp::DefaultKind Kind = llvm::omp::OMP_DEFAULT_unknown;
 871
 872   /// Start location of the kind in source code.
 873   SourceLocation KindKwLoc;
 874
 875   /// Set kind of the clauses.
 876   ///
 877   /// \param K Argument of clause.
 878   void setDefaultKind(llvm::omp::DefaultKind K) { Kind = K; }
 879
 880   /// Set argument location.
 881   ///
 882   /// \param KLoc Argument location.
 883   void setDefaultKindKwLoc(SourceLocation KLoc) { KindKwLoc = KLoc; }
 884
 885 public:
 886   /// Build 'default' clause with argument \a A ('none' or 'shared').
 887   ///
 888   /// \param A Argument of the clause ('none' or 'shared').
 889   /// \param ALoc Starting location of the argument.
 890   /// \param StartLoc Starting location of the clause.
 891   /// \param LParenLoc Location of '('.
 892   /// \param EndLoc Ending location of the clause.
 893   OMPDefaultClause(llvm::omp::DefaultKind A, SourceLocation ALoc,
 894                    SourceLocation StartLoc, SourceLocation LParenLoc,
 895                    SourceLocation EndLoc)
 896       : OMPClause(OMPC_default, StartLoc, EndLoc), LParenLoc(LParenLoc),
 897         Kind(A), KindKwLoc(ALoc) {}
 898
 899   /// Build an empty clause.
 900   OMPDefaultClause()
 901       : OMPClause(OMPC_default, SourceLocation(), SourceLocation()) {}
 902
 903   /// Sets the location of '('.
 904   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 905
 906   /// Returns the location of '('.
 907   SourceLocation getLParenLoc() const { return LParenLoc; }
 908
 909   /// Returns kind of the clause.
 910   llvm::omp::DefaultKind getDefaultKind() const { return Kind; }
 911
 912   /// Returns location of clause kind.
 913   SourceLocation getDefaultKindKwLoc() const { return KindKwLoc; }
 914
 915   child_range children() {
 916     return child_range(child_iterator(), child_iterator());
 917   }
 918
 919   const_child_range children() const {
 920     return const_child_range(const_child_iterator(), const_child_iterator());
 921   }
 922
 923   child_range used_children() {
 924     return child_range(child_iterator(), child_iterator());
 925   }
 926   const_child_range used_children() const {
 927     return const_child_range(const_child_iterator(), const_child_iterator());
 928   }
 929
 930   static bool classof(const OMPClause *T) {
 931     return T->getClauseKind() == OMPC_default;
 932   }
 933 };
 934
 935 /// This represents 'proc_bind' clause in the '#pragma omp ...'
 936 /// directive.
 937 ///
 938 /// \code
 939 /// #pragma omp parallel proc_bind(master)
 940 /// \endcode
 941 /// In this example directive '#pragma omp parallel' has simple 'proc_bind'
 942 /// clause with kind 'master'.
 943 class OMPProcBindClause : public OMPClause {
 944   friend class OMPClauseReader;
 945
 946   /// Location of '('.
 947   SourceLocation LParenLoc;
 948
 949   /// A kind of the 'proc_bind' clause.
 950   llvm::omp::ProcBindKind Kind = llvm::omp::OMP_PROC_BIND_unknown;
 951
 952   /// Start location of the kind in source code.
 953   SourceLocation KindKwLoc;
 954
 955   /// Set kind of the clause.
 956   ///
 957   /// \param K Kind of clause.
 958   void setProcBindKind(llvm::omp::ProcBindKind K) { Kind = K; }
 959
 960   /// Set clause kind location.
 961   ///
 962   /// \param KLoc Kind location.
 963   void setProcBindKindKwLoc(SourceLocation KLoc) { KindKwLoc = KLoc; }
 964
 965 public:
 966   /// Build 'proc_bind' clause with argument \a A ('master', 'close' or
 967   ///        'spread').
 968   ///
 969   /// \param A Argument of the clause ('master', 'close' or 'spread').
 970   /// \param ALoc Starting location of the argument.
 971   /// \param StartLoc Starting location of the clause.
 972   /// \param LParenLoc Location of '('.
 973   /// \param EndLoc Ending location of the clause.
 974   OMPProcBindClause(llvm::omp::ProcBindKind A, SourceLocation ALoc,
 975                     SourceLocation StartLoc, SourceLocation LParenLoc,
 976                     SourceLocation EndLoc)
 977       : OMPClause(OMPC_proc_bind, StartLoc, EndLoc), LParenLoc(LParenLoc),
 978         Kind(A), KindKwLoc(ALoc) {}
 979
 980   /// Build an empty clause.
 981   OMPProcBindClause()
 982       : OMPClause(OMPC_proc_bind, SourceLocation(), SourceLocation()) {}
 983
 984   /// Sets the location of '('.
 985   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 986
 987   /// Returns the location of '('.
 988   SourceLocation getLParenLoc() const { return LParenLoc; }
 989
 990   /// Returns kind of the clause.
 991   llvm::omp::ProcBindKind getProcBindKind() const { return Kind; }
 992
 993   /// Returns location of clause kind.
 994   SourceLocation getProcBindKindKwLoc() const { return KindKwLoc; }
 995
 996   child_range children() {
 997     return child_range(child_iterator(), child_iterator());
 998   }
 999
1000   const_child_range children() const {
1001     return const_child_range(const_child_iterator(), const_child_iterator());
1002   }
1003
1004   child_range used_children() {
1005     return child_range(child_iterator(), child_iterator());
1006   }
1007   const_child_range used_children() const {
1008     return const_child_range(const_child_iterator(), const_child_iterator());
1009   }
1010
1011   static bool classof(const OMPClause *T) {
1012     return T->getClauseKind() == OMPC_proc_bind;
1013   }
1014 };
1015
1016 /// This represents 'unified_address' clause in the '#pragma omp requires'
1017 /// directive.
1018 ///
1019 /// \code
1020 /// #pragma omp requires unified_address
1021 /// \endcode
1022 /// In this example directive '#pragma omp requires' has 'unified_address'
1023 /// clause.
1024 class OMPUnifiedAddressClause final : public OMPClause {
1025 public:
1026   friend class OMPClauseReader;
1027   /// Build 'unified_address' clause.
1028   ///
1029   /// \param StartLoc Starting location of the clause.
1030   /// \param EndLoc Ending location of the clause.
1031   OMPUnifiedAddressClause(SourceLocation StartLoc, SourceLocation EndLoc)
1032       : OMPClause(OMPC_unified_address, StartLoc, EndLoc) {}
1033
1034   /// Build an empty clause.
1035   OMPUnifiedAddressClause()
1036       : OMPClause(OMPC_unified_address, SourceLocation(), SourceLocation()) {}
1037
1038   child_range children() {
1039     return child_range(child_iterator(), child_iterator());
1040   }
1041
1042   const_child_range children() const {
1043     return const_child_range(const_child_iterator(), const_child_iterator());
1044   }
1045
1046   child_range used_children() {
1047     return child_range(child_iterator(), child_iterator());
1048   }
1049   const_child_range used_children() const {
1050     return const_child_range(const_child_iterator(), const_child_iterator());
1051   }
1052
1053   static bool classof(const OMPClause *T) {
1054     return T->getClauseKind() == OMPC_unified_address;
1055   }
1056 };
1057
1058 /// This represents 'unified_shared_memory' clause in the '#pragma omp requires'
1059 /// directive.
1060 ///
1061 /// \code
1062 /// #pragma omp requires unified_shared_memory
1063 /// \endcode
1064 /// In this example directive '#pragma omp requires' has 'unified_shared_memory'
1065 /// clause.
1066 class OMPUnifiedSharedMemoryClause final : public OMPClause {
1067 public:
1068   friend class OMPClauseReader;
1069   /// Build 'unified_shared_memory' clause.
1070   ///
1071   /// \param StartLoc Starting location of the clause.
1072   /// \param EndLoc Ending location of the clause.
1073   OMPUnifiedSharedMemoryClause(SourceLocation StartLoc, SourceLocation EndLoc)
1074       : OMPClause(OMPC_unified_shared_memory, StartLoc, EndLoc) {}
1075
1076   /// Build an empty clause.
1077   OMPUnifiedSharedMemoryClause()
1078       : OMPClause(OMPC_unified_shared_memory, SourceLocation(), SourceLocation()) {}
1079
1080   child_range children() {
1081     return child_range(child_iterator(), child_iterator());
1082   }
1083
1084   const_child_range children() const {
1085     return const_child_range(const_child_iterator(), const_child_iterator());
1086   }
1087
1088   child_range used_children() {
1089     return child_range(child_iterator(), child_iterator());
1090   }
1091   const_child_range used_children() const {
1092     return const_child_range(const_child_iterator(), const_child_iterator());
1093   }
1094
1095   static bool classof(const OMPClause *T) {
1096     return T->getClauseKind() == OMPC_unified_shared_memory;
1097   }
1098 };
1099
1100 /// This represents 'reverse_offload' clause in the '#pragma omp requires'
1101 /// directive.
1102 ///
1103 /// \code
1104 /// #pragma omp requires reverse_offload
1105 /// \endcode
1106 /// In this example directive '#pragma omp requires' has 'reverse_offload'
1107 /// clause.
1108 class OMPReverseOffloadClause final : public OMPClause {
1109 public:
1110   friend class OMPClauseReader;
1111   /// Build 'reverse_offload' clause.
1112   ///
1113   /// \param StartLoc Starting location of the clause.
1114   /// \param EndLoc Ending location of the clause.
1115   OMPReverseOffloadClause(SourceLocation StartLoc, SourceLocation EndLoc)
1116       : OMPClause(OMPC_reverse_offload, StartLoc, EndLoc) {}
1117
1118   /// Build an empty clause.
1119   OMPReverseOffloadClause()
1120       : OMPClause(OMPC_reverse_offload, SourceLocation(), SourceLocation()) {}
1121
1122   child_range children() {
1123     return child_range(child_iterator(), child_iterator());
1124   }
1125
1126   const_child_range children() const {
1127     return const_child_range(const_child_iterator(), const_child_iterator());
1128   }
1129
1130   child_range used_children() {
1131     return child_range(child_iterator(), child_iterator());
1132   }
1133   const_child_range used_children() const {
1134     return const_child_range(const_child_iterator(), const_child_iterator());
1135   }
1136
1137   static bool classof(const OMPClause *T) {
1138     return T->getClauseKind() == OMPC_reverse_offload;
1139   }
1140 };
1141
1142 /// This represents 'dynamic_allocators' clause in the '#pragma omp requires'
1143 /// directive.
1144 ///
1145 /// \code
1146 /// #pragma omp requires dynamic_allocators
1147 /// \endcode
1148 /// In this example directive '#pragma omp requires' has 'dynamic_allocators'
1149 /// clause.
1150 class OMPDynamicAllocatorsClause final : public OMPClause {
1151 public:
1152   friend class OMPClauseReader;
1153   /// Build 'dynamic_allocators' clause.
1154   ///
1155   /// \param StartLoc Starting location of the clause.
1156   /// \param EndLoc Ending location of the clause.
1157   OMPDynamicAllocatorsClause(SourceLocation StartLoc, SourceLocation EndLoc)
1158       : OMPClause(OMPC_dynamic_allocators, StartLoc, EndLoc) {}
1159
1160   /// Build an empty clause.
1161   OMPDynamicAllocatorsClause()
1162       : OMPClause(OMPC_dynamic_allocators, SourceLocation(), SourceLocation()) {
1163   }
1164
1165   child_range children() {
1166     return child_range(child_iterator(), child_iterator());
1167   }
1168
1169   const_child_range children() const {
1170     return const_child_range(const_child_iterator(), const_child_iterator());
1171   }
1172
1173   child_range used_children() {
1174     return child_range(child_iterator(), child_iterator());
1175   }
1176   const_child_range used_children() const {
1177     return const_child_range(const_child_iterator(), const_child_iterator());
1178   }
1179
1180   static bool classof(const OMPClause *T) {
1181     return T->getClauseKind() == OMPC_dynamic_allocators;
1182   }
1183 };
1184
1185 /// This represents 'atomic_default_mem_order' clause in the '#pragma omp
1186 /// requires'  directive.
1187 ///
1188 /// \code
1189 /// #pragma omp requires atomic_default_mem_order(seq_cst)
1190 /// \endcode
1191 /// In this example directive '#pragma omp requires' has simple
1192 /// atomic_default_mem_order' clause with kind 'seq_cst'.
1193 class OMPAtomicDefaultMemOrderClause final : public OMPClause {
1194   friend class OMPClauseReader;
1195
1196   /// Location of '('
1197   SourceLocation LParenLoc;
1198
1199   /// A kind of the 'atomic_default_mem_order' clause.
1200   OpenMPAtomicDefaultMemOrderClauseKind Kind =
1201       OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown;
1202
1203   /// Start location of the kind in source code.
1204   SourceLocation KindKwLoc;
1205
1206   /// Set kind of the clause.
1207   ///
1208   /// \param K Kind of clause.
1209   void setAtomicDefaultMemOrderKind(OpenMPAtomicDefaultMemOrderClauseKind K) {
1210     Kind = K;
1211   }
1212
1213   /// Set clause kind location.
1214   ///
1215   /// \param KLoc Kind location.
1216   void setAtomicDefaultMemOrderKindKwLoc(SourceLocation KLoc) {
1217     KindKwLoc = KLoc;
1218   }
1219
1220 public:
1221   /// Build 'atomic_default_mem_order' clause with argument \a A ('seq_cst',
1222   /// 'acq_rel' or 'relaxed').
1223   ///
1224   /// \param A Argument of the clause ('seq_cst', 'acq_rel' or 'relaxed').
1225   /// \param ALoc Starting location of the argument.
1226   /// \param StartLoc Starting location of the clause.
1227   /// \param LParenLoc Location of '('.
1228   /// \param EndLoc Ending location of the clause.
1229   OMPAtomicDefaultMemOrderClause(OpenMPAtomicDefaultMemOrderClauseKind A,
1230                                  SourceLocation ALoc, SourceLocation StartLoc,
1231                                  SourceLocation LParenLoc,
1232                                  SourceLocation EndLoc)
1233       : OMPClause(OMPC_atomic_default_mem_order, StartLoc, EndLoc),
1234         LParenLoc(LParenLoc), Kind(A), KindKwLoc(ALoc) {}
1235
1236   /// Build an empty clause.
1237   OMPAtomicDefaultMemOrderClause()
1238       : OMPClause(OMPC_atomic_default_mem_order, SourceLocation(),
1239                   SourceLocation()) {}
1240
1241   /// Sets the location of '('.
1242   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
1243
1244   /// Returns the locaiton of '('.
1245   SourceLocation getLParenLoc() const { return LParenLoc; }
1246
1247   /// Returns kind of the clause.
1248   OpenMPAtomicDefaultMemOrderClauseKind getAtomicDefaultMemOrderKind() const {
1249     return Kind;
1250   }
1251
1252   /// Returns location of clause kind.
1253   SourceLocation getAtomicDefaultMemOrderKindKwLoc() const { return KindKwLoc; }
1254
1255   child_range children() {
1256     return child_range(child_iterator(), child_iterator());
1257   }
1258
1259   const_child_range children() const {
1260     return const_child_range(const_child_iterator(), const_child_iterator());
1261   }
1262
1263   child_range used_children() {
1264     return child_range(child_iterator(), child_iterator());
1265   }
1266   const_child_range used_children() const {
1267     return const_child_range(const_child_iterator(), const_child_iterator());
1268   }
1269
1270   static bool classof(const OMPClause *T) {
1271     return T->getClauseKind() == OMPC_atomic_default_mem_order;
1272   }
1273 };
1274
1275 /// This represents 'schedule' clause in the '#pragma omp ...' directive.
1276 ///
1277 /// \code
1278 /// #pragma omp for schedule(static, 3)
1279 /// \endcode
1280 /// In this example directive '#pragma omp for' has 'schedule' clause with
1281 /// arguments 'static' and '3'.
1282 class OMPScheduleClause : public OMPClause, public OMPClauseWithPreInit {
1283   friend class OMPClauseReader;
1284
1285   /// Location of '('.
1286   SourceLocation LParenLoc;
1287
1288   /// A kind of the 'schedule' clause.
1289   OpenMPScheduleClauseKind Kind = OMPC_SCHEDULE_unknown;
1290
1291   /// Modifiers for 'schedule' clause.
1292   enum {FIRST, SECOND, NUM_MODIFIERS};
1293   OpenMPScheduleClauseModifier Modifiers[NUM_MODIFIERS];
1294
1295   /// Locations of modifiers.
1296   SourceLocation ModifiersLoc[NUM_MODIFIERS];
1297
1298   /// Start location of the schedule ind in source code.
1299   SourceLocation KindLoc;
1300
1301   /// Location of ',' (if any).
1302   SourceLocation CommaLoc;
1303
1304   /// Chunk size.
1305   Expr *ChunkSize = nullptr;
1306
1307   /// Set schedule kind.
1308   ///
1309   /// \param K Schedule kind.
1310   void setScheduleKind(OpenMPScheduleClauseKind K) { Kind = K; }
1311
1312   /// Set the first schedule modifier.
1313   ///
1314   /// \param M Schedule modifier.
1315   void setFirstScheduleModifier(OpenMPScheduleClauseModifier M) {
1316     Modifiers[FIRST] = M;
1317   }
1318
1319   /// Set the second schedule modifier.
1320   ///
1321   /// \param M Schedule modifier.
1322   void setSecondScheduleModifier(OpenMPScheduleClauseModifier M) {
1323     Modifiers[SECOND] = M;
1324   }
1325
1326   /// Set location of the first schedule modifier.
1327   void setFirstScheduleModifierLoc(SourceLocation Loc) {
1328     ModifiersLoc[FIRST] = Loc;
1329   }
1330
1331   /// Set location of the second schedule modifier.
1332   void setSecondScheduleModifierLoc(SourceLocation Loc) {
1333     ModifiersLoc[SECOND] = Loc;
1334   }
1335
1336   /// Set schedule modifier location.
1337   ///
1338   /// \param M Schedule modifier location.
1339   void setScheduleModifer(OpenMPScheduleClauseModifier M) {
1340     if (Modifiers[FIRST] == OMPC_SCHEDULE_MODIFIER_unknown)
1341       Modifiers[FIRST] = M;
1342     else {
1343       assert(Modifiers[SECOND] == OMPC_SCHEDULE_MODIFIER_unknown);
1344       Modifiers[SECOND] = M;
1345     }
1346   }
1347
1348   /// Sets the location of '('.
1349   ///
1350   /// \param Loc Location of '('.
1351   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
1352
1353   /// Set schedule kind start location.
1354   ///
1355   /// \param KLoc Schedule kind location.
1356   void setScheduleKindLoc(SourceLocation KLoc) { KindLoc = KLoc; }
1357
1358   /// Set location of ','.
1359   ///
1360   /// \param Loc Location of ','.
1361   void setCommaLoc(SourceLocation Loc) { CommaLoc = Loc; }
1362
1363   /// Set chunk size.
1364   ///
1365   /// \param E Chunk size.
1366   void setChunkSize(Expr *E) { ChunkSize = E; }
1367
1368 public:
1369   /// Build 'schedule' clause with schedule kind \a Kind and chunk size
1370   /// expression \a ChunkSize.
1371   ///
1372   /// \param StartLoc Starting location of the clause.
1373   /// \param LParenLoc Location of '('.
1374   /// \param KLoc Starting location of the argument.
1375   /// \param CommaLoc Location of ','.
1376   /// \param EndLoc Ending location of the clause.
1377   /// \param Kind Schedule kind.
1378   /// \param ChunkSize Chunk size.
1379   /// \param HelperChunkSize Helper chunk size for combined directives.
1380   /// \param M1 The first modifier applied to 'schedule' clause.
1381   /// \param M1Loc Location of the first modifier
1382   /// \param M2 The second modifier applied to 'schedule' clause.
1383   /// \param M2Loc Location of the second modifier
1384   OMPScheduleClause(SourceLocation StartLoc, SourceLocation LParenLoc,
1385                     SourceLocation KLoc, SourceLocation CommaLoc,
1386                     SourceLocation EndLoc, OpenMPScheduleClauseKind Kind,
1387                     Expr *ChunkSize, Stmt *HelperChunkSize,
1388                     OpenMPScheduleClauseModifier M1, SourceLocation M1Loc,
1389                     OpenMPScheduleClauseModifier M2, SourceLocation M2Loc)
1390       : OMPClause(OMPC_schedule, StartLoc, EndLoc), OMPClauseWithPreInit(this),
1391         LParenLoc(LParenLoc), Kind(Kind), KindLoc(KLoc), CommaLoc(CommaLoc),
1392         ChunkSize(ChunkSize) {
1393     setPreInitStmt(HelperChunkSize);
1394     Modifiers[FIRST] = M1;
1395     Modifiers[SECOND] = M2;
1396     ModifiersLoc[FIRST] = M1Loc;
1397     ModifiersLoc[SECOND] = M2Loc;
1398   }
1399
1400   /// Build an empty clause.
1401   explicit OMPScheduleClause()
1402       : OMPClause(OMPC_schedule, SourceLocation(), SourceLocation()),
1403         OMPClauseWithPreInit(this) {
1404     Modifiers[FIRST] = OMPC_SCHEDULE_MODIFIER_unknown;
1405     Modifiers[SECOND] = OMPC_SCHEDULE_MODIFIER_unknown;
1406   }
1407
1408   /// Get kind of the clause.
1409   OpenMPScheduleClauseKind getScheduleKind() const { return Kind; }
1410
1411   /// Get the first modifier of the clause.
1412   OpenMPScheduleClauseModifier getFirstScheduleModifier() const {
1413     return Modifiers[FIRST];
1414   }
1415
1416   /// Get the second modifier of the clause.
1417   OpenMPScheduleClauseModifier getSecondScheduleModifier() const {
1418     return Modifiers[SECOND];
1419   }
1420
1421   /// Get location of '('.
1422   SourceLocation getLParenLoc() { return LParenLoc; }
1423
1424   /// Get kind location.
1425   SourceLocation getScheduleKindLoc() { return KindLoc; }
1426
1427   /// Get the first modifier location.
1428   SourceLocation getFirstScheduleModifierLoc() const {
1429     return ModifiersLoc[FIRST];
1430   }
1431
1432   /// Get the second modifier location.
1433   SourceLocation getSecondScheduleModifierLoc() const {
1434     return ModifiersLoc[SECOND];
1435   }
1436
1437   /// Get location of ','.
1438   SourceLocation getCommaLoc() { return CommaLoc; }
1439
1440   /// Get chunk size.
1441   Expr *getChunkSize() { return ChunkSize; }
1442
1443   /// Get chunk size.
1444   const Expr *getChunkSize() const { return ChunkSize; }
1445
1446   child_range children() {
1447     return child_range(reinterpret_cast<Stmt **>(&ChunkSize),
1448                        reinterpret_cast<Stmt **>(&ChunkSize) + 1);
1449   }
1450
1451   const_child_range children() const {
1452     auto Children = const_cast<OMPScheduleClause *>(this)->children();
1453     return const_child_range(Children.begin(), Children.end());
1454   }
1455
1456   child_range used_children() {
1457     return child_range(child_iterator(), child_iterator());
1458   }
1459   const_child_range used_children() const {
1460     return const_child_range(const_child_iterator(), const_child_iterator());
1461   }
1462
1463   static bool classof(const OMPClause *T) {
1464     return T->getClauseKind() == OMPC_schedule;
1465   }
1466 };
1467
1468 /// This represents 'ordered' clause in the '#pragma omp ...' directive.
1469 ///
1470 /// \code
1471 /// #pragma omp for ordered (2)
1472 /// \endcode
1473 /// In this example directive '#pragma omp for' has 'ordered' clause with
1474 /// parameter 2.
1475 class OMPOrderedClause final
1476     : public OMPClause,
1477       private llvm::TrailingObjects<OMPOrderedClause, Expr *> {
1478   friend class OMPClauseReader;
1479   friend TrailingObjects;
1480
1481   /// Location of '('.
1482   SourceLocation LParenLoc;
1483
1484   /// Number of for-loops.
1485   Stmt *NumForLoops = nullptr;
1486
1487   /// Real number of loops.
1488   unsigned NumberOfLoops = 0;
1489
1490   /// Build 'ordered' clause.
1491   ///
1492   /// \param Num Expression, possibly associated with this clause.
1493   /// \param NumLoops Number of loops, associated with this clause.
1494   /// \param StartLoc Starting location of the clause.
1495   /// \param LParenLoc Location of '('.
1496   /// \param EndLoc Ending location of the clause.
1497   OMPOrderedClause(Expr *Num, unsigned NumLoops, SourceLocation StartLoc,
1498                    SourceLocation LParenLoc, SourceLocation EndLoc)
1499       : OMPClause(OMPC_ordered, StartLoc, EndLoc), LParenLoc(LParenLoc),
1500         NumForLoops(Num), NumberOfLoops(NumLoops) {}
1501
1502   /// Build an empty clause.
1503   explicit OMPOrderedClause(unsigned NumLoops)
1504       : OMPClause(OMPC_ordered, SourceLocation(), SourceLocation()),
1505         NumberOfLoops(NumLoops) {}
1506
1507   /// Set the number of associated for-loops.
1508   void setNumForLoops(Expr *Num) { NumForLoops = Num; }
1509
1510 public:
1511   /// Build 'ordered' clause.
1512   ///
1513   /// \param Num Expression, possibly associated with this clause.
1514   /// \param NumLoops Number of loops, associated with this clause.
1515   /// \param StartLoc Starting location of the clause.
1516   /// \param LParenLoc Location of '('.
1517   /// \param EndLoc Ending location of the clause.
1518   static OMPOrderedClause *Create(const ASTContext &C, Expr *Num,
1519                                   unsigned NumLoops, SourceLocation StartLoc,
1520                                   SourceLocation LParenLoc,
1521                                   SourceLocation EndLoc);
1522
1523   /// Build an empty clause.
1524   static OMPOrderedClause* CreateEmpty(const ASTContext &C, unsigned NumLoops);
1525
1526   /// Sets the location of '('.
1527   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
1528
1529   /// Returns the location of '('.
1530   SourceLocation getLParenLoc() const { return LParenLoc; }
1531
1532   /// Return the number of associated for-loops.
1533   Expr *getNumForLoops() const { return cast_or_null<Expr>(NumForLoops); }
1534
1535   /// Set number of iterations for the specified loop.
1536   void setLoopNumIterations(unsigned NumLoop, Expr *NumIterations);
1537   /// Get number of iterations for all the loops.
1538   ArrayRef<Expr *> getLoopNumIterations() const;
1539
1540   /// Set loop counter for the specified loop.
1541   void setLoopCounter(unsigned NumLoop, Expr *Counter);
1542   /// Get loops counter for the specified loop.
1543   Expr *getLoopCounter(unsigned NumLoop);
1544   const Expr *getLoopCounter(unsigned NumLoop) const;
1545
1546   child_range children() { return child_range(&NumForLoops, &NumForLoops + 1); }
1547
1548   const_child_range children() const {
1549     return const_child_range(&NumForLoops, &NumForLoops + 1);
1550   }
1551
1552   child_range used_children() {
1553     return child_range(child_iterator(), child_iterator());
1554   }
1555   const_child_range used_children() const {
1556     return const_child_range(const_child_iterator(), const_child_iterator());
1557   }
1558
1559   static bool classof(const OMPClause *T) {
1560     return T->getClauseKind() == OMPC_ordered;
1561   }
1562 };
1563
1564 /// This represents 'nowait' clause in the '#pragma omp ...' directive.
1565 ///
1566 /// \code
1567 /// #pragma omp for nowait
1568 /// \endcode
1569 /// In this example directive '#pragma omp for' has 'nowait' clause.
1570 class OMPNowaitClause : public OMPClause {
1571 public:
1572   /// Build 'nowait' clause.
1573   ///
1574   /// \param StartLoc Starting location of the clause.
1575   /// \param EndLoc Ending location of the clause.
1576   OMPNowaitClause(SourceLocation StartLoc, SourceLocation EndLoc)
1577       : OMPClause(OMPC_nowait, StartLoc, EndLoc) {}
1578
1579   /// Build an empty clause.
1580   OMPNowaitClause()
1581       : OMPClause(OMPC_nowait, SourceLocation(), SourceLocation()) {}
1582
1583   child_range children() {
1584     return child_range(child_iterator(), child_iterator());
1585   }
1586
1587   const_child_range children() const {
1588     return const_child_range(const_child_iterator(), const_child_iterator());
1589   }
1590
1591   child_range used_children() {
1592     return child_range(child_iterator(), child_iterator());
1593   }
1594   const_child_range used_children() const {
1595     return const_child_range(const_child_iterator(), const_child_iterator());
1596   }
1597
1598   static bool classof(const OMPClause *T) {
1599     return T->getClauseKind() == OMPC_nowait;
1600   }
1601 };
1602
1603 /// This represents 'untied' clause in the '#pragma omp ...' directive.
1604 ///
1605 /// \code
1606 /// #pragma omp task untied
1607 /// \endcode
1608 /// In this example directive '#pragma omp task' has 'untied' clause.
1609 class OMPUntiedClause : public OMPClause {
1610 public:
1611   /// Build 'untied' clause.
1612   ///
1613   /// \param StartLoc Starting location of the clause.
1614   /// \param EndLoc Ending location of the clause.
1615   OMPUntiedClause(SourceLocation StartLoc, SourceLocation EndLoc)
1616       : OMPClause(OMPC_untied, StartLoc, EndLoc) {}
1617
1618   /// Build an empty clause.
1619   OMPUntiedClause()
1620       : OMPClause(OMPC_untied, SourceLocation(), SourceLocation()) {}
1621
1622   child_range children() {
1623     return child_range(child_iterator(), child_iterator());
1624   }
1625
1626   const_child_range children() const {
1627     return const_child_range(const_child_iterator(), const_child_iterator());
1628   }
1629
1630   child_range used_children() {
1631     return child_range(child_iterator(), child_iterator());
1632   }
1633   const_child_range used_children() const {
1634     return const_child_range(const_child_iterator(), const_child_iterator());
1635   }
1636
1637   static bool classof(const OMPClause *T) {
1638     return T->getClauseKind() == OMPC_untied;
1639   }
1640 };
1641
1642 /// This represents 'mergeable' clause in the '#pragma omp ...'
1643 /// directive.
1644 ///
1645 /// \code
1646 /// #pragma omp task mergeable
1647 /// \endcode
1648 /// In this example directive '#pragma omp task' has 'mergeable' clause.
1649 class OMPMergeableClause : public OMPClause {
1650 public:
1651   /// Build 'mergeable' clause.
1652   ///
1653   /// \param StartLoc Starting location of the clause.
1654   /// \param EndLoc Ending location of the clause.
1655   OMPMergeableClause(SourceLocation StartLoc, SourceLocation EndLoc)
1656       : OMPClause(OMPC_mergeable, StartLoc, EndLoc) {}
1657
1658   /// Build an empty clause.
1659   OMPMergeableClause()
1660       : OMPClause(OMPC_mergeable, SourceLocation(), SourceLocation()) {}
1661
1662   child_range children() {
1663     return child_range(child_iterator(), child_iterator());
1664   }
1665
1666   const_child_range children() const {
1667     return const_child_range(const_child_iterator(), const_child_iterator());
1668   }
1669
1670   child_range used_children() {
1671     return child_range(child_iterator(), child_iterator());
1672   }
1673   const_child_range used_children() const {
1674     return const_child_range(const_child_iterator(), const_child_iterator());
1675   }
1676
1677   static bool classof(const OMPClause *T) {
1678     return T->getClauseKind() == OMPC_mergeable;
1679   }
1680 };
1681
1682 /// This represents 'read' clause in the '#pragma omp atomic' directive.
1683 ///
1684 /// \code
1685 /// #pragma omp atomic read
1686 /// \endcode
1687 /// In this example directive '#pragma omp atomic' has 'read' clause.
1688 class OMPReadClause : public OMPClause {
1689 public:
1690   /// Build 'read' clause.
1691   ///
1692   /// \param StartLoc Starting location of the clause.
1693   /// \param EndLoc Ending location of the clause.
1694   OMPReadClause(SourceLocation StartLoc, SourceLocation EndLoc)
1695       : OMPClause(OMPC_read, StartLoc, EndLoc) {}
1696
1697   /// Build an empty clause.
1698   OMPReadClause() : OMPClause(OMPC_read, SourceLocation(), SourceLocation()) {}
1699
1700   child_range children() {
1701     return child_range(child_iterator(), child_iterator());
1702   }
1703
1704   const_child_range children() const {
1705     return const_child_range(const_child_iterator(), const_child_iterator());
1706   }
1707
1708   child_range used_children() {
1709     return child_range(child_iterator(), child_iterator());
1710   }
1711   const_child_range used_children() const {
1712     return const_child_range(const_child_iterator(), const_child_iterator());
1713   }
1714
1715   static bool classof(const OMPClause *T) {
1716     return T->getClauseKind() == OMPC_read;
1717   }
1718 };
1719
1720 /// This represents 'write' clause in the '#pragma omp atomic' directive.
1721 ///
1722 /// \code
1723 /// #pragma omp atomic write
1724 /// \endcode
1725 /// In this example directive '#pragma omp atomic' has 'write' clause.
1726 class OMPWriteClause : public OMPClause {
1727 public:
1728   /// Build 'write' clause.
1729   ///
1730   /// \param StartLoc Starting location of the clause.
1731   /// \param EndLoc Ending location of the clause.
1732   OMPWriteClause(SourceLocation StartLoc, SourceLocation EndLoc)
1733       : OMPClause(OMPC_write, StartLoc, EndLoc) {}
1734
1735   /// Build an empty clause.
1736   OMPWriteClause()
1737       : OMPClause(OMPC_write, SourceLocation(), SourceLocation()) {}
1738
1739   child_range children() {
1740     return child_range(child_iterator(), child_iterator());
1741   }
1742
1743   const_child_range children() const {
1744     return const_child_range(const_child_iterator(), const_child_iterator());
1745   }
1746
1747   child_range used_children() {
1748     return child_range(child_iterator(), child_iterator());
1749   }
1750   const_child_range used_children() const {
1751     return const_child_range(const_child_iterator(), const_child_iterator());
1752   }
1753
1754   static bool classof(const OMPClause *T) {
1755     return T->getClauseKind() == OMPC_write;
1756   }
1757 };
1758
1759 /// This represents 'update' clause in the '#pragma omp atomic'
1760 /// directive.
1761 ///
1762 /// \code
1763 /// #pragma omp atomic update
1764 /// \endcode
1765 /// In this example directive '#pragma omp atomic' has 'update' clause.
1766 /// Also, this class represents 'update' clause in  '#pragma omp depobj'
1767 /// directive.
1768 ///
1769 /// \code
1770 /// #pragma omp depobj(a) update(in)
1771 /// \endcode
1772 /// In this example directive '#pragma omp depobj' has 'update' clause with 'in'
1773 /// dependence kind.
1774 class OMPUpdateClause final
1775     : public OMPClause,
1776       private llvm::TrailingObjects<OMPUpdateClause, SourceLocation,
1777                                     OpenMPDependClauseKind> {
1778   friend class OMPClauseReader;
1779   friend TrailingObjects;
1780
1781   /// true if extended version of the clause for 'depobj' directive.
1782   bool IsExtended = false;
1783
1784   /// Define the sizes of each trailing object array except the last one. This
1785   /// is required for TrailingObjects to work properly.
1786   size_t numTrailingObjects(OverloadToken<SourceLocation>) const {
1787     // 2 locations: for '(' and argument location.
1788     return IsExtended ? 2 : 0;
1789   }
1790
1791   /// Sets the the location of '(' in clause for 'depobj' directive.
1792   void setLParenLoc(SourceLocation Loc) {
1793     assert(IsExtended && "Expected extended clause.");
1794     *getTrailingObjects<SourceLocation>() = Loc;
1795   }
1796
1797   /// Sets the the location of '(' in clause for 'depobj' directive.
1798   void setArgumentLoc(SourceLocation Loc) {
1799     assert(IsExtended && "Expected extended clause.");
1800     *std::next(getTrailingObjects<SourceLocation>(), 1) = Loc;
1801   }
1802
1803   /// Sets the dependence kind for the clause for 'depobj' directive.
1804   void setDependencyKind(OpenMPDependClauseKind DK) {
1805     assert(IsExtended && "Expected extended clause.");
1806     *getTrailingObjects<OpenMPDependClauseKind>() = DK;
1807   }
1808
1809   /// Build 'update' clause.
1810   ///
1811   /// \param StartLoc Starting location of the clause.
1812   /// \param EndLoc Ending location of the clause.
1813   OMPUpdateClause(SourceLocation StartLoc, SourceLocation EndLoc,
1814                   bool IsExtended)
1815       : OMPClause(OMPC_update, StartLoc, EndLoc), IsExtended(IsExtended) {}
1816
1817   /// Build an empty clause.
1818   OMPUpdateClause(bool IsExtended)
1819       : OMPClause(OMPC_update, SourceLocation(), SourceLocation()),
1820         IsExtended(IsExtended) {}
1821
1822 public:
1823   /// Creates clause for 'atomic' directive.
1824   ///
1825   /// \param C AST context.
1826   /// \param StartLoc Starting location of the clause.
1827   /// \param EndLoc Ending location of the clause.
1828   static OMPUpdateClause *Create(const ASTContext &C, SourceLocation StartLoc,
1829                                  SourceLocation EndLoc);
1830
1831   /// Creates clause for 'depobj' directive.
1832   ///
1833   /// \param C AST context.
1834   /// \param StartLoc Starting location of the clause.
1835   /// \param LParenLoc Location of '('.
1836   /// \param ArgumentLoc Location of the argument.
1837   /// \param DK Dependence kind.
1838   /// \param EndLoc Ending location of the clause.
1839   static OMPUpdateClause *Create(const ASTContext &C, SourceLocation StartLoc,
1840                                  SourceLocation LParenLoc,
1841                                  SourceLocation ArgumentLoc,
1842                                  OpenMPDependClauseKind DK,
1843                                  SourceLocation EndLoc);
1844
1845   /// Creates an empty clause with the place for \a N variables.
1846   ///
1847   /// \param C AST context.
1848   /// \param IsExtended true if extended clause for 'depobj' directive must be
1849   /// created.
1850   static OMPUpdateClause *CreateEmpty(const ASTContext &C, bool IsExtended);
1851
1852   /// Checks if the clause is the extended clauses for 'depobj' directive.
1853   bool isExtended() const { return IsExtended; }
1854
1855   child_range children() {
1856     return child_range(child_iterator(), child_iterator());
1857   }
1858
1859   const_child_range children() const {
1860     return const_child_range(const_child_iterator(), const_child_iterator());
1861   }
1862
1863   child_range used_children() {
1864     return child_range(child_iterator(), child_iterator());
1865   }
1866   const_child_range used_children() const {
1867     return const_child_range(const_child_iterator(), const_child_iterator());
1868   }
1869
1870   /// Gets the the location of '(' in clause for 'depobj' directive.
1871   SourceLocation getLParenLoc() const {
1872     assert(IsExtended && "Expected extended clause.");
1873     return *getTrailingObjects<SourceLocation>();
1874   }
1875
1876   /// Gets the the location of argument in clause for 'depobj' directive.
1877   SourceLocation getArgumentLoc() const {
1878     assert(IsExtended && "Expected extended clause.");
1879     return *std::next(getTrailingObjects<SourceLocation>(), 1);
1880   }
1881
1882   /// Gets the dependence kind in clause for 'depobj' directive.
1883   OpenMPDependClauseKind getDependencyKind() const {
1884     assert(IsExtended && "Expected extended clause.");
1885     return *getTrailingObjects<OpenMPDependClauseKind>();
1886   }
1887
1888   static bool classof(const OMPClause *T) {
1889     return T->getClauseKind() == OMPC_update;
1890   }
1891 };
1892
1893 /// This represents 'capture' clause in the '#pragma omp atomic'
1894 /// directive.
1895 ///
1896 /// \code
1897 /// #pragma omp atomic capture
1898 /// \endcode
1899 /// In this example directive '#pragma omp atomic' has 'capture' clause.
1900 class OMPCaptureClause : public OMPClause {
1901 public:
1902   /// Build 'capture' clause.
1903   ///
1904   /// \param StartLoc Starting location of the clause.
1905   /// \param EndLoc Ending location of the clause.
1906   OMPCaptureClause(SourceLocation StartLoc, SourceLocation EndLoc)
1907       : OMPClause(OMPC_capture, StartLoc, EndLoc) {}
1908
1909   /// Build an empty clause.
1910   OMPCaptureClause()
1911       : OMPClause(OMPC_capture, SourceLocation(), SourceLocation()) {}
1912
1913   child_range children() {
1914     return child_range(child_iterator(), child_iterator());
1915   }
1916
1917   const_child_range children() const {
1918     return const_child_range(const_child_iterator(), const_child_iterator());
1919   }
1920
1921   child_range used_children() {
1922     return child_range(child_iterator(), child_iterator());
1923   }
1924   const_child_range used_children() const {
1925     return const_child_range(const_child_iterator(), const_child_iterator());
1926   }
1927
1928   static bool classof(const OMPClause *T) {
1929     return T->getClauseKind() == OMPC_capture;
1930   }
1931 };
1932
1933 /// This represents 'seq_cst' clause in the '#pragma omp atomic'
1934 /// directive.
1935 ///
1936 /// \code
1937 /// #pragma omp atomic seq_cst
1938 /// \endcode
1939 /// In this example directive '#pragma omp atomic' has 'seq_cst' clause.
1940 class OMPSeqCstClause : public OMPClause {
1941 public:
1942   /// Build 'seq_cst' clause.
1943   ///
1944   /// \param StartLoc Starting location of the clause.
1945   /// \param EndLoc Ending location of the clause.
1946   OMPSeqCstClause(SourceLocation StartLoc, SourceLocation EndLoc)
1947       : OMPClause(OMPC_seq_cst, StartLoc, EndLoc) {}
1948
1949   /// Build an empty clause.
1950   OMPSeqCstClause()
1951       : OMPClause(OMPC_seq_cst, SourceLocation(), SourceLocation()) {}
1952
1953   child_range children() {
1954     return child_range(child_iterator(), child_iterator());
1955   }
1956
1957   const_child_range children() const {
1958     return const_child_range(const_child_iterator(), const_child_iterator());
1959   }
1960
1961   child_range used_children() {
1962     return child_range(child_iterator(), child_iterator());
1963   }
1964   const_child_range used_children() const {
1965     return const_child_range(const_child_iterator(), const_child_iterator());
1966   }
1967
1968   static bool classof(const OMPClause *T) {
1969     return T->getClauseKind() == OMPC_seq_cst;
1970   }
1971 };
1972
1973 /// This represents 'acq_rel' clause in the '#pragma omp atomic|flush'
1974 /// directives.
1975 ///
1976 /// \code
1977 /// #pragma omp flush acq_rel
1978 /// \endcode
1979 /// In this example directive '#pragma omp flush' has 'acq_rel' clause.
1980 class OMPAcqRelClause final : public OMPClause {
1981 public:
1982   /// Build 'ack_rel' clause.
1983   ///
1984   /// \param StartLoc Starting location of the clause.
1985   /// \param EndLoc Ending location of the clause.
1986   OMPAcqRelClause(SourceLocation StartLoc, SourceLocation EndLoc)
1987       : OMPClause(OMPC_acq_rel, StartLoc, EndLoc) {}
1988
1989   /// Build an empty clause.
1990   OMPAcqRelClause()
1991       : OMPClause(OMPC_acq_rel, SourceLocation(), SourceLocation()) {}
1992
1993   child_range children() {
1994     return child_range(child_iterator(), child_iterator());
1995   }
1996
1997   const_child_range children() const {
1998     return const_child_range(const_child_iterator(), const_child_iterator());
1999   }
2000
2001   child_range used_children() {
2002     return child_range(child_iterator(), child_iterator());
2003   }
2004   const_child_range used_children() const {
2005     return const_child_range(const_child_iterator(), const_child_iterator());
2006   }
2007
2008   static bool classof(const OMPClause *T) {
2009     return T->getClauseKind() == OMPC_acq_rel;
2010   }
2011 };
2012
2013 /// This represents 'acquire' clause in the '#pragma omp atomic|flush'
2014 /// directives.
2015 ///
2016 /// \code
2017 /// #pragma omp flush acquire
2018 /// \endcode
2019 /// In this example directive '#pragma omp flush' has 'acquire' clause.
2020 class OMPAcquireClause final : public OMPClause {
2021 public:
2022   /// Build 'acquire' clause.
2023   ///
2024   /// \param StartLoc Starting location of the clause.
2025   /// \param EndLoc Ending location of the clause.
2026   OMPAcquireClause(SourceLocation StartLoc, SourceLocation EndLoc)
2027       : OMPClause(OMPC_acquire, StartLoc, EndLoc) {}
2028
2029   /// Build an empty clause.
2030   OMPAcquireClause()
2031       : OMPClause(OMPC_acquire, SourceLocation(), SourceLocation()) {}
2032
2033   child_range children() {
2034     return child_range(child_iterator(), child_iterator());
2035   }
2036
2037   const_child_range children() const {
2038     return const_child_range(const_child_iterator(), const_child_iterator());
2039   }
2040
2041   child_range used_children() {
2042     return child_range(child_iterator(), child_iterator());
2043   }
2044   const_child_range used_children() const {
2045     return const_child_range(const_child_iterator(), const_child_iterator());
2046   }
2047
2048   static bool classof(const OMPClause *T) {
2049     return T->getClauseKind() == OMPC_acquire;
2050   }
2051 };
2052
2053 /// This represents 'release' clause in the '#pragma omp atomic|flush'
2054 /// directives.
2055 ///
2056 /// \code
2057 /// #pragma omp flush release
2058 /// \endcode
2059 /// In this example directive '#pragma omp flush' has 'release' clause.
2060 class OMPReleaseClause final : public OMPClause {
2061 public:
2062   /// Build 'release' clause.
2063   ///
2064   /// \param StartLoc Starting location of the clause.
2065   /// \param EndLoc Ending location of the clause.
2066   OMPReleaseClause(SourceLocation StartLoc, SourceLocation EndLoc)
2067       : OMPClause(OMPC_release, StartLoc, EndLoc) {}
2068
2069   /// Build an empty clause.
2070   OMPReleaseClause()
2071       : OMPClause(OMPC_release, SourceLocation(), SourceLocation()) {}
2072
2073   child_range children() {
2074     return child_range(child_iterator(), child_iterator());
2075   }
2076
2077   const_child_range children() const {
2078     return const_child_range(const_child_iterator(), const_child_iterator());
2079   }
2080
2081   child_range used_children() {
2082     return child_range(child_iterator(), child_iterator());
2083   }
2084   const_child_range used_children() const {
2085     return const_child_range(const_child_iterator(), const_child_iterator());
2086   }
2087
2088   static bool classof(const OMPClause *T) {
2089     return T->getClauseKind() == OMPC_release;
2090   }
2091 };
2092
2093 /// This represents 'relaxed' clause in the '#pragma omp atomic'
2094 /// directives.
2095 ///
2096 /// \code
2097 /// #pragma omp atomic relaxed
2098 /// \endcode
2099 /// In this example directive '#pragma omp atomic' has 'relaxed' clause.
2100 class OMPRelaxedClause final : public OMPClause {
2101 public:
2102   /// Build 'relaxed' clause.
2103   ///
2104   /// \param StartLoc Starting location of the clause.
2105   /// \param EndLoc Ending location of the clause.
2106   OMPRelaxedClause(SourceLocation StartLoc, SourceLocation EndLoc)
2107       : OMPClause(OMPC_relaxed, StartLoc, EndLoc) {}
2108
2109   /// Build an empty clause.
2110   OMPRelaxedClause()
2111       : OMPClause(OMPC_relaxed, SourceLocation(), SourceLocation()) {}
2112
2113   child_range children() {
2114     return child_range(child_iterator(), child_iterator());
2115   }
2116
2117   const_child_range children() const {
2118     return const_child_range(const_child_iterator(), const_child_iterator());
2119   }
2120
2121   child_range used_children() {
2122     return child_range(child_iterator(), child_iterator());
2123   }
2124   const_child_range used_children() const {
2125     return const_child_range(const_child_iterator(), const_child_iterator());
2126   }
2127
2128   static bool classof(const OMPClause *T) {
2129     return T->getClauseKind() == OMPC_relaxed;
2130   }
2131 };
2132
2133 /// This represents clause 'private' in the '#pragma omp ...' directives.
2134 ///
2135 /// \code
2136 /// #pragma omp parallel private(a,b)
2137 /// \endcode
2138 /// In this example directive '#pragma omp parallel' has clause 'private'
2139 /// with the variables 'a' and 'b'.
2140 class OMPPrivateClause final
2141     : public OMPVarListClause<OMPPrivateClause>,
2142       private llvm::TrailingObjects<OMPPrivateClause, Expr *> {
2143   friend class OMPClauseReader;
2144   friend OMPVarListClause;
2145   friend TrailingObjects;
2146
2147   /// Build clause with number of variables \a N.
2148   ///
2149   /// \param StartLoc Starting location of the clause.
2150   /// \param LParenLoc Location of '('.
2151   /// \param EndLoc Ending location of the clause.
2152   /// \param N Number of the variables in the clause.
2153   OMPPrivateClause(SourceLocation StartLoc, SourceLocation LParenLoc,
2154                    SourceLocation EndLoc, unsigned N)
2155       : OMPVarListClause<OMPPrivateClause>(OMPC_private, StartLoc, LParenLoc,
2156                                            EndLoc, N) {}
2157
2158   /// Build an empty clause.
2159   ///
2160   /// \param N Number of variables.
2161   explicit OMPPrivateClause(unsigned N)
2162       : OMPVarListClause<OMPPrivateClause>(OMPC_private, SourceLocation(),
2163                                            SourceLocation(), SourceLocation(),
2164                                            N) {}
2165
2166   /// Sets the list of references to private copies with initializers for
2167   /// new private variables.
2168   /// \param VL List of references.
2169   void setPrivateCopies(ArrayRef<Expr *> VL);
2170
2171   /// Gets the list of references to private copies with initializers for
2172   /// new private variables.
2173   MutableArrayRef<Expr *> getPrivateCopies() {
2174     return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
2175   }
2176   ArrayRef<const Expr *> getPrivateCopies() const {
2177     return llvm::makeArrayRef(varlist_end(), varlist_size());
2178   }
2179
2180 public:
2181   /// Creates clause with a list of variables \a VL.
2182   ///
2183   /// \param C AST context.
2184   /// \param StartLoc Starting location of the clause.
2185   /// \param LParenLoc Location of '('.
2186   /// \param EndLoc Ending location of the clause.
2187   /// \param VL List of references to the variables.
2188   /// \param PrivateVL List of references to private copies with initializers.
2189   static OMPPrivateClause *Create(const ASTContext &C, SourceLocation StartLoc,
2190                                   SourceLocation LParenLoc,
2191                                   SourceLocation EndLoc, ArrayRef<Expr *> VL,
2192                                   ArrayRef<Expr *> PrivateVL);
2193
2194   /// Creates an empty clause with the place for \a N variables.
2195   ///
2196   /// \param C AST context.
2197   /// \param N The number of variables.
2198   static OMPPrivateClause *CreateEmpty(const ASTContext &C, unsigned N);
2199
2200   using private_copies_iterator = MutableArrayRef<Expr *>::iterator;
2201   using private_copies_const_iterator = ArrayRef<const Expr *>::iterator;
2202   using private_copies_range = llvm::iterator_range<private_copies_iterator>;
2203   using private_copies_const_range =
2204       llvm::iterator_range<private_copies_const_iterator>;
2205
2206   private_copies_range private_copies() {
2207     return private_copies_range(getPrivateCopies().begin(),
2208                                 getPrivateCopies().end());
2209   }
2210
2211   private_copies_const_range private_copies() const {
2212     return private_copies_const_range(getPrivateCopies().begin(),
2213                                       getPrivateCopies().end());
2214   }
2215
2216   child_range children() {
2217     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
2218                        reinterpret_cast<Stmt **>(varlist_end()));
2219   }
2220
2221   const_child_range children() const {
2222     auto Children = const_cast<OMPPrivateClause *>(this)->children();
2223     return const_child_range(Children.begin(), Children.end());
2224   }
2225
2226   child_range used_children() {
2227     return child_range(child_iterator(), child_iterator());
2228   }
2229   const_child_range used_children() const {
2230     return const_child_range(const_child_iterator(), const_child_iterator());
2231   }
2232
2233   static bool classof(const OMPClause *T) {
2234     return T->getClauseKind() == OMPC_private;
2235   }
2236 };
2237
2238 /// This represents clause 'firstprivate' in the '#pragma omp ...'
2239 /// directives.
2240 ///
2241 /// \code
2242 /// #pragma omp parallel firstprivate(a,b)
2243 /// \endcode
2244 /// In this example directive '#pragma omp parallel' has clause 'firstprivate'
2245 /// with the variables 'a' and 'b'.
2246 class OMPFirstprivateClause final
2247     : public OMPVarListClause<OMPFirstprivateClause>,
2248       public OMPClauseWithPreInit,
2249       private llvm::TrailingObjects<OMPFirstprivateClause, Expr *> {
2250   friend class OMPClauseReader;
2251   friend OMPVarListClause;
2252   friend TrailingObjects;
2253
2254   /// Build clause with number of variables \a N.
2255   ///
2256   /// \param StartLoc Starting location of the clause.
2257   /// \param LParenLoc Location of '('.
2258   /// \param EndLoc Ending location of the clause.
2259   /// \param N Number of the variables in the clause.
2260   OMPFirstprivateClause(SourceLocation StartLoc, SourceLocation LParenLoc,
2261                         SourceLocation EndLoc, unsigned N)
2262       : OMPVarListClause<OMPFirstprivateClause>(OMPC_firstprivate, StartLoc,
2263                                                 LParenLoc, EndLoc, N),
2264         OMPClauseWithPreInit(this) {}
2265
2266   /// Build an empty clause.
2267   ///
2268   /// \param N Number of variables.
2269   explicit OMPFirstprivateClause(unsigned N)
2270       : OMPVarListClause<OMPFirstprivateClause>(
2271             OMPC_firstprivate, SourceLocation(), SourceLocation(),
2272             SourceLocation(), N),
2273         OMPClauseWithPreInit(this) {}
2274
2275   /// Sets the list of references to private copies with initializers for
2276   /// new private variables.
2277   /// \param VL List of references.
2278   void setPrivateCopies(ArrayRef<Expr *> VL);
2279
2280   /// Gets the list of references to private copies with initializers for
2281   /// new private variables.
2282   MutableArrayRef<Expr *> getPrivateCopies() {
2283     return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
2284   }
2285   ArrayRef<const Expr *> getPrivateCopies() const {
2286     return llvm::makeArrayRef(varlist_end(), varlist_size());
2287   }
2288
2289   /// Sets the list of references to initializer variables for new
2290   /// private variables.
2291   /// \param VL List of references.
2292   void setInits(ArrayRef<Expr *> VL);
2293
2294   /// Gets the list of references to initializer variables for new
2295   /// private variables.
2296   MutableArrayRef<Expr *> getInits() {
2297     return MutableArrayRef<Expr *>(getPrivateCopies().end(), varlist_size());
2298   }
2299   ArrayRef<const Expr *> getInits() const {
2300     return llvm::makeArrayRef(getPrivateCopies().end(), varlist_size());
2301   }
2302
2303 public:
2304   /// Creates clause with a list of variables \a VL.
2305   ///
2306   /// \param C AST context.
2307   /// \param StartLoc Starting location of the clause.
2308   /// \param LParenLoc Location of '('.
2309   /// \param EndLoc Ending location of the clause.
2310   /// \param VL List of references to the original variables.
2311   /// \param PrivateVL List of references to private copies with initializers.
2312   /// \param InitVL List of references to auto generated variables used for
2313   /// initialization of a single array element. Used if firstprivate variable is
2314   /// of array type.
2315   /// \param PreInit Statement that must be executed before entering the OpenMP
2316   /// region with this clause.
2317   static OMPFirstprivateClause *
2318   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
2319          SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
2320          ArrayRef<Expr *> InitVL, Stmt *PreInit);
2321
2322   /// Creates an empty clause with the place for \a N variables.
2323   ///
2324   /// \param C AST context.
2325   /// \param N The number of variables.
2326   static OMPFirstprivateClause *CreateEmpty(const ASTContext &C, unsigned N);
2327
2328   using private_copies_iterator = MutableArrayRef<Expr *>::iterator;
2329   using private_copies_const_iterator = ArrayRef<const Expr *>::iterator;
2330   using private_copies_range = llvm::iterator_range<private_copies_iterator>;
2331   using private_copies_const_range =
2332       llvm::iterator_range<private_copies_const_iterator>;
2333
2334   private_copies_range private_copies() {
2335     return private_copies_range(getPrivateCopies().begin(),
2336                                 getPrivateCopies().end());
2337   }
2338   private_copies_const_range private_copies() const {
2339     return private_copies_const_range(getPrivateCopies().begin(),
2340                                       getPrivateCopies().end());
2341   }
2342
2343   using inits_iterator = MutableArrayRef<Expr *>::iterator;
2344   using inits_const_iterator = ArrayRef<const Expr *>::iterator;
2345   using inits_range = llvm::iterator_range<inits_iterator>;
2346   using inits_const_range = llvm::iterator_range<inits_const_iterator>;
2347
2348   inits_range inits() {
2349     return inits_range(getInits().begin(), getInits().end());
2350   }
2351   inits_const_range inits() const {
2352     return inits_const_range(getInits().begin(), getInits().end());
2353   }
2354
2355   child_range children() {
2356     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
2357                        reinterpret_cast<Stmt **>(varlist_end()));
2358   }
2359
2360   const_child_range children() const {
2361     auto Children = const_cast<OMPFirstprivateClause *>(this)->children();
2362     return const_child_range(Children.begin(), Children.end());
2363   }
2364
2365   child_range used_children() {
2366     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
2367                        reinterpret_cast<Stmt **>(varlist_end()));
2368   }
2369   const_child_range used_children() const {
2370     auto Children = const_cast<OMPFirstprivateClause *>(this)->used_children();
2371     return const_child_range(Children.begin(), Children.end());
2372   }
2373
2374   static bool classof(const OMPClause *T) {
2375     return T->getClauseKind() == OMPC_firstprivate;
2376   }
2377 };
2378
2379 /// This represents clause 'lastprivate' in the '#pragma omp ...'
2380 /// directives.
2381 ///
2382 /// \code
2383 /// #pragma omp simd lastprivate(a,b)
2384 /// \endcode
2385 /// In this example directive '#pragma omp simd' has clause 'lastprivate'
2386 /// with the variables 'a' and 'b'.
2387 class OMPLastprivateClause final
2388     : public OMPVarListClause<OMPLastprivateClause>,
2389       public OMPClauseWithPostUpdate,
2390       private llvm::TrailingObjects<OMPLastprivateClause, Expr *> {
2391   // There are 4 additional tail-allocated arrays at the end of the class:
2392   // 1. Contains list of pseudo variables with the default initialization for
2393   // each non-firstprivate variables. Used in codegen for initialization of
2394   // lastprivate copies.
2395   // 2. List of helper expressions for proper generation of assignment operation
2396   // required for lastprivate clause. This list represents private variables
2397   // (for arrays, single array element).
2398   // 3. List of helper expressions for proper generation of assignment operation
2399   // required for lastprivate clause. This list represents original variables
2400   // (for arrays, single array element).
2401   // 4. List of helper expressions that represents assignment operation:
2402   // \code
2403   // DstExprs = SrcExprs;
2404   // \endcode
2405   // Required for proper codegen of final assignment performed by the
2406   // lastprivate clause.
2407   friend class OMPClauseReader;
2408   friend OMPVarListClause;
2409   friend TrailingObjects;
2410
2411   /// Optional lastprivate kind, e.g. 'conditional', if specified by user.
2412   OpenMPLastprivateModifier LPKind;
2413   /// Optional location of the lasptrivate kind, if specified by user.
2414   SourceLocation LPKindLoc;
2415   /// Optional colon location, if specified by user.
2416   SourceLocation ColonLoc;
2417
2418   /// Build clause with number of variables \a N.
2419   ///
2420   /// \param StartLoc Starting location of the clause.
2421   /// \param LParenLoc Location of '('.
2422   /// \param EndLoc Ending location of the clause.
2423   /// \param N Number of the variables in the clause.
2424   OMPLastprivateClause(SourceLocation StartLoc, SourceLocation LParenLoc,
2425                        SourceLocation EndLoc, OpenMPLastprivateModifier LPKind,
2426                        SourceLocation LPKindLoc, SourceLocation ColonLoc,
2427                        unsigned N)
2428       : OMPVarListClause<OMPLastprivateClause>(OMPC_lastprivate, StartLoc,
2429                                                LParenLoc, EndLoc, N),
2430         OMPClauseWithPostUpdate(this), LPKind(LPKind), LPKindLoc(LPKindLoc),
2431         ColonLoc(ColonLoc) {}
2432
2433   /// Build an empty clause.
2434   ///
2435   /// \param N Number of variables.
2436   explicit OMPLastprivateClause(unsigned N)
2437       : OMPVarListClause<OMPLastprivateClause>(
2438             OMPC_lastprivate, SourceLocation(), SourceLocation(),
2439             SourceLocation(), N),
2440         OMPClauseWithPostUpdate(this) {}
2441
2442   /// Get the list of helper expressions for initialization of private
2443   /// copies for lastprivate variables.
2444   MutableArrayRef<Expr *> getPrivateCopies() {
2445     return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
2446   }
2447   ArrayRef<const Expr *> getPrivateCopies() const {
2448     return llvm::makeArrayRef(varlist_end(), varlist_size());
2449   }
2450
2451   /// Set list of helper expressions, required for proper codegen of the
2452   /// clause. These expressions represent private variables (for arrays, single
2453   /// array element) in the final assignment statement performed by the
2454   /// lastprivate clause.
2455   void setSourceExprs(ArrayRef<Expr *> SrcExprs);
2456
2457   /// Get the list of helper source expressions.
2458   MutableArrayRef<Expr *> getSourceExprs() {
2459     return MutableArrayRef<Expr *>(getPrivateCopies().end(), varlist_size());
2460   }
2461   ArrayRef<const Expr *> getSourceExprs() const {
2462     return llvm::makeArrayRef(getPrivateCopies().end(), varlist_size());
2463   }
2464
2465   /// Set list of helper expressions, required for proper codegen of the
2466   /// clause. These expressions represent original variables (for arrays, single
2467   /// array element) in the final assignment statement performed by the
2468   /// lastprivate clause.
2469   void setDestinationExprs(ArrayRef<Expr *> DstExprs);
2470
2471   /// Get the list of helper destination expressions.
2472   MutableArrayRef<Expr *> getDestinationExprs() {
2473     return MutableArrayRef<Expr *>(getSourceExprs().end(), varlist_size());
2474   }
2475   ArrayRef<const Expr *> getDestinationExprs() const {
2476     return llvm::makeArrayRef(getSourceExprs().end(), varlist_size());
2477   }
2478
2479   /// Set list of helper assignment expressions, required for proper
2480   /// codegen of the clause. These expressions are assignment expressions that
2481   /// assign private copy of the variable to original variable.
2482   void setAssignmentOps(ArrayRef<Expr *> AssignmentOps);
2483
2484   /// Get the list of helper assignment expressions.
2485   MutableArrayRef<Expr *> getAssignmentOps() {
2486     return MutableArrayRef<Expr *>(getDestinationExprs().end(), varlist_size());
2487   }
2488   ArrayRef<const Expr *> getAssignmentOps() const {
2489     return llvm::makeArrayRef(getDestinationExprs().end(), varlist_size());
2490   }
2491
2492   /// Sets lastprivate kind.
2493   void setKind(OpenMPLastprivateModifier Kind) { LPKind = Kind; }
2494   /// Sets location of the lastprivate kind.
2495   void setKindLoc(SourceLocation Loc) { LPKindLoc = Loc; }
2496   /// Sets colon symbol location.
2497   void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; }
2498
2499 public:
2500   /// Creates clause with a list of variables \a VL.
2501   ///
2502   /// \param C AST context.
2503   /// \param StartLoc Starting location of the clause.
2504   /// \param LParenLoc Location of '('.
2505   /// \param EndLoc Ending location of the clause.
2506   /// \param VL List of references to the variables.
2507   /// \param SrcExprs List of helper expressions for proper generation of
2508   /// assignment operation required for lastprivate clause. This list represents
2509   /// private variables (for arrays, single array element).
2510   /// \param DstExprs List of helper expressions for proper generation of
2511   /// assignment operation required for lastprivate clause. This list represents
2512   /// original variables (for arrays, single array element).
2513   /// \param AssignmentOps List of helper expressions that represents assignment
2514   /// operation:
2515   /// \code
2516   /// DstExprs = SrcExprs;
2517   /// \endcode
2518   /// Required for proper codegen of final assignment performed by the
2519   /// lastprivate clause.
2520   /// \param LPKind Lastprivate kind, e.g. 'conditional'.
2521   /// \param LPKindLoc Location of the lastprivate kind.
2522   /// \param ColonLoc Location of the ':' symbol if lastprivate kind is used.
2523   /// \param PreInit Statement that must be executed before entering the OpenMP
2524   /// region with this clause.
2525   /// \param PostUpdate Expression that must be executed after exit from the
2526   /// OpenMP region with this clause.
2527   static OMPLastprivateClause *
2528   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
2529          SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
2530          ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps,
2531          OpenMPLastprivateModifier LPKind, SourceLocation LPKindLoc,
2532          SourceLocation ColonLoc, Stmt *PreInit, Expr *PostUpdate);
2533
2534   /// Creates an empty clause with the place for \a N variables.
2535   ///
2536   /// \param C AST context.
2537   /// \param N The number of variables.
2538   static OMPLastprivateClause *CreateEmpty(const ASTContext &C, unsigned N);
2539
2540   /// Lastprivate kind.
2541   OpenMPLastprivateModifier getKind() const { return LPKind; }
2542   /// Returns the location of the lastprivate kind.
2543   SourceLocation getKindLoc() const { return LPKindLoc; }
2544   /// Returns the location of the ':' symbol, if any.
2545   SourceLocation getColonLoc() const { return ColonLoc; }
2546
2547   using helper_expr_iterator = MutableArrayRef<Expr *>::iterator;
2548   using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator;
2549   using helper_expr_range = llvm::iterator_range<helper_expr_iterator>;
2550   using helper_expr_const_range =
2551       llvm::iterator_range<helper_expr_const_iterator>;
2552
2553   /// Set list of helper expressions, required for generation of private
2554   /// copies of original lastprivate variables.
2555   void setPrivateCopies(ArrayRef<Expr *> PrivateCopies);
2556
2557   helper_expr_const_range private_copies() const {
2558     return helper_expr_const_range(getPrivateCopies().begin(),
2559                                    getPrivateCopies().end());
2560   }
2561
2562   helper_expr_range private_copies() {
2563     return helper_expr_range(getPrivateCopies().begin(),
2564                              getPrivateCopies().end());
2565   }
2566
2567   helper_expr_const_range source_exprs() const {
2568     return helper_expr_const_range(getSourceExprs().begin(),
2569                                    getSourceExprs().end());
2570   }
2571
2572   helper_expr_range source_exprs() {
2573     return helper_expr_range(getSourceExprs().begin(), getSourceExprs().end());
2574   }
2575
2576   helper_expr_const_range destination_exprs() const {
2577     return helper_expr_const_range(getDestinationExprs().begin(),
2578                                    getDestinationExprs().end());
2579   }
2580
2581   helper_expr_range destination_exprs() {
2582     return helper_expr_range(getDestinationExprs().begin(),
2583                              getDestinationExprs().end());
2584   }
2585
2586   helper_expr_const_range assignment_ops() const {
2587     return helper_expr_const_range(getAssignmentOps().begin(),
2588                                    getAssignmentOps().end());
2589   }
2590
2591   helper_expr_range assignment_ops() {
2592     return helper_expr_range(getAssignmentOps().begin(),
2593                              getAssignmentOps().end());
2594   }
2595
2596   child_range children() {
2597     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
2598                        reinterpret_cast<Stmt **>(varlist_end()));
2599   }
2600
2601   const_child_range children() const {
2602     auto Children = const_cast<OMPLastprivateClause *>(this)->children();
2603     return const_child_range(Children.begin(), Children.end());
2604   }
2605
2606   child_range used_children() {
2607     return child_range(child_iterator(), child_iterator());
2608   }
2609   const_child_range used_children() const {
2610     return const_child_range(const_child_iterator(), const_child_iterator());
2611   }
2612
2613   static bool classof(const OMPClause *T) {
2614     return T->getClauseKind() == OMPC_lastprivate;
2615   }
2616 };
2617
2618 /// This represents clause 'shared' in the '#pragma omp ...' directives.
2619 ///
2620 /// \code
2621 /// #pragma omp parallel shared(a,b)
2622 /// \endcode
2623 /// In this example directive '#pragma omp parallel' has clause 'shared'
2624 /// with the variables 'a' and 'b'.
2625 class OMPSharedClause final
2626     : public OMPVarListClause<OMPSharedClause>,
2627       private llvm::TrailingObjects<OMPSharedClause, Expr *> {
2628   friend OMPVarListClause;
2629   friend TrailingObjects;
2630
2631   /// Build clause with number of variables \a N.
2632   ///
2633   /// \param StartLoc Starting location of the clause.
2634   /// \param LParenLoc Location of '('.
2635   /// \param EndLoc Ending location of the clause.
2636   /// \param N Number of the variables in the clause.
2637   OMPSharedClause(SourceLocation StartLoc, SourceLocation LParenLoc,
2638                   SourceLocation EndLoc, unsigned N)
2639       : OMPVarListClause<OMPSharedClause>(OMPC_shared, StartLoc, LParenLoc,
2640                                           EndLoc, N) {}
2641
2642   /// Build an empty clause.
2643   ///
2644   /// \param N Number of variables.
2645   explicit OMPSharedClause(unsigned N)
2646       : OMPVarListClause<OMPSharedClause>(OMPC_shared, SourceLocation(),
2647                                           SourceLocation(), SourceLocation(),
2648                                           N) {}
2649
2650 public:
2651   /// Creates clause with a list of variables \a VL.
2652   ///
2653   /// \param C AST context.
2654   /// \param StartLoc Starting location of the clause.
2655   /// \param LParenLoc Location of '('.
2656   /// \param EndLoc Ending location of the clause.
2657   /// \param VL List of references to the variables.
2658   static OMPSharedClause *Create(const ASTContext &C, SourceLocation StartLoc,
2659                                  SourceLocation LParenLoc,
2660                                  SourceLocation EndLoc, ArrayRef<Expr *> VL);
2661
2662   /// Creates an empty clause with \a N variables.
2663   ///
2664   /// \param C AST context.
2665   /// \param N The number of variables.
2666   static OMPSharedClause *CreateEmpty(const ASTContext &C, unsigned N);
2667
2668   child_range children() {
2669     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
2670                        reinterpret_cast<Stmt **>(varlist_end()));
2671   }
2672
2673   const_child_range children() const {
2674     auto Children = const_cast<OMPSharedClause *>(this)->children();
2675     return const_child_range(Children.begin(), Children.end());
2676   }
2677
2678   child_range used_children() {
2679     return child_range(child_iterator(), child_iterator());
2680   }
2681   const_child_range used_children() const {
2682     return const_child_range(const_child_iterator(), const_child_iterator());
2683   }
2684
2685   static bool classof(const OMPClause *T) {
2686     return T->getClauseKind() == OMPC_shared;
2687   }
2688 };
2689
2690 /// This represents clause 'reduction' in the '#pragma omp ...'
2691 /// directives.
2692 ///
2693 /// \code
2694 /// #pragma omp parallel reduction(+:a,b)
2695 /// \endcode
2696 /// In this example directive '#pragma omp parallel' has clause 'reduction'
2697 /// with operator '+' and the variables 'a' and 'b'.
2698 class OMPReductionClause final
2699     : public OMPVarListClause<OMPReductionClause>,
2700       public OMPClauseWithPostUpdate,
2701       private llvm::TrailingObjects<OMPReductionClause, Expr *> {
2702   friend class OMPClauseReader;
2703   friend OMPVarListClause;
2704   friend TrailingObjects;
2705
2706   /// Reduction modifier.
2707   OpenMPReductionClauseModifier Modifier = OMPC_REDUCTION_unknown;
2708
2709   /// Reduction modifier location.
2710   SourceLocation ModifierLoc;
2711
2712   /// Location of ':'.
2713   SourceLocation ColonLoc;
2714
2715   /// Nested name specifier for C++.
2716   NestedNameSpecifierLoc QualifierLoc;
2717
2718   /// Name of custom operator.
2719   DeclarationNameInfo NameInfo;
2720
2721   /// Build clause with number of variables \a N.
2722   ///
2723   /// \param StartLoc Starting location of the clause.
2724   /// \param LParenLoc Location of '('.
2725   /// \param ModifierLoc Modifier location.
2726   /// \param ColonLoc Location of ':'.
2727   /// \param EndLoc Ending location of the clause.
2728   /// \param N Number of the variables in the clause.
2729   /// \param QualifierLoc The nested-name qualifier with location information
2730   /// \param NameInfo The full name info for reduction identifier.
2731   OMPReductionClause(SourceLocation StartLoc, SourceLocation LParenLoc,
2732                      SourceLocation ModifierLoc, SourceLocation ColonLoc,
2733                      SourceLocation EndLoc,
2734                      OpenMPReductionClauseModifier Modifier, unsigned N,
2735                      NestedNameSpecifierLoc QualifierLoc,
2736                      const DeclarationNameInfo &NameInfo)
2737       : OMPVarListClause<OMPReductionClause>(OMPC_reduction, StartLoc,
2738                                              LParenLoc, EndLoc, N),
2739         OMPClauseWithPostUpdate(this), Modifier(Modifier),
2740         ModifierLoc(ModifierLoc), ColonLoc(ColonLoc),
2741         QualifierLoc(QualifierLoc), NameInfo(NameInfo) {}
2742
2743   /// Build an empty clause.
2744   ///
2745   /// \param N Number of variables.
2746   explicit OMPReductionClause(unsigned N)
2747       : OMPVarListClause<OMPReductionClause>(OMPC_reduction, SourceLocation(),
2748                                              SourceLocation(), SourceLocation(),
2749                                              N),
2750         OMPClauseWithPostUpdate(this) {}
2751
2752   /// Sets reduction modifier.
2753   void setModifier(OpenMPReductionClauseModifier M) { Modifier = M; }
2754
2755   /// Sets location of the modifier.
2756   void setModifierLoc(SourceLocation Loc) { ModifierLoc = Loc; }
2757
2758   /// Sets location of ':' symbol in clause.
2759   void setColonLoc(SourceLocation CL) { ColonLoc = CL; }
2760
2761   /// Sets the name info for specified reduction identifier.
2762   void setNameInfo(DeclarationNameInfo DNI) { NameInfo = DNI; }
2763
2764   /// Sets the nested name specifier.
2765   void setQualifierLoc(NestedNameSpecifierLoc NSL) { QualifierLoc = NSL; }
2766
2767   /// Set list of helper expressions, required for proper codegen of the
2768   /// clause. These expressions represent private copy of the reduction
2769   /// variable.
2770   void setPrivates(ArrayRef<Expr *> Privates);
2771
2772   /// Get the list of helper privates.
2773   MutableArrayRef<Expr *> getPrivates() {
2774     return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
2775   }
2776   ArrayRef<const Expr *> getPrivates() const {
2777     return llvm::makeArrayRef(varlist_end(), varlist_size());
2778   }
2779
2780   /// Set list of helper expressions, required for proper codegen of the
2781   /// clause. These expressions represent LHS expression in the final
2782   /// reduction expression performed by the reduction clause.
2783   void setLHSExprs(ArrayRef<Expr *> LHSExprs);
2784
2785   /// Get the list of helper LHS expressions.
2786   MutableArrayRef<Expr *> getLHSExprs() {
2787     return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size());
2788   }
2789   ArrayRef<const Expr *> getLHSExprs() const {
2790     return llvm::makeArrayRef(getPrivates().end(), varlist_size());
2791   }
2792
2793   /// Set list of helper expressions, required for proper codegen of the
2794   /// clause. These expressions represent RHS expression in the final
2795   /// reduction expression performed by the reduction clause.
2796   /// Also, variables in these expressions are used for proper initialization of
2797   /// reduction copies.
2798   void setRHSExprs(ArrayRef<Expr *> RHSExprs);
2799
2800   /// Get the list of helper destination expressions.
2801   MutableArrayRef<Expr *> getRHSExprs() {
2802     return MutableArrayRef<Expr *>(getLHSExprs().end(), varlist_size());
2803   }
2804   ArrayRef<const Expr *> getRHSExprs() const {
2805     return llvm::makeArrayRef(getLHSExprs().end(), varlist_size());
2806   }
2807
2808   /// Set list of helper reduction expressions, required for proper
2809   /// codegen of the clause. These expressions are binary expressions or
2810   /// operator/custom reduction call that calculates new value from source
2811   /// helper expressions to destination helper expressions.
2812   void setReductionOps(ArrayRef<Expr *> ReductionOps);
2813
2814   /// Get the list of helper reduction expressions.
2815   MutableArrayRef<Expr *> getReductionOps() {
2816     return MutableArrayRef<Expr *>(getRHSExprs().end(), varlist_size());
2817   }
2818   ArrayRef<const Expr *> getReductionOps() const {
2819     return llvm::makeArrayRef(getRHSExprs().end(), varlist_size());
2820   }
2821
2822 public:
2823   /// Creates clause with a list of variables \a VL.
2824   ///
2825   /// \param StartLoc Starting location of the clause.
2826   /// \param LParenLoc Location of '('.
2827   /// \param ModifierLoc Modifier location.
2828   /// \param ColonLoc Location of ':'.
2829   /// \param EndLoc Ending location of the clause.
2830   /// \param VL The variables in the clause.
2831   /// \param QualifierLoc The nested-name qualifier with location information
2832   /// \param NameInfo The full name info for reduction identifier.
2833   /// \param Privates List of helper expressions for proper generation of
2834   /// private copies.
2835   /// \param LHSExprs List of helper expressions for proper generation of
2836   /// assignment operation required for copyprivate clause. This list represents
2837   /// LHSs of the reduction expressions.
2838   /// \param RHSExprs List of helper expressions for proper generation of
2839   /// assignment operation required for copyprivate clause. This list represents
2840   /// RHSs of the reduction expressions.
2841   /// Also, variables in these expressions are used for proper initialization of
2842   /// reduction copies.
2843   /// \param ReductionOps List of helper expressions that represents reduction
2844   /// expressions:
2845   /// \code
2846   /// LHSExprs binop RHSExprs;
2847   /// operator binop(LHSExpr, RHSExpr);
2848   /// <CutomReduction>(LHSExpr, RHSExpr);
2849   /// \endcode
2850   /// Required for proper codegen of final reduction operation performed by the
2851   /// reduction clause.
2852   /// \param PreInit Statement that must be executed before entering the OpenMP
2853   /// region with this clause.
2854   /// \param PostUpdate Expression that must be executed after exit from the
2855   /// OpenMP region with this clause.
2856   static OMPReductionClause *
2857   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
2858          SourceLocation ModifierLoc, SourceLocation ColonLoc,
2859          SourceLocation EndLoc, OpenMPReductionClauseModifier Modifier,
2860          ArrayRef<Expr *> VL, NestedNameSpecifierLoc QualifierLoc,
2861          const DeclarationNameInfo &NameInfo, ArrayRef<Expr *> Privates,
2862          ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
2863          ArrayRef<Expr *> ReductionOps, Stmt *PreInit, Expr *PostUpdate);
2864
2865   /// Creates an empty clause with the place for \a N variables.
2866   ///
2867   /// \param C AST context.
2868   /// \param N The number of variables.
2869   static OMPReductionClause *CreateEmpty(const ASTContext &C, unsigned N);
2870
2871   /// Returns modifier.
2872   OpenMPReductionClauseModifier getModifier() const { return Modifier; }
2873
2874   /// Returns modifier location.
2875   SourceLocation getModifierLoc() const { return ModifierLoc; }
2876
2877   /// Gets location of ':' symbol in clause.
2878   SourceLocation getColonLoc() const { return ColonLoc; }
2879
2880   /// Gets the name info for specified reduction identifier.
2881   const DeclarationNameInfo &getNameInfo() const { return NameInfo; }
2882
2883   /// Gets the nested name specifier.
2884   NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
2885
2886   using helper_expr_iterator = MutableArrayRef<Expr *>::iterator;
2887   using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator;
2888   using helper_expr_range = llvm::iterator_range<helper_expr_iterator>;
2889   using helper_expr_const_range =
2890       llvm::iterator_range<helper_expr_const_iterator>;
2891
2892   helper_expr_const_range privates() const {
2893     return helper_expr_const_range(getPrivates().begin(), getPrivates().end());
2894   }
2895
2896   helper_expr_range privates() {
2897     return helper_expr_range(getPrivates().begin(), getPrivates().end());
2898   }
2899
2900   helper_expr_const_range lhs_exprs() const {
2901     return helper_expr_const_range(getLHSExprs().begin(), getLHSExprs().end());
2902   }
2903
2904   helper_expr_range lhs_exprs() {
2905     return helper_expr_range(getLHSExprs().begin(), getLHSExprs().end());
2906   }
2907
2908   helper_expr_const_range rhs_exprs() const {
2909     return helper_expr_const_range(getRHSExprs().begin(), getRHSExprs().end());
2910   }
2911
2912   helper_expr_range rhs_exprs() {
2913     return helper_expr_range(getRHSExprs().begin(), getRHSExprs().end());
2914   }
2915
2916   helper_expr_const_range reduction_ops() const {
2917     return helper_expr_const_range(getReductionOps().begin(),
2918                                    getReductionOps().end());
2919   }
2920
2921   helper_expr_range reduction_ops() {
2922     return helper_expr_range(getReductionOps().begin(),
2923                              getReductionOps().end());
2924   }
2925
2926   child_range children() {
2927     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
2928                        reinterpret_cast<Stmt **>(varlist_end()));
2929   }
2930
2931   const_child_range children() const {
2932     auto Children = const_cast<OMPReductionClause *>(this)->children();
2933     return const_child_range(Children.begin(), Children.end());
2934   }
2935
2936   child_range used_children() {
2937     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
2938                        reinterpret_cast<Stmt **>(varlist_end()));
2939   }
2940   const_child_range used_children() const {
2941     auto Children = const_cast<OMPReductionClause *>(this)->used_children();
2942     return const_child_range(Children.begin(), Children.end());
2943   }
2944
2945   static bool classof(const OMPClause *T) {
2946     return T->getClauseKind() == OMPC_reduction;
2947   }
2948 };
2949
2950 /// This represents clause 'task_reduction' in the '#pragma omp taskgroup'
2951 /// directives.
2952 ///
2953 /// \code
2954 /// #pragma omp taskgroup task_reduction(+:a,b)
2955 /// \endcode
2956 /// In this example directive '#pragma omp taskgroup' has clause
2957 /// 'task_reduction' with operator '+' and the variables 'a' and 'b'.
2958 class OMPTaskReductionClause final
2959     : public OMPVarListClause<OMPTaskReductionClause>,
2960       public OMPClauseWithPostUpdate,
2961       private llvm::TrailingObjects<OMPTaskReductionClause, Expr *> {
2962   friend class OMPClauseReader;
2963   friend OMPVarListClause;
2964   friend TrailingObjects;
2965
2966   /// Location of ':'.
2967   SourceLocation ColonLoc;
2968
2969   /// Nested name specifier for C++.
2970   NestedNameSpecifierLoc QualifierLoc;
2971
2972   /// Name of custom operator.
2973   DeclarationNameInfo NameInfo;
2974
2975   /// Build clause with number of variables \a N.
2976   ///
2977   /// \param StartLoc Starting location of the clause.
2978   /// \param LParenLoc Location of '('.
2979   /// \param EndLoc Ending location of the clause.
2980   /// \param ColonLoc Location of ':'.
2981   /// \param N Number of the variables in the clause.
2982   /// \param QualifierLoc The nested-name qualifier with location information
2983   /// \param NameInfo The full name info for reduction identifier.
2984   OMPTaskReductionClause(SourceLocation StartLoc, SourceLocation LParenLoc,
2985                          SourceLocation ColonLoc, SourceLocation EndLoc,
2986                          unsigned N, NestedNameSpecifierLoc QualifierLoc,
2987                          const DeclarationNameInfo &NameInfo)
2988       : OMPVarListClause<OMPTaskReductionClause>(OMPC_task_reduction, StartLoc,
2989                                                  LParenLoc, EndLoc, N),
2990         OMPClauseWithPostUpdate(this), ColonLoc(ColonLoc),
2991         QualifierLoc(QualifierLoc), NameInfo(NameInfo) {}
2992
2993   /// Build an empty clause.
2994   ///
2995   /// \param N Number of variables.
2996   explicit OMPTaskReductionClause(unsigned N)
2997       : OMPVarListClause<OMPTaskReductionClause>(
2998             OMPC_task_reduction, SourceLocation(), SourceLocation(),
2999             SourceLocation(), N),
3000         OMPClauseWithPostUpdate(this) {}
3001
3002   /// Sets location of ':' symbol in clause.
3003   void setColonLoc(SourceLocation CL) { ColonLoc = CL; }
3004
3005   /// Sets the name info for specified reduction identifier.
3006   void setNameInfo(DeclarationNameInfo DNI) { NameInfo = DNI; }
3007
3008   /// Sets the nested name specifier.
3009   void setQualifierLoc(NestedNameSpecifierLoc NSL) { QualifierLoc = NSL; }
3010
3011   /// Set list of helper expressions, required for proper codegen of the clause.
3012   /// These expressions represent private copy of the reduction variable.
3013   void setPrivates(ArrayRef<Expr *> Privates);
3014
3015   /// Get the list of helper privates.
3016   MutableArrayRef<Expr *> getPrivates() {
3017     return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
3018   }
3019   ArrayRef<const Expr *> getPrivates() const {
3020     return llvm::makeArrayRef(varlist_end(), varlist_size());
3021   }
3022
3023   /// Set list of helper expressions, required for proper codegen of the clause.
3024   /// These expressions represent LHS expression in the final reduction
3025   /// expression performed by the reduction clause.
3026   void setLHSExprs(ArrayRef<Expr *> LHSExprs);
3027
3028   /// Get the list of helper LHS expressions.
3029   MutableArrayRef<Expr *> getLHSExprs() {
3030     return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size());
3031   }
3032   ArrayRef<const Expr *> getLHSExprs() const {
3033     return llvm::makeArrayRef(getPrivates().end(), varlist_size());
3034   }
3035
3036   /// Set list of helper expressions, required for proper codegen of the clause.
3037   /// These expressions represent RHS expression in the final reduction
3038   /// expression performed by the reduction clause. Also, variables in these
3039   /// expressions are used for proper initialization of reduction copies.
3040   void setRHSExprs(ArrayRef<Expr *> RHSExprs);
3041
3042   ///  Get the list of helper destination expressions.
3043   MutableArrayRef<Expr *> getRHSExprs() {
3044     return MutableArrayRef<Expr *>(getLHSExprs().end(), varlist_size());
3045   }
3046   ArrayRef<const Expr *> getRHSExprs() const {
3047     return llvm::makeArrayRef(getLHSExprs().end(), varlist_size());
3048   }
3049
3050   /// Set list of helper reduction expressions, required for proper
3051   /// codegen of the clause. These expressions are binary expressions or
3052   /// operator/custom reduction call that calculates new value from source
3053   /// helper expressions to destination helper expressions.
3054   void setReductionOps(ArrayRef<Expr *> ReductionOps);
3055
3056   ///  Get the list of helper reduction expressions.
3057   MutableArrayRef<Expr *> getReductionOps() {
3058     return MutableArrayRef<Expr *>(getRHSExprs().end(), varlist_size());
3059   }
3060   ArrayRef<const Expr *> getReductionOps() const {
3061     return llvm::makeArrayRef(getRHSExprs().end(), varlist_size());
3062   }
3063
3064 public:
3065   /// Creates clause with a list of variables \a VL.
3066   ///
3067   /// \param StartLoc Starting location of the clause.
3068   /// \param LParenLoc Location of '('.
3069   /// \param ColonLoc Location of ':'.
3070   /// \param EndLoc Ending location of the clause.
3071   /// \param VL The variables in the clause.
3072   /// \param QualifierLoc The nested-name qualifier with location information
3073   /// \param NameInfo The full name info for reduction identifier.
3074   /// \param Privates List of helper expressions for proper generation of
3075   /// private copies.
3076   /// \param LHSExprs List of helper expressions for proper generation of
3077   /// assignment operation required for copyprivate clause. This list represents
3078   /// LHSs of the reduction expressions.
3079   /// \param RHSExprs List of helper expressions for proper generation of
3080   /// assignment operation required for copyprivate clause. This list represents
3081   /// RHSs of the reduction expressions.
3082   /// Also, variables in these expressions are used for proper initialization of
3083   /// reduction copies.
3084   /// \param ReductionOps List of helper expressions that represents reduction
3085   /// expressions:
3086   /// \code
3087   /// LHSExprs binop RHSExprs;
3088   /// operator binop(LHSExpr, RHSExpr);
3089   /// <CutomReduction>(LHSExpr, RHSExpr);
3090   /// \endcode
3091   /// Required for proper codegen of final reduction operation performed by the
3092   /// reduction clause.
3093   /// \param PreInit Statement that must be executed before entering the OpenMP
3094   /// region with this clause.
3095   /// \param PostUpdate Expression that must be executed after exit from the
3096   /// OpenMP region with this clause.
3097   static OMPTaskReductionClause *
3098   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
3099          SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
3100          NestedNameSpecifierLoc QualifierLoc,
3101          const DeclarationNameInfo &NameInfo, ArrayRef<Expr *> Privates,
3102          ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
3103          ArrayRef<Expr *> ReductionOps, Stmt *PreInit, Expr *PostUpdate);
3104
3105   /// Creates an empty clause with the place for \a N variables.
3106   ///
3107   /// \param C AST context.
3108   /// \param N The number of variables.
3109   static OMPTaskReductionClause *CreateEmpty(const ASTContext &C, unsigned N);
3110
3111   /// Gets location of ':' symbol in clause.
3112   SourceLocation getColonLoc() const { return ColonLoc; }
3113
3114   /// Gets the name info for specified reduction identifier.
3115   const DeclarationNameInfo &getNameInfo() const { return NameInfo; }
3116
3117   /// Gets the nested name specifier.
3118   NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
3119
3120   using helper_expr_iterator = MutableArrayRef<Expr *>::iterator;
3121   using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator;
3122   using helper_expr_range = llvm::iterator_range<helper_expr_iterator>;
3123   using helper_expr_const_range =
3124       llvm::iterator_range<helper_expr_const_iterator>;
3125
3126   helper_expr_const_range privates() const {
3127     return helper_expr_const_range(getPrivates().begin(), getPrivates().end());
3128   }
3129
3130   helper_expr_range privates() {
3131     return helper_expr_range(getPrivates().begin(), getPrivates().end());
3132   }
3133
3134   helper_expr_const_range lhs_exprs() const {
3135     return helper_expr_const_range(getLHSExprs().begin(), getLHSExprs().end());
3136   }
3137
3138   helper_expr_range lhs_exprs() {
3139     return helper_expr_range(getLHSExprs().begin(), getLHSExprs().end());
3140   }
3141
3142   helper_expr_const_range rhs_exprs() const {
3143     return helper_expr_const_range(getRHSExprs().begin(), getRHSExprs().end());
3144   }
3145
3146   helper_expr_range rhs_exprs() {
3147     return helper_expr_range(getRHSExprs().begin(), getRHSExprs().end());
3148   }
3149
3150   helper_expr_const_range reduction_ops() const {
3151     return helper_expr_const_range(getReductionOps().begin(),
3152                                    getReductionOps().end());
3153   }
3154
3155   helper_expr_range reduction_ops() {
3156     return helper_expr_range(getReductionOps().begin(),
3157                              getReductionOps().end());
3158   }
3159
3160   child_range children() {
3161     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
3162                        reinterpret_cast<Stmt **>(varlist_end()));
3163   }
3164
3165   const_child_range children() const {
3166     auto Children = const_cast<OMPTaskReductionClause *>(this)->children();
3167     return const_child_range(Children.begin(), Children.end());
3168   }
3169
3170   child_range used_children() {
3171     return child_range(child_iterator(), child_iterator());
3172   }
3173   const_child_range used_children() const {
3174     return const_child_range(const_child_iterator(), const_child_iterator());
3175   }
3176
3177   static bool classof(const OMPClause *T) {
3178     return T->getClauseKind() == OMPC_task_reduction;
3179   }
3180 };
3181
3182 /// This represents clause 'in_reduction' in the '#pragma omp task' directives.
3183 ///
3184 /// \code
3185 /// #pragma omp task in_reduction(+:a,b)
3186 /// \endcode
3187 /// In this example directive '#pragma omp task' has clause 'in_reduction' with
3188 /// operator '+' and the variables 'a' and 'b'.
3189 class OMPInReductionClause final
3190     : public OMPVarListClause<OMPInReductionClause>,
3191       public OMPClauseWithPostUpdate,
3192       private llvm::TrailingObjects<OMPInReductionClause, Expr *> {
3193   friend class OMPClauseReader;
3194   friend OMPVarListClause;
3195   friend TrailingObjects;
3196
3197   /// Location of ':'.
3198   SourceLocation ColonLoc;
3199
3200   /// Nested name specifier for C++.
3201   NestedNameSpecifierLoc QualifierLoc;
3202
3203   /// Name of custom operator.
3204   DeclarationNameInfo NameInfo;
3205
3206   /// Build clause with number of variables \a N.
3207   ///
3208   /// \param StartLoc Starting location of the clause.
3209   /// \param LParenLoc Location of '('.
3210   /// \param EndLoc Ending location of the clause.
3211   /// \param ColonLoc Location of ':'.
3212   /// \param N Number of the variables in the clause.
3213   /// \param QualifierLoc The nested-name qualifier with location information
3214   /// \param NameInfo The full name info for reduction identifier.
3215   OMPInReductionClause(SourceLocation StartLoc, SourceLocation LParenLoc,
3216                        SourceLocation ColonLoc, SourceLocation EndLoc,
3217                        unsigned N, NestedNameSpecifierLoc QualifierLoc,
3218                        const DeclarationNameInfo &NameInfo)
3219       : OMPVarListClause<OMPInReductionClause>(OMPC_in_reduction, StartLoc,
3220                                                LParenLoc, EndLoc, N),
3221         OMPClauseWithPostUpdate(this), ColonLoc(ColonLoc),
3222         QualifierLoc(QualifierLoc), NameInfo(NameInfo) {}
3223
3224   /// Build an empty clause.
3225   ///
3226   /// \param N Number of variables.
3227   explicit OMPInReductionClause(unsigned N)
3228       : OMPVarListClause<OMPInReductionClause>(
3229             OMPC_in_reduction, SourceLocation(), SourceLocation(),
3230             SourceLocation(), N),
3231         OMPClauseWithPostUpdate(this) {}
3232
3233   /// Sets location of ':' symbol in clause.
3234   void setColonLoc(SourceLocation CL) { ColonLoc = CL; }
3235
3236   /// Sets the name info for specified reduction identifier.
3237   void setNameInfo(DeclarationNameInfo DNI) { NameInfo = DNI; }
3238
3239   /// Sets the nested name specifier.
3240   void setQualifierLoc(NestedNameSpecifierLoc NSL) { QualifierLoc = NSL; }
3241
3242   /// Set list of helper expressions, required for proper codegen of the clause.
3243   /// These expressions represent private copy of the reduction variable.
3244   void setPrivates(ArrayRef<Expr *> Privates);
3245
3246   /// Get the list of helper privates.
3247   MutableArrayRef<Expr *> getPrivates() {
3248     return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
3249   }
3250   ArrayRef<const Expr *> getPrivates() const {
3251     return llvm::makeArrayRef(varlist_end(), varlist_size());
3252   }
3253
3254   /// Set list of helper expressions, required for proper codegen of the clause.
3255   /// These expressions represent LHS expression in the final reduction
3256   /// expression performed by the reduction clause.
3257   void setLHSExprs(ArrayRef<Expr *> LHSExprs);
3258
3259   /// Get the list of helper LHS expressions.
3260   MutableArrayRef<Expr *> getLHSExprs() {
3261     return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size());
3262   }
3263   ArrayRef<const Expr *> getLHSExprs() const {
3264     return llvm::makeArrayRef(getPrivates().end(), varlist_size());
3265   }
3266
3267   /// Set list of helper expressions, required for proper codegen of the clause.
3268   /// These expressions represent RHS expression in the final reduction
3269   /// expression performed by the reduction clause. Also, variables in these
3270   /// expressions are used for proper initialization of reduction copies.
3271   void setRHSExprs(ArrayRef<Expr *> RHSExprs);
3272
3273   ///  Get the list of helper destination expressions.
3274   MutableArrayRef<Expr *> getRHSExprs() {
3275     return MutableArrayRef<Expr *>(getLHSExprs().end(), varlist_size());
3276   }
3277   ArrayRef<const Expr *> getRHSExprs() const {
3278     return llvm::makeArrayRef(getLHSExprs().end(), varlist_size());
3279   }
3280
3281   /// Set list of helper reduction expressions, required for proper
3282   /// codegen of the clause. These expressions are binary expressions or
3283   /// operator/custom reduction call that calculates new value from source
3284   /// helper expressions to destination helper expressions.
3285   void setReductionOps(ArrayRef<Expr *> ReductionOps);
3286
3287   ///  Get the list of helper reduction expressions.
3288   MutableArrayRef<Expr *> getReductionOps() {
3289     return MutableArrayRef<Expr *>(getRHSExprs().end(), varlist_size());
3290   }
3291   ArrayRef<const Expr *> getReductionOps() const {
3292     return llvm::makeArrayRef(getRHSExprs().end(), varlist_size());
3293   }
3294
3295   /// Set list of helper reduction taskgroup descriptors.
3296   void setTaskgroupDescriptors(ArrayRef<Expr *> ReductionOps);
3297
3298   ///  Get the list of helper reduction taskgroup descriptors.
3299   MutableArrayRef<Expr *> getTaskgroupDescriptors() {
3300     return MutableArrayRef<Expr *>(getReductionOps().end(), varlist_size());
3301   }
3302   ArrayRef<const Expr *> getTaskgroupDescriptors() const {
3303     return llvm::makeArrayRef(getReductionOps().end(), varlist_size());
3304   }
3305
3306 public:
3307   /// Creates clause with a list of variables \a VL.
3308   ///
3309   /// \param StartLoc Starting location of the clause.
3310   /// \param LParenLoc Location of '('.
3311   /// \param ColonLoc Location of ':'.
3312   /// \param EndLoc Ending location of the clause.
3313   /// \param VL The variables in the clause.
3314   /// \param QualifierLoc The nested-name qualifier with location information
3315   /// \param NameInfo The full name info for reduction identifier.
3316   /// \param Privates List of helper expressions for proper generation of
3317   /// private copies.
3318   /// \param LHSExprs List of helper expressions for proper generation of
3319   /// assignment operation required for copyprivate clause. This list represents
3320   /// LHSs of the reduction expressions.
3321   /// \param RHSExprs List of helper expressions for proper generation of
3322   /// assignment operation required for copyprivate clause. This list represents
3323   /// RHSs of the reduction expressions.
3324   /// Also, variables in these expressions are used for proper initialization of
3325   /// reduction copies.
3326   /// \param ReductionOps List of helper expressions that represents reduction
3327   /// expressions:
3328   /// \code
3329   /// LHSExprs binop RHSExprs;
3330   /// operator binop(LHSExpr, RHSExpr);
3331   /// <CutomReduction>(LHSExpr, RHSExpr);
3332   /// \endcode
3333   /// Required for proper codegen of final reduction operation performed by the
3334   /// reduction clause.
3335   /// \param TaskgroupDescriptors List of helper taskgroup descriptors for
3336   /// corresponding items in parent taskgroup task_reduction clause.
3337   /// \param PreInit Statement that must be executed before entering the OpenMP
3338   /// region with this clause.
3339   /// \param PostUpdate Expression that must be executed after exit from the
3340   /// OpenMP region with this clause.
3341   static OMPInReductionClause *
3342   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
3343          SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
3344          NestedNameSpecifierLoc QualifierLoc,
3345          const DeclarationNameInfo &NameInfo, ArrayRef<Expr *> Privates,
3346          ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
3347          ArrayRef<Expr *> ReductionOps, ArrayRef<Expr *> TaskgroupDescriptors,
3348          Stmt *PreInit, Expr *PostUpdate);
3349
3350   /// Creates an empty clause with the place for \a N variables.
3351   ///
3352   /// \param C AST context.
3353   /// \param N The number of variables.
3354   static OMPInReductionClause *CreateEmpty(const ASTContext &C, unsigned N);
3355
3356   /// Gets location of ':' symbol in clause.
3357   SourceLocation getColonLoc() const { return ColonLoc; }
3358
3359   /// Gets the name info for specified reduction identifier.
3360   const DeclarationNameInfo &getNameInfo() const { return NameInfo; }
3361
3362   /// Gets the nested name specifier.
3363   NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
3364
3365   using helper_expr_iterator = MutableArrayRef<Expr *>::iterator;
3366   using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator;
3367   using helper_expr_range = llvm::iterator_range<helper_expr_iterator>;
3368   using helper_expr_const_range =
3369       llvm::iterator_range<helper_expr_const_iterator>;
3370
3371   helper_expr_const_range privates() const {
3372     return helper_expr_const_range(getPrivates().begin(), getPrivates().end());
3373   }
3374
3375   helper_expr_range privates() {
3376     return helper_expr_range(getPrivates().begin(), getPrivates().end());
3377   }
3378
3379   helper_expr_const_range lhs_exprs() const {
3380     return helper_expr_const_range(getLHSExprs().begin(), getLHSExprs().end());
3381   }
3382
3383   helper_expr_range lhs_exprs() {
3384     return helper_expr_range(getLHSExprs().begin(), getLHSExprs().end());
3385   }
3386
3387   helper_expr_const_range rhs_exprs() const {
3388     return helper_expr_const_range(getRHSExprs().begin(), getRHSExprs().end());
3389   }
3390
3391   helper_expr_range rhs_exprs() {
3392     return helper_expr_range(getRHSExprs().begin(), getRHSExprs().end());
3393   }
3394
3395   helper_expr_const_range reduction_ops() const {
3396     return helper_expr_const_range(getReductionOps().begin(),
3397                                    getReductionOps().end());
3398   }
3399
3400   helper_expr_range reduction_ops() {
3401     return helper_expr_range(getReductionOps().begin(),
3402                              getReductionOps().end());
3403   }
3404
3405   helper_expr_const_range taskgroup_descriptors() const {
3406     return helper_expr_const_range(getTaskgroupDescriptors().begin(),
3407                                    getTaskgroupDescriptors().end());
3408   }
3409
3410   helper_expr_range taskgroup_descriptors() {
3411     return helper_expr_range(getTaskgroupDescriptors().begin(),
3412                              getTaskgroupDescriptors().end());
3413   }
3414
3415   child_range children() {
3416     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
3417                        reinterpret_cast<Stmt **>(varlist_end()));
3418   }
3419
3420   const_child_range children() const {
3421     auto Children = const_cast<OMPInReductionClause *>(this)->children();
3422     return const_child_range(Children.begin(), Children.end());
3423   }
3424
3425   child_range used_children() {
3426     return child_range(child_iterator(), child_iterator());
3427   }
3428   const_child_range used_children() const {
3429     return const_child_range(const_child_iterator(), const_child_iterator());
3430   }
3431
3432   static bool classof(const OMPClause *T) {
3433     return T->getClauseKind() == OMPC_in_reduction;
3434   }
3435 };
3436
3437 /// This represents clause 'linear' in the '#pragma omp ...'
3438 /// directives.
3439 ///
3440 /// \code
3441 /// #pragma omp simd linear(a,b : 2)
3442 /// \endcode
3443 /// In this example directive '#pragma omp simd' has clause 'linear'
3444 /// with variables 'a', 'b' and linear step '2'.
3445 class OMPLinearClause final
3446     : public OMPVarListClause<OMPLinearClause>,
3447       public OMPClauseWithPostUpdate,
3448       private llvm::TrailingObjects<OMPLinearClause, Expr *> {
3449   friend class OMPClauseReader;
3450   friend OMPVarListClause;
3451   friend TrailingObjects;
3452
3453   /// Modifier of 'linear' clause.
3454   OpenMPLinearClauseKind Modifier = OMPC_LINEAR_val;
3455
3456   /// Location of linear modifier if any.
3457   SourceLocation ModifierLoc;
3458
3459   /// Location of ':'.
3460   SourceLocation ColonLoc;
3461
3462   /// Sets the linear step for clause.
3463   void setStep(Expr *Step) { *(getFinals().end()) = Step; }
3464
3465   /// Sets the expression to calculate linear step for clause.
3466   void setCalcStep(Expr *CalcStep) { *(getFinals().end() + 1) = CalcStep; }
3467
3468   /// Build 'linear' clause with given number of variables \a NumVars.
3469   ///
3470   /// \param StartLoc Starting location of the clause.
3471   /// \param LParenLoc Location of '('.
3472   /// \param ColonLoc Location of ':'.
3473   /// \param EndLoc Ending location of the clause.
3474   /// \param NumVars Number of variables.
3475   OMPLinearClause(SourceLocation StartLoc, SourceLocation LParenLoc,
3476                   OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
3477                   SourceLocation ColonLoc, SourceLocation EndLoc,
3478                   unsigned NumVars)
3479       : OMPVarListClause<OMPLinearClause>(OMPC_linear, StartLoc, LParenLoc,
3480                                           EndLoc, NumVars),
3481         OMPClauseWithPostUpdate(this), Modifier(Modifier),
3482         ModifierLoc(ModifierLoc), ColonLoc(ColonLoc) {}
3483
3484   /// Build an empty clause.
3485   ///
3486   /// \param NumVars Number of variables.
3487   explicit OMPLinearClause(unsigned NumVars)
3488       : OMPVarListClause<OMPLinearClause>(OMPC_linear, SourceLocation(),
3489                                           SourceLocation(), SourceLocation(),
3490                                           NumVars),
3491         OMPClauseWithPostUpdate(this) {}
3492
3493   /// Gets the list of initial values for linear variables.
3494   ///
3495   /// There are NumVars expressions with initial values allocated after the
3496   /// varlist, they are followed by NumVars update expressions (used to update
3497   /// the linear variable's value on current iteration) and they are followed by
3498   /// NumVars final expressions (used to calculate the linear variable's
3499   /// value after the loop body). After these lists, there are 2 helper
3500   /// expressions - linear step and a helper to calculate it before the
3501   /// loop body (used when the linear step is not constant):
3502   ///
3503   /// { Vars[] /* in OMPVarListClause */; Privates[]; Inits[]; Updates[];
3504   /// Finals[]; Step; CalcStep; }
3505   MutableArrayRef<Expr *> getPrivates() {
3506     return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
3507   }
3508   ArrayRef<const Expr *> getPrivates() const {
3509     return llvm::makeArrayRef(varlist_end(), varlist_size());
3510   }
3511
3512   MutableArrayRef<Expr *> getInits() {
3513     return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size());
3514   }
3515   ArrayRef<const Expr *> getInits() const {
3516     return llvm::makeArrayRef(getPrivates().end(), varlist_size());
3517   }
3518
3519   /// Sets the list of update expressions for linear variables.
3520   MutableArrayRef<Expr *> getUpdates() {
3521     return MutableArrayRef<Expr *>(getInits().end(), varlist_size());
3522   }
3523   ArrayRef<const Expr *> getUpdates() const {
3524     return llvm::makeArrayRef(getInits().end(), varlist_size());
3525   }
3526
3527   /// Sets the list of final update expressions for linear variables.
3528   MutableArrayRef<Expr *> getFinals() {
3529     return MutableArrayRef<Expr *>(getUpdates().end(), varlist_size());
3530   }
3531   ArrayRef<const Expr *> getFinals() const {
3532     return llvm::makeArrayRef(getUpdates().end(), varlist_size());
3533   }
3534
3535   /// Gets the list of used expressions for linear variables.
3536   MutableArrayRef<Expr *> getUsedExprs() {
3537     return MutableArrayRef<Expr *>(getFinals().end() + 2, varlist_size() + 1);
3538   }
3539   ArrayRef<const Expr *> getUsedExprs() const {
3540     return llvm::makeArrayRef(getFinals().end() + 2, varlist_size() + 1);
3541   }
3542
3543   /// Sets the list of the copies of original linear variables.
3544   /// \param PL List of expressions.
3545   void setPrivates(ArrayRef<Expr *> PL);
3546
3547   /// Sets the list of the initial values for linear variables.
3548   /// \param IL List of expressions.
3549   void setInits(ArrayRef<Expr *> IL);
3550
3551 public:
3552   /// Creates clause with a list of variables \a VL and a linear step
3553   /// \a Step.
3554   ///
3555   /// \param C AST Context.
3556   /// \param StartLoc Starting location of the clause.
3557   /// \param LParenLoc Location of '('.
3558   /// \param Modifier Modifier of 'linear' clause.
3559   /// \param ModifierLoc Modifier location.
3560   /// \param ColonLoc Location of ':'.
3561   /// \param EndLoc Ending location of the clause.
3562   /// \param VL List of references to the variables.
3563   /// \param PL List of private copies of original variables.
3564   /// \param IL List of initial values for the variables.
3565   /// \param Step Linear step.
3566   /// \param CalcStep Calculation of the linear step.
3567   /// \param PreInit Statement that must be executed before entering the OpenMP
3568   /// region with this clause.
3569   /// \param PostUpdate Expression that must be executed after exit from the
3570   /// OpenMP region with this clause.
3571   static OMPLinearClause *
3572   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
3573          OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
3574          SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
3575          ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
3576          Stmt *PreInit, Expr *PostUpdate);
3577
3578   /// Creates an empty clause with the place for \a NumVars variables.
3579   ///
3580   /// \param C AST context.
3581   /// \param NumVars Number of variables.
3582   static OMPLinearClause *CreateEmpty(const ASTContext &C, unsigned NumVars);
3583
3584   /// Set modifier.
3585   void setModifier(OpenMPLinearClauseKind Kind) { Modifier = Kind; }
3586
3587   /// Return modifier.
3588   OpenMPLinearClauseKind getModifier() const { return Modifier; }
3589
3590   /// Set modifier location.
3591   void setModifierLoc(SourceLocation Loc) { ModifierLoc = Loc; }
3592
3593   /// Return modifier location.
3594   SourceLocation getModifierLoc() const { return ModifierLoc; }
3595
3596   /// Sets the location of ':'.
3597   void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; }
3598
3599   /// Returns the location of ':'.
3600   SourceLocation getColonLoc() const { return ColonLoc; }
3601
3602   /// Returns linear step.
3603   Expr *getStep() { return *(getFinals().end()); }
3604
3605   /// Returns linear step.
3606   const Expr *getStep() const { return *(getFinals().end()); }
3607
3608   /// Returns expression to calculate linear step.
3609   Expr *getCalcStep() { return *(getFinals().end() + 1); }
3610
3611   /// Returns expression to calculate linear step.
3612   const Expr *getCalcStep() const { return *(getFinals().end() + 1); }
3613
3614   /// Sets the list of update expressions for linear variables.
3615   /// \param UL List of expressions.
3616   void setUpdates(ArrayRef<Expr *> UL);
3617
3618   /// Sets the list of final update expressions for linear variables.
3619   /// \param FL List of expressions.
3620   void setFinals(ArrayRef<Expr *> FL);
3621
3622   /// Sets the list of used expressions for the linear clause.
3623   void setUsedExprs(ArrayRef<Expr *> UE);
3624
3625   using privates_iterator = MutableArrayRef<Expr *>::iterator;
3626   using privates_const_iterator = ArrayRef<const Expr *>::iterator;
3627   using privates_range = llvm::iterator_range<privates_iterator>;
3628   using privates_const_range = llvm::iterator_range<privates_const_iterator>;
3629
3630   privates_range privates() {
3631     return privates_range(getPrivates().begin(), getPrivates().end());
3632   }
3633
3634   privates_const_range privates() const {
3635     return privates_const_range(getPrivates().begin(), getPrivates().end());
3636   }
3637
3638   using inits_iterator = MutableArrayRef<Expr *>::iterator;
3639   using inits_const_iterator = ArrayRef<const Expr *>::iterator;
3640   using inits_range = llvm::iterator_range<inits_iterator>;
3641   using inits_const_range = llvm::iterator_range<inits_const_iterator>;
3642
3643   inits_range inits() {
3644     return inits_range(getInits().begin(), getInits().end());