clang-r428724/include/clang/AST/ExprOpenMP.h - platform/prebuilts/clang/host/windows-x86 - Git at Google

 //===--- ExprOpenMP.h - Classes for representing expressions ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the Expr interface and subclasses.
 //
 //===----------------------------------------------------------------------===//

 #ifndef LLVM_CLANG_AST_EXPROPENMP_H
 #define LLVM_CLANG_AST_EXPROPENMP_H

 #include "clang/AST/ComputeDependence.h"
 #include "clang/AST/Expr.h"

 namespace clang {
 /// OpenMP 5.0 [2.1.5, Array Sections].
 /// To specify an array section in an OpenMP construct, array subscript
 /// expressions are extended with the following syntax:
 /// \code
 /// [ lower-bound : length : stride ]
 /// [ lower-bound : length : ]
 /// [ lower-bound : length ]
 /// [ lower-bound : : stride ]
 /// [ lower-bound : : ]
 /// [ lower-bound : ]
 /// [ : length : stride ]
 /// [ : length : ]
 /// [ : length ]
 /// [ : : stride ]
 /// [ : : ]
 /// [ : ]
 /// \endcode
 /// The array section must be a subset of the original array.
 /// Array sections are allowed on multidimensional arrays. Base language array
 /// subscript expressions can be used to specify length-one dimensions of
 /// multidimensional array sections.
 /// Each of the lower-bound, length, and stride expressions if specified must be
 /// an integral type expressions of the base language. When evaluated
 /// they represent a set of integer values as follows:
 /// \code
 /// { lower-bound, lower-bound + stride, lower-bound + 2 * stride,... ,
 /// lower-bound + ((length - 1) * stride) }
 /// \endcode
 /// The lower-bound and length must evaluate to non-negative integers.
 /// The stride must evaluate to a positive integer.
 /// When the size of the array dimension is not known, the length must be
 /// specified explicitly.
 /// When the stride is absent it defaults to 1.
 /// When the length is absent it defaults to ⌈(size − lower-bound)/stride⌉,
 /// where size is the size of the array dimension. When the lower-bound is
 /// absent it defaults to 0.
 class OMPArraySectionExpr : public Expr {
   enum { BASE, LOWER_BOUND, LENGTH, STRIDE, END_EXPR };
   Stmt *SubExprs[END_EXPR];
   SourceLocation ColonLocFirst;
   SourceLocation ColonLocSecond;
   SourceLocation RBracketLoc;

 public:
   OMPArraySectionExpr(Expr *Base, Expr *LowerBound, Expr *Length, Expr *Stride,
                       QualType Type, ExprValueKind VK, ExprObjectKind OK,
                       SourceLocation ColonLocFirst,
                       SourceLocation ColonLocSecond, SourceLocation RBracketLoc)
       : Expr(OMPArraySectionExprClass, Type, VK, OK),
         ColonLocFirst(ColonLocFirst), ColonLocSecond(ColonLocSecond),
         RBracketLoc(RBracketLoc) {
     SubExprs[BASE] = Base;
     SubExprs[LOWER_BOUND] = LowerBound;
     SubExprs[LENGTH] = Length;
     SubExprs[STRIDE] = Stride;
     setDependence(computeDependence(this));
   }

   /// Create an empty array section expression.
   explicit OMPArraySectionExpr(EmptyShell Shell)
       : Expr(OMPArraySectionExprClass, Shell) {}

   /// An array section can be written only as Base[LowerBound:Length].

   /// Get base of the array section.
   Expr *getBase() { return cast<Expr>(SubExprs[BASE]); }
   const Expr *getBase() const { return cast<Expr>(SubExprs[BASE]); }
   /// Set base of the array section.
   void setBase(Expr *E) { SubExprs[BASE] = E; }

   /// Return original type of the base expression for array section.
   static QualType getBaseOriginalType(const Expr *Base);

   /// Get lower bound of array section.
   Expr *getLowerBound() { return cast_or_null<Expr>(SubExprs[LOWER_BOUND]); }
   const Expr *getLowerBound() const {
     return cast_or_null<Expr>(SubExprs[LOWER_BOUND]);
   }
   /// Set lower bound of the array section.
   void setLowerBound(Expr *E) { SubExprs[LOWER_BOUND] = E; }

   /// Get length of array section.
   Expr *getLength() { return cast_or_null<Expr>(SubExprs[LENGTH]); }
   const Expr *getLength() const { return cast_or_null<Expr>(SubExprs[LENGTH]); }
   /// Set length of the array section.
   void setLength(Expr *E) { SubExprs[LENGTH] = E; }

   /// Get stride of array section.
   Expr *getStride() { return cast_or_null<Expr>(SubExprs[STRIDE]); }
   const Expr *getStride() const { return cast_or_null<Expr>(SubExprs[STRIDE]); }
   /// Set length of the array section.
   void setStride(Expr *E) { SubExprs[STRIDE] = E; }

   SourceLocation getBeginLoc() const LLVM_READONLY {
     return getBase()->getBeginLoc();
   }
   SourceLocation getEndLoc() const LLVM_READONLY { return RBracketLoc; }

   SourceLocation getColonLocFirst() const { return ColonLocFirst; }
   void setColonLocFirst(SourceLocation L) { ColonLocFirst = L; }

   SourceLocation getColonLocSecond() const { return ColonLocSecond; }
   void setColonLocSecond(SourceLocation L) { ColonLocSecond = L; }

   SourceLocation getRBracketLoc() const { return RBracketLoc; }
   void setRBracketLoc(SourceLocation L) { RBracketLoc = L; }

   SourceLocation getExprLoc() const LLVM_READONLY {
     return getBase()->getExprLoc();
   }

   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPArraySectionExprClass;
   }

   child_range children() {
     return child_range(&SubExprs[BASE], &SubExprs[END_EXPR]);
   }

   const_child_range children() const {
     return const_child_range(&SubExprs[BASE], &SubExprs[END_EXPR]);
   }
 };

 /// An explicit cast in C or a C-style cast in C++, which uses the syntax
 /// ([s1][s2]...[sn])expr. For example: @c ([3][3])f.
 class OMPArrayShapingExpr final
     : public Expr,
       private llvm::TrailingObjects<OMPArrayShapingExpr, Expr *, SourceRange> {
   friend TrailingObjects;
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
   /// Base node.
   SourceLocation LPLoc; /// The location of the left paren
   SourceLocation RPLoc; /// The location of the right paren
   unsigned NumDims = 0; /// Number of dimensions in the shaping expression.

   /// Construct full expression.
   OMPArrayShapingExpr(QualType ExprTy, Expr *Op, SourceLocation L,
                       SourceLocation R, ArrayRef<Expr *> Dims);

   /// Construct an empty expression.
   explicit OMPArrayShapingExpr(EmptyShell Shell, unsigned NumDims)
       : Expr(OMPArrayShapingExprClass, Shell), NumDims(NumDims) {}

   /// Sets the dimensions for the array shaping.
   void setDimensions(ArrayRef<Expr *> Dims);

   /// Sets the base expression for array shaping operation.
   void setBase(Expr *Op) { getTrailingObjects<Expr *>()[NumDims] = Op; }

   /// Sets source ranges for the brackets in the array shaping operation.
   void setBracketsRanges(ArrayRef<SourceRange> BR);

   unsigned numTrailingObjects(OverloadToken<Expr *>) const {
     // Add an extra one for the base expression.
     return NumDims + 1;
   }

   unsigned numTrailingObjects(OverloadToken<SourceRange>) const {
     return NumDims;
   }

 public:
   static OMPArrayShapingExpr *Create(const ASTContext &Context, QualType T,
                                      Expr *Op, SourceLocation L,
                                      SourceLocation R, ArrayRef<Expr *> Dims,
                                      ArrayRef<SourceRange> BracketRanges);

   static OMPArrayShapingExpr *CreateEmpty(const ASTContext &Context,
                                           unsigned NumDims);

   SourceLocation getLParenLoc() const { return LPLoc; }
   void setLParenLoc(SourceLocation L) { LPLoc = L; }

   SourceLocation getRParenLoc() const { return RPLoc; }
   void setRParenLoc(SourceLocation L) { RPLoc = L; }

   SourceLocation getBeginLoc() const LLVM_READONLY { return LPLoc; }
   SourceLocation getEndLoc() const LLVM_READONLY {
     return getBase()->getEndLoc();
   }

   /// Fetches the dimensions for array shaping expression.
   ArrayRef<Expr *> getDimensions() const {
     return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumDims);
   }

   /// Fetches source ranges for the brackets os the array shaping expression.
   ArrayRef<SourceRange> getBracketsRanges() const {
     return llvm::makeArrayRef(getTrailingObjects<SourceRange>(), NumDims);
   }

   /// Fetches base expression of array shaping expression.
   Expr *getBase() { return getTrailingObjects<Expr *>()[NumDims]; }
   const Expr *getBase() const { return getTrailingObjects<Expr *>()[NumDims]; }

   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPArrayShapingExprClass;
   }

   // Iterators
   child_range children() {
     Stmt **Begin = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>());
     return child_range(Begin, Begin + NumDims + 1);
   }
   const_child_range children() const {
     Stmt *const *Begin =
         reinterpret_cast<Stmt *const *>(getTrailingObjects<Expr *>());
     return const_child_range(Begin, Begin + NumDims + 1);
   }
 };

 /// Helper expressions and declaration for OMPIteratorExpr class for each
 /// iteration space.
 struct OMPIteratorHelperData {
   /// Internal normalized counter.
   VarDecl *CounterVD = nullptr;
   /// Normalized upper bound. Normalized loop iterates from 0 to Upper with
   /// step 1.
   Expr *Upper = nullptr;
   /// Update expression for the originally specified iteration variable,
   /// calculated as VD = Begin + CounterVD * Step;
   Expr *Update = nullptr;
   /// Updater for the internal counter: ++CounterVD;
   Expr *CounterUpdate = nullptr;
 };

 /// OpenMP 5.0 [2.1.6 Iterators]
 /// Iterators are identifiers that expand to multiple values in the clause on
 /// which they appear.
 /// The syntax of the iterator modifier is as follows:
 /// \code
 /// iterator(iterators-definition)
 /// \endcode
 /// where iterators-definition is one of the following:
 /// \code
 /// iterator-specifier [, iterators-definition ]
 /// \endcode
 /// where iterator-specifier is one of the following:
 /// \code
 /// [ iterator-type ] identifier = range-specification
 /// \endcode
 /// where identifier is a base language identifier.
 /// iterator-type is a type name.
 /// range-specification is of the form begin:end[:step], where begin and end are
 /// expressions for which their types can be converted to iterator-type and step
 /// is an integral expression.
 /// In an iterator-specifier, if the iterator-type is not specified then the
 /// type of that iterator is of int type.
 /// The iterator-type must be an integral or pointer type.
 /// The iterator-type must not be const qualified.
 class OMPIteratorExpr final
     : public Expr,
       private llvm::TrailingObjects<OMPIteratorExpr, Decl *, Expr *,
                                     SourceLocation, OMPIteratorHelperData> {
 public:
   /// Iterator range representation begin:end[:step].
   struct IteratorRange {
     Expr *Begin = nullptr;
     Expr *End = nullptr;
     Expr *Step = nullptr;
   };
   /// Iterator definition representation.
   struct IteratorDefinition {
     Decl *IteratorDecl = nullptr;
     IteratorRange Range;
     SourceLocation AssignmentLoc;
     SourceLocation ColonLoc, SecondColonLoc;
   };

 private:
   friend TrailingObjects;
   friend class ASTStmtReader;
   friend class ASTStmtWriter;

   /// Offset in the list of expressions for subelements of the ranges.
   enum class RangeExprOffset {
     Begin = 0,
     End = 1,
     Step = 2,
     Total = 3,
   };
   /// Offset in the list of locations for subelements of colon symbols
   /// locations.
   enum class RangeLocOffset {
     AssignLoc = 0,
     FirstColonLoc = 1,
     SecondColonLoc = 2,
     Total = 3,
   };
   /// Location of 'iterator' keyword.
   SourceLocation IteratorKwLoc;
   /// Location of '('.
   SourceLocation LPLoc;
   /// Location of ')'.
   SourceLocation RPLoc;
   /// Number of iterator definitions.
   unsigned NumIterators = 0;

   OMPIteratorExpr(QualType ExprTy, SourceLocation IteratorKwLoc,
                   SourceLocation L, SourceLocation R,
                   ArrayRef<IteratorDefinition> Data,
                   ArrayRef<OMPIteratorHelperData> Helpers);

   /// Construct an empty expression.
   explicit OMPIteratorExpr(EmptyShell Shell, unsigned NumIterators)
       : Expr(OMPIteratorExprClass, Shell), NumIterators(NumIterators) {}

   /// Sets basic declaration for the specified iterator definition.
   void setIteratorDeclaration(unsigned I, Decl *D);

   /// Sets the location of the assignment symbol for the specified iterator
   /// definition.
   void setAssignmentLoc(unsigned I, SourceLocation Loc);

   /// Sets begin, end and optional step expressions for specified iterator
   /// definition.
   void setIteratorRange(unsigned I, Expr *Begin, SourceLocation ColonLoc,
                         Expr *End, SourceLocation SecondColonLoc, Expr *Step);

   /// Sets helpers for the specified iteration space.
   void setHelper(unsigned I, const OMPIteratorHelperData &D);

   unsigned numTrailingObjects(OverloadToken<Decl *>) const {
     return NumIterators;
   }

   unsigned numTrailingObjects(OverloadToken<Expr *>) const {
     return NumIterators * static_cast<int>(RangeExprOffset::Total);
   }

   unsigned numTrailingObjects(OverloadToken<SourceLocation>) const {
     return NumIterators * static_cast<int>(RangeLocOffset::Total);
   }

 public:
   static OMPIteratorExpr *Create(const ASTContext &Context, QualType T,
                                  SourceLocation IteratorKwLoc, SourceLocation L,
                                  SourceLocation R,
                                  ArrayRef<IteratorDefinition> Data,
                                  ArrayRef<OMPIteratorHelperData> Helpers);

   static OMPIteratorExpr *CreateEmpty(const ASTContext &Context,
                                       unsigned NumIterators);

   SourceLocation getLParenLoc() const { return LPLoc; }
   void setLParenLoc(SourceLocation L) { LPLoc = L; }

   SourceLocation getRParenLoc() const { return RPLoc; }
   void setRParenLoc(SourceLocation L) { RPLoc = L; }

   SourceLocation getIteratorKwLoc() const { return IteratorKwLoc; }
   void setIteratorKwLoc(SourceLocation L) { IteratorKwLoc = L; }
   SourceLocation getBeginLoc() const LLVM_READONLY { return IteratorKwLoc; }
   SourceLocation getEndLoc() const LLVM_READONLY { return RPLoc; }

   /// Gets the iterator declaration for the given iterator.
   Decl *getIteratorDecl(unsigned I);
   const Decl *getIteratorDecl(unsigned I) const {
     return const_cast<OMPIteratorExpr *>(this)->getIteratorDecl(I);
   }

   /// Gets the iterator range for the given iterator.
   IteratorRange getIteratorRange(unsigned I);
   const IteratorRange getIteratorRange(unsigned I) const {
     return const_cast<OMPIteratorExpr *>(this)->getIteratorRange(I);
   }

   /// Gets the location of '=' for the given iterator definition.
   SourceLocation getAssignLoc(unsigned I) const;
   /// Gets the location of the first ':' in the range for the given iterator
   /// definition.
   SourceLocation getColonLoc(unsigned I) const;
   /// Gets the location of the second ':' (if any) in the range for the given
   /// iteratori definition.
   SourceLocation getSecondColonLoc(unsigned I) const;

   /// Returns number of iterator definitions.
   unsigned numOfIterators() const { return NumIterators; }

   /// Fetches helper data for the specified iteration space.
   OMPIteratorHelperData &getHelper(unsigned I);
   const OMPIteratorHelperData &getHelper(unsigned I) const;

   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPIteratorExprClass;
   }

   // Iterators
   child_range children() {
     Stmt **Begin = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>());
     return child_range(
         Begin, Begin + NumIterators * static_cast<int>(RangeExprOffset::Total));
   }
   const_child_range children() const {
     Stmt *const *Begin =
         reinterpret_cast<Stmt *const *>(getTrailingObjects<Expr *>());
     return const_child_range(
         Begin, Begin + NumIterators * static_cast<int>(RangeExprOffset::Total));
   }
 };

 } // end namespace clang

 #endif
	//===--- ExprOpenMP.h - Classes for representing expressions ----- C++ --===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//
	//
	// This file defines the Expr interface and subclasses.
	//
	//===----------------------------------------------------------------------===//

	#ifndef LLVM_CLANG_AST_EXPROPENMP_H
	#define LLVM_CLANG_AST_EXPROPENMP_H

	#include "clang/AST/ComputeDependence.h"
	#include "clang/AST/Expr.h"

	namespace clang {
	/// OpenMP 5.0 [2.1.5, Array Sections].
	/// To specify an array section in an OpenMP construct, array subscript
	/// expressions are extended with the following syntax:
	/// \code
	/// [ lower-bound : length : stride ]
	/// [ lower-bound : length : ]
	/// [ lower-bound : length ]
	/// [ lower-bound : : stride ]
	/// [ lower-bound : : ]
	/// [ lower-bound : ]
	/// [ : length : stride ]
	/// [ : length : ]
	/// [ : length ]
	/// [ : : stride ]
	/// [ : : ]
	/// [ : ]
	/// \endcode
	/// The array section must be a subset of the original array.
	/// Array sections are allowed on multidimensional arrays. Base language array
	/// subscript expressions can be used to specify length-one dimensions of
	/// multidimensional array sections.
	/// Each of the lower-bound, length, and stride expressions if specified must be
	/// an integral type expressions of the base language. When evaluated
	/// they represent a set of integer values as follows:
	/// \code
	/// { lower-bound, lower-bound + stride, lower-bound + 2 * stride,... ,
	/// lower-bound + ((length - 1) * stride) }
	/// \endcode
	/// The lower-bound and length must evaluate to non-negative integers.
	/// The stride must evaluate to a positive integer.
	/// When the size of the array dimension is not known, the length must be
	/// specified explicitly.
	/// When the stride is absent it defaults to 1.
	/// When the length is absent it defaults to ⌈(size − lower-bound)/stride⌉,
	/// where size is the size of the array dimension. When the lower-bound is
	/// absent it defaults to 0.
	class OMPArraySectionExpr : public Expr {
	enum { BASE, LOWER_BOUND, LENGTH, STRIDE, END_EXPR };
	Stmt *SubExprs[END_EXPR];
	SourceLocation ColonLocFirst;
	SourceLocation ColonLocSecond;
	SourceLocation RBracketLoc;

	public:
	OMPArraySectionExpr(Expr Base, Expr LowerBound, Expr Length, Expr Stride,
	QualType Type, ExprValueKind VK, ExprObjectKind OK,
	SourceLocation ColonLocFirst,
	SourceLocation ColonLocSecond, SourceLocation RBracketLoc)
	: Expr(OMPArraySectionExprClass, Type, VK, OK),
	ColonLocFirst(ColonLocFirst), ColonLocSecond(ColonLocSecond),
	RBracketLoc(RBracketLoc) {
	SubExprs[BASE] = Base;
	SubExprs[LOWER_BOUND] = LowerBound;
	SubExprs[LENGTH] = Length;
	SubExprs[STRIDE] = Stride;
	setDependence(computeDependence(this));
	}

	/// Create an empty array section expression.
	explicit OMPArraySectionExpr(EmptyShell Shell)
	: Expr(OMPArraySectionExprClass, Shell) {}

	/// An array section can be written only as Base[LowerBound:Length].

	/// Get base of the array section.
	Expr *getBase() { return cast<Expr>(SubExprs[BASE]); }
	const Expr *getBase() const { return cast<Expr>(SubExprs[BASE]); }
	/// Set base of the array section.
	void setBase(Expr *E) { SubExprs[BASE] = E; }

	/// Return original type of the base expression for array section.
	static QualType getBaseOriginalType(const Expr *Base);

	/// Get lower bound of array section.
	Expr *getLowerBound() { return cast_or_null<Expr>(SubExprs[LOWER_BOUND]); }
	const Expr *getLowerBound() const {
	return cast_or_null<Expr>(SubExprs[LOWER_BOUND]);
	}
	/// Set lower bound of the array section.
	void setLowerBound(Expr *E) { SubExprs[LOWER_BOUND] = E; }

	/// Get length of array section.
	Expr *getLength() { return cast_or_null<Expr>(SubExprs[LENGTH]); }
	const Expr *getLength() const { return cast_or_null<Expr>(SubExprs[LENGTH]); }
	/// Set length of the array section.
	void setLength(Expr *E) { SubExprs[LENGTH] = E; }

	/// Get stride of array section.
	Expr *getStride() { return cast_or_null<Expr>(SubExprs[STRIDE]); }
	const Expr *getStride() const { return cast_or_null<Expr>(SubExprs[STRIDE]); }
	/// Set length of the array section.
	void setStride(Expr *E) { SubExprs[STRIDE] = E; }

	SourceLocation getBeginLoc() const LLVM_READONLY {
	return getBase()->getBeginLoc();
	}
	SourceLocation getEndLoc() const LLVM_READONLY { return RBracketLoc; }

	SourceLocation getColonLocFirst() const { return ColonLocFirst; }
	void setColonLocFirst(SourceLocation L) { ColonLocFirst = L; }

	SourceLocation getColonLocSecond() const { return ColonLocSecond; }
	void setColonLocSecond(SourceLocation L) { ColonLocSecond = L; }

	SourceLocation getRBracketLoc() const { return RBracketLoc; }
	void setRBracketLoc(SourceLocation L) { RBracketLoc = L; }

	SourceLocation getExprLoc() const LLVM_READONLY {
	return getBase()->getExprLoc();
	}

	static bool classof(const Stmt *T) {
	return T->getStmtClass() == OMPArraySectionExprClass;
	}

	child_range children() {
	return child_range(&SubExprs[BASE], &SubExprs[END_EXPR]);
	}

	const_child_range children() const {
	return const_child_range(&SubExprs[BASE], &SubExprs[END_EXPR]);
	}
	};

	/// An explicit cast in C or a C-style cast in C++, which uses the syntax
	/// ([s1][s2]...[sn])expr. For example: @c ([3][3])f.
	class OMPArrayShapingExpr final
	: public Expr,
	private llvm::TrailingObjects<OMPArrayShapingExpr, Expr *, SourceRange> {
	friend TrailingObjects;
	friend class ASTStmtReader;
	friend class ASTStmtWriter;
	/// Base node.
	SourceLocation LPLoc; /// The location of the left paren
	SourceLocation RPLoc; /// The location of the right paren
	unsigned NumDims = 0; /// Number of dimensions in the shaping expression.

	/// Construct full expression.
	OMPArrayShapingExpr(QualType ExprTy, Expr *Op, SourceLocation L,
	SourceLocation R, ArrayRef<Expr *> Dims);

	/// Construct an empty expression.
	explicit OMPArrayShapingExpr(EmptyShell Shell, unsigned NumDims)
	: Expr(OMPArrayShapingExprClass, Shell), NumDims(NumDims) {}

	/// Sets the dimensions for the array shaping.
	void setDimensions(ArrayRef<Expr *> Dims);

	/// Sets the base expression for array shaping operation.
	void setBase(Expr Op) { getTrailingObjects<Expr >()[NumDims] = Op; }

	/// Sets source ranges for the brackets in the array shaping operation.
	void setBracketsRanges(ArrayRef<SourceRange> BR);

	unsigned numTrailingObjects(OverloadToken<Expr *>) const {
	// Add an extra one for the base expression.
	return NumDims + 1;
	}

	unsigned numTrailingObjects(OverloadToken<SourceRange>) const {
	return NumDims;
	}

	public:
	static OMPArrayShapingExpr *Create(const ASTContext &Context, QualType T,
	Expr *Op, SourceLocation L,
	SourceLocation R, ArrayRef<Expr *> Dims,
	ArrayRef<SourceRange> BracketRanges);

	static OMPArrayShapingExpr *CreateEmpty(const ASTContext &Context,
	unsigned NumDims);

	SourceLocation getLParenLoc() const { return LPLoc; }
	void setLParenLoc(SourceLocation L) { LPLoc = L; }

	SourceLocation getRParenLoc() const { return RPLoc; }
	void setRParenLoc(SourceLocation L) { RPLoc = L; }

	SourceLocation getBeginLoc() const LLVM_READONLY { return LPLoc; }
	SourceLocation getEndLoc() const LLVM_READONLY {
	return getBase()->getEndLoc();
	}

	/// Fetches the dimensions for array shaping expression.
	ArrayRef<Expr *> getDimensions() const {
	return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumDims);
	}

	/// Fetches source ranges for the brackets os the array shaping expression.
	ArrayRef<SourceRange> getBracketsRanges() const {
	return llvm::makeArrayRef(getTrailingObjects<SourceRange>(), NumDims);
	}

	/// Fetches base expression of array shaping expression.
	Expr getBase() { return getTrailingObjects<Expr >()[NumDims]; }
	const Expr getBase() const { return getTrailingObjects<Expr >()[NumDims]; }

	static bool classof(const Stmt *T) {
	return T->getStmtClass() == OMPArrayShapingExprClass;
	}

	// Iterators
	child_range children() {
	Stmt Begin = reinterpret_cast<Stmt >(getTrailingObjects<Expr *>());
	return child_range(Begin, Begin + NumDims + 1);
	}
	const_child_range children() const {
	Stmt const Begin =
	reinterpret_cast<Stmt const >(getTrailingObjects<Expr *>());
	return const_child_range(Begin, Begin + NumDims + 1);
	}
	};

	/// Helper expressions and declaration for OMPIteratorExpr class for each
	/// iteration space.
	struct OMPIteratorHelperData {
	/// Internal normalized counter.
	VarDecl *CounterVD = nullptr;
	/// Normalized upper bound. Normalized loop iterates from 0 to Upper with
	/// step 1.
	Expr *Upper = nullptr;
	/// Update expression for the originally specified iteration variable,
	/// calculated as VD = Begin + CounterVD * Step;
	Expr *Update = nullptr;
	/// Updater for the internal counter: ++CounterVD;
	Expr *CounterUpdate = nullptr;
	};

	/// OpenMP 5.0 [2.1.6 Iterators]
	/// Iterators are identifiers that expand to multiple values in the clause on
	/// which they appear.
	/// The syntax of the iterator modifier is as follows:
	/// \code
	/// iterator(iterators-definition)
	/// \endcode
	/// where iterators-definition is one of the following:
	/// \code
	/// iterator-specifier [, iterators-definition ]
	/// \endcode
	/// where iterator-specifier is one of the following:
	/// \code
	/// [ iterator-type ] identifier = range-specification
	/// \endcode
	/// where identifier is a base language identifier.
	/// iterator-type is a type name.
	/// range-specification is of the form begin:end[:step], where begin and end are
	/// expressions for which their types can be converted to iterator-type and step
	/// is an integral expression.
	/// In an iterator-specifier, if the iterator-type is not specified then the
	/// type of that iterator is of int type.
	/// The iterator-type must be an integral or pointer type.
	/// The iterator-type must not be const qualified.
	class OMPIteratorExpr final
	: public Expr,
	private llvm::TrailingObjects<OMPIteratorExpr, Decl , Expr ,
	SourceLocation, OMPIteratorHelperData> {
	public:
	/// Iterator range representation begin:end[:step].
	struct IteratorRange {
	Expr *Begin = nullptr;
	Expr *End = nullptr;
	Expr *Step = nullptr;
	};
	/// Iterator definition representation.
	struct IteratorDefinition {
	Decl *IteratorDecl = nullptr;
	IteratorRange Range;
	SourceLocation AssignmentLoc;
	SourceLocation ColonLoc, SecondColonLoc;
	};

	private:
	friend TrailingObjects;
	friend class ASTStmtReader;
	friend class ASTStmtWriter;

	/// Offset in the list of expressions for subelements of the ranges.
	enum class RangeExprOffset {
	Begin = 0,
	End = 1,
	Step = 2,
	Total = 3,
	};
	/// Offset in the list of locations for subelements of colon symbols
	/// locations.
	enum class RangeLocOffset {
	AssignLoc = 0,
	FirstColonLoc = 1,
	SecondColonLoc = 2,
	Total = 3,
	};
	/// Location of 'iterator' keyword.
	SourceLocation IteratorKwLoc;
	/// Location of '('.
	SourceLocation LPLoc;
	/// Location of ')'.
	SourceLocation RPLoc;
	/// Number of iterator definitions.
	unsigned NumIterators = 0;

	OMPIteratorExpr(QualType ExprTy, SourceLocation IteratorKwLoc,
	SourceLocation L, SourceLocation R,
	ArrayRef<IteratorDefinition> Data,
	ArrayRef<OMPIteratorHelperData> Helpers);

	/// Construct an empty expression.
	explicit OMPIteratorExpr(EmptyShell Shell, unsigned NumIterators)
	: Expr(OMPIteratorExprClass, Shell), NumIterators(NumIterators) {}

	/// Sets basic declaration for the specified iterator definition.
	void setIteratorDeclaration(unsigned I, Decl *D);

	/// Sets the location of the assignment symbol for the specified iterator
	/// definition.
	void setAssignmentLoc(unsigned I, SourceLocation Loc);

	/// Sets begin, end and optional step expressions for specified iterator
	/// definition.
	void setIteratorRange(unsigned I, Expr *Begin, SourceLocation ColonLoc,
	Expr End, SourceLocation SecondColonLoc, Expr Step);

	/// Sets helpers for the specified iteration space.
	void setHelper(unsigned I, const OMPIteratorHelperData &D);

	unsigned numTrailingObjects(OverloadToken<Decl *>) const {
	return NumIterators;
	}

	unsigned numTrailingObjects(OverloadToken<Expr *>) const {
	return NumIterators * static_cast<int>(RangeExprOffset::Total);
	}

	unsigned numTrailingObjects(OverloadToken<SourceLocation>) const {
	return NumIterators * static_cast<int>(RangeLocOffset::Total);
	}

	public:
	static OMPIteratorExpr *Create(const ASTContext &Context, QualType T,
	SourceLocation IteratorKwLoc, SourceLocation L,
	SourceLocation R,
	ArrayRef<IteratorDefinition> Data,
	ArrayRef<OMPIteratorHelperData> Helpers);

	static OMPIteratorExpr *CreateEmpty(const ASTContext &Context,
	unsigned NumIterators);

	SourceLocation getLParenLoc() const { return LPLoc; }
	void setLParenLoc(SourceLocation L) { LPLoc = L; }

	SourceLocation getRParenLoc() const { return RPLoc; }
	void setRParenLoc(SourceLocation L) { RPLoc = L; }

	SourceLocation getIteratorKwLoc() const { return IteratorKwLoc; }
	void setIteratorKwLoc(SourceLocation L) { IteratorKwLoc = L; }
	SourceLocation getBeginLoc() const LLVM_READONLY { return IteratorKwLoc; }
	SourceLocation getEndLoc() const LLVM_READONLY { return RPLoc; }

	/// Gets the iterator declaration for the given iterator.
	Decl *getIteratorDecl(unsigned I);
	const Decl *getIteratorDecl(unsigned I) const {
	return const_cast<OMPIteratorExpr *>(this)->getIteratorDecl(I);
	}

	/// Gets the iterator range for the given iterator.
	IteratorRange getIteratorRange(unsigned I);
	const IteratorRange getIteratorRange(unsigned I) const {
	return const_cast<OMPIteratorExpr *>(this)->getIteratorRange(I);
	}

	/// Gets the location of '=' for the given iterator definition.
	SourceLocation getAssignLoc(unsigned I) const;
	/// Gets the location of the first ':' in the range for the given iterator
	/// definition.
	SourceLocation getColonLoc(unsigned I) const;
	/// Gets the location of the second ':' (if any) in the range for the given
	/// iteratori definition.
	SourceLocation getSecondColonLoc(unsigned I) const;

	/// Returns number of iterator definitions.
	unsigned numOfIterators() const { return NumIterators; }

	/// Fetches helper data for the specified iteration space.
	OMPIteratorHelperData &getHelper(unsigned I);
	const OMPIteratorHelperData &getHelper(unsigned I) const;

	static bool classof(const Stmt *T) {
	return T->getStmtClass() == OMPIteratorExprClass;
	}

	// Iterators
	child_range children() {
	Stmt Begin = reinterpret_cast<Stmt >(getTrailingObjects<Expr *>());
	return child_range(
	Begin, Begin + NumIterators * static_cast<int>(RangeExprOffset::Total));
	}
	const_child_range children() const {
	Stmt const Begin =
	reinterpret_cast<Stmt const >(getTrailingObjects<Expr *>());
	return const_child_range(
	Begin, Begin + NumIterators * static_cast<int>(RangeExprOffset::Total));
	}
	};

	} // end namespace clang

	#endif