1 //======- ParsedAttr.cpp --------------------------------------------------===//
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 ParsedAttr class implementation
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/Sema/ParsedAttr.h"
14 #include "clang/AST/ASTContext.h"
15 #include "clang/Basic/AttrSubjectMatchRules.h"
16 #include "clang/Basic/IdentifierTable.h"
17 #include "clang/Basic/TargetInfo.h"
18 #include "clang/Sema/SemaInternal.h"
19 #include "llvm/ADT/SmallString.h"
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/ADT/StringRef.h"
22 #include "llvm/Support/ManagedStatic.h"
23 #include <cassert>
24 #include <cstddef>
25 #include <utility>
26 
27 using namespace clang;
28 
29 LLVM_INSTANTIATE_REGISTRY(ParsedAttrInfoRegistry)
30 
31 IdentifierLoc *IdentifierLoc::create(ASTContext &Ctx, SourceLocation Loc,
32                                      IdentifierInfo *Ident) {
33   IdentifierLoc *Result = new (Ctx) IdentifierLoc;
34   Result->Loc = Loc;
35   Result->Ident = Ident;
36   return Result;
37 }
38 
39 size_t ParsedAttr::allocated_size() const {
40   if (IsAvailability) return AttributeFactory::AvailabilityAllocSize;
41   else if (IsTypeTagForDatatype)
42     return AttributeFactory::TypeTagForDatatypeAllocSize;
43   else if (IsProperty)
44     return AttributeFactory::PropertyAllocSize;
45   else if (HasParsedType)
46     return totalSizeToAlloc<ArgsUnion, detail::AvailabilityData,
47                             detail::TypeTagForDatatypeData, ParsedType,
48                             detail::PropertyData>(0, 0, 0, 1, 0);
49   return totalSizeToAlloc<ArgsUnion, detail::AvailabilityData,
50                           detail::TypeTagForDatatypeData, ParsedType,
51                           detail::PropertyData>(NumArgs, 0, 0, 0, 0);
52 }
53 
54 AttributeFactory::AttributeFactory() {
55   // Go ahead and configure all the inline capacity.  This is just a memset.
56   FreeLists.resize(InlineFreeListsCapacity);
57 }
58 AttributeFactory::~AttributeFactory() = default;
59 
60 static size_t getFreeListIndexForSize(size_t size) {
61   assert(size >= sizeof(ParsedAttr));
62   assert((size % sizeof(void*)) == 0);
63   return ((size - sizeof(ParsedAttr)) / sizeof(void *));
64 }
65 
66 void *AttributeFactory::allocate(size_t size) {
67   // Check for a previously reclaimed attribute.
68   size_t index = getFreeListIndexForSize(size);
69   if (index < FreeLists.size() && !FreeLists[index].empty()) {
70     ParsedAttr *attr = FreeLists[index].back();
71     FreeLists[index].pop_back();
72     return attr;
73   }
74 
75   // Otherwise, allocate something new.
76   return Alloc.Allocate(size, alignof(AttributeFactory));
77 }
78 
79 void AttributeFactory::deallocate(ParsedAttr *Attr) {
80   size_t size = Attr->allocated_size();
81   size_t freeListIndex = getFreeListIndexForSize(size);
82 
83   // Expand FreeLists to the appropriate size, if required.
84   if (freeListIndex >= FreeLists.size())
85     FreeLists.resize(freeListIndex + 1);
86 
87 #ifndef NDEBUG
88   // In debug mode, zero out the attribute to help find memory overwriting.
89   memset(Attr, 0, size);
90 #endif
91 
92   // Add 'Attr' to the appropriate free-list.
93   FreeLists[freeListIndex].push_back(Attr);
94 }
95 
96 void AttributeFactory::reclaimPool(AttributePool &cur) {
97   for (ParsedAttr *AL : cur.Attrs)
98     deallocate(AL);
99 }
100 
101 void AttributePool::takePool(AttributePool &pool) {
102   Attrs.insert(Attrs.end(), pool.Attrs.begin(), pool.Attrs.end());
103   pool.Attrs.clear();
104 }
105 
106 namespace {
107 
108 #include "clang/Sema/AttrParsedAttrImpl.inc"
109 
110 } // namespace
111 
112 const ParsedAttrInfo &ParsedAttrInfo::get(const AttributeCommonInfo &A) {
113   // If we have a ParsedAttrInfo for this ParsedAttr then return that.
114   if ((size_t)A.getParsedKind() < llvm::array_lengthof(AttrInfoMap))
115     return *AttrInfoMap[A.getParsedKind()];
116 
117   // If this is an ignored attribute then return an appropriate ParsedAttrInfo.
118   static const ParsedAttrInfo IgnoredParsedAttrInfo(
119       AttributeCommonInfo::IgnoredAttribute);
120   if (A.getParsedKind() == AttributeCommonInfo::IgnoredAttribute)
121     return IgnoredParsedAttrInfo;
122 
123   // Otherwise this may be an attribute defined by a plugin. First instantiate
124   // all plugin attributes if we haven't already done so.
125   static llvm::ManagedStatic<std::list<std::unique_ptr<ParsedAttrInfo>>>
126       PluginAttrInstances;
127   if (PluginAttrInstances->empty())
128     for (auto It : ParsedAttrInfoRegistry::entries())
129       PluginAttrInstances->emplace_back(It.instantiate());
130 
131   // Search for a ParsedAttrInfo whose name and syntax match.
132   std::string FullName = A.getNormalizedFullName();
133   AttributeCommonInfo::Syntax SyntaxUsed = A.getSyntax();
134   if (SyntaxUsed == AttributeCommonInfo::AS_ContextSensitiveKeyword)
135     SyntaxUsed = AttributeCommonInfo::AS_Keyword;
136 
137   for (auto &Ptr : *PluginAttrInstances)
138     for (auto &S : Ptr->Spellings)
139       if (S.Syntax == SyntaxUsed && S.NormalizedFullName == FullName)
140         return *Ptr;
141 
142   // If we failed to find a match then return a default ParsedAttrInfo.
143   static const ParsedAttrInfo DefaultParsedAttrInfo(
144       AttributeCommonInfo::UnknownAttribute);
145   return DefaultParsedAttrInfo;
146 }
147 
148 unsigned ParsedAttr::getMinArgs() const { return getInfo().NumArgs; }
149 
150 unsigned ParsedAttr::getMaxArgs() const {
151   return getMinArgs() + getInfo().OptArgs;
152 }
153 
154 bool ParsedAttr::hasCustomParsing() const {
155   return getInfo().HasCustomParsing;
156 }
157 
158 bool ParsedAttr::diagnoseAppertainsTo(Sema &S, const Decl *D) const {
159   return getInfo().diagAppertainsToDecl(S, *this, D);
160 }
161 
162 bool ParsedAttr::diagnoseAppertainsTo(Sema &S, const Stmt *St) const {
163   return getInfo().diagAppertainsToStmt(S, *this, St);
164 }
165 
166 bool ParsedAttr::appliesToDecl(const Decl *D,
167                                attr::SubjectMatchRule MatchRule) const {
168   return checkAttributeMatchRuleAppliesTo(D, MatchRule);
169 }
170 
171 void ParsedAttr::getMatchRules(
172     const LangOptions &LangOpts,
173     SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules)
174     const {
175   return getInfo().getPragmaAttributeMatchRules(MatchRules, LangOpts);
176 }
177 
178 bool ParsedAttr::diagnoseLangOpts(Sema &S) const {
179   return getInfo().diagLangOpts(S, *this);
180 }
181 
182 bool ParsedAttr::isTargetSpecificAttr() const {
183   return getInfo().IsTargetSpecific;
184 }
185 
186 bool ParsedAttr::isTypeAttr() const { return getInfo().IsType; }
187 
188 bool ParsedAttr::isStmtAttr() const { return getInfo().IsStmt; }
189 
190 bool ParsedAttr::existsInTarget(const TargetInfo &Target) const {
191   return getInfo().existsInTarget(Target);
192 }
193 
194 bool ParsedAttr::isKnownToGCC() const { return getInfo().IsKnownToGCC; }
195 
196 bool ParsedAttr::isSupportedByPragmaAttribute() const {
197   return getInfo().IsSupportedByPragmaAttribute;
198 }
199 
200 unsigned ParsedAttr::getSemanticSpelling() const {
201   return getInfo().spellingIndexToSemanticSpelling(*this);
202 }
203 
204 bool ParsedAttr::hasVariadicArg() const {
205   // If the attribute has the maximum number of optional arguments, we will
206   // claim that as being variadic. If we someday get an attribute that
207   // legitimately bumps up against that maximum, we can use another bit to track
208   // whether it's truly variadic or not.
209   return getInfo().OptArgs == 15;
210 }
211 
212 static unsigned getNumAttributeArgs(const ParsedAttr &AL) {
213   // FIXME: Include the type in the argument list.
214   return AL.getNumArgs() + AL.hasParsedType();
215 }
216 
217 template <typename Compare>
218 static bool checkAttributeNumArgsImpl(Sema &S, const ParsedAttr &AL,
219                                       unsigned Num, unsigned Diag,
220                                       Compare Comp) {
221   if (Comp(getNumAttributeArgs(AL), Num)) {
222     S.Diag(AL.getLoc(), Diag) << AL << Num;
223     return false;
224   }
225   return true;
226 }
227 
228 bool ParsedAttr::checkExactlyNumArgs(Sema &S, unsigned Num) const {
229   return checkAttributeNumArgsImpl(S, *this, Num,
230                                    diag::err_attribute_wrong_number_arguments,
231                                    std::not_equal_to<unsigned>());
232 }
233 bool ParsedAttr::checkAtLeastNumArgs(Sema &S, unsigned Num) const {
234   return checkAttributeNumArgsImpl(S, *this, Num,
235                                    diag::err_attribute_too_few_arguments,
236                                    std::less<unsigned>());
237 }
238 bool ParsedAttr::checkAtMostNumArgs(Sema &S, unsigned Num) const {
239   return checkAttributeNumArgsImpl(S, *this, Num,
240                                    diag::err_attribute_too_many_arguments,
241                                    std::greater<unsigned>());
242 }
243