[OPENMP50]Add support for extended device clause in target directives.
[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   /// Location of ':'.
2707   SourceLocation ColonLoc;
2708
2709   /// Nested name specifier for C++.
2710   NestedNameSpecifierLoc QualifierLoc;
2711
2712   /// Name of custom operator.
2713   DeclarationNameInfo NameInfo;
2714
2715   /// Build clause with number of variables \a N.
2716   ///
2717   /// \param StartLoc Starting location of the clause.
2718   /// \param LParenLoc Location of '('.
2719   /// \param EndLoc Ending location of the clause.
2720   /// \param ColonLoc Location of ':'.
2721   /// \param N Number of the variables in the clause.
2722   /// \param QualifierLoc The nested-name qualifier with location information
2723   /// \param NameInfo The full name info for reduction identifier.
2724   OMPReductionClause(SourceLocation StartLoc, SourceLocation LParenLoc,
2725                      SourceLocation ColonLoc, SourceLocation EndLoc, unsigned N,
2726                      NestedNameSpecifierLoc QualifierLoc,
2727                      const DeclarationNameInfo &NameInfo)
2728       : OMPVarListClause<OMPReductionClause>(OMPC_reduction, StartLoc,
2729                                              LParenLoc, EndLoc, N),
2730         OMPClauseWithPostUpdate(this), ColonLoc(ColonLoc),
2731         QualifierLoc(QualifierLoc), NameInfo(NameInfo) {}
2732
2733   /// Build an empty clause.
2734   ///
2735   /// \param N Number of variables.
2736   explicit OMPReductionClause(unsigned N)
2737       : OMPVarListClause<OMPReductionClause>(OMPC_reduction, SourceLocation(),
2738                                              SourceLocation(), SourceLocation(),
2739                                              N),
2740         OMPClauseWithPostUpdate(this) {}
2741
2742   /// Sets location of ':' symbol in clause.
2743   void setColonLoc(SourceLocation CL) { ColonLoc = CL; }
2744
2745   /// Sets the name info for specified reduction identifier.
2746   void setNameInfo(DeclarationNameInfo DNI) { NameInfo = DNI; }
2747
2748   /// Sets the nested name specifier.
2749   void setQualifierLoc(NestedNameSpecifierLoc NSL) { QualifierLoc = NSL; }
2750
2751   /// Set list of helper expressions, required for proper codegen of the
2752   /// clause. These expressions represent private copy of the reduction
2753   /// variable.
2754   void setPrivates(ArrayRef<Expr *> Privates);
2755
2756   /// Get the list of helper privates.
2757   MutableArrayRef<Expr *> getPrivates() {
2758     return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
2759   }
2760   ArrayRef<const Expr *> getPrivates() const {
2761     return llvm::makeArrayRef(varlist_end(), varlist_size());
2762   }
2763
2764   /// Set list of helper expressions, required for proper codegen of the
2765   /// clause. These expressions represent LHS expression in the final
2766   /// reduction expression performed by the reduction clause.
2767   void setLHSExprs(ArrayRef<Expr *> LHSExprs);
2768
2769   /// Get the list of helper LHS expressions.
2770   MutableArrayRef<Expr *> getLHSExprs() {
2771     return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size());
2772   }
2773   ArrayRef<const Expr *> getLHSExprs() const {
2774     return llvm::makeArrayRef(getPrivates().end(), varlist_size());
2775   }
2776
2777   /// Set list of helper expressions, required for proper codegen of the
2778   /// clause. These expressions represent RHS expression in the final
2779   /// reduction expression performed by the reduction clause.
2780   /// Also, variables in these expressions are used for proper initialization of
2781   /// reduction copies.
2782   void setRHSExprs(ArrayRef<Expr *> RHSExprs);
2783
2784   /// Get the list of helper destination expressions.
2785   MutableArrayRef<Expr *> getRHSExprs() {
2786     return MutableArrayRef<Expr *>(getLHSExprs().end(), varlist_size());
2787   }
2788   ArrayRef<const Expr *> getRHSExprs() const {
2789     return llvm::makeArrayRef(getLHSExprs().end(), varlist_size());
2790   }
2791
2792   /// Set list of helper reduction expressions, required for proper
2793   /// codegen of the clause. These expressions are binary expressions or
2794   /// operator/custom reduction call that calculates new value from source
2795   /// helper expressions to destination helper expressions.
2796   void setReductionOps(ArrayRef<Expr *> ReductionOps);
2797
2798   /// Get the list of helper reduction expressions.
2799   MutableArrayRef<Expr *> getReductionOps() {
2800     return MutableArrayRef<Expr *>(getRHSExprs().end(), varlist_size());
2801   }
2802   ArrayRef<const Expr *> getReductionOps() const {
2803     return llvm::makeArrayRef(getRHSExprs().end(), varlist_size());
2804   }
2805
2806 public:
2807   /// Creates clause with a list of variables \a VL.
2808   ///
2809   /// \param StartLoc Starting location of the clause.
2810   /// \param LParenLoc Location of '('.
2811   /// \param ColonLoc Location of ':'.
2812   /// \param EndLoc Ending location of the clause.
2813   /// \param VL The variables in the clause.
2814   /// \param QualifierLoc The nested-name qualifier with location information
2815   /// \param NameInfo The full name info for reduction identifier.
2816   /// \param Privates List of helper expressions for proper generation of
2817   /// private copies.
2818   /// \param LHSExprs List of helper expressions for proper generation of
2819   /// assignment operation required for copyprivate clause. This list represents
2820   /// LHSs of the reduction expressions.
2821   /// \param RHSExprs List of helper expressions for proper generation of
2822   /// assignment operation required for copyprivate clause. This list represents
2823   /// RHSs of the reduction expressions.
2824   /// Also, variables in these expressions are used for proper initialization of
2825   /// reduction copies.
2826   /// \param ReductionOps List of helper expressions that represents reduction
2827   /// expressions:
2828   /// \code
2829   /// LHSExprs binop RHSExprs;
2830   /// operator binop(LHSExpr, RHSExpr);
2831   /// <CutomReduction>(LHSExpr, RHSExpr);
2832   /// \endcode
2833   /// Required for proper codegen of final reduction operation performed by the
2834   /// reduction clause.
2835   /// \param PreInit Statement that must be executed before entering the OpenMP
2836   /// region with this clause.
2837   /// \param PostUpdate Expression that must be executed after exit from the
2838   /// OpenMP region with this clause.
2839   static OMPReductionClause *
2840   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
2841          SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
2842          NestedNameSpecifierLoc QualifierLoc,
2843          const DeclarationNameInfo &NameInfo, ArrayRef<Expr *> Privates,
2844          ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
2845          ArrayRef<Expr *> ReductionOps, Stmt *PreInit, Expr *PostUpdate);
2846
2847   /// Creates an empty clause with the place for \a N variables.
2848   ///
2849   /// \param C AST context.
2850   /// \param N The number of variables.
2851   static OMPReductionClause *CreateEmpty(const ASTContext &C, unsigned N);
2852
2853   /// Gets location of ':' symbol in clause.
2854   SourceLocation getColonLoc() const { return ColonLoc; }
2855
2856   /// Gets the name info for specified reduction identifier.
2857   const DeclarationNameInfo &getNameInfo() const { return NameInfo; }
2858
2859   /// Gets the nested name specifier.
2860   NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
2861
2862   using helper_expr_iterator = MutableArrayRef<Expr *>::iterator;
2863   using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator;
2864   using helper_expr_range = llvm::iterator_range<helper_expr_iterator>;
2865   using helper_expr_const_range =
2866       llvm::iterator_range<helper_expr_const_iterator>;
2867
2868   helper_expr_const_range privates() const {
2869     return helper_expr_const_range(getPrivates().begin(), getPrivates().end());
2870   }
2871
2872   helper_expr_range privates() {
2873     return helper_expr_range(getPrivates().begin(), getPrivates().end());
2874   }
2875
2876   helper_expr_const_range lhs_exprs() const {
2877     return helper_expr_const_range(getLHSExprs().begin(), getLHSExprs().end());
2878   }
2879
2880   helper_expr_range lhs_exprs() {
2881     return helper_expr_range(getLHSExprs().begin(), getLHSExprs().end());
2882   }
2883
2884   helper_expr_const_range rhs_exprs() const {
2885     return helper_expr_const_range(getRHSExprs().begin(), getRHSExprs().end());
2886   }
2887
2888   helper_expr_range rhs_exprs() {
2889     return helper_expr_range(getRHSExprs().begin(), getRHSExprs().end());
2890   }
2891
2892   helper_expr_const_range reduction_ops() const {
2893     return helper_expr_const_range(getReductionOps().begin(),
2894                                    getReductionOps().end());
2895   }
2896
2897   helper_expr_range reduction_ops() {
2898     return helper_expr_range(getReductionOps().begin(),
2899                              getReductionOps().end());
2900   }
2901
2902   child_range children() {
2903     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
2904                        reinterpret_cast<Stmt **>(varlist_end()));
2905   }
2906
2907   const_child_range children() const {
2908     auto Children = const_cast<OMPReductionClause *>(this)->children();
2909     return const_child_range(Children.begin(), Children.end());
2910   }
2911
2912   child_range used_children() {
2913     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
2914                        reinterpret_cast<Stmt **>(varlist_end()));
2915   }
2916   const_child_range used_children() const {
2917     auto Children = const_cast<OMPReductionClause *>(this)->used_children();
2918     return const_child_range(Children.begin(), Children.end());
2919   }
2920
2921   static bool classof(const OMPClause *T) {
2922     return T->getClauseKind() == OMPC_reduction;
2923   }
2924 };
2925
2926 /// This represents clause 'task_reduction' in the '#pragma omp taskgroup'
2927 /// directives.
2928 ///
2929 /// \code
2930 /// #pragma omp taskgroup task_reduction(+:a,b)
2931 /// \endcode
2932 /// In this example directive '#pragma omp taskgroup' has clause
2933 /// 'task_reduction' with operator '+' and the variables 'a' and 'b'.
2934 class OMPTaskReductionClause final
2935     : public OMPVarListClause<OMPTaskReductionClause>,
2936       public OMPClauseWithPostUpdate,
2937       private llvm::TrailingObjects<OMPTaskReductionClause, Expr *> {
2938   friend class OMPClauseReader;
2939   friend OMPVarListClause;
2940   friend TrailingObjects;
2941
2942   /// Location of ':'.
2943   SourceLocation ColonLoc;
2944
2945   /// Nested name specifier for C++.
2946   NestedNameSpecifierLoc QualifierLoc;
2947
2948   /// Name of custom operator.
2949   DeclarationNameInfo NameInfo;
2950
2951   /// Build clause with number of variables \a N.
2952   ///
2953   /// \param StartLoc Starting location of the clause.
2954   /// \param LParenLoc Location of '('.
2955   /// \param EndLoc Ending location of the clause.
2956   /// \param ColonLoc Location of ':'.
2957   /// \param N Number of the variables in the clause.
2958   /// \param QualifierLoc The nested-name qualifier with location information
2959   /// \param NameInfo The full name info for reduction identifier.
2960   OMPTaskReductionClause(SourceLocation StartLoc, SourceLocation LParenLoc,
2961                          SourceLocation ColonLoc, SourceLocation EndLoc,
2962                          unsigned N, NestedNameSpecifierLoc QualifierLoc,
2963                          const DeclarationNameInfo &NameInfo)
2964       : OMPVarListClause<OMPTaskReductionClause>(OMPC_task_reduction, StartLoc,
2965                                                  LParenLoc, EndLoc, N),
2966         OMPClauseWithPostUpdate(this), ColonLoc(ColonLoc),
2967         QualifierLoc(QualifierLoc), NameInfo(NameInfo) {}
2968
2969   /// Build an empty clause.
2970   ///
2971   /// \param N Number of variables.
2972   explicit OMPTaskReductionClause(unsigned N)
2973       : OMPVarListClause<OMPTaskReductionClause>(
2974             OMPC_task_reduction, SourceLocation(), SourceLocation(),
2975             SourceLocation(), N),
2976         OMPClauseWithPostUpdate(this) {}
2977
2978   /// Sets location of ':' symbol in clause.
2979   void setColonLoc(SourceLocation CL) { ColonLoc = CL; }
2980
2981   /// Sets the name info for specified reduction identifier.
2982   void setNameInfo(DeclarationNameInfo DNI) { NameInfo = DNI; }
2983
2984   /// Sets the nested name specifier.
2985   void setQualifierLoc(NestedNameSpecifierLoc NSL) { QualifierLoc = NSL; }
2986
2987   /// Set list of helper expressions, required for proper codegen of the clause.
2988   /// These expressions represent private copy of the reduction variable.
2989   void setPrivates(ArrayRef<Expr *> Privates);
2990
2991   /// Get the list of helper privates.
2992   MutableArrayRef<Expr *> getPrivates() {
2993     return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
2994   }
2995   ArrayRef<const Expr *> getPrivates() const {
2996     return llvm::makeArrayRef(varlist_end(), varlist_size());
2997   }
2998
2999   /// Set list of helper expressions, required for proper codegen of the clause.
3000   /// These expressions represent LHS expression in the final reduction
3001   /// expression performed by the reduction clause.
3002   void setLHSExprs(ArrayRef<Expr *> LHSExprs);
3003
3004   /// Get the list of helper LHS expressions.
3005   MutableArrayRef<Expr *> getLHSExprs() {
3006     return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size());
3007   }
3008   ArrayRef<const Expr *> getLHSExprs() const {
3009     return llvm::makeArrayRef(getPrivates().end(), varlist_size());
3010   }
3011
3012   /// Set list of helper expressions, required for proper codegen of the clause.
3013   /// These expressions represent RHS expression in the final reduction
3014   /// expression performed by the reduction clause. Also, variables in these
3015   /// expressions are used for proper initialization of reduction copies.
3016   void setRHSExprs(ArrayRef<Expr *> RHSExprs);
3017
3018   ///  Get the list of helper destination expressions.
3019   MutableArrayRef<Expr *> getRHSExprs() {
3020     return MutableArrayRef<Expr *>(getLHSExprs().end(), varlist_size());
3021   }
3022   ArrayRef<const Expr *> getRHSExprs() const {
3023     return llvm::makeArrayRef(getLHSExprs().end(), varlist_size());
3024   }
3025
3026   /// Set list of helper reduction expressions, required for proper
3027   /// codegen of the clause. These expressions are binary expressions or
3028   /// operator/custom reduction call that calculates new value from source
3029   /// helper expressions to destination helper expressions.
3030   void setReductionOps(ArrayRef<Expr *> ReductionOps);
3031
3032   ///  Get the list of helper reduction expressions.
3033   MutableArrayRef<Expr *> getReductionOps() {
3034     return MutableArrayRef<Expr *>(getRHSExprs().end(), varlist_size());
3035   }
3036   ArrayRef<const Expr *> getReductionOps() const {
3037     return llvm::makeArrayRef(getRHSExprs().end(), varlist_size());
3038   }
3039
3040 public:
3041   /// Creates clause with a list of variables \a VL.
3042   ///
3043   /// \param StartLoc Starting location of the clause.
3044   /// \param LParenLoc Location of '('.
3045   /// \param ColonLoc Location of ':'.
3046   /// \param EndLoc Ending location of the clause.
3047   /// \param VL The variables in the clause.
3048   /// \param QualifierLoc The nested-name qualifier with location information
3049   /// \param NameInfo The full name info for reduction identifier.
3050   /// \param Privates List of helper expressions for proper generation of
3051   /// private copies.
3052   /// \param LHSExprs List of helper expressions for proper generation of
3053   /// assignment operation required for copyprivate clause. This list represents
3054   /// LHSs of the reduction expressions.
3055   /// \param RHSExprs List of helper expressions for proper generation of
3056   /// assignment operation required for copyprivate clause. This list represents
3057   /// RHSs of the reduction expressions.
3058   /// Also, variables in these expressions are used for proper initialization of
3059   /// reduction copies.
3060   /// \param ReductionOps List of helper expressions that represents reduction
3061   /// expressions:
3062   /// \code
3063   /// LHSExprs binop RHSExprs;
3064   /// operator binop(LHSExpr, RHSExpr);
3065   /// <CutomReduction>(LHSExpr, RHSExpr);
3066   /// \endcode
3067   /// Required for proper codegen of final reduction operation performed by the
3068   /// reduction clause.
3069   /// \param PreInit Statement that must be executed before entering the OpenMP
3070   /// region with this clause.
3071   /// \param PostUpdate Expression that must be executed after exit from the
3072   /// OpenMP region with this clause.
3073   static OMPTaskReductionClause *
3074   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
3075          SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
3076          NestedNameSpecifierLoc QualifierLoc,
3077          const DeclarationNameInfo &NameInfo, ArrayRef<Expr *> Privates,
3078          ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
3079          ArrayRef<Expr *> ReductionOps, Stmt *PreInit, Expr *PostUpdate);
3080
3081   /// Creates an empty clause with the place for \a N variables.
3082   ///
3083   /// \param C AST context.
3084   /// \param N The number of variables.
3085   static OMPTaskReductionClause *CreateEmpty(const ASTContext &C, unsigned N);
3086
3087   /// Gets location of ':' symbol in clause.
3088   SourceLocation getColonLoc() const { return ColonLoc; }
3089
3090   /// Gets the name info for specified reduction identifier.
3091   const DeclarationNameInfo &getNameInfo() const { return NameInfo; }
3092
3093   /// Gets the nested name specifier.
3094   NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
3095
3096   using helper_expr_iterator = MutableArrayRef<Expr *>::iterator;
3097   using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator;
3098   using helper_expr_range = llvm::iterator_range<helper_expr_iterator>;
3099   using helper_expr_const_range =
3100       llvm::iterator_range<helper_expr_const_iterator>;
3101
3102   helper_expr_const_range privates() const {
3103     return helper_expr_const_range(getPrivates().begin(), getPrivates().end());
3104   }
3105
3106   helper_expr_range privates() {
3107     return helper_expr_range(getPrivates().begin(), getPrivates().end());
3108   }
3109
3110   helper_expr_const_range lhs_exprs() const {
3111     return helper_expr_const_range(getLHSExprs().begin(), getLHSExprs().end());
3112   }
3113
3114   helper_expr_range lhs_exprs() {
3115     return helper_expr_range(getLHSExprs().begin(), getLHSExprs().end());
3116   }
3117
3118   helper_expr_const_range rhs_exprs() const {
3119     return helper_expr_const_range(getRHSExprs().begin(), getRHSExprs().end());
3120   }
3121
3122   helper_expr_range rhs_exprs() {
3123     return helper_expr_range(getRHSExprs().begin(), getRHSExprs().end());
3124   }
3125
3126   helper_expr_const_range reduction_ops() const {
3127     return helper_expr_const_range(getReductionOps().begin(),
3128                                    getReductionOps().end());
3129   }
3130
3131   helper_expr_range reduction_ops() {
3132     return helper_expr_range(getReductionOps().begin(),
3133                              getReductionOps().end());
3134   }
3135
3136   child_range children() {
3137     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
3138                        reinterpret_cast<Stmt **>(varlist_end()));
3139   }
3140
3141   const_child_range children() const {
3142     auto Children = const_cast<OMPTaskReductionClause *>(this)->children();
3143     return const_child_range(Children.begin(), Children.end());
3144   }
3145
3146   child_range used_children() {
3147     return child_range(child_iterator(), child_iterator());
3148   }
3149   const_child_range used_children() const {
3150     return const_child_range(const_child_iterator(), const_child_iterator());
3151   }
3152
3153   static bool classof(const OMPClause *T) {
3154     return T->getClauseKind() == OMPC_task_reduction;
3155   }
3156 };
3157
3158 /// This represents clause 'in_reduction' in the '#pragma omp task' directives.
3159 ///
3160 /// \code
3161 /// #pragma omp task in_reduction(+:a,b)
3162 /// \endcode
3163 /// In this example directive '#pragma omp task' has clause 'in_reduction' with
3164 /// operator '+' and the variables 'a' and 'b'.
3165 class OMPInReductionClause final
3166     : public OMPVarListClause<OMPInReductionClause>,
3167       public OMPClauseWithPostUpdate,
3168       private llvm::TrailingObjects<OMPInReductionClause, Expr *> {
3169   friend class OMPClauseReader;
3170   friend OMPVarListClause;
3171   friend TrailingObjects;
3172
3173   /// Location of ':'.
3174   SourceLocation ColonLoc;
3175
3176   /// Nested name specifier for C++.
3177   NestedNameSpecifierLoc QualifierLoc;
3178
3179   /// Name of custom operator.
3180   DeclarationNameInfo NameInfo;
3181
3182   /// Build clause with number of variables \a N.
3183   ///
3184   /// \param StartLoc Starting location of the clause.
3185   /// \param LParenLoc Location of '('.
3186   /// \param EndLoc Ending location of the clause.
3187   /// \param ColonLoc Location of ':'.
3188   /// \param N Number of the variables in the clause.
3189   /// \param QualifierLoc The nested-name qualifier with location information
3190   /// \param NameInfo The full name info for reduction identifier.
3191   OMPInReductionClause(SourceLocation StartLoc, SourceLocation LParenLoc,
3192                        SourceLocation ColonLoc, SourceLocation EndLoc,
3193                        unsigned N, NestedNameSpecifierLoc QualifierLoc,
3194                        const DeclarationNameInfo &NameInfo)
3195       : OMPVarListClause<OMPInReductionClause>(OMPC_in_reduction, StartLoc,
3196                                                LParenLoc, EndLoc, N),
3197         OMPClauseWithPostUpdate(this), ColonLoc(ColonLoc),
3198         QualifierLoc(QualifierLoc), NameInfo(NameInfo) {}
3199
3200   /// Build an empty clause.
3201   ///
3202   /// \param N Number of variables.
3203   explicit OMPInReductionClause(unsigned N)
3204       : OMPVarListClause<OMPInReductionClause>(
3205             OMPC_in_reduction, SourceLocation(), SourceLocation(),
3206             SourceLocation(), N),
3207         OMPClauseWithPostUpdate(this) {}
3208
3209   /// Sets location of ':' symbol in clause.
3210   void setColonLoc(SourceLocation CL) { ColonLoc = CL; }
3211
3212   /// Sets the name info for specified reduction identifier.
3213   void setNameInfo(DeclarationNameInfo DNI) { NameInfo = DNI; }
3214
3215   /// Sets the nested name specifier.
3216   void setQualifierLoc(NestedNameSpecifierLoc NSL) { QualifierLoc = NSL; }
3217
3218   /// Set list of helper expressions, required for proper codegen of the clause.
3219   /// These expressions represent private copy of the reduction variable.
3220   void setPrivates(ArrayRef<Expr *> Privates);
3221
3222   /// Get the list of helper privates.
3223   MutableArrayRef<Expr *> getPrivates() {
3224     return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
3225   }
3226   ArrayRef<const Expr *> getPrivates() const {
3227     return llvm::makeArrayRef(varlist_end(), varlist_size());
3228   }
3229
3230   /// Set list of helper expressions, required for proper codegen of the clause.
3231   /// These expressions represent LHS expression in the final reduction
3232   /// expression performed by the reduction clause.
3233   void setLHSExprs(ArrayRef<Expr *> LHSExprs);
3234
3235   /// Get the list of helper LHS expressions.
3236   MutableArrayRef<Expr *> getLHSExprs() {
3237     return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size());
3238   }
3239   ArrayRef<const Expr *> getLHSExprs() const {
3240     return llvm::makeArrayRef(getPrivates().end(), varlist_size());
3241   }
3242
3243   /// Set list of helper expressions, required for proper codegen of the clause.
3244   /// These expressions represent RHS expression in the final reduction
3245   /// expression performed by the reduction clause. Also, variables in these
3246   /// expressions are used for proper initialization of reduction copies.
3247   void setRHSExprs(ArrayRef<Expr *> RHSExprs);
3248
3249   ///  Get the list of helper destination expressions.
3250   MutableArrayRef<Expr *> getRHSExprs() {
3251     return MutableArrayRef<Expr *>(getLHSExprs().end(), varlist_size());
3252   }
3253   ArrayRef<const Expr *> getRHSExprs() const {
3254     return llvm::makeArrayRef(getLHSExprs().end(), varlist_size());
3255   }
3256
3257   /// Set list of helper reduction expressions, required for proper
3258   /// codegen of the clause. These expressions are binary expressions or
3259   /// operator/custom reduction call that calculates new value from source
3260   /// helper expressions to destination helper expressions.
3261   void setReductionOps(ArrayRef<Expr *> ReductionOps);
3262
3263   ///  Get the list of helper reduction expressions.
3264   MutableArrayRef<Expr *> getReductionOps() {
3265     return MutableArrayRef<Expr *>(getRHSExprs().end(), varlist_size());
3266   }
3267   ArrayRef<const Expr *> getReductionOps() const {
3268     return llvm::makeArrayRef(getRHSExprs().end(), varlist_size());
3269   }
3270
3271   /// Set list of helper reduction taskgroup descriptors.
3272   void setTaskgroupDescriptors(ArrayRef<Expr *> ReductionOps);
3273
3274   ///  Get the list of helper reduction taskgroup descriptors.
3275   MutableArrayRef<Expr *> getTaskgroupDescriptors() {
3276     return MutableArrayRef<Expr *>(getReductionOps().end(), varlist_size());
3277   }
3278   ArrayRef<const Expr *> getTaskgroupDescriptors() const {
3279     return llvm::makeArrayRef(getReductionOps().end(), varlist_size());
3280   }
3281
3282 public:
3283   /// Creates clause with a list of variables \a VL.
3284   ///
3285   /// \param StartLoc Starting location of the clause.
3286   /// \param LParenLoc Location of '('.
3287   /// \param ColonLoc Location of ':'.
3288   /// \param EndLoc Ending location of the clause.
3289   /// \param VL The variables in the clause.
3290   /// \param QualifierLoc The nested-name qualifier with location information
3291   /// \param NameInfo The full name info for reduction identifier.
3292   /// \param Privates List of helper expressions for proper generation of
3293   /// private copies.
3294   /// \param LHSExprs List of helper expressions for proper generation of
3295   /// assignment operation required for copyprivate clause. This list represents
3296   /// LHSs of the reduction expressions.
3297   /// \param RHSExprs List of helper expressions for proper generation of
3298   /// assignment operation required for copyprivate clause. This list represents
3299   /// RHSs of the reduction expressions.
3300   /// Also, variables in these expressions are used for proper initialization of
3301   /// reduction copies.
3302   /// \param ReductionOps List of helper expressions that represents reduction
3303   /// expressions:
3304   /// \code
3305   /// LHSExprs binop RHSExprs;
3306   /// operator binop(LHSExpr, RHSExpr);
3307   /// <CutomReduction>(LHSExpr, RHSExpr);
3308   /// \endcode
3309   /// Required for proper codegen of final reduction operation performed by the
3310   /// reduction clause.
3311   /// \param TaskgroupDescriptors List of helper taskgroup descriptors for
3312   /// corresponding items in parent taskgroup task_reduction clause.
3313   /// \param PreInit Statement that must be executed before entering the OpenMP
3314   /// region with this clause.
3315   /// \param PostUpdate Expression that must be executed after exit from the
3316   /// OpenMP region with this clause.
3317   static OMPInReductionClause *
3318   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
3319          SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
3320          NestedNameSpecifierLoc QualifierLoc,
3321          const DeclarationNameInfo &NameInfo, ArrayRef<Expr *> Privates,
3322          ArrayRef<Expr *> LHSExprs, ArrayRef<Expr *> RHSExprs,
3323          ArrayRef<Expr *> ReductionOps, ArrayRef<Expr *> TaskgroupDescriptors,
3324          Stmt *PreInit, Expr *PostUpdate);
3325
3326   /// Creates an empty clause with the place for \a N variables.
3327   ///
3328   /// \param C AST context.
3329   /// \param N The number of variables.
3330   static OMPInReductionClause *CreateEmpty(const ASTContext &C, unsigned N);
3331
3332   /// Gets location of ':' symbol in clause.
3333   SourceLocation getColonLoc() const { return ColonLoc; }
3334
3335   /// Gets the name info for specified reduction identifier.
3336   const DeclarationNameInfo &getNameInfo() const { return NameInfo; }
3337
3338   /// Gets the nested name specifier.
3339   NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
3340
3341   using helper_expr_iterator = MutableArrayRef<Expr *>::iterator;
3342   using helper_expr_const_iterator = ArrayRef<const Expr *>::iterator;
3343   using helper_expr_range = llvm::iterator_range<helper_expr_iterator>;
3344   using helper_expr_const_range =
3345       llvm::iterator_range<helper_expr_const_iterator>;
3346
3347   helper_expr_const_range privates() const {
3348     return helper_expr_const_range(getPrivates().begin(), getPrivates().end());
3349   }
3350
3351   helper_expr_range privates() {
3352     return helper_expr_range(getPrivates().begin(), getPrivates().end());
3353   }
3354
3355   helper_expr_const_range lhs_exprs() const {
3356     return helper_expr_const_range(getLHSExprs().begin(), getLHSExprs().end());
3357   }
3358
3359   helper_expr_range lhs_exprs() {
3360     return helper_expr_range(getLHSExprs().begin(), getLHSExprs().end());
3361   }
3362
3363   helper_expr_const_range rhs_exprs() const {
3364     return helper_expr_const_range(getRHSExprs().begin(), getRHSExprs().end());
3365   }
3366
3367   helper_expr_range rhs_exprs() {
3368     return helper_expr_range(getRHSExprs().begin(), getRHSExprs().end());
3369   }
3370
3371   helper_expr_const_range reduction_ops() const {
3372     return helper_expr_const_range(getReductionOps().begin(),
3373                                    getReductionOps().end());
3374   }
3375
3376   helper_expr_range reduction_ops() {
3377     return helper_expr_range(getReductionOps().begin(),
3378                              getReductionOps().end());
3379   }
3380
3381   helper_expr_const_range taskgroup_descriptors() const {
3382     return helper_expr_const_range(getTaskgroupDescriptors().begin(),
3383                                    getTaskgroupDescriptors().end());
3384   }
3385
3386   helper_expr_range taskgroup_descriptors() {
3387     return helper_expr_range(getTaskgroupDescriptors().begin(),
3388                              getTaskgroupDescriptors().end());
3389   }
3390
3391   child_range children() {
3392     return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
3393                        reinterpret_cast<Stmt **>(varlist_end()));
3394   }
3395
3396   const_child_range children() const {
3397     auto Children = const_cast<OMPInReductionClause *>(this)->children();
3398     return const_child_range(Children.begin(), Children.end());
3399   }
3400
3401   child_range used_children() {
3402     return child_range(child_iterator(), child_iterator());
3403   }
3404   const_child_range used_children() const {
3405     return const_child_range(const_child_iterator(), const_child_iterator());
3406   }
3407
3408   static bool classof(const OMPClause *T) {
3409     return T->getClauseKind() == OMPC_in_reduction;
3410   }
3411 };
3412
3413 /// This represents clause 'linear' in the '#pragma omp ...'
3414 /// directives.
3415 ///
3416 /// \code
3417 /// #pragma omp simd linear(a,b : 2)
3418 /// \endcode
3419 /// In this example directive '#pragma omp simd' has clause 'linear'
3420 /// with variables 'a', 'b' and linear step '2'.
3421 class OMPLinearClause final
3422     : public OMPVarListClause<OMPLinearClause>,
3423       public OMPClauseWithPostUpdate,
3424       private llvm::TrailingObjects<OMPLinearClause, Expr *> {
3425   friend class OMPClauseReader;
3426   friend OMPVarListClause;
3427   friend TrailingObjects;
3428
3429   /// Modifier of 'linear' clause.
3430   OpenMPLinearClauseKind Modifier = OMPC_LINEAR_val;
3431
3432   /// Location of linear modifier if any.
3433   SourceLocation ModifierLoc;
3434
3435   /// Location of ':'.
3436   SourceLocation ColonLoc;
3437
3438   /// Sets the linear step for clause.
3439   void setStep(Expr *Step) { *(getFinals().end()) = Step; }
3440
3441   /// Sets the expression to calculate linear step for clause.
3442   void setCalcStep(Expr *CalcStep) { *(getFinals().end() + 1) = CalcStep; }
3443
3444   /// Build 'linear' clause with given number of variables \a NumVars.
3445   ///
3446   /// \param StartLoc Starting location of the clause.
3447   /// \param LParenLoc Location of '('.
3448   /// \param ColonLoc Location of ':'.
3449   /// \param EndLoc Ending location of the clause.
3450   /// \param NumVars Number of variables.
3451   OMPLinearClause(SourceLocation StartLoc, SourceLocation LParenLoc,
3452                   OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
3453                   SourceLocation ColonLoc, SourceLocation EndLoc,
3454                   unsigned NumVars)
3455       : OMPVarListClause<OMPLinearClause>(OMPC_linear, StartLoc, LParenLoc,
3456                                           EndLoc, NumVars),
3457         OMPClauseWithPostUpdate(this), Modifier(Modifier),
3458         ModifierLoc(ModifierLoc), ColonLoc(ColonLoc) {}
3459
3460   /// Build an empty clause.
3461   ///
3462   /// \param NumVars Number of variables.
3463   explicit OMPLinearClause(unsigned NumVars)
3464       : OMPVarListClause<OMPLinearClause>(OMPC_linear, SourceLocation(),
3465                                           SourceLocation(), SourceLocation(),
3466                                           NumVars),
3467         OMPClauseWithPostUpdate(this) {}
3468
3469   /// Gets the list of initial values for linear variables.
3470   ///
3471   /// There are NumVars expressions with initial values allocated after the
3472   /// varlist, they are followed by NumVars update expressions (used to update
3473   /// the linear variable's value on current iteration) and they are followed by
3474   /// NumVars final expressions (used to calculate the linear variable's
3475   /// value after the loop body). After these lists, there are 2 helper
3476   /// expressions - linear step and a helper to calculate it before the
3477   /// loop body (used when the linear step is not constant):
3478   ///
3479   /// { Vars[] /* in OMPVarListClause */; Privates[]; Inits[]; Updates[];
3480   /// Finals[]; Step; CalcStep; }
3481   MutableArrayRef<Expr *> getPrivates() {
3482     return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
3483   }
3484   ArrayRef<const Expr *> getPrivates() const {
3485     return llvm::makeArrayRef(varlist_end(), varlist_size());
3486   }
3487
3488   MutableArrayRef<Expr *> getInits() {
3489     return MutableArrayRef<Expr *>(getPrivates().end(), varlist_size());
3490   }
3491   ArrayRef<const Expr *> getInits() const {
3492     return llvm::makeArrayRef(getPrivates().end(), varlist_size());
3493   }
3494
3495   /// Sets the list of update expressions for linear variables.
3496   MutableArrayRef<Expr *> getUpdates() {
3497     return MutableArrayRef<Expr *>(getInits().end(), varlist_size());
3498   }
3499   ArrayRef<const Expr *> getUpdates() const {
3500     return llvm::makeArrayRef(getInits().end(), varlist_size());
3501   }
3502
3503   /// Sets the list of final update expressions for linear variables.
3504   MutableArrayRef<Expr *> getFinals() {
3505     return MutableArrayRef<Expr *>(getUpdates().end(), varlist_size());
3506   }
3507   ArrayRef<const Expr *> getFinals() const {
3508     return llvm::makeArrayRef(getUpdates().end(), varlist_size());
3509   }
3510
3511   /// Gets the list of used expressions for linear variables.
3512   MutableArrayRef<Expr *> getUsedExprs() {
3513     return MutableArrayRef<Expr *>(getFinals().end() + 2, varlist_size() + 1);
3514   }
3515   ArrayRef<const Expr *> getUsedExprs() const {
3516     return llvm::makeArrayRef(getFinals().end() + 2, varlist_size() + 1);
3517   }
3518
3519   /// Sets the list of the copies of original linear variables.
3520   /// \param PL List of expressions.
3521   void setPrivates(ArrayRef<Expr *> PL);
3522
3523   /// Sets the list of the initial values for linear variables.
3524   /// \param IL List of expressions.
3525   void setInits(ArrayRef<Expr *> IL);
3526
3527 public:
3528   /// Creates clause with a list of variables \a VL and a linear step
3529   /// \a Step.
3530   ///
3531   /// \param C AST Context.
3532   /// \param StartLoc Starting location of the clause.
3533   /// \param LParenLoc Location of '('.
3534   /// \param Modifier Modifier of 'linear' clause.
3535   /// \param ModifierLoc Modifier location.
3536   /// \param ColonLoc Location of ':'.
3537   /// \param EndLoc Ending location of the clause.
3538   /// \param VL List of references to the variables.
3539   /// \param PL List of private copies of original variables.
3540   /// \param IL List of initial values for the variables.
3541   /// \param Step Linear step.
3542   /// \param CalcStep Calculation of the linear step.
3543   /// \param PreInit Statement that must be executed before entering the OpenMP
3544   /// region with this clause.
3545   /// \param PostUpdate Expression that must be executed after exit from the
3546   /// OpenMP region with this clause.
3547   static OMPLinearClause *
3548   Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
3549          OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
3550          SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
3551          ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
3552          Stmt *PreInit, Expr *PostUpdate);
3553
3554   /// Creates an empty clause with the place for \a NumVars variables.
3555   ///
3556   /// \param C AST context.
3557   /// \param NumVars Number of variables.
3558   static OMPLinearClause *CreateEmpty(const ASTContext &C, unsigned NumVars);
3559
3560   /// Set modifier.
3561   void setModifier(OpenMPLinearClauseKind Kind) { Modifier = Kind; }
3562
3563   /// Return modifier.
3564   OpenMPLinearClauseKind getModifier() const { return Modifier; }
3565
3566   /// Set modifier location.
3567   void setModifierLoc(SourceLocation Loc) { ModifierLoc = Loc; }
3568
3569   /// Return modifier location.
3570   SourceLocation getModifierLoc() const { return ModifierLoc; }
3571
3572   /// Sets the location of ':'.
3573   void setColonLoc(SourceLocation Loc) { ColonLoc = Loc; }
3574
3575   /// Returns the location of ':'.
3576   SourceLocation getColonLoc() const { return ColonLoc; }
3577
3578   /// Returns linear step.
3579   Expr *getStep() { return *(getFinals().end()); }
3580
3581   /// Returns linear step.
3582   const Expr *getStep() const { return *(getFinals().end()); }
3583
3584   /// Returns expression to calculate linear step.
3585   Expr *getCalcStep() { return *(getFinals().end() + 1); }
3586
3587   /// Returns expression to calculate linear step.
3588   const Expr *getCalcStep() const { return *(getFinals().end() + 1); }
3589
3590   /// Sets the list of update expressions for linear variables.
3591   /// \param UL List of expressions.
3592   void setUpdates(ArrayRef<Expr *> UL);
3593
3594   /// Sets the list of final update expressions for linear variables.
3595   /// \param FL List of expressions.
3596   void setFinals(ArrayRef<Expr *> FL);
3597
3598   /// Sets the list of used expressions for the linear clause.
3599   void setUsedExprs(ArrayRef<Expr *> UE);
3600
3601   using privates_iterator = MutableArrayRef<Expr *>::iterator;
3602   using privates_const_iterator = ArrayRef<const Expr *>::iterator;
3603   using privates_range = llvm::iterator_range<privates_iterator>;
3604   using privates_const_range = llvm::iterator_range<privates_const_iterator>;
3605
3606   privates_range privates() {
3607     return privates_range(getPrivates().begin(), getPrivates().end());
3608   }
3609
3610   privates_const_range privates() const {
3611     return privates_const_range(getPrivates().begin(), getPrivates().end());
3612   }
3613
3614   using inits_iterator = MutableArrayRef<Expr *>::iterator;
3615   using inits_const_iterator = ArrayRef<const Expr *>::iterator;
3616   using inits_range = llvm::iterator_range<inits_iterator>;
3617   using inits_const_range = llvm::iterator_range<inits_const_iterator>;
3618
3619   inits_range inits() {
3620     return inits_range(getInits().begin(), getInits().end());
3621   }
3622
3623   inits_const_range inits() const {
3624     return inits_const_range(getInits().begin(), getInits().end());
3625   }
3626
3627   using updates_iterator = MutableArrayRef<Expr *>::iterator;
3628   using updates_const_iterator = ArrayRef<const Expr *>::iterator;
3629   using updates_range = llvm::iterator_range<updates_iterator>;
3630   using updates_const_range = llvm::iterator_range<updates_const_iterator>;
3631
3632   updates_range updates() {
3633     return updates_range(getUpdates().begin(), getUpdates().end());
3634   }
3635
3636   updates_const_range updates() const {
3637     return updates_const_range(getUpdates().begin(), getUpdates().end());
3638   }
3639
3640   using finals_iterator = MutableArrayRef<Expr *>::iterator;
3641   using finals_const_iterator = ArrayRef<const Expr *>::iterator;
3642   using finals_range = llvm::iterator_range<finals_iterator>;
3643   using finals_const_range = llvm::iterator_range<finals_const_iterator>;
3644
3645   finals_range finals() {