/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/tools/clang/include/clang/AST/ExprOpenMP.h
Line | Count | Source |
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: |
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 | 1.90k | ColonLoc(ColonLoc), RBracketLoc(RBracketLoc) { |
70 | 1.90k | SubExprs[BASE] = Base; |
71 | 1.90k | SubExprs[LOWER_BOUND] = LowerBound; |
72 | 1.90k | SubExprs[LENGTH] = Length; |
73 | 1.90k | } |
74 | | |
75 | | /// \brief Create an empty array section expression. |
76 | | explicit OMPArraySectionExpr(EmptyShell Shell) |
77 | 362 | : 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. |
82 | 4.20k | Expr *getBase() { return cast<Expr>(SubExprs[BASE]); } |
83 | 13.5k | const Expr *getBase() const { return cast<Expr>(SubExprs[BASE]); } |
84 | | /// \brief Set base of the array section. |
85 | 362 | 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. |
91 | 2.21k | Expr *getLowerBound() { return cast_or_null<Expr>(SubExprs[LOWER_BOUND]); } |
92 | 1.43k | const Expr *getLowerBound() const { |
93 | 1.43k | return cast_or_null<Expr>(SubExprs[LOWER_BOUND]); |
94 | 1.43k | } |
95 | | /// \brief Set lower bound of the array section. |
96 | 362 | void setLowerBound(Expr *E) { SubExprs[LOWER_BOUND] = E; } |
97 | | |
98 | | /// \brief Get length of array section. |
99 | 2.56k | Expr *getLength() { return cast_or_null<Expr>(SubExprs[LENGTH]); } |
100 | 3.24k | const Expr *getLength() const { return cast_or_null<Expr>(SubExprs[LENGTH]); } |
101 | | /// \brief Set length of the array section. |
102 | 362 | void setLength(Expr *E) { SubExprs[LENGTH] = E; } |
103 | | |
104 | 4.03k | SourceLocation getLocStart() const LLVM_READONLY { |
105 | 4.03k | return getBase()->getLocStart(); |
106 | 4.03k | } |
107 | 3.01k | SourceLocation getLocEnd() const LLVM_READONLY { return RBracketLoc; } |
108 | | |
109 | 4.04k | SourceLocation getColonLoc() const { return ColonLoc; } |
110 | 362 | void setColonLoc(SourceLocation L) { ColonLoc = L; } |
111 | | |
112 | 1.01k | SourceLocation getRBracketLoc() const { return RBracketLoc; } |
113 | 362 | void setRBracketLoc(SourceLocation L) { RBracketLoc = L; } |
114 | | |
115 | 6.51k | SourceLocation getExprLoc() const LLVM_READONLY { |
116 | 6.51k | return getBase()->getExprLoc(); |
117 | 6.51k | } |
118 | | |
119 | 38.4k | static bool classof(const Stmt *T) { |
120 | 38.4k | return T->getStmtClass() == OMPArraySectionExprClass; |
121 | 38.4k | } |
122 | | |
123 | 212 | child_range children() { |
124 | 212 | return child_range(&SubExprs[BASE], &SubExprs[END_EXPR]); |
125 | 212 | } |
126 | | }; |
127 | | } // end namespace clang |
128 | | |
129 | | #endif |