clang  10.0.0svn
ExprOpenMP.h
Go to the documentation of this file.
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/Expr.h"
17 
18 namespace clang {
19 /// OpenMP 4.0 [2.4, Array Sections].
20 /// To specify an array section in an OpenMP construct, array subscript
21 /// expressions are extended with the following syntax:
22 /// \code
23 /// [ lower-bound : length ]
24 /// [ lower-bound : ]
25 /// [ : length ]
26 /// [ : ]
27 /// \endcode
28 /// The array section must be a subset of the original array.
29 /// Array sections are allowed on multidimensional arrays. Base language array
30 /// subscript expressions can be used to specify length-one dimensions of
31 /// multidimensional array sections.
32 /// The lower-bound and length are integral type expressions. When evaluated
33 /// they represent a set of integer values as follows:
34 /// \code
35 /// { lower-bound, lower-bound + 1, lower-bound + 2,... , lower-bound + length -
36 /// 1 }
37 /// \endcode
38 /// The lower-bound and length must evaluate to non-negative integers.
39 /// When the size of the array dimension is not known, the length must be
40 /// specified explicitly.
41 /// When the length is absent, it defaults to the size of the array dimension
42 /// minus the lower-bound.
43 /// When the lower-bound is absent it defaults to 0.
44 class OMPArraySectionExpr : public Expr {
45  enum { BASE, LOWER_BOUND, LENGTH, END_EXPR };
46  Stmt *SubExprs[END_EXPR];
47  SourceLocation ColonLoc;
48  SourceLocation RBracketLoc;
49 
50 public:
51  OMPArraySectionExpr(Expr *Base, Expr *LowerBound, Expr *Length, QualType Type,
53  SourceLocation ColonLoc, SourceLocation RBracketLoc)
54  : Expr(
55  OMPArraySectionExprClass, Type, VK, OK,
56  Base->isTypeDependent() ||
57  (LowerBound && LowerBound->isTypeDependent()) ||
58  (Length && Length->isTypeDependent()),
59  Base->isValueDependent() ||
60  (LowerBound && LowerBound->isValueDependent()) ||
61  (Length && Length->isValueDependent()),
62  Base->isInstantiationDependent() ||
63  (LowerBound && LowerBound->isInstantiationDependent()) ||
64  (Length && Length->isInstantiationDependent()),
66  (LowerBound && LowerBound->containsUnexpandedParameterPack()) ||
67  (Length && Length->containsUnexpandedParameterPack())),
68  ColonLoc(ColonLoc), RBracketLoc(RBracketLoc) {
69  SubExprs[BASE] = Base;
70  SubExprs[LOWER_BOUND] = LowerBound;
71  SubExprs[LENGTH] = Length;
72  }
73 
74  /// Create an empty array section expression.
76  : Expr(OMPArraySectionExprClass, Shell) {}
77 
78  /// An array section can be written only as Base[LowerBound:Length].
79 
80  /// Get base of the array section.
81  Expr *getBase() { return cast<Expr>(SubExprs[BASE]); }
82  const Expr *getBase() const { return cast<Expr>(SubExprs[BASE]); }
83  /// Set base of the array section.
84  void setBase(Expr *E) { SubExprs[BASE] = E; }
85 
86  /// Return original type of the base expression for array section.
87  static QualType getBaseOriginalType(const Expr *Base);
88 
89  /// Get lower bound of array section.
90  Expr *getLowerBound() { return cast_or_null<Expr>(SubExprs[LOWER_BOUND]); }
91  const Expr *getLowerBound() const {
92  return cast_or_null<Expr>(SubExprs[LOWER_BOUND]);
93  }
94  /// Set lower bound of the array section.
95  void setLowerBound(Expr *E) { SubExprs[LOWER_BOUND] = E; }
96 
97  /// Get length of array section.
98  Expr *getLength() { return cast_or_null<Expr>(SubExprs[LENGTH]); }
99  const Expr *getLength() const { return cast_or_null<Expr>(SubExprs[LENGTH]); }
100  /// Set length of the array section.
101  void setLength(Expr *E) { SubExprs[LENGTH] = E; }
102 
103  SourceLocation getBeginLoc() const LLVM_READONLY {
104  return getBase()->getBeginLoc();
105  }
106  SourceLocation getEndLoc() const LLVM_READONLY { return RBracketLoc; }
107 
108  SourceLocation getColonLoc() const { return ColonLoc; }
109  void setColonLoc(SourceLocation L) { ColonLoc = L; }
110 
111  SourceLocation getRBracketLoc() const { return RBracketLoc; }
112  void setRBracketLoc(SourceLocation L) { RBracketLoc = L; }
113 
114  SourceLocation getExprLoc() const LLVM_READONLY {
115  return getBase()->getExprLoc();
116  }
117 
118  static bool classof(const Stmt *T) {
119  return T->getStmtClass() == OMPArraySectionExprClass;
120  }
121 
123  return child_range(&SubExprs[BASE], &SubExprs[END_EXPR]);
124  }
125 
127  return const_child_range(&SubExprs[BASE], &SubExprs[END_EXPR]);
128  }
129 };
130 } // end namespace clang
131 
132 #endif
SourceLocation getExprLoc() const LLVM_READONLY
Definition: ExprOpenMP.h:114
A (possibly-)qualified type.
Definition: Type.h:643
Stmt - This represents one statement.
Definition: Stmt.h:66
const_child_range children() const
Definition: ExprOpenMP.h:126
const Expr * getLength() const
Definition: ExprOpenMP.h:99
Expr * getLowerBound()
Get lower bound of array section.
Definition: ExprOpenMP.h:90
The base class of the type hierarchy.
Definition: Type.h:1436
llvm::iterator_range< child_iterator > child_range
Definition: Stmt.h:1158
void setLength(Expr *E)
Set length of the array section.
Definition: ExprOpenMP.h:101
void setBase(Expr *E)
Set base of the array section.
Definition: ExprOpenMP.h:84
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprOpenMP.h:106
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:274
OMPArraySectionExpr(Expr *Base, Expr *LowerBound, Expr *Length, QualType Type, ExprValueKind VK, ExprObjectKind OK, SourceLocation ColonLoc, SourceLocation RBracketLoc)
Definition: ExprOpenMP.h:51
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:176
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprOpenMP.h:103
OpenMP 4.0 [2.4, Array Sections].
Definition: ExprOpenMP.h:44
llvm::iterator_range< const_child_iterator > const_child_range
Definition: Stmt.h:1159
OMPArraySectionExpr(EmptyShell Shell)
Create an empty array section expression.
Definition: ExprOpenMP.h:75
This represents one expression.
Definition: Expr.h:108
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:122
void setRBracketLoc(SourceLocation L)
Definition: ExprOpenMP.h:112
SourceLocation getRBracketLoc() const
Definition: ExprOpenMP.h:111
void setColonLoc(SourceLocation L)
Definition: ExprOpenMP.h:109
const Expr * getBase() const
Definition: ExprOpenMP.h:82
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on a template...
Definition: Expr.h:200
Encodes a location in the source.
const Expr * getLowerBound() const
Definition: ExprOpenMP.h:91
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
Definition: Specifiers.h:139
SourceLocation getColonLoc() const
Definition: ExprOpenMP.h:108
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:158
A placeholder type used to construct an empty shell of a type, that will be filled in later (e...
Definition: Stmt.h:1034
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:221
Dataflow Directional Tag Classes.
StmtClass getStmtClass() const
Definition: Stmt.h:1087
void setLowerBound(Expr *E)
Set lower bound of the array section.
Definition: ExprOpenMP.h:95
static QualType getBaseOriginalType(const Expr *Base)
Return original type of the base expression for array section.
Definition: Expr.cpp:4647
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates)...
Definition: Expr.h:223
static bool classof(const Stmt *T)
Definition: ExprOpenMP.h:118
Expr * getLength()
Get length of array section.
Definition: ExprOpenMP.h:98
Expr * getBase()
An array section can be written only as Base[LowerBound:Length].
Definition: ExprOpenMP.h:81