1 | //===--- ExprOpenMP.h - Classes for representing expressions ----*- C++ -*-===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | // |
9 | // This file defines the Expr interface and subclasses. |
10 | // |
11 | //===----------------------------------------------------------------------===// |
12 | |
13 | #ifndef LLVM_CLANG_AST_EXPROPENMP_H |
14 | #define LLVM_CLANG_AST_EXPROPENMP_H |
15 | |
16 | #include "clang/AST/ComputeDependence.h" |
17 | #include "clang/AST/Expr.h" |
18 | |
19 | namespace clang { |
20 | /// OpenMP 5.0 [2.1.5, 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 : stride ] |
25 | /// [ lower-bound : length : ] |
26 | /// [ lower-bound : length ] |
27 | /// [ lower-bound : : stride ] |
28 | /// [ lower-bound : : ] |
29 | /// [ lower-bound : ] |
30 | /// [ : length : stride ] |
31 | /// [ : length : ] |
32 | /// [ : length ] |
33 | /// [ : : stride ] |
34 | /// [ : : ] |
35 | /// [ : ] |
36 | /// \endcode |
37 | /// The array section must be a subset of the original array. |
38 | /// Array sections are allowed on multidimensional arrays. Base language array |
39 | /// subscript expressions can be used to specify length-one dimensions of |
40 | /// multidimensional array sections. |
41 | /// Each of the lower-bound, length, and stride expressions if specified must be |
42 | /// an integral type expressions of the base language. When evaluated |
43 | /// they represent a set of integer values as follows: |
44 | /// \code |
45 | /// { lower-bound, lower-bound + stride, lower-bound + 2 * stride,... , |
46 | /// lower-bound + ((length - 1) * stride) } |
47 | /// \endcode |
48 | /// The lower-bound and length must evaluate to non-negative integers. |
49 | /// The stride must evaluate to a positive integer. |
50 | /// When the size of the array dimension is not known, the length must be |
51 | /// specified explicitly. |
52 | /// When the stride is absent it defaults to 1. |
53 | /// When the length is absent it defaults to ⌈(size − lower-bound)/stride⌉, |
54 | /// where size is the size of the array dimension. When the lower-bound is |
55 | /// absent it defaults to 0. |
56 | class OMPArraySectionExpr : public Expr { |
57 | enum { BASE, LOWER_BOUND, LENGTH, STRIDE, END_EXPR }; |
58 | Stmt *SubExprs[END_EXPR]; |
59 | SourceLocation ColonLocFirst; |
60 | SourceLocation ColonLocSecond; |
61 | SourceLocation RBracketLoc; |
62 | |
63 | public: |
64 | OMPArraySectionExpr(Expr *Base, Expr *LowerBound, Expr *Length, Expr *Stride, |
65 | QualType Type, ExprValueKind VK, ExprObjectKind OK, |
66 | SourceLocation ColonLocFirst, |
67 | SourceLocation ColonLocSecond, SourceLocation RBracketLoc) |
68 | : Expr(OMPArraySectionExprClass, Type, VK, OK), |
69 | ColonLocFirst(ColonLocFirst), ColonLocSecond(ColonLocSecond), |
70 | RBracketLoc(RBracketLoc) { |
71 | SubExprs[BASE] = Base; |
72 | SubExprs[LOWER_BOUND] = LowerBound; |
73 | SubExprs[LENGTH] = Length; |
74 | SubExprs[STRIDE] = Stride; |
75 | setDependence(computeDependence(E: this)); |
76 | } |
77 | |
78 | /// Create an empty array section expression. |
79 | explicit OMPArraySectionExpr(EmptyShell Shell) |
80 | : Expr(OMPArraySectionExprClass, Shell) {} |
81 | |
82 | /// An array section can be written only as Base[LowerBound:Length]. |
83 | |
84 | /// Get base of the array section. |
85 | Expr *getBase() { return cast<Expr>(Val: SubExprs[BASE]); } |
86 | const Expr *getBase() const { return cast<Expr>(Val: SubExprs[BASE]); } |
87 | /// Set base of the array section. |
88 | void setBase(Expr *E) { SubExprs[BASE] = E; } |
89 | |
90 | /// Return original type of the base expression for array section. |
91 | static QualType getBaseOriginalType(const Expr *Base); |
92 | |
93 | /// Get lower bound of array section. |
94 | Expr *getLowerBound() { return cast_or_null<Expr>(Val: SubExprs[LOWER_BOUND]); } |
95 | const Expr *getLowerBound() const { |
96 | return cast_or_null<Expr>(Val: SubExprs[LOWER_BOUND]); |
97 | } |
98 | /// Set lower bound of the array section. |
99 | void setLowerBound(Expr *E) { SubExprs[LOWER_BOUND] = E; } |
100 | |
101 | /// Get length of array section. |
102 | Expr *getLength() { return cast_or_null<Expr>(Val: SubExprs[LENGTH]); } |
103 | const Expr *getLength() const { return cast_or_null<Expr>(Val: SubExprs[LENGTH]); } |
104 | /// Set length of the array section. |
105 | void setLength(Expr *E) { SubExprs[LENGTH] = E; } |
106 | |
107 | /// Get stride of array section. |
108 | Expr *getStride() { return cast_or_null<Expr>(Val: SubExprs[STRIDE]); } |
109 | const Expr *getStride() const { return cast_or_null<Expr>(Val: SubExprs[STRIDE]); } |
110 | /// Set length of the array section. |
111 | void setStride(Expr *E) { SubExprs[STRIDE] = E; } |
112 | |
113 | SourceLocation getBeginLoc() const LLVM_READONLY { |
114 | return getBase()->getBeginLoc(); |
115 | } |
116 | SourceLocation getEndLoc() const LLVM_READONLY { return RBracketLoc; } |
117 | |
118 | SourceLocation getColonLocFirst() const { return ColonLocFirst; } |
119 | void setColonLocFirst(SourceLocation L) { ColonLocFirst = L; } |
120 | |
121 | SourceLocation getColonLocSecond() const { return ColonLocSecond; } |
122 | void setColonLocSecond(SourceLocation L) { ColonLocSecond = L; } |
123 | |
124 | SourceLocation getRBracketLoc() const { return RBracketLoc; } |
125 | void setRBracketLoc(SourceLocation L) { RBracketLoc = L; } |
126 | |
127 | SourceLocation getExprLoc() const LLVM_READONLY { |
128 | return getBase()->getExprLoc(); |
129 | } |
130 | |
131 | static bool classof(const Stmt *T) { |
132 | return T->getStmtClass() == OMPArraySectionExprClass; |
133 | } |
134 | |
135 | child_range children() { |
136 | return child_range(&SubExprs[BASE], &SubExprs[END_EXPR]); |
137 | } |
138 | |
139 | const_child_range children() const { |
140 | return const_child_range(&SubExprs[BASE], &SubExprs[END_EXPR]); |
141 | } |
142 | }; |
143 | |
144 | /// An explicit cast in C or a C-style cast in C++, which uses the syntax |
145 | /// ([s1][s2]...[sn])expr. For example: @c ([3][3])f. |
146 | class OMPArrayShapingExpr final |
147 | : public Expr, |
148 | private llvm::TrailingObjects<OMPArrayShapingExpr, Expr *, SourceRange> { |
149 | friend TrailingObjects; |
150 | friend class ASTStmtReader; |
151 | friend class ASTStmtWriter; |
152 | /// Base node. |
153 | SourceLocation LPLoc; /// The location of the left paren |
154 | SourceLocation RPLoc; /// The location of the right paren |
155 | unsigned NumDims = 0; /// Number of dimensions in the shaping expression. |
156 | |
157 | /// Construct full expression. |
158 | OMPArrayShapingExpr(QualType ExprTy, Expr *Op, SourceLocation L, |
159 | SourceLocation R, ArrayRef<Expr *> Dims); |
160 | |
161 | /// Construct an empty expression. |
162 | explicit OMPArrayShapingExpr(EmptyShell Shell, unsigned NumDims) |
163 | : Expr(OMPArrayShapingExprClass, Shell), NumDims(NumDims) {} |
164 | |
165 | /// Sets the dimensions for the array shaping. |
166 | void setDimensions(ArrayRef<Expr *> Dims); |
167 | |
168 | /// Sets the base expression for array shaping operation. |
169 | void setBase(Expr *Op) { getTrailingObjects<Expr *>()[NumDims] = Op; } |
170 | |
171 | /// Sets source ranges for the brackets in the array shaping operation. |
172 | void setBracketsRanges(ArrayRef<SourceRange> BR); |
173 | |
174 | unsigned numTrailingObjects(OverloadToken<Expr *>) const { |
175 | // Add an extra one for the base expression. |
176 | return NumDims + 1; |
177 | } |
178 | |
179 | unsigned numTrailingObjects(OverloadToken<SourceRange>) const { |
180 | return NumDims; |
181 | } |
182 | |
183 | public: |
184 | static OMPArrayShapingExpr *Create(const ASTContext &Context, QualType T, |
185 | Expr *Op, SourceLocation L, |
186 | SourceLocation R, ArrayRef<Expr *> Dims, |
187 | ArrayRef<SourceRange> BracketRanges); |
188 | |
189 | static OMPArrayShapingExpr *CreateEmpty(const ASTContext &Context, |
190 | unsigned NumDims); |
191 | |
192 | SourceLocation getLParenLoc() const { return LPLoc; } |
193 | void setLParenLoc(SourceLocation L) { LPLoc = L; } |
194 | |
195 | SourceLocation getRParenLoc() const { return RPLoc; } |
196 | void setRParenLoc(SourceLocation L) { RPLoc = L; } |
197 | |
198 | SourceLocation getBeginLoc() const LLVM_READONLY { return LPLoc; } |
199 | SourceLocation getEndLoc() const LLVM_READONLY { |
200 | return getBase()->getEndLoc(); |
201 | } |
202 | |
203 | /// Fetches the dimensions for array shaping expression. |
204 | ArrayRef<Expr *> getDimensions() const { |
205 | return llvm::ArrayRef(getTrailingObjects<Expr *>(), NumDims); |
206 | } |
207 | |
208 | /// Fetches source ranges for the brackets os the array shaping expression. |
209 | ArrayRef<SourceRange> getBracketsRanges() const { |
210 | return llvm::ArrayRef(getTrailingObjects<SourceRange>(), NumDims); |
211 | } |
212 | |
213 | /// Fetches base expression of array shaping expression. |
214 | Expr *getBase() { return getTrailingObjects<Expr *>()[NumDims]; } |
215 | const Expr *getBase() const { return getTrailingObjects<Expr *>()[NumDims]; } |
216 | |
217 | static bool classof(const Stmt *T) { |
218 | return T->getStmtClass() == OMPArrayShapingExprClass; |
219 | } |
220 | |
221 | // Iterators |
222 | child_range children() { |
223 | Stmt **Begin = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>()); |
224 | return child_range(Begin, Begin + NumDims + 1); |
225 | } |
226 | const_child_range children() const { |
227 | Stmt *const *Begin = |
228 | reinterpret_cast<Stmt *const *>(getTrailingObjects<Expr *>()); |
229 | return const_child_range(Begin, Begin + NumDims + 1); |
230 | } |
231 | }; |
232 | |
233 | /// Helper expressions and declaration for OMPIteratorExpr class for each |
234 | /// iteration space. |
235 | struct OMPIteratorHelperData { |
236 | /// Internal normalized counter. |
237 | VarDecl *CounterVD = nullptr; |
238 | /// Normalized upper bound. Normalized loop iterates from 0 to Upper with |
239 | /// step 1. |
240 | Expr *Upper = nullptr; |
241 | /// Update expression for the originally specified iteration variable, |
242 | /// calculated as VD = Begin + CounterVD * Step; |
243 | Expr *Update = nullptr; |
244 | /// Updater for the internal counter: ++CounterVD; |
245 | Expr *CounterUpdate = nullptr; |
246 | }; |
247 | |
248 | /// OpenMP 5.0 [2.1.6 Iterators] |
249 | /// Iterators are identifiers that expand to multiple values in the clause on |
250 | /// which they appear. |
251 | /// The syntax of the iterator modifier is as follows: |
252 | /// \code |
253 | /// iterator(iterators-definition) |
254 | /// \endcode |
255 | /// where iterators-definition is one of the following: |
256 | /// \code |
257 | /// iterator-specifier [, iterators-definition ] |
258 | /// \endcode |
259 | /// where iterator-specifier is one of the following: |
260 | /// \code |
261 | /// [ iterator-type ] identifier = range-specification |
262 | /// \endcode |
263 | /// where identifier is a base language identifier. |
264 | /// iterator-type is a type name. |
265 | /// range-specification is of the form begin:end[:step], where begin and end are |
266 | /// expressions for which their types can be converted to iterator-type and step |
267 | /// is an integral expression. |
268 | /// In an iterator-specifier, if the iterator-type is not specified then the |
269 | /// type of that iterator is of int type. |
270 | /// The iterator-type must be an integral or pointer type. |
271 | /// The iterator-type must not be const qualified. |
272 | class OMPIteratorExpr final |
273 | : public Expr, |
274 | private llvm::TrailingObjects<OMPIteratorExpr, Decl *, Expr *, |
275 | SourceLocation, OMPIteratorHelperData> { |
276 | public: |
277 | /// Iterator range representation begin:end[:step]. |
278 | struct IteratorRange { |
279 | Expr *Begin = nullptr; |
280 | Expr *End = nullptr; |
281 | Expr *Step = nullptr; |
282 | }; |
283 | /// Iterator definition representation. |
284 | struct IteratorDefinition { |
285 | Decl *IteratorDecl = nullptr; |
286 | IteratorRange Range; |
287 | SourceLocation AssignmentLoc; |
288 | SourceLocation ColonLoc, SecondColonLoc; |
289 | }; |
290 | |
291 | private: |
292 | friend TrailingObjects; |
293 | friend class ASTStmtReader; |
294 | friend class ASTStmtWriter; |
295 | |
296 | /// Offset in the list of expressions for subelements of the ranges. |
297 | enum class RangeExprOffset { |
298 | Begin = 0, |
299 | End = 1, |
300 | Step = 2, |
301 | Total = 3, |
302 | }; |
303 | /// Offset in the list of locations for subelements of colon symbols |
304 | /// locations. |
305 | enum class RangeLocOffset { |
306 | AssignLoc = 0, |
307 | FirstColonLoc = 1, |
308 | SecondColonLoc = 2, |
309 | Total = 3, |
310 | }; |
311 | /// Location of 'iterator' keyword. |
312 | SourceLocation IteratorKwLoc; |
313 | /// Location of '('. |
314 | SourceLocation LPLoc; |
315 | /// Location of ')'. |
316 | SourceLocation RPLoc; |
317 | /// Number of iterator definitions. |
318 | unsigned NumIterators = 0; |
319 | |
320 | OMPIteratorExpr(QualType ExprTy, SourceLocation IteratorKwLoc, |
321 | SourceLocation L, SourceLocation R, |
322 | ArrayRef<IteratorDefinition> Data, |
323 | ArrayRef<OMPIteratorHelperData> Helpers); |
324 | |
325 | /// Construct an empty expression. |
326 | explicit OMPIteratorExpr(EmptyShell Shell, unsigned NumIterators) |
327 | : Expr(OMPIteratorExprClass, Shell), NumIterators(NumIterators) {} |
328 | |
329 | /// Sets basic declaration for the specified iterator definition. |
330 | void setIteratorDeclaration(unsigned I, Decl *D); |
331 | |
332 | /// Sets the location of the assignment symbol for the specified iterator |
333 | /// definition. |
334 | void setAssignmentLoc(unsigned I, SourceLocation Loc); |
335 | |
336 | /// Sets begin, end and optional step expressions for specified iterator |
337 | /// definition. |
338 | void setIteratorRange(unsigned I, Expr *Begin, SourceLocation ColonLoc, |
339 | Expr *End, SourceLocation SecondColonLoc, Expr *Step); |
340 | |
341 | /// Sets helpers for the specified iteration space. |
342 | void setHelper(unsigned I, const OMPIteratorHelperData &D); |
343 | |
344 | unsigned numTrailingObjects(OverloadToken<Decl *>) const { |
345 | return NumIterators; |
346 | } |
347 | |
348 | unsigned numTrailingObjects(OverloadToken<Expr *>) const { |
349 | return NumIterators * static_cast<int>(RangeExprOffset::Total); |
350 | } |
351 | |
352 | unsigned numTrailingObjects(OverloadToken<SourceLocation>) const { |
353 | return NumIterators * static_cast<int>(RangeLocOffset::Total); |
354 | } |
355 | |
356 | public: |
357 | static OMPIteratorExpr *Create(const ASTContext &Context, QualType T, |
358 | SourceLocation IteratorKwLoc, SourceLocation L, |
359 | SourceLocation R, |
360 | ArrayRef<IteratorDefinition> Data, |
361 | ArrayRef<OMPIteratorHelperData> Helpers); |
362 | |
363 | static OMPIteratorExpr *CreateEmpty(const ASTContext &Context, |
364 | unsigned NumIterators); |
365 | |
366 | SourceLocation getLParenLoc() const { return LPLoc; } |
367 | void setLParenLoc(SourceLocation L) { LPLoc = L; } |
368 | |
369 | SourceLocation getRParenLoc() const { return RPLoc; } |
370 | void setRParenLoc(SourceLocation L) { RPLoc = L; } |
371 | |
372 | SourceLocation getIteratorKwLoc() const { return IteratorKwLoc; } |
373 | void setIteratorKwLoc(SourceLocation L) { IteratorKwLoc = L; } |
374 | SourceLocation getBeginLoc() const LLVM_READONLY { return IteratorKwLoc; } |
375 | SourceLocation getEndLoc() const LLVM_READONLY { return RPLoc; } |
376 | |
377 | /// Gets the iterator declaration for the given iterator. |
378 | Decl *getIteratorDecl(unsigned I); |
379 | const Decl *getIteratorDecl(unsigned I) const { |
380 | return const_cast<OMPIteratorExpr *>(this)->getIteratorDecl(I); |
381 | } |
382 | |
383 | /// Gets the iterator range for the given iterator. |
384 | IteratorRange getIteratorRange(unsigned I); |
385 | const IteratorRange getIteratorRange(unsigned I) const { |
386 | return const_cast<OMPIteratorExpr *>(this)->getIteratorRange(I); |
387 | } |
388 | |
389 | /// Gets the location of '=' for the given iterator definition. |
390 | SourceLocation getAssignLoc(unsigned I) const; |
391 | /// Gets the location of the first ':' in the range for the given iterator |
392 | /// definition. |
393 | SourceLocation getColonLoc(unsigned I) const; |
394 | /// Gets the location of the second ':' (if any) in the range for the given |
395 | /// iteratori definition. |
396 | SourceLocation getSecondColonLoc(unsigned I) const; |
397 | |
398 | /// Returns number of iterator definitions. |
399 | unsigned numOfIterators() const { return NumIterators; } |
400 | |
401 | /// Fetches helper data for the specified iteration space. |
402 | OMPIteratorHelperData &getHelper(unsigned I); |
403 | const OMPIteratorHelperData &getHelper(unsigned I) const; |
404 | |
405 | static bool classof(const Stmt *T) { |
406 | return T->getStmtClass() == OMPIteratorExprClass; |
407 | } |
408 | |
409 | // Iterators |
410 | child_range children() { |
411 | Stmt **Begin = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>()); |
412 | return child_range( |
413 | Begin, Begin + NumIterators * static_cast<int>(RangeExprOffset::Total)); |
414 | } |
415 | const_child_range children() const { |
416 | Stmt *const *Begin = |
417 | reinterpret_cast<Stmt *const *>(getTrailingObjects<Expr *>()); |
418 | return const_child_range( |
419 | Begin, Begin + NumIterators * static_cast<int>(RangeExprOffset::Total)); |
420 | } |
421 | }; |
422 | |
423 | } // end namespace clang |
424 | |
425 | #endif |
426 | |