028af6ac9a721e382f0b212311877c36de8ae851
[lldb.git] / 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());
3645   }
3646
3647   inits_const_range inits() const {
3648     return inits_const_range(getInits().begin(), getInits().end());
3649   }
3650
3651   using updates_iterator = MutableArrayRef<Expr *>::iterator;
3652   using updates_const_iterator = ArrayRef<const Expr *>::iterator;
3653   using updates_range = llvm::iterator_range<updates_iterator>;
3654   using updates_const_range = llvm::iterator_range<updates_const_iterator>;
3655
3656   updates_range updates() {
3657     return updates_range(getUpdates().begin(), getUpdates().end());
3658   }
3659
3660   updates_const_range updates() const {
3661     return updates_const_range(getUpdates().begin(), getUpdates().end());
3662   }
3663
3664   using finals_iterator = MutableArrayRef<Expr *>::iterator;
3665   using finals_const_iterator = ArrayRef<const Expr *>::iterator;
3666   using finals_range = llvm::iterator_range<finals_iterator>;
3667   using finals_const_range = llvm::iterator_range<finals_const_iterator>;
3668
3669   finals_range finals() {
3670     return finals_range(getFinals().begin(), getFinals().end());
3671   }
3672
3673   finals_const_range finals() const {
3674     return finals_const_range(getFinals().begin(), getFinals().end());
3675   }
3676
3677   using used_expressions_iterator = MutableArrayRef<Expr *>::iterator;
3678   using used_expressions_const_iterator = ArrayRef<const Expr *>::iterator;
3679   using used_expressions_range =
3680       llvm::iterator_range<used_expressions_iterator>;
3681   using used_expressions_const_range =
3682       llvm::iterator_range<used_expressions_const_iterator>;
3683
3684   used_expressions_range used_expressions() {
3685     return finals_range(getUsedExprs().begin(), getUsedExprs().end());
3686   }
3687
3688   used_expressions_const_range used_expressions() const {
3689     return finals_const_range(getUsedExprs().begin(), getUsedExprs().end());
3690   }
3691
3692   child_range children() {
3693     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
3694                        reinterpret_cast<Stmt **>(varlist_end()));
3695   }
3696
3697   const_child_range children() const {
3698     auto Children = const_cast<OMPLinearClause *>(this)->children();
3699     return const_child_range(Children.begin(), Children.end());
3700   }
3701
3702   child_range used_children();
3703
3704   const_child_range used_children() const {
3705     auto Children = const_cast<OMPLinearClause *>(this)->used_children();
3706     return const_child_range(Children.begin(), Children.end());
3707   }
3708
3709   static bool classof(const OMPClause *T) {
3710     return T->getClauseKind() == OMPC_linear;
3711   }
3712 };
3713
3714 /// This represents clause 'aligned' in the '#pragma omp ...'
3715 /// directives.
3716 ///
3717 /// \code
3718 /// #pragma omp simd aligned(a,b : 8)
3719 /// \endcode
3720 /// In this example directive '#pragma omp simd' has clause 'aligned'
3721 /// with variables 'a', 'b' and alignment '8'.
3722 class OMPAlignedClause final
3723     : public OMPVarListClause<OMPAlignedClause>,
3724       private llvm::TrailingObjects<OMPAlignedClause, Expr *> {
3725   friend class OMPClauseReader;
3726   friend OMPVarListClause;
3727   friend TrailingObjects;
3728
3729   /// Location of ':'.
3730   SourceLocation ColonLoc;
3731
3732   /// Sets the alignment for clause.
3733   void setAlignment(Expr *A) { *varlist_end() = A; }
3734
3735   /// Build 'aligned' clause with given number of variables \a NumVars.
3736   ///
3737   /// \param StartLoc Starting location of the clause.
3738   /// \param LParenLoc Location of '('.
3739   /// \param ColonLoc Location of ':'.
3740   /// \param EndLoc Ending location of the clause.
3741   /// \param NumVars Number of variables.
3742   OMPAlignedClause(SourceLocation StartLoc, SourceLocation LParenLoc,
3743                    SourceLocation ColonLoc, SourceLocation EndLoc,
3744                    unsigned NumVars)
3745       : OMPVarListClause<OMPAlignedClause>(OMPC_aligned, StartLoc, LParenLoc,
3746                                            EndLoc, NumVars),
3747         ColonLoc(ColonLoc) {}
3748
3749   /// Build an empty clause.
3750   ///
3751   /// \param NumVars Number of variables.
3752   explicit OMPAlignedClause(unsigned NumVars)
3753       : OMPVarListClause<OMPAlignedClause>(OMPC_aligned, SourceLocation(),
3754                                            SourceLocation(), SourceLocation(),
3755                                            NumVars) {}
3756
3757 public:
3758   /// Creates clause with a list of variables \a VL and alignment \a A.
3759   ///
3760   /// \param C AST Context.
3761   /// \param StartLoc Starting location of the clause.
3762   /// \param LParenLoc Location of '('.
3763   /// \param ColonLoc Location of ':'.
3764   /// \param EndLoc Ending location of the clause.
3765   /// \param VL List of references to the variables.
3766   /// \param A Alignment.
3767   static OMPAlignedClause *Create(const ASTContext &C, SourceLocation StartLoc,
3768                                   SourceLocation LParenLoc,
3769                                   SourceLocation ColonLoc,
3770                                   SourceLocation EndLoc, ArrayRef<Expr *> VL,
3771                                   Expr *A);
3772
3773   /// Creates an empty clause with the place for \a NumVars variables.
3774   ///
3775   /// \param C AST context.
3776   /// \param NumVars Number of variables.
3777   static OMPAlignedClause *CreateEmpty(const ASTContext &C, unsigned NumVars);
3778
3779   /// Sets the location of ':'.
3780   void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; }
3781
3782   /// Returns the location of ':'.
3783   SourceLocation getColonLoc() const { return ColonLoc; }
3784
3785   /// Returns alignment.
3786   Expr *getAlignment() { return *varlist_end(); }
3787
3788   /// Returns alignment.
3789   const Expr *getAlignment() const { return *varlist_end(); }
3790
3791   child_range children() {
3792     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
3793                        reinterpret_cast<Stmt **>(varlist_end()));
3794   }
3795
3796   const_child_range children() const {
3797     auto Children = const_cast<OMPAlignedClause *>(this)->children();
3798     return const_child_range(Children.begin(), Children.end());
3799   }
3800
3801   child_range used_children() {
3802     return child_range(child_iterator(), child_iterator());
3803   }
3804   const_child_range used_children() const {
3805     return const_child_range(const_child_iterator(), const_child_iterator());
3806   }
3807
3808   static bool classof(const OMPClause *T) {
3809     return T->getClauseKind() == OMPC_aligned;
3810   }
3811 };
3812
3813 /// This represents clause 'copyin' in the '#pragma omp ...' directives.
3814 ///
3815 /// \code
3816 /// #pragma omp parallel copyin(a,b)
3817 /// \endcode
3818 /// In this example directive '#pragma omp parallel' has clause 'copyin'
3819 /// with the variables 'a' and 'b'.
3820 class OMPCopyinClause final
3821     : public OMPVarListClause<OMPCopyinClause>,
3822       private llvm::TrailingObjects<OMPCopyinClause, Expr *> {
3823   // Class has 3 additional tail allocated arrays:
3824   // 1. List of helper expressions for proper generation of assignment operation
3825   // required for copyin clause. This list represents sources.
3826   // 2. List of helper expressions for proper generation of assignment operation
3827   // required for copyin clause. This list represents destinations.
3828   // 3. List of helper expressions that represents assignment operation:
3829   // \code
3830   // DstExprs = SrcExprs;
3831   // \endcode
3832   // Required for proper codegen of propagation of master's thread values of
3833   // threadprivate variables to local instances of that variables in other
3834   // implicit threads.
3835
3836   friend class OMPClauseReader;
3837   friend OMPVarListClause;
3838   friend TrailingObjects;
3839
3840   /// Build clause with number of variables \a N.
3841   ///
3842   /// \param StartLoc Starting location of the clause.
3843   /// \param LParenLoc Location of '('.
3844   /// \param EndLoc Ending location of the clause.
3845   /// \param N Number of the variables in the clause.
3846   OMPCopyinClause(SourceLocation StartLoc, SourceLocation LParenLoc,
3847                   SourceLocation EndLoc, unsigned N)
3848       : OMPVarListClause<OMPCopyinClause>(OMPC_copyin, StartLoc, LParenLoc,
3849                                           EndLoc, N) {}
3850
3851   /// Build an empty clause.
3852   ///
3853   /// \param N Number of variables.
3854   explicit OMPCopyinClause(unsigned N)
3855       : OMPVarListClause<OMPCopyinClause>(OMPC_copyin, SourceLocation(),
3856                                           SourceLocation(), SourceLocation(),
3857                                           N) {}
3858
3859   /// Set list of helper expressions, required for proper codegen of the
3860   /// clause. These expressions represent source expression in the final
3861   /// assignment statement performed by the copyin clause.
3862   void setSourceExprs(ArrayRef<Expr *> SrcExprs);
3863
3864   /// Get the list of helper source expressions.
3865   MutableArrayRef<Expr *> getSourceExprs() {
3866     return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
3867   }
3868   ArrayRef<const Expr *> getSourceExprs() const {
3869     return llvm::makeArrayRef(varlist_end(), varlist_size());
3870   }
3871
3872   /// Set list of helper expressions, required for proper codegen of the
3873   /// clause. These expressions represent destination expression in the final
3874   /// assignment statement performed by the copyin clause.
3875   void setDestinationExprs(ArrayRef<Expr *> DstExprs);
3876
3877   /// Get the list of helper destination expressions.
3878   MutableArrayRef<Expr *> getDestinationExprs() {
3879     return MutableArrayRef<Expr *>(getSourceExprs().end(), varlist_size());
3880   }
3881   ArrayRef<const Expr *> getDestinationExprs() const {
3882     return llvm::makeArrayRef(getSourceExprs().end(), varlist_size());
3883   }
3884
3885   /// Set list of helper assignment expressions, required for proper
3886   /// codegen of the clause. These expressions are assignment expressions that
3887   /// assign source helper expressions to destination helper expressions
3888   /// correspondingly.
3889   void setAssignmentOps(ArrayRef<Expr *> AssignmentOps);
3890
3891   /// Get the list of helper assignment expressions.
3892   MutableArrayRef<Expr *> getAssignmentOps() {
3893     return MutableArrayRef<Expr *>(getDestinationExprs().end(), varlist_size());
3894   }
3895   ArrayRef<const Expr *> getAssignmentOps() const {
3896     return llvm::makeArrayRef(getDestinationExprs().end(), varlist_size());
3897   }
3898
3899 public:
3900   /// Creates clause with a list of variables \a VL.
3901   ///
3902   /// \param C AST context.
3903   /// \param StartLoc Starting location of the clause.
3904   /// \param LParenLoc Location of '('.
3905   /// \param EndLoc Ending location of the clause.
3906   /// \param VL List of references to the variables.
3907   /// \param SrcExprs List of helper expressions for proper generation of
3908   /// assignment operation required for copyin clause. This list represents
3909   /// sources.
3910   /// \param DstExprs List of helper expressions for proper generation of
3911   /// assignment operation required for copyin clause. This list represents
3912   /// destinations.
3913   /// \param AssignmentOps List of helper expressions that represents assignment
3914   /// operation:
3915   /// \code
3916   /// DstExprs = SrcExprs;
3917   /// \endcode
3918   /// Required for proper codegen of propagation of master's thread values of
3919   /// threadprivate variables to local instances of that variables in other
3920   /// implicit threads.
3921   static OMPCopyinClause *
3922   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
3923          SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
3924          ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps);
3925
3926   /// Creates an empty clause with \a N variables.
3927   ///
3928   /// \param C AST context.
3929   /// \param N The number of variables.
3930   static OMPCopyinClause *CreateEmpty(const ASTContext &C, unsigned N);
3931
3932   using helper_expr_iterator = MutableArrayRef<Expr *>::iterator;
3933   using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator;
3934   using helper_expr_range = llvm::iterator_range<helper_expr_iterator>;
3935   using helper_expr_const_range =
3936       llvm::iterator_range<helper_expr_const_iterator>;
3937
3938   helper_expr_const_range source_exprs() const {
3939     return helper_expr_const_range(getSourceExprs().begin(),
3940                                    getSourceExprs().end());
3941   }
3942
3943   helper_expr_range source_exprs() {
3944     return helper_expr_range(getSourceExprs().begin(), getSourceExprs().end());
3945   }
3946
3947   helper_expr_const_range destination_exprs() const {
3948     return helper_expr_const_range(getDestinationExprs().begin(),
3949                                    getDestinationExprs().end());
3950   }
3951
3952   helper_expr_range destination_exprs() {
3953     return helper_expr_range(getDestinationExprs().begin(),
3954                              getDestinationExprs().end());
3955   }
3956
3957   helper_expr_const_range assignment_ops() const {
3958     return helper_expr_const_range(getAssignmentOps().begin(),
3959                                    getAssignmentOps().end());
3960   }
3961
3962   helper_expr_range assignment_ops() {
3963     return helper_expr_range(getAssignmentOps().begin(),
3964                              getAssignmentOps().end());
3965   }
3966
3967   child_range children() {
3968     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
3969                        reinterpret_cast<Stmt **>(varlist_end()));
3970   }
3971
3972   const_child_range children() const {
3973     auto Children = const_cast<OMPCopyinClause *>(this)->children();
3974     return const_child_range(Children.begin(), Children.end());
3975   }
3976
3977   child_range used_children() {
3978     return child_range(child_iterator(), child_iterator());
3979   }
3980   const_child_range used_children() const {
3981     return const_child_range(const_child_iterator(), const_child_iterator());
3982   }
3983
3984   static bool classof(const OMPClause *T) {
3985     return T->getClauseKind() == OMPC_copyin;
3986   }
3987 };
3988
3989 /// This represents clause 'copyprivate' in the '#pragma omp ...'
3990 /// directives.
3991 ///
3992 /// \code
3993 /// #pragma omp single copyprivate(a,b)
3994 /// \endcode
3995 /// In this example directive '#pragma omp single' has clause 'copyprivate'
3996 /// with the variables 'a' and 'b'.
3997 class OMPCopyprivateClause final
3998     : public OMPVarListClause<OMPCopyprivateClause>,
3999       private llvm::TrailingObjects<OMPCopyprivateClause, Expr *> {
4000   friend class OMPClauseReader;
4001   friend OMPVarListClause;
4002   friend TrailingObjects;
4003
4004   /// Build clause with number of variables \a N.
4005   ///
4006   /// \param StartLoc Starting location of the clause.
4007   /// \param LParenLoc Location of '('.
4008   /// \param EndLoc Ending location of the clause.
4009   /// \param N Number of the variables in the clause.
4010   OMPCopyprivateClause(SourceLocation StartLoc, SourceLocation LParenLoc,
4011                        SourceLocation EndLoc, unsigned N)
4012       : OMPVarListClause<OMPCopyprivateClause>(OMPC_copyprivate, StartLoc,
4013                                                LParenLoc, EndLoc, N) {}
4014
4015   /// Build an empty clause.
4016   ///
4017   /// \param N Number of variables.
4018   explicit OMPCopyprivateClause(unsigned N)
4019       : OMPVarListClause<OMPCopyprivateClause>(
4020             OMPC_copyprivate, SourceLocation(), SourceLocation(),
4021             SourceLocation(), N) {}
4022
4023   /// Set list of helper expressions, required for proper codegen of the
4024   /// clause. These expressions represent source expression in the final
4025   /// assignment statement performed by the copyprivate clause.
4026   void setSourceExprs(ArrayRef<Expr *> SrcExprs);
4027
4028   /// Get the list of helper source expressions.
4029   MutableArrayRef<Expr *> getSourceExprs() {
4030     return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
4031   }
4032   ArrayRef<const Expr *> getSourceExprs() const {
4033     return llvm::makeArrayRef(varlist_end(), varlist_size());
4034   }
4035
4036   /// Set list of helper expressions, required for proper codegen of the
4037   /// clause. These expressions represent destination expression in the final
4038   /// assignment statement performed by the copyprivate clause.
4039   void setDestinationExprs(ArrayRef<Expr *> DstExprs);
4040
4041   /// Get the list of helper destination expressions.
4042   MutableArrayRef<Expr *> getDestinationExprs() {
4043     return MutableArrayRef<Expr *>(getSourceExprs().end(), varlist_size());
4044   }
4045   ArrayRef<const Expr *> getDestinationExprs() const {
4046     return llvm::makeArrayRef(getSourceExprs().end(), varlist_size());
4047   }
4048
4049   /// Set list of helper assignment expressions, required for proper
4050   /// codegen of the clause. These expressions are assignment expressions that
4051   /// assign source helper expressions to destination helper expressions
4052   /// correspondingly.
4053   void setAssignmentOps(ArrayRef<Expr *> AssignmentOps);
4054
4055   /// Get the list of helper assignment expressions.
4056   MutableArrayRef<Expr *> getAssignmentOps() {
4057     return MutableArrayRef<Expr *>(getDestinationExprs().end(), varlist_size());
4058   }
4059   ArrayRef<const Expr *> getAssignmentOps() const {
4060     return llvm::makeArrayRef(getDestinationExprs().end(), varlist_size());
4061   }
4062
4063 public:
4064   /// Creates clause with a list of variables \a VL.
4065   ///
4066   /// \param C AST context.
4067   /// \param StartLoc Starting location of the clause.
4068   /// \param LParenLoc Location of '('.
4069   /// \param EndLoc Ending location of the clause.
4070   /// \param VL List of references to the variables.
4071   /// \param SrcExprs List of helper expressions for proper generation of
4072   /// assignment operation required for copyprivate clause. This list represents
4073   /// sources.
4074   /// \param DstExprs List of helper expressions for proper generation of
4075   /// assignment operation required for copyprivate clause. This list represents
4076   /// destinations.
4077   /// \param AssignmentOps List of helper expressions that represents assignment
4078   /// operation:
4079   /// \code
4080   /// DstExprs = SrcExprs;
4081   /// \endcode
4082   /// Required for proper codegen of final assignment performed by the
4083   /// copyprivate clause.
4084   static OMPCopyprivateClause *
4085   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
4086          SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
4087          ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps);
4088
4089   /// Creates an empty clause with \a N variables.
4090   ///
4091   /// \param C AST context.
4092   /// \param N The number of variables.
4093   static OMPCopyprivateClause *CreateEmpty(const ASTContext &C, unsigned N);
4094
4095   using helper_expr_iterator = MutableArrayRef<Expr *>::iterator;
4096   using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator;
4097   using helper_expr_range = llvm::iterator_range<helper_expr_iterator>;
4098   using helper_expr_const_range =
4099       llvm::iterator_range<helper_expr_const_iterator>;
4100
4101   helper_expr_const_range source_exprs() const {
4102     return helper_expr_const_range(getSourceExprs().begin(),
4103                                    getSourceExprs().end());
4104   }
4105
4106   helper_expr_range source_exprs() {
4107     return helper_expr_range(getSourceExprs().begin(), getSourceExprs().end());
4108   }
4109
4110   helper_expr_const_range destination_exprs() const {
4111     return helper_expr_const_range(getDestinationExprs().begin(),
4112                                    getDestinationExprs().end());
4113   }
4114
4115   helper_expr_range destination_exprs() {
4116     return helper_expr_range(getDestinationExprs().begin(),
4117                              getDestinationExprs().end());
4118   }
4119
4120   helper_expr_const_range assignment_ops() const {
4121     return helper_expr_const_range(getAssignmentOps().begin(),
4122                                    getAssignmentOps().end());
4123   }
4124
4125   helper_expr_range assignment_ops() {
4126     return helper_expr_range(getAssignmentOps().begin(),
4127                              getAssignmentOps().end());
4128   }
4129
4130   child_range children() {
4131     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
4132                        reinterpret_cast<Stmt **>(varlist_end()));
4133   }
4134
4135   const_child_range children() const {
4136     auto Children = const_cast<OMPCopyprivateClause *>(this)->children();
4137     return const_child_range(Children.begin(), Children.end());
4138   }
4139
4140   child_range used_children() {
4141     return child_range(child_iterator(), child_iterator());
4142   }
4143   const_child_range used_children() const {
4144     return const_child_range(const_child_iterator(), const_child_iterator());
4145   }
4146
4147   static bool classof(const OMPClause *T) {
4148     return T->getClauseKind() == OMPC_copyprivate;
4149   }
4150 };
4151
4152 /// This represents implicit clause 'flush' for the '#pragma omp flush'
4153 /// directive.
4154 /// This clause does not exist by itself, it can be only as a part of 'omp
4155 /// flush' directive. This clause is introduced to keep the original structure
4156 /// of \a OMPExecutableDirective class and its derivatives and to use the
4157 /// existing infrastructure of clauses with the list of variables.
4158 ///
4159 /// \code
4160 /// #pragma omp flush(a,b)
4161 /// \endcode
4162 /// In this example directive '#pragma omp flush' has implicit clause 'flush'
4163 /// with the variables 'a' and 'b'.
4164 class OMPFlushClause final
4165     : public OMPVarListClause<OMPFlushClause>,
4166       private llvm::TrailingObjects<OMPFlushClause, Expr *> {
4167   friend OMPVarListClause;
4168   friend TrailingObjects;
4169
4170   /// Build clause with number of variables \a N.
4171   ///
4172   /// \param StartLoc Starting location of the clause.
4173   /// \param LParenLoc Location of '('.
4174   /// \param EndLoc Ending location of the clause.
4175   /// \param N Number of the variables in the clause.
4176   OMPFlushClause(SourceLocation StartLoc, SourceLocation LParenLoc,
4177                  SourceLocation EndLoc, unsigned N)
4178       : OMPVarListClause<OMPFlushClause>(OMPC_flush, StartLoc, LParenLoc,
4179                                          EndLoc, N) {}
4180
4181   /// Build an empty clause.
4182   ///
4183   /// \param N Number of variables.
4184   explicit OMPFlushClause(unsigned N)
4185       : OMPVarListClause<OMPFlushClause>(OMPC_flush, SourceLocation(),
4186                                          SourceLocation(), SourceLocation(),
4187                                          N) {}
4188
4189 public:
4190   /// Creates clause with a list of variables \a VL.
4191   ///
4192   /// \param C AST context.
4193   /// \param StartLoc Starting location of the clause.
4194   /// \param LParenLoc Location of '('.
4195   /// \param EndLoc Ending location of the clause.
4196   /// \param VL List of references to the variables.
4197   static OMPFlushClause *Create(const ASTContext &C, SourceLocation StartLoc,
4198                                 SourceLocation LParenLoc, SourceLocation EndLoc,
4199                                 ArrayRef<Expr *> VL);
4200
4201   /// Creates an empty clause with \a N variables.
4202   ///
4203   /// \param C AST context.
4204   /// \param N The number of variables.
4205   static OMPFlushClause *CreateEmpty(const ASTContext &C, unsigned N);
4206
4207   child_range children() {
4208     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
4209                        reinterpret_cast<Stmt **>(varlist_end()));
4210   }
4211
4212   const_child_range children() const {
4213     auto Children = const_cast<OMPFlushClause *>(this)->children();
4214     return const_child_range(Children.begin(), Children.end());
4215   }
4216
4217   child_range used_children() {
4218     return child_range(child_iterator(), child_iterator());
4219   }
4220   const_child_range used_children() const {
4221     return const_child_range(const_child_iterator(), const_child_iterator());
4222   }
4223
4224   static bool classof(const OMPClause *T) {
4225     return T->getClauseKind() == OMPC_flush;
4226   }
4227 };
4228
4229 /// This represents implicit clause 'depobj' for the '#pragma omp depobj'
4230 /// directive.
4231 /// This clause does not exist by itself, it can be only as a part of 'omp
4232 /// depobj' directive. This clause is introduced to keep the original structure
4233 /// of \a OMPExecutableDirective class and its derivatives and to use the
4234 /// existing infrastructure of clauses with the list of variables.
4235 ///
4236 /// \code
4237 /// #pragma omp depobj(a) destroy
4238 /// \endcode
4239 /// In this example directive '#pragma omp depobj' has implicit clause 'depobj'
4240 /// with the depobj 'a'.
4241 class OMPDepobjClause final : public OMPClause {
4242   friend class OMPClauseReader;
4243
4244   /// Location of '('.
4245   SourceLocation LParenLoc;
4246
4247   /// Chunk size.
4248   Expr *Depobj = nullptr;
4249
4250   /// Build clause with number of variables \a N.
4251   ///
4252   /// \param StartLoc Starting location of the clause.
4253   /// \param LParenLoc Location of '('.
4254   /// \param EndLoc Ending location of the clause.
4255   OMPDepobjClause(SourceLocation StartLoc, SourceLocation LParenLoc,
4256                   SourceLocation EndLoc)
4257       : OMPClause(OMPC_depobj, StartLoc, EndLoc), LParenLoc(LParenLoc) {}
4258
4259   /// Build an empty clause.
4260   ///
4261   explicit OMPDepobjClause()
4262       : OMPClause(OMPC_depobj, SourceLocation(), SourceLocation()) {}
4263
4264   void setDepobj(Expr *E) { Depobj = E; }
4265
4266   /// Sets the location of '('.
4267   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
4268
4269 public:
4270   /// Creates clause.
4271   ///
4272   /// \param C AST context.
4273   /// \param StartLoc Starting location of the clause.
4274   /// \param LParenLoc Location of '('.
4275   /// \param EndLoc Ending location of the clause.
4276   /// \param Depobj depobj expression associated with the 'depobj' directive.
4277   static OMPDepobjClause *Create(const ASTContext &C, SourceLocation StartLoc,
4278                                  SourceLocation LParenLoc,
4279                                  SourceLocation EndLoc, Expr *Depobj);
4280
4281   /// Creates an empty clause.
4282   ///
4283   /// \param C AST context.
4284   static OMPDepobjClause *CreateEmpty(const ASTContext &C);
4285
4286   /// Returns depobj expression associated with the clause.
4287   Expr *getDepobj() { return Depobj; }
4288   const Expr *getDepobj() const { return Depobj; }
4289
4290   /// R