| //===--- 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 |