clang  8.0.0svn
Attr.h
Go to the documentation of this file.
1 //===--- Attr.h - Classes for representing attributes ----------*- 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 Attr interface and subclasses.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_AST_ATTR_H
15 #define LLVM_CLANG_AST_ATTR_H
16 
17 #include "clang/AST/AttrIterator.h"
18 #include "clang/AST/Decl.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/AST/Type.h"
21 #include "clang/Basic/AttrKinds.h"
22 #include "clang/Basic/LLVM.h"
24 #include "clang/Basic/Sanitizers.h"
26 #include "llvm/ADT/StringSwitch.h"
27 #include "llvm/Support/ErrorHandling.h"
28 #include "llvm/Support/VersionTuple.h"
29 #include "llvm/Support/raw_ostream.h"
30 #include <algorithm>
31 #include <cassert>
32 
33 namespace clang {
34  class ASTContext;
35  class IdentifierInfo;
36  class ObjCInterfaceDecl;
37  class Expr;
38  class QualType;
39  class FunctionDecl;
40  class TypeSourceInfo;
41 
42 /// Attr - This represents one attribute.
43 class Attr {
44 private:
45  SourceRange Range;
46  unsigned AttrKind : 16;
47 
48 protected:
49  /// An index into the spelling list of an
50  /// attribute defined in Attr.td file.
51  unsigned SpellingListIndex : 4;
52  unsigned Inherited : 1;
53  unsigned IsPackExpansion : 1;
54  unsigned Implicit : 1;
55  // FIXME: These are properties of the attribute kind, not state for this
56  // instance of the attribute.
57  unsigned IsLateParsed : 1;
59 
60  void *operator new(size_t bytes) noexcept {
61  llvm_unreachable("Attrs cannot be allocated with regular 'new'.");
62  }
63  void operator delete(void *data) noexcept {
64  llvm_unreachable("Attrs cannot be released with regular 'delete'.");
65  }
66 
67 public:
68  // Forward so that the regular new and delete do not hide global ones.
69  void *operator new(size_t Bytes, ASTContext &C,
70  size_t Alignment = 8) noexcept {
71  return ::operator new(Bytes, C, Alignment);
72  }
73  void operator delete(void *Ptr, ASTContext &C, size_t Alignment) noexcept {
74  return ::operator delete(Ptr, C, Alignment);
75  }
76 
77 protected:
79  bool IsLateParsed)
80  : Range(R), AttrKind(AK), SpellingListIndex(SpellingListIndex),
82  IsLateParsed(IsLateParsed), InheritEvenIfAlreadyPresent(false) {}
83 
84 public:
85 
86  attr::Kind getKind() const {
87  return static_cast<attr::Kind>(AttrKind);
88  }
89 
90  unsigned getSpellingListIndex() const { return SpellingListIndex; }
91  const char *getSpelling() const;
92 
93  SourceLocation getLocation() const { return Range.getBegin(); }
94  SourceRange getRange() const { return Range; }
95  void setRange(SourceRange R) { Range = R; }
96 
97  bool isInherited() const { return Inherited; }
98 
99  /// Returns true if the attribute has been implicitly created instead
100  /// of explicitly written by the user.
101  bool isImplicit() const { return Implicit; }
102  void setImplicit(bool I) { Implicit = I; }
103 
104  void setPackExpansion(bool PE) { IsPackExpansion = PE; }
105  bool isPackExpansion() const { return IsPackExpansion; }
106 
107  // Clone this attribute.
108  Attr *clone(ASTContext &C) const;
109 
110  bool isLateParsed() const { return IsLateParsed; }
111 
112  // Pretty print this attribute.
113  void printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const;
114 };
115 
116 class TypeAttr : public Attr {
117 protected:
119  bool IsLateParsed)
120  : Attr(AK, R, SpellingListIndex, IsLateParsed) {}
121 
122 public:
123  static bool classof(const Attr *A) {
124  return A->getKind() >= attr::FirstTypeAttr &&
125  A->getKind() <= attr::LastTypeAttr;
126  }
127 };
128 
129 class StmtAttr : public Attr {
130 protected:
132  bool IsLateParsed)
133  : Attr(AK, R, SpellingListIndex, IsLateParsed) {}
134 
135 public:
136  static bool classof(const Attr *A) {
137  return A->getKind() >= attr::FirstStmtAttr &&
138  A->getKind() <= attr::LastStmtAttr;
139  }
140 };
141 
142 class InheritableAttr : public Attr {
143 protected:
146  : Attr(AK, R, SpellingListIndex, IsLateParsed) {
147  this->InheritEvenIfAlreadyPresent = InheritEvenIfAlreadyPresent;
148  }
149 
150 public:
151  void setInherited(bool I) { Inherited = I; }
152 
153  /// Should this attribute be inherited from a prior declaration even if it's
154  /// explicitly provided in the current declaration?
157  }
158 
159  // Implement isa/cast/dyncast/etc.
160  static bool classof(const Attr *A) {
161  return A->getKind() >= attr::FirstInheritableAttr &&
162  A->getKind() <= attr::LastInheritableAttr;
163  }
164 };
165 
167 protected:
170  : InheritableAttr(AK, R, SpellingListIndex, IsLateParsed,
171  InheritEvenIfAlreadyPresent) {}
172 
173 public:
174  // Implement isa/cast/dyncast/etc.
175  static bool classof(const Attr *A) {
176  return A->getKind() >= attr::FirstInheritableParamAttr &&
177  A->getKind() <= attr::LastInheritableParamAttr;
178  }
179 };
180 
181 /// A parameter attribute which changes the argument-passing ABI rule
182 /// for the parameter.
184 protected:
186  unsigned SpellingListIndex, bool IsLateParsed,
188  : InheritableParamAttr(AK, R, SpellingListIndex, IsLateParsed,
189  InheritEvenIfAlreadyPresent) {}
190 
191 public:
193  switch (getKind()) {
194  case attr::SwiftContext:
196  case attr::SwiftErrorResult:
198  case attr::SwiftIndirectResult:
200  default:
201  llvm_unreachable("bad parameter ABI attribute kind");
202  }
203  }
204 
205  static bool classof(const Attr *A) {
206  return A->getKind() >= attr::FirstParameterABIAttr &&
207  A->getKind() <= attr::LastParameterABIAttr;
208  }
209 };
210 
211 /// A single parameter index whose accessors require each use to make explicit
212 /// the parameter index encoding needed.
213 class ParamIdx {
214  // Idx is exposed only via accessors that specify specific encodings.
215  unsigned Idx : 30;
216  unsigned HasThis : 1;
217  unsigned IsValid : 1;
218 
219  void assertComparable(const ParamIdx &I) const {
220  assert(isValid() && I.isValid() &&
221  "ParamIdx must be valid to be compared");
222  // It's possible to compare indices from separate functions, but so far
223  // it's not proven useful. Moreover, it might be confusing because a
224  // comparison on the results of getASTIndex might be inconsistent with a
225  // comparison on the ParamIdx objects themselves.
226  assert(HasThis == I.HasThis &&
227  "ParamIdx must be for the same function to be compared");
228  }
229 
230 public:
231  /// Construct an invalid parameter index (\c isValid returns false and
232  /// accessors fail an assert).
233  ParamIdx() : Idx(0), HasThis(false), IsValid(false) {}
234 
235  /// \param Idx is the parameter index as it is normally specified in
236  /// attributes in the source: one-origin including any C++ implicit this
237  /// parameter.
238  ///
239  /// \param D is the declaration containing the parameters. It is used to
240  /// determine if there is a C++ implicit this parameter.
241  ParamIdx(unsigned Idx, const Decl *D)
242  : Idx(Idx), HasThis(false), IsValid(true) {
243  assert(Idx >= 1 && "Idx must be one-origin");
244  if (const auto *FD = dyn_cast<FunctionDecl>(D))
245  HasThis = FD->isCXXInstanceMember();
246  }
247 
248  /// A type into which \c ParamIdx can be serialized.
249  ///
250  /// A static assertion that it's of the correct size follows the \c ParamIdx
251  /// class definition.
252  typedef uint32_t SerialType;
253 
254  /// Produce a representation that can later be passed to \c deserialize to
255  /// construct an equivalent \c ParamIdx.
256  SerialType serialize() const {
257  return *reinterpret_cast<const SerialType *>(this);
258  }
259 
260  /// Construct from a result from \c serialize.
261  static ParamIdx deserialize(SerialType S) {
262  ParamIdx P(*reinterpret_cast<ParamIdx *>(&S));
263  assert((!P.IsValid || P.Idx >= 1) && "valid Idx must be one-origin");
264  return P;
265  }
266 
267  /// Is this parameter index valid?
268  bool isValid() const { return IsValid; }
269 
270  /// Get the parameter index as it would normally be encoded for attributes at
271  /// the source level of representation: one-origin including any C++ implicit
272  /// this parameter.
273  ///
274  /// This encoding thus makes sense for diagnostics, pretty printing, and
275  /// constructing new attributes from a source-like specification.
276  unsigned getSourceIndex() const {
277  assert(isValid() && "ParamIdx must be valid");
278  return Idx;
279  }
280 
281  /// Get the parameter index as it would normally be encoded at the AST level
282  /// of representation: zero-origin not including any C++ implicit this
283  /// parameter.
284  ///
285  /// This is the encoding primarily used in Sema. However, in diagnostics,
286  /// Sema uses \c getSourceIndex instead.
287  unsigned getASTIndex() const {
288  assert(isValid() && "ParamIdx must be valid");
289  assert(Idx >= 1 + HasThis &&
290  "stored index must be base-1 and not specify C++ implicit this");
291  return Idx - 1 - HasThis;
292  }
293 
294  /// Get the parameter index as it would normally be encoded at the LLVM level
295  /// of representation: zero-origin including any C++ implicit this parameter.
296  ///
297  /// This is the encoding primarily used in CodeGen.
298  unsigned getLLVMIndex() const {
299  assert(isValid() && "ParamIdx must be valid");
300  assert(Idx >= 1 && "stored index must be base-1");
301  return Idx - 1;
302  }
303 
304  bool operator==(const ParamIdx &I) const {
305  assertComparable(I);
306  return Idx == I.Idx;
307  }
308  bool operator!=(const ParamIdx &I) const {
309  assertComparable(I);
310  return Idx != I.Idx;
311  }
312  bool operator<(const ParamIdx &I) const {
313  assertComparable(I);
314  return Idx < I.Idx;
315  }
316  bool operator>(const ParamIdx &I) const {
317  assertComparable(I);
318  return Idx > I.Idx;
319  }
320  bool operator<=(const ParamIdx &I) const {
321  assertComparable(I);
322  return Idx <= I.Idx;
323  }
324  bool operator>=(const ParamIdx &I) const {
325  assertComparable(I);
326  return Idx >= I.Idx;
327  }
328 };
329 
330 static_assert(sizeof(ParamIdx) == sizeof(ParamIdx::SerialType),
331  "ParamIdx does not fit its serialization type");
332 
333 #include "clang/AST/Attrs.inc"
334 
336  const Attr *At) {
337  DB.AddTaggedVal(reinterpret_cast<intptr_t>(At),
339  return DB;
340 }
341 
343  const Attr *At) {
344  PD.AddTaggedVal(reinterpret_cast<intptr_t>(At),
346  return PD;
347 }
348 } // end namespace clang
349 
350 #endif
const char * getSpelling() const
Attr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex, bool IsLateParsed)
Definition: Attr.h:78
ParamIdx()
Construct an invalid parameter index (isValid returns false and accessors fail an assert)...
Definition: Attr.h:233
C Language Family Type Representation.
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
void AddTaggedVal(intptr_t V, DiagnosticsEngine::ArgumentKind Kind) const
unsigned Implicit
Definition: Attr.h:54
StringRef P
const DiagnosticBuilder & operator<<(const DiagnosticBuilder &DB, const Attr *At)
Definition: Attr.h:335
unsigned Inherited
Definition: Attr.h:52
InheritableAttr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex, bool IsLateParsed, bool InheritEvenIfAlreadyPresent)
Definition: Attr.h:144
static bool classof(const Attr *A)
Definition: Attr.h:205
bool operator<=(const ParamIdx &I) const
Definition: Attr.h:320
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
static StringRef bytes(const std::vector< T, Allocator > &v)
Definition: ASTWriter.cpp:120
bool isValid() const
Is this parameter index valid?
Definition: Attr.h:268
Defines the clang::SanitizerKind enum.
void AddTaggedVal(intptr_t V, DiagnosticsEngine::ArgumentKind Kind) const
Definition: Diagnostic.h:1155
unsigned InheritEvenIfAlreadyPresent
Definition: Attr.h:58
bool isImplicit() const
Returns true if the attribute has been implicitly created instead of explicitly written by the user...
Definition: Attr.h:101
ParameterABI getABI() const
Definition: Attr.h:192
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
unsigned getSourceIndex() const
Get the parameter index as it would normally be encoded for attributes at the source level of represe...
Definition: Attr.h:276
Defines the clang::attr::Kind enum.
Defines some OpenMP-specific enums and functions.
This parameter (which must have pointer type) uses the special Swift context-pointer ABI treatment...
void setRange(SourceRange R)
Definition: Attr.h:95
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
static bool classof(const Attr *A)
Definition: Attr.h:136
This parameter (which must have pointer-to-pointer type) uses the special Swift error-result ABI trea...
InheritableParamAttr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex, bool IsLateParsed, bool InheritEvenIfAlreadyPresent)
Definition: Attr.h:168
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:1042
static bool classof(const Attr *A)
Definition: Attr.h:160
unsigned getLLVMIndex() const
Get the parameter index as it would normally be encoded at the LLVM level of representation: zero-ori...
Definition: Attr.h:298
bool operator<(const ParamIdx &I) const
Definition: Attr.h:312
bool operator!=(const ParamIdx &I) const
Definition: Attr.h:308
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
Definition: Attr.h:213
TypeAttr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex, bool IsLateParsed)
Definition: Attr.h:118
bool isPackExpansion() const
Definition: Attr.h:105
unsigned IsPackExpansion
Definition: Attr.h:53
bool shouldInheritEvenIfAlreadyPresent() const
Should this attribute be inherited from a prior declaration even if it&#39;s explicitly provided in the c...
Definition: Attr.h:155
bool operator==(const ParamIdx &I) const
Definition: Attr.h:304
static bool classof(const Attr *A)
Definition: Attr.h:123
bool operator>(const ParamIdx &I) const
Definition: Attr.h:316
unsigned getASTIndex() const
Get the parameter index as it would normally be encoded at the AST level of representation: zero-orig...
Definition: Attr.h:287
A parameter attribute which changes the argument-passing ABI rule for the parameter.
Definition: Attr.h:183
void setImplicit(bool I)
Definition: Attr.h:102
#define false
Definition: stdbool.h:33
Encodes a location in the source.
Attr * clone(ASTContext &C) const
unsigned getSpellingListIndex() const
Definition: Attr.h:90
void setPackExpansion(bool PE)
Definition: Attr.h:104
StmtAttr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex, bool IsLateParsed)
Definition: Attr.h:131
ParamIdx(unsigned Idx, const Decl *D)
Definition: Attr.h:241
SourceLocation getLocation() const
Definition: Attr.h:93
void printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const
ParameterABI
Kinds of parameter ABI.
Definition: Specifiers.h:308
SourceRange getRange() const
Definition: Attr.h:94
Dataflow Directional Tag Classes.
static ParamIdx deserialize(SerialType S)
Construct from a result from serialize.
Definition: Attr.h:261
unsigned SpellingListIndex
An index into the spelling list of an attribute defined in Attr.td file.
Definition: Attr.h:51
bool isLateParsed() const
Definition: Attr.h:110
SerialType serialize() const
Produce a representation that can later be passed to deserialize to construct an equivalent ParamIdx...
Definition: Attr.h:256
uint32_t SerialType
A type into which ParamIdx can be serialized.
Definition: Attr.h:252
void setInherited(bool I)
Definition: Attr.h:151
static bool classof(const Attr *A)
Definition: Attr.h:175
Defines the clang::SourceLocation class and associated facilities.
bool isInherited() const
Definition: Attr.h:97
bool operator>=(const ParamIdx &I) const
Definition: Attr.h:324
ParameterABIAttr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex, bool IsLateParsed, bool InheritEvenIfAlreadyPresent)
Definition: Attr.h:185
#define true
Definition: stdbool.h:32
A trivial tuple used to represent a source range.
unsigned IsLateParsed
Definition: Attr.h:57
attr::Kind getKind() const
Definition: Attr.h:86
SourceLocation getBegin() const
Attr - This represents one attribute.
Definition: Attr.h:43
This parameter (which must have pointer type) is a Swift indirect result parameter.