• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 /// \brief 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   /// \brief 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   /// \brief 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   /// \brief Set base of the array section.
setBase(Expr * E)85   void setBase(Expr *E) { SubExprs[BASE] = E; }
86 
87   /// \brief Return original type of the base expression for array section.
88   static QualType getBaseOriginalType(const Expr *Base);
89 
90   /// \brief 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   /// \brief Set lower bound of the array section.
setLowerBound(Expr * E)96   void setLowerBound(Expr *E) { SubExprs[LOWER_BOUND] = E; }
97 
98   /// \brief 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   /// \brief 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 {
105     return getBase()->getLocStart();
106   }
getLocEnd()107   SourceLocation getLocEnd() const LLVM_READONLY { return RBracketLoc; }
108 
getColonLoc()109   SourceLocation getColonLoc() const { return ColonLoc; }
setColonLoc(SourceLocation L)110   void setColonLoc(SourceLocation L) { ColonLoc = L; }
111 
getRBracketLoc()112   SourceLocation getRBracketLoc() const { return RBracketLoc; }
setRBracketLoc(SourceLocation L)113   void setRBracketLoc(SourceLocation L) { RBracketLoc = L; }
114 
getExprLoc()115   SourceLocation getExprLoc() const LLVM_READONLY {
116     return getBase()->getExprLoc();
117   }
118 
classof(const Stmt * T)119   static bool classof(const Stmt *T) {
120     return T->getStmtClass() == OMPArraySectionExprClass;
121   }
122 
children()123   child_range children() {
124     return child_range(&SubExprs[BASE], &SubExprs[END_EXPR]);
125   }
126 };
127 } // end namespace clang
128 
129 #endif
130