1 //===--- AttributeList.cpp --------------------------------------*- 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 AttributeList class implementation
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/Sema/AttributeList.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/DeclCXX.h"
17 #include "clang/AST/DeclTemplate.h"
18 #include "clang/AST/Expr.h"
19 #include "clang/Basic/IdentifierTable.h"
20 #include "clang/Basic/TargetInfo.h"
21 #include "clang/Sema/SemaInternal.h"
22 #include "llvm/ADT/SmallString.h"
23 #include "llvm/ADT/StringSwitch.h"
24 using namespace clang;
25
create(ASTContext & Ctx,SourceLocation Loc,IdentifierInfo * Ident)26 IdentifierLoc *IdentifierLoc::create(ASTContext &Ctx, SourceLocation Loc,
27 IdentifierInfo *Ident) {
28 IdentifierLoc *Result = new (Ctx) IdentifierLoc;
29 Result->Loc = Loc;
30 Result->Ident = Ident;
31 return Result;
32 }
33
allocated_size() const34 size_t AttributeList::allocated_size() const {
35 if (IsAvailability) return AttributeFactory::AvailabilityAllocSize;
36 else if (IsTypeTagForDatatype)
37 return AttributeFactory::TypeTagForDatatypeAllocSize;
38 else if (IsProperty)
39 return AttributeFactory::PropertyAllocSize;
40 return (sizeof(AttributeList) + NumArgs * sizeof(ArgsUnion));
41 }
42
AttributeFactory()43 AttributeFactory::AttributeFactory() {
44 // Go ahead and configure all the inline capacity. This is just a memset.
45 FreeLists.resize(InlineFreeListsCapacity);
46 }
~AttributeFactory()47 AttributeFactory::~AttributeFactory() {}
48
getFreeListIndexForSize(size_t size)49 static size_t getFreeListIndexForSize(size_t size) {
50 assert(size >= sizeof(AttributeList));
51 assert((size % sizeof(void*)) == 0);
52 return ((size - sizeof(AttributeList)) / sizeof(void*));
53 }
54
allocate(size_t size)55 void *AttributeFactory::allocate(size_t size) {
56 // Check for a previously reclaimed attribute.
57 size_t index = getFreeListIndexForSize(size);
58 if (index < FreeLists.size()) {
59 if (AttributeList *attr = FreeLists[index]) {
60 FreeLists[index] = attr->NextInPool;
61 return attr;
62 }
63 }
64
65 // Otherwise, allocate something new.
66 return Alloc.Allocate(size, llvm::AlignOf<AttributeFactory>::Alignment);
67 }
68
reclaimPool(AttributeList * cur)69 void AttributeFactory::reclaimPool(AttributeList *cur) {
70 assert(cur && "reclaiming empty pool!");
71 do {
72 // Read this here, because we're going to overwrite NextInPool
73 // when we toss 'cur' into the appropriate queue.
74 AttributeList *next = cur->NextInPool;
75
76 size_t size = cur->allocated_size();
77 size_t freeListIndex = getFreeListIndexForSize(size);
78
79 // Expand FreeLists to the appropriate size, if required.
80 if (freeListIndex >= FreeLists.size())
81 FreeLists.resize(freeListIndex+1);
82
83 // Add 'cur' to the appropriate free-list.
84 cur->NextInPool = FreeLists[freeListIndex];
85 FreeLists[freeListIndex] = cur;
86
87 cur = next;
88 } while (cur);
89 }
90
takePool(AttributeList * pool)91 void AttributePool::takePool(AttributeList *pool) {
92 assert(pool);
93
94 // Fast path: this pool is empty.
95 if (!Head) {
96 Head = pool;
97 return;
98 }
99
100 // Reverse the pool onto the current head. This optimizes for the
101 // pattern of pulling a lot of pools into a single pool.
102 do {
103 AttributeList *next = pool->NextInPool;
104 pool->NextInPool = Head;
105 Head = pool;
106 pool = next;
107 } while (pool);
108 }
109
110 #include "clang/Sema/AttrParsedAttrKinds.inc"
111
normalizeAttrName(StringRef AttrName,StringRef ScopeName,AttributeList::Syntax SyntaxUsed)112 static StringRef normalizeAttrName(StringRef AttrName, StringRef ScopeName,
113 AttributeList::Syntax SyntaxUsed) {
114 // Normalize the attribute name, __foo__ becomes foo. This is only allowable
115 // for GNU attributes.
116 bool IsGNU = SyntaxUsed == AttributeList::AS_GNU ||
117 (SyntaxUsed == AttributeList::AS_CXX11 && ScopeName == "gnu");
118 if (IsGNU && AttrName.size() >= 4 && AttrName.startswith("__") &&
119 AttrName.endswith("__"))
120 AttrName = AttrName.slice(2, AttrName.size() - 2);
121
122 return AttrName;
123 }
124
getKind(const IdentifierInfo * Name,const IdentifierInfo * ScopeName,Syntax SyntaxUsed)125 AttributeList::Kind AttributeList::getKind(const IdentifierInfo *Name,
126 const IdentifierInfo *ScopeName,
127 Syntax SyntaxUsed) {
128 StringRef AttrName = Name->getName();
129
130 SmallString<64> FullName;
131 if (ScopeName)
132 FullName += ScopeName->getName();
133
134 AttrName = normalizeAttrName(AttrName, FullName, SyntaxUsed);
135
136 // Ensure that in the case of C++11 attributes, we look for '::foo' if it is
137 // unscoped.
138 if (ScopeName || SyntaxUsed == AS_CXX11)
139 FullName += "::";
140 FullName += AttrName;
141
142 return ::getAttrKind(FullName, SyntaxUsed);
143 }
144
getAttributeSpellingListIndex() const145 unsigned AttributeList::getAttributeSpellingListIndex() const {
146 // Both variables will be used in tablegen generated
147 // attribute spell list index matching code.
148 StringRef Scope = ScopeName ? ScopeName->getName() : "";
149 StringRef Name = normalizeAttrName(AttrName->getName(), Scope,
150 (AttributeList::Syntax)SyntaxUsed);
151
152 #include "clang/Sema/AttrSpellingListIndex.inc"
153
154 }
155
156 struct ParsedAttrInfo {
157 unsigned NumArgs : 4;
158 unsigned OptArgs : 4;
159 unsigned HasCustomParsing : 1;
160 unsigned IsTargetSpecific : 1;
161 unsigned IsType : 1;
162 unsigned IsStmt : 1;
163 unsigned IsKnownToGCC : 1;
164
165 bool (*DiagAppertainsToDecl)(Sema &S, const AttributeList &Attr,
166 const Decl *);
167 bool (*DiagLangOpts)(Sema &S, const AttributeList &Attr);
168 bool (*ExistsInTarget)(const TargetInfo &Target);
169 unsigned (*SpellingIndexToSemanticSpelling)(const AttributeList &Attr);
170 };
171
172 namespace {
173 #include "clang/Sema/AttrParsedAttrImpl.inc"
174 }
175
getInfo(const AttributeList & A)176 static const ParsedAttrInfo &getInfo(const AttributeList &A) {
177 return AttrInfoMap[A.getKind()];
178 }
179
getMinArgs() const180 unsigned AttributeList::getMinArgs() const {
181 return getInfo(*this).NumArgs;
182 }
183
getMaxArgs() const184 unsigned AttributeList::getMaxArgs() const {
185 return getMinArgs() + getInfo(*this).OptArgs;
186 }
187
hasCustomParsing() const188 bool AttributeList::hasCustomParsing() const {
189 return getInfo(*this).HasCustomParsing;
190 }
191
diagnoseAppertainsTo(Sema & S,const Decl * D) const192 bool AttributeList::diagnoseAppertainsTo(Sema &S, const Decl *D) const {
193 return getInfo(*this).DiagAppertainsToDecl(S, *this, D);
194 }
195
diagnoseLangOpts(Sema & S) const196 bool AttributeList::diagnoseLangOpts(Sema &S) const {
197 return getInfo(*this).DiagLangOpts(S, *this);
198 }
199
isTargetSpecificAttr() const200 bool AttributeList::isTargetSpecificAttr() const {
201 return getInfo(*this).IsTargetSpecific;
202 }
203
isTypeAttr() const204 bool AttributeList::isTypeAttr() const {
205 return getInfo(*this).IsType;
206 }
207
isStmtAttr() const208 bool AttributeList::isStmtAttr() const {
209 return getInfo(*this).IsStmt;
210 }
211
existsInTarget(const TargetInfo & Target) const212 bool AttributeList::existsInTarget(const TargetInfo &Target) const {
213 return getInfo(*this).ExistsInTarget(Target);
214 }
215
isKnownToGCC() const216 bool AttributeList::isKnownToGCC() const {
217 return getInfo(*this).IsKnownToGCC;
218 }
219
getSemanticSpelling() const220 unsigned AttributeList::getSemanticSpelling() const {
221 return getInfo(*this).SpellingIndexToSemanticSpelling(*this);
222 }
223
hasVariadicArg() const224 bool AttributeList::hasVariadicArg() const {
225 // If the attribute has the maximum number of optional arguments, we will
226 // claim that as being variadic. If we someday get an attribute that
227 // legitimately bumps up against that maximum, we can use another bit to track
228 // whether it's truly variadic or not.
229 return getInfo(*this).OptArgs == 15;
230 }
231