]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - contrib/llvm/tools/clang/lib/Sema/AttributeList.cpp
Merge clang trunk r321017 to contrib/llvm/tools/clang.
[FreeBSD/FreeBSD.git] / contrib / llvm / tools / clang / lib / Sema / AttributeList.cpp
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/AttrSubjectMatchRules.h"
20 #include "clang/Basic/IdentifierTable.h"
21 #include "clang/Basic/TargetInfo.h"
22 #include "clang/Sema/SemaInternal.h"
23 #include "llvm/ADT/SmallString.h"
24 using namespace clang;
25
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
34 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
43 AttributeFactory::AttributeFactory() {
44   // Go ahead and configure all the inline capacity.  This is just a memset.
45   FreeLists.resize(InlineFreeListsCapacity);
46 }
47 AttributeFactory::~AttributeFactory() {}
48
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
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, alignof(AttributeFactory));
67 }
68
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
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
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 ||
118                 SyntaxUsed == AttributeList::AS_C2x) && ScopeName == "gnu");
119   if (IsGNU && AttrName.size() >= 4 && AttrName.startswith("__") &&
120       AttrName.endswith("__"))
121     AttrName = AttrName.slice(2, AttrName.size() - 2);
122
123   return AttrName;
124 }
125
126 AttributeList::Kind AttributeList::getKind(const IdentifierInfo *Name,
127                                            const IdentifierInfo *ScopeName,
128                                            Syntax SyntaxUsed) {
129   StringRef AttrName = Name->getName();
130
131   SmallString<64> FullName;
132   if (ScopeName)
133     FullName += ScopeName->getName();
134
135   AttrName = normalizeAttrName(AttrName, FullName, SyntaxUsed);
136
137   // Ensure that in the case of C++11 attributes, we look for '::foo' if it is
138   // unscoped.
139   if (ScopeName || SyntaxUsed == AS_CXX11 || SyntaxUsed == AS_C2x)
140     FullName += "::";
141   FullName += AttrName;
142
143   return ::getAttrKind(FullName, SyntaxUsed);
144 }
145
146 unsigned AttributeList::getAttributeSpellingListIndex() const {
147   // Both variables will be used in tablegen generated
148   // attribute spell list index matching code.
149   StringRef Scope = ScopeName ? ScopeName->getName() : "";
150   StringRef Name = normalizeAttrName(AttrName->getName(), Scope,
151                                      (AttributeList::Syntax)SyntaxUsed);
152
153 #include "clang/Sema/AttrSpellingListIndex.inc"
154
155 }
156
157 struct ParsedAttrInfo {
158   unsigned NumArgs : 4;
159   unsigned OptArgs : 4;
160   unsigned HasCustomParsing : 1;
161   unsigned IsTargetSpecific : 1;
162   unsigned IsType : 1;
163   unsigned IsStmt : 1;
164   unsigned IsKnownToGCC : 1;
165   unsigned IsSupportedByPragmaAttribute : 1;
166
167   bool (*DiagAppertainsToDecl)(Sema &S, const AttributeList &Attr,
168                                const Decl *);
169   bool (*DiagLangOpts)(Sema &S, const AttributeList &Attr);
170   bool (*ExistsInTarget)(const TargetInfo &Target);
171   unsigned (*SpellingIndexToSemanticSpelling)(const AttributeList &Attr);
172   void (*GetPragmaAttributeMatchRules)(
173       llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &Rules,
174       const LangOptions &LangOpts);
175 };
176
177 namespace {
178   #include "clang/Sema/AttrParsedAttrImpl.inc"
179 }
180
181 static const ParsedAttrInfo &getInfo(const AttributeList &A) {
182   return AttrInfoMap[A.getKind()];
183 }
184
185 unsigned AttributeList::getMinArgs() const {
186   return getInfo(*this).NumArgs;
187 }
188
189 unsigned AttributeList::getMaxArgs() const {
190   return getMinArgs() + getInfo(*this).OptArgs;
191 }
192
193 bool AttributeList::hasCustomParsing() const {
194   return getInfo(*this).HasCustomParsing;
195 }
196
197 bool AttributeList::diagnoseAppertainsTo(Sema &S, const Decl *D) const {
198   return getInfo(*this).DiagAppertainsToDecl(S, *this, D);
199 }
200
201 bool AttributeList::appliesToDecl(const Decl *D,
202                                   attr::SubjectMatchRule MatchRule) const {
203   return checkAttributeMatchRuleAppliesTo(D, MatchRule);
204 }
205
206 void AttributeList::getMatchRules(
207     const LangOptions &LangOpts,
208     SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules)
209     const {
210   return getInfo(*this).GetPragmaAttributeMatchRules(MatchRules, LangOpts);
211 }
212
213 bool AttributeList::diagnoseLangOpts(Sema &S) const {
214   return getInfo(*this).DiagLangOpts(S, *this);
215 }
216
217 bool AttributeList::isTargetSpecificAttr() const {
218   return getInfo(*this).IsTargetSpecific;
219 }
220
221 bool AttributeList::isTypeAttr() const {
222   return getInfo(*this).IsType;
223 }
224
225 bool AttributeList::isStmtAttr() const {
226   return getInfo(*this).IsStmt;
227 }
228
229 bool AttributeList::existsInTarget(const TargetInfo &Target) const {
230   return getInfo(*this).ExistsInTarget(Target);
231 }
232
233 bool AttributeList::isKnownToGCC() const {
234   return getInfo(*this).IsKnownToGCC;
235 }
236
237 bool AttributeList::isSupportedByPragmaAttribute() const {
238   return getInfo(*this).IsSupportedByPragmaAttribute;
239 }
240
241 unsigned AttributeList::getSemanticSpelling() const {
242   return getInfo(*this).SpellingIndexToSemanticSpelling(*this);
243 }
244
245 bool AttributeList::hasVariadicArg() const {
246   // If the attribute has the maximum number of optional arguments, we will
247   // claim that as being variadic. If we someday get an attribute that
248   // legitimately bumps up against that maximum, we can use another bit to track
249   // whether it's truly variadic or not.
250   return getInfo(*this).OptArgs == 15;
251 }