Coverage Report

Created: 2018-07-19 20:53

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/AST/Attr.h
Line
Count
Source (jump to first uncovered line)
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"
23
#include "clang/Basic/OpenMPKinds.h"
24
#include "clang/Basic/Sanitizers.h"
25
#include "clang/Basic/SourceLocation.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;
58
  unsigned InheritEvenIfAlreadyPresent : 1;
59
60
0
  void *operator new(size_t bytes) noexcept {
61
0
    llvm_unreachable("Attrs cannot be allocated with regular 'new'.");
62
0
  }
63
0
  void operator delete(void *data) noexcept {
64
0
    llvm_unreachable("Attrs cannot be released with regular 'delete'.");
65
0
  }
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
2.63M
                     size_t Alignment = 8) noexcept {
71
2.63M
    return ::operator new(Bytes, C, Alignment);
72
2.63M
  }
73
0
  void operator delete(void *Ptr, ASTContext &C, size_t Alignment) noexcept {
74
0
    return ::operator delete(Ptr, C, Alignment);
75
0
  }
76
77
protected:
78
  Attr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex,
79
       bool IsLateParsed)
80
    : Range(R), AttrKind(AK), SpellingListIndex(SpellingListIndex),
81
      Inherited(false), IsPackExpansion(false), Implicit(false),
82
8.86M
      IsLateParsed(IsLateParsed), InheritEvenIfAlreadyPresent(false) {}
83
84
public:
85
86
500M
  attr::Kind getKind() const {
87
500M
    return static_cast<attr::Kind>(AttrKind);
88
500M
  }
89
  
90
1.65M
  unsigned getSpellingListIndex() const { return SpellingListIndex; }
91
  const char *getSpelling() const;
92
93
970k
  SourceLocation getLocation() const { return Range.getBegin(); }
94
488k
  SourceRange getRange() const { return Range; }
95
123
  void setRange(SourceRange R) { Range = R; }
96
97
158k
  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
268k
  bool isImplicit() const { return Implicit; }
102
2.31M
  void setImplicit(bool I) { Implicit = I; }
103
104
28.0k
  void setPackExpansion(bool PE) { IsPackExpansion = PE; }
105
194
  bool isPackExpansion() const { return IsPackExpansion; }
106
107
  // Clone this attribute.
108
  Attr *clone(ASTContext &C) const;
109
110
1.83M
  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 StmtAttr : public Attr {
117
protected:
118
  StmtAttr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex,
119
                  bool IsLateParsed)
120
80
      : Attr(AK, R, SpellingListIndex, IsLateParsed) {}
121
122
public:
123
0
  static bool classof(const Attr *A) {
124
0
    return A->getKind() >= attr::FirstStmtAttr &&
125
0
           A->getKind() <= attr::LastStmtAttr;
126
0
  }
127
};
128
129
class InheritableAttr : public Attr {
130
protected:
131
  InheritableAttr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex,
132
                  bool IsLateParsed, bool InheritEvenIfAlreadyPresent)
133
8.28M
      : Attr(AK, R, SpellingListIndex, IsLateParsed) {
134
8.28M
    this->InheritEvenIfAlreadyPresent = InheritEvenIfAlreadyPresent;
135
8.28M
  }
136
137
public:
138
370k
  void setInherited(bool I) { Inherited = I; }
139
140
  /// Should this attribute be inherited from a prior declaration even if it's
141
  /// explicitly provided in the current declaration?
142
239k
  bool shouldInheritEvenIfAlreadyPresent() const {
143
239k
    return InheritEvenIfAlreadyPresent;
144
239k
  }
145
146
  // Implement isa/cast/dyncast/etc.
147
977k
  static bool classof(const Attr *A) {
148
977k
    return A->getKind() >= attr::FirstInheritableAttr &&
149
977k
           A->getKind() <= attr::LastInheritableAttr;
150
977k
  }
151
};
152
153
class InheritableParamAttr : public InheritableAttr {
154
protected:
155
  InheritableParamAttr(attr::Kind AK, SourceRange R, unsigned SpellingListIndex,
156
                       bool IsLateParsed, bool InheritEvenIfAlreadyPresent)
157
      : InheritableAttr(AK, R, SpellingListIndex, IsLateParsed,
158
9.96k
                        InheritEvenIfAlreadyPresent) {}
159
160
public:
161
  // Implement isa/cast/dyncast/etc.
162
827
  static bool classof(const Attr *A) {
163
827
    return A->getKind() >= attr::FirstInheritableParamAttr &&
164
827
           A->getKind() <= attr::LastInheritableParamAttr;
165
827
  }
166
};
167
168
/// A parameter attribute which changes the argument-passing ABI rule
169
/// for the parameter.
170
class ParameterABIAttr : public InheritableParamAttr {
171
protected:
172
  ParameterABIAttr(attr::Kind AK, SourceRange R,
173
                   unsigned SpellingListIndex, bool IsLateParsed,
174
                   bool InheritEvenIfAlreadyPresent)
175
    : InheritableParamAttr(AK, R, SpellingListIndex, IsLateParsed,
176
166
                           InheritEvenIfAlreadyPresent) {}
177
178
public:
179
166
  ParameterABI getABI() const {
180
166
    switch (getKind()) {
181
166
    case attr::SwiftContext:
182
58
      return ParameterABI::SwiftContext;
183
166
    case attr::SwiftErrorResult:
184
34
      return ParameterABI::SwiftErrorResult;
185
166
    case attr::SwiftIndirectResult:
186
74
      return ParameterABI::SwiftIndirectResult;
187
166
    default:
188
0
      llvm_unreachable("bad parameter ABI attribute kind");
189
166
    }
190
166
  }
191
192
1.84M
  static bool classof(const Attr *A) {
193
1.84M
    return A->getKind() >= attr::FirstParameterABIAttr &&
194
1.84M
           A->getKind() <= attr::LastParameterABIAttr;
195
1.84M
   }
196
};
197
198
/// A single parameter index whose accessors require each use to make explicit
199
/// the parameter index encoding needed.
200
class ParamIdx {
201
  // Idx is exposed only via accessors that specify specific encodings.
202
  unsigned Idx : 30;
203
  unsigned HasThis : 1;
204
  unsigned IsValid : 1;
205
206
75
  void assertComparable(const ParamIdx &I) const {
207
75
    assert(isValid() && I.isValid() &&
208
75
           "ParamIdx must be valid to be compared");
209
75
    // It's possible to compare indices from separate functions, but so far
210
75
    // it's not proven useful.  Moreover, it might be confusing because a
211
75
    // comparison on the results of getASTIndex might be inconsistent with a
212
75
    // comparison on the ParamIdx objects themselves.
213
75
    assert(HasThis == I.HasThis &&
214
75
           "ParamIdx must be for the same function to be compared");
215
75
  }
216
217
public:
218
  /// Construct an invalid parameter index (\c isValid returns false and
219
  /// accessors fail an assert).
220
34.3k
  ParamIdx() : Idx(0), HasThis(false), IsValid(false) {}
221
222
  /// \param Idx is the parameter index as it is normally specified in
223
  /// attributes in the source: one-origin including any C++ implicit this
224
  /// parameter.
225
  ///
226
  /// \param D is the declaration containing the parameters.  It is used to
227
  /// determine if there is a C++ implicit this parameter.
228
  ParamIdx(unsigned Idx, const Decl *D)
229
30.3k
      : Idx(Idx), HasThis(false), IsValid(true) {
230
30.3k
    assert(Idx >= 1 && "Idx must be one-origin");
231
30.3k
    if (const auto *FD = dyn_cast<FunctionDecl>(D))
232
30.3k
      HasThis = FD->isCXXInstanceMember();
233
30.3k
  }
234
235
  /// A type into which \c ParamIdx can be serialized.
236
  ///
237
  /// A static assertion that it's of the correct size follows the \c ParamIdx
238
  /// class definition.
239
  typedef uint32_t SerialType;
240
241
  /// Produce a representation that can later be passed to \c deserialize to
242
  /// construct an equivalent \c ParamIdx.
243
34
  SerialType serialize() const {
244
34
    return *reinterpret_cast<const SerialType *>(this);
245
34
  }
246
247
  /// Construct from a result from \c serialize.
248
34
  static ParamIdx deserialize(SerialType S) {
249
34
    ParamIdx P(*reinterpret_cast<ParamIdx *>(&S));
250
34
    assert((!P.IsValid || P.Idx >= 1) && "valid Idx must be one-origin");
251
34
    return P;
252
34
  }
253
254
  /// Is this parameter index valid?
255
3.03k
  bool isValid() const { return IsValid; }
256
257
  /// Get the parameter index as it would normally be encoded for attributes at
258
  /// the source level of representation: one-origin including any C++ implicit
259
  /// this parameter.
260
  ///
261
  /// This encoding thus makes sense for diagnostics, pretty printing, and
262
  /// constructing new attributes from a source-like specification.
263
97
  unsigned getSourceIndex() const {
264
97
    assert(isValid() && "ParamIdx must be valid");
265
97
    return Idx;
266
97
  }
267
268
  /// Get the parameter index as it would normally be encoded at the AST level
269
  /// of representation: zero-origin not including any C++ implicit this
270
  /// parameter.
271
  ///
272
  /// This is the encoding primarily used in Sema.  However, in diagnostics,
273
  /// Sema uses \c getSourceIndex instead.
274
31.7k
  unsigned getASTIndex() const {
275
31.7k
    assert(isValid() && "ParamIdx must be valid");
276
31.7k
    assert(Idx >= 1 + HasThis &&
277
31.7k
           "stored index must be base-1 and not specify C++ implicit this");
278
31.7k
    return Idx - 1 - HasThis;
279
31.7k
  }
280
281
  /// Get the parameter index as it would normally be encoded at the LLVM level
282
  /// of representation: zero-origin including any C++ implicit this parameter.
283
  ///
284
  /// This is the encoding primarily used in CodeGen.
285
3.44k
  unsigned getLLVMIndex() const {
286
3.44k
    assert(isValid() && "ParamIdx must be valid");
287
3.44k
    assert(Idx >= 1 && "stored index must be base-1");
288
3.44k
    return Idx - 1;
289
3.44k
  }
290
291
4
  bool operator==(const ParamIdx &I) const {
292
4
    assertComparable(I);
293
4
    return Idx == I.Idx;
294
4
  }
295
  bool operator!=(const ParamIdx &I) const {
296
    assertComparable(I);
297
    return Idx != I.Idx;
298
  }
299
71
  bool operator<(const ParamIdx &I) const {
300
71
    assertComparable(I);
301
71
    return Idx < I.Idx;
302
71
  }
303
  bool operator>(const ParamIdx &I) const {
304
    assertComparable(I);
305
    return Idx > I.Idx;
306
  }
307
  bool operator<=(const ParamIdx &I) const {
308
    assertComparable(I);
309
    return Idx <= I.Idx;
310
  }
311
  bool operator>=(const ParamIdx &I) const {
312
    assertComparable(I);
313
    return Idx >= I.Idx;
314
  }
315
};
316
317
static_assert(sizeof(ParamIdx) == sizeof(ParamIdx::SerialType),
318
              "ParamIdx does not fit its serialization type");
319
320
#include "clang/AST/Attrs.inc"
321
322
inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
323
1.35k
                                           const Attr *At) {
324
1.35k
  DB.AddTaggedVal(reinterpret_cast<intptr_t>(At),
325
1.35k
                  DiagnosticsEngine::ak_attr);
326
1.35k
  return DB;
327
1.35k
}
328
329
inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
330
0
                                           const Attr *At) {
331
0
  PD.AddTaggedVal(reinterpret_cast<intptr_t>(At),
332
0
                  DiagnosticsEngine::ak_attr);
333
0
  return PD;
334
0
}
335
}  // end namespace clang
336
337
#endif