1 //===--- ExprOpenMP.h - Classes for representing expressions ----*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines the Expr interface and subclasses. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_CLANG_AST_EXPROPENMP_H 15 #define LLVM_CLANG_AST_EXPROPENMP_H 16 17 #include "clang/AST/Expr.h" 18 19 namespace clang { 20 /// OpenMP 4.0 [2.4, Array Sections]. 21 /// To specify an array section in an OpenMP construct, array subscript 22 /// expressions are extended with the following syntax: 23 /// \code 24 /// [ lower-bound : length ] 25 /// [ lower-bound : ] 26 /// [ : length ] 27 /// [ : ] 28 /// \endcode 29 /// The array section must be a subset of the original array. 30 /// Array sections are allowed on multidimensional arrays. Base language array 31 /// subscript expressions can be used to specify length-one dimensions of 32 /// multidimensional array sections. 33 /// The lower-bound and length are integral type expressions. When evaluated 34 /// they represent a set of integer values as follows: 35 /// \code 36 /// { lower-bound, lower-bound + 1, lower-bound + 2,... , lower-bound + length - 37 /// 1 } 38 /// \endcode 39 /// The lower-bound and length must evaluate to non-negative integers. 40 /// When the size of the array dimension is not known, the length must be 41 /// specified explicitly. 42 /// When the length is absent, it defaults to the size of the array dimension 43 /// minus the lower-bound. 44 /// When the lower-bound is absent it defaults to 0. 45 class OMPArraySectionExpr : public Expr { 46 enum { BASE, LOWER_BOUND, LENGTH, END_EXPR }; 47 Stmt *SubExprs[END_EXPR]; 48 SourceLocation ColonLoc; 49 SourceLocation RBracketLoc; 50 51 public: OMPArraySectionExpr(Expr * Base,Expr * LowerBound,Expr * Length,QualType Type,ExprValueKind VK,ExprObjectKind OK,SourceLocation ColonLoc,SourceLocation RBracketLoc)52 OMPArraySectionExpr(Expr *Base, Expr *LowerBound, Expr *Length, QualType Type, 53 ExprValueKind VK, ExprObjectKind OK, 54 SourceLocation ColonLoc, SourceLocation RBracketLoc) 55 : Expr( 56 OMPArraySectionExprClass, Type, VK, OK, 57 Base->isTypeDependent() || 58 (LowerBound && LowerBound->isTypeDependent()) || 59 (Length && Length->isTypeDependent()), 60 Base->isValueDependent() || 61 (LowerBound && LowerBound->isValueDependent()) || 62 (Length && Length->isValueDependent()), 63 Base->isInstantiationDependent() || 64 (LowerBound && LowerBound->isInstantiationDependent()) || 65 (Length && Length->isInstantiationDependent()), 66 Base->containsUnexpandedParameterPack() || 67 (LowerBound && LowerBound->containsUnexpandedParameterPack()) || 68 (Length && Length->containsUnexpandedParameterPack())), 69 ColonLoc(ColonLoc), RBracketLoc(RBracketLoc) { 70 SubExprs[BASE] = Base; 71 SubExprs[LOWER_BOUND] = LowerBound; 72 SubExprs[LENGTH] = Length; 73 } 74 75 /// Create an empty array section expression. OMPArraySectionExpr(EmptyShell Shell)76 explicit OMPArraySectionExpr(EmptyShell Shell) 77 : Expr(OMPArraySectionExprClass, Shell) {} 78 79 /// An array section can be written only as Base[LowerBound:Length]. 80 81 /// Get base of the array section. getBase()82 Expr *getBase() { return cast<Expr>(SubExprs[BASE]); } getBase()83 const Expr *getBase() const { return cast<Expr>(SubExprs[BASE]); } 84 /// Set base of the array section. setBase(Expr * E)85 void setBase(Expr *E) { SubExprs[BASE] = E; } 86 87 /// Return original type of the base expression for array section. 88 static QualType getBaseOriginalType(const Expr *Base); 89 90 /// Get lower bound of array section. getLowerBound()91 Expr *getLowerBound() { return cast_or_null<Expr>(SubExprs[LOWER_BOUND]); } getLowerBound()92 const Expr *getLowerBound() const { 93 return cast_or_null<Expr>(SubExprs[LOWER_BOUND]); 94 } 95 /// Set lower bound of the array section. setLowerBound(Expr * E)96 void setLowerBound(Expr *E) { SubExprs[LOWER_BOUND] = E; } 97 98 /// Get length of array section. getLength()99 Expr *getLength() { return cast_or_null<Expr>(SubExprs[LENGTH]); } getLength()100 const Expr *getLength() const { return cast_or_null<Expr>(SubExprs[LENGTH]); } 101 /// Set length of the array section. setLength(Expr * E)102 void setLength(Expr *E) { SubExprs[LENGTH] = E; } 103 getLocStart()104 SourceLocation getLocStart() const LLVM_READONLY { return getBeginLoc(); } getBeginLoc()105 SourceLocation getBeginLoc() const LLVM_READONLY { 106 return getBase()->getLocStart(); 107 } getLocEnd()108 SourceLocation getLocEnd() const LLVM_READONLY { return getEndLoc(); } getEndLoc()109 SourceLocation getEndLoc() const LLVM_READONLY { return RBracketLoc; } 110 getColonLoc()111 SourceLocation getColonLoc() const { return ColonLoc; } setColonLoc(SourceLocation L)112 void setColonLoc(SourceLocation L) { ColonLoc = L; } 113 getRBracketLoc()114 SourceLocation getRBracketLoc() const { return RBracketLoc; } setRBracketLoc(SourceLocation L)115 void setRBracketLoc(SourceLocation L) { RBracketLoc = L; } 116 getExprLoc()117 SourceLocation getExprLoc() const LLVM_READONLY { 118 return getBase()->getExprLoc(); 119 } 120 classof(const Stmt * T)121 static bool classof(const Stmt *T) { 122 return T->getStmtClass() == OMPArraySectionExprClass; 123 } 124 children()125 child_range children() { 126 return child_range(&SubExprs[BASE], &SubExprs[END_EXPR]); 127 } 128 }; 129 } // end namespace clang 130 131 #endif 132