Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 1 | //======- ParsedAttr.cpp --------------------------------------------------===// |
Steve Naroff | b8371e1 | 2007-06-09 03:39:29 +0000 | [diff] [blame] | 2 | // |
Chandler Carruth | 2946cd7 | 2019-01-19 08:50:56 +0000 | [diff] [blame] | 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 |
Steve Naroff | b8371e1 | 2007-06-09 03:39:29 +0000 | [diff] [blame] | 6 | // |
| 7 | //===----------------------------------------------------------------------===// |
| 8 | // |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 9 | // This file defines the ParsedAttr class implementation |
Steve Naroff | b8371e1 | 2007-06-09 03:39:29 +0000 | [diff] [blame] | 10 | // |
| 11 | //===----------------------------------------------------------------------===// |
| 12 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 13 | #include "clang/Sema/ParsedAttr.h" |
Benjamin Kramer | 1ea8e09 | 2012-07-04 17:04:04 +0000 | [diff] [blame] | 14 | #include "clang/AST/ASTContext.h" |
Alex Lorenz | 9e7bf16 | 2017-04-18 14:33:39 +0000 | [diff] [blame] | 15 | #include "clang/Basic/AttrSubjectMatchRules.h" |
Chris Lattner | 7e0fe44 | 2009-04-11 18:48:18 +0000 | [diff] [blame] | 16 | #include "clang/Basic/IdentifierTable.h" |
Bob Wilson | 7c73083 | 2015-07-20 22:57:31 +0000 | [diff] [blame] | 17 | #include "clang/Basic/TargetInfo.h" |
Chandler Carruth | 5553d0d | 2014-01-07 11:51:46 +0000 | [diff] [blame] | 18 | #include "clang/Sema/SemaInternal.h" |
Richard Smith | 84837d5 | 2012-05-03 18:27:39 +0000 | [diff] [blame] | 19 | #include "llvm/ADT/SmallString.h" |
Eugene Zelenko | 711964d | 2018-02-20 02:16:28 +0000 | [diff] [blame] | 20 | #include "llvm/ADT/SmallVector.h" |
| 21 | #include "llvm/ADT/StringRef.h" |
| 22 | #include <cassert> |
| 23 | #include <cstddef> |
| 24 | #include <utility> |
| 25 | |
Steve Naroff | b8371e1 | 2007-06-09 03:39:29 +0000 | [diff] [blame] | 26 | using namespace clang; |
| 27 | |
Richard Smith | feefaf5 | 2013-09-03 18:01:40 +0000 | [diff] [blame] | 28 | IdentifierLoc *IdentifierLoc::create(ASTContext &Ctx, SourceLocation Loc, |
| 29 | IdentifierInfo *Ident) { |
| 30 | IdentifierLoc *Result = new (Ctx) IdentifierLoc; |
| 31 | Result->Loc = Loc; |
| 32 | Result->Ident = Ident; |
| 33 | return Result; |
| 34 | } |
| 35 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 36 | size_t ParsedAttr::allocated_size() const { |
John McCall | 084e83d | 2011-03-24 11:26:52 +0000 | [diff] [blame] | 37 | if (IsAvailability) return AttributeFactory::AvailabilityAllocSize; |
Dmitri Gribenko | e4a5a90 | 2012-08-17 00:08:38 +0000 | [diff] [blame] | 38 | else if (IsTypeTagForDatatype) |
| 39 | return AttributeFactory::TypeTagForDatatypeAllocSize; |
John McCall | 5e77d76 | 2013-04-16 07:28:30 +0000 | [diff] [blame] | 40 | else if (IsProperty) |
| 41 | return AttributeFactory::PropertyAllocSize; |
Erich Keane | 87cfcfd | 2018-06-22 17:34:44 +0000 | [diff] [blame] | 42 | else if (HasParsedType) |
Erich Keane | 03406c5 | 2018-08-09 20:25:12 +0000 | [diff] [blame] | 43 | return totalSizeToAlloc<ArgsUnion, detail::AvailabilityData, |
| 44 | detail::TypeTagForDatatypeData, ParsedType, |
| 45 | detail::PropertyData>(0, 0, 0, 1, 0); |
| 46 | return totalSizeToAlloc<ArgsUnion, detail::AvailabilityData, |
| 47 | detail::TypeTagForDatatypeData, ParsedType, |
| 48 | detail::PropertyData>(NumArgs, 0, 0, 0, 0); |
Steve Naroff | b8371e1 | 2007-06-09 03:39:29 +0000 | [diff] [blame] | 49 | } |
Chris Lattner | f18c743 | 2008-02-20 23:14:47 +0000 | [diff] [blame] | 50 | |
John McCall | 084e83d | 2011-03-24 11:26:52 +0000 | [diff] [blame] | 51 | AttributeFactory::AttributeFactory() { |
| 52 | // Go ahead and configure all the inline capacity. This is just a memset. |
| 53 | FreeLists.resize(InlineFreeListsCapacity); |
| 54 | } |
Eugene Zelenko | 711964d | 2018-02-20 02:16:28 +0000 | [diff] [blame] | 55 | AttributeFactory::~AttributeFactory() = default; |
John McCall | 084e83d | 2011-03-24 11:26:52 +0000 | [diff] [blame] | 56 | |
| 57 | static size_t getFreeListIndexForSize(size_t size) { |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 58 | assert(size >= sizeof(ParsedAttr)); |
John McCall | 084e83d | 2011-03-24 11:26:52 +0000 | [diff] [blame] | 59 | assert((size % sizeof(void*)) == 0); |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 60 | return ((size - sizeof(ParsedAttr)) / sizeof(void *)); |
John McCall | 084e83d | 2011-03-24 11:26:52 +0000 | [diff] [blame] | 61 | } |
| 62 | |
| 63 | void *AttributeFactory::allocate(size_t size) { |
| 64 | // Check for a previously reclaimed attribute. |
| 65 | size_t index = getFreeListIndexForSize(size); |
Erich Keane | c480f30 | 2018-07-12 21:09:05 +0000 | [diff] [blame] | 66 | if (index < FreeLists.size() && !FreeLists[index].empty()) { |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 67 | ParsedAttr *attr = FreeLists[index].back(); |
Erich Keane | c480f30 | 2018-07-12 21:09:05 +0000 | [diff] [blame] | 68 | FreeLists[index].pop_back(); |
| 69 | return attr; |
John McCall | 084e83d | 2011-03-24 11:26:52 +0000 | [diff] [blame] | 70 | } |
| 71 | |
| 72 | // Otherwise, allocate something new. |
Benjamin Kramer | c3f8925 | 2016-10-20 14:27:22 +0000 | [diff] [blame] | 73 | return Alloc.Allocate(size, alignof(AttributeFactory)); |
John McCall | 084e83d | 2011-03-24 11:26:52 +0000 | [diff] [blame] | 74 | } |
| 75 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 76 | void AttributeFactory::deallocate(ParsedAttr *Attr) { |
Erich Keane | c480f30 | 2018-07-12 21:09:05 +0000 | [diff] [blame] | 77 | size_t size = Attr->allocated_size(); |
| 78 | size_t freeListIndex = getFreeListIndexForSize(size); |
John McCall | 084e83d | 2011-03-24 11:26:52 +0000 | [diff] [blame] | 79 | |
Erich Keane | c480f30 | 2018-07-12 21:09:05 +0000 | [diff] [blame] | 80 | // Expand FreeLists to the appropriate size, if required. |
| 81 | if (freeListIndex >= FreeLists.size()) |
| 82 | FreeLists.resize(freeListIndex + 1); |
John McCall | 084e83d | 2011-03-24 11:26:52 +0000 | [diff] [blame] | 83 | |
Sven van Haastregt | 7b39a08 | 2018-09-24 12:12:03 +0000 | [diff] [blame] | 84 | #ifndef NDEBUG |
Erich Keane | c480f30 | 2018-07-12 21:09:05 +0000 | [diff] [blame] | 85 | // In debug mode, zero out the attribute to help find memory overwriting. |
| 86 | memset(Attr, 0, size); |
| 87 | #endif |
John McCall | 084e83d | 2011-03-24 11:26:52 +0000 | [diff] [blame] | 88 | |
Erich Keane | c480f30 | 2018-07-12 21:09:05 +0000 | [diff] [blame] | 89 | // Add 'Attr' to the appropriate free-list. |
| 90 | FreeLists[freeListIndex].push_back(Attr); |
John McCall | 084e83d | 2011-03-24 11:26:52 +0000 | [diff] [blame] | 91 | } |
| 92 | |
Erich Keane | c480f30 | 2018-07-12 21:09:05 +0000 | [diff] [blame] | 93 | void AttributeFactory::reclaimPool(AttributePool &cur) { |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 94 | for (ParsedAttr *AL : cur.Attrs) |
Erich Keane | c480f30 | 2018-07-12 21:09:05 +0000 | [diff] [blame] | 95 | deallocate(AL); |
| 96 | } |
John McCall | 084e83d | 2011-03-24 11:26:52 +0000 | [diff] [blame] | 97 | |
Erich Keane | c480f30 | 2018-07-12 21:09:05 +0000 | [diff] [blame] | 98 | void AttributePool::takePool(AttributePool &pool) { |
| 99 | Attrs.insert(Attrs.end(), pool.Attrs.begin(), pool.Attrs.end()); |
| 100 | pool.Attrs.clear(); |
John McCall | 084e83d | 2011-03-24 11:26:52 +0000 | [diff] [blame] | 101 | } |
| 102 | |
Douglas Gregor | 377f99b | 2012-05-02 17:33:51 +0000 | [diff] [blame] | 103 | #include "clang/Sema/AttrParsedAttrKinds.inc" |
| 104 | |
Aaron Ballman | ad672ff | 2018-10-24 12:26:23 +0000 | [diff] [blame] | 105 | static StringRef normalizeAttrScopeName(StringRef ScopeName, |
| 106 | ParsedAttr::Syntax SyntaxUsed) { |
Aaron Ballman | c44c1742 | 2018-11-09 17:19:45 +0000 | [diff] [blame] | 107 | // Normalize the "__gnu__" scope name to be "gnu" and the "_Clang" scope name |
| 108 | // to be "clang". |
| 109 | if (SyntaxUsed == ParsedAttr::AS_CXX11 || |
| 110 | SyntaxUsed == ParsedAttr::AS_C2x) { |
| 111 | if (ScopeName == "__gnu__") |
| 112 | ScopeName = "gnu"; |
| 113 | else if (ScopeName == "_Clang") |
| 114 | ScopeName = "clang"; |
| 115 | } |
Aaron Ballman | ad672ff | 2018-10-24 12:26:23 +0000 | [diff] [blame] | 116 | return ScopeName; |
| 117 | } |
| 118 | |
| 119 | static StringRef normalizeAttrName(StringRef AttrName, |
| 120 | StringRef NormalizedScopeName, |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 121 | ParsedAttr::Syntax SyntaxUsed) { |
David Majnemer | a94e7b6 | 2015-08-25 16:44:38 +0000 | [diff] [blame] | 122 | // Normalize the attribute name, __foo__ becomes foo. This is only allowable |
Aaron Ballman | ad672ff | 2018-10-24 12:26:23 +0000 | [diff] [blame] | 123 | // for GNU attributes, and attributes using the double square bracket syntax. |
Aaron Ballman | ac77dcd | 2018-11-09 19:37:18 +0000 | [diff] [blame] | 124 | bool ShouldNormalize = |
| 125 | SyntaxUsed == ParsedAttr::AS_GNU || |
| 126 | ((SyntaxUsed == ParsedAttr::AS_CXX11 || |
| 127 | SyntaxUsed == ParsedAttr::AS_C2x) && |
| 128 | (NormalizedScopeName == "gnu" || NormalizedScopeName == "clang")); |
| 129 | if (ShouldNormalize && AttrName.size() >= 4 && AttrName.startswith("__") && |
David Majnemer | a94e7b6 | 2015-08-25 16:44:38 +0000 | [diff] [blame] | 130 | AttrName.endswith("__")) |
| 131 | AttrName = AttrName.slice(2, AttrName.size() - 2); |
| 132 | |
| 133 | return AttrName; |
| 134 | } |
| 135 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 136 | ParsedAttr::Kind ParsedAttr::getKind(const IdentifierInfo *Name, |
| 137 | const IdentifierInfo *ScopeName, |
| 138 | Syntax SyntaxUsed) { |
Chris Lattner | 0e62c1c | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 139 | StringRef AttrName = Name->getName(); |
Chris Lattner | f18c743 | 2008-02-20 23:14:47 +0000 | [diff] [blame] | 140 | |
Aaron Ballman | c698809 | 2013-12-11 22:27:44 +0000 | [diff] [blame] | 141 | SmallString<64> FullName; |
Richard Smith | 84837d5 | 2012-05-03 18:27:39 +0000 | [diff] [blame] | 142 | if (ScopeName) |
Aaron Ballman | ad672ff | 2018-10-24 12:26:23 +0000 | [diff] [blame] | 143 | FullName += normalizeAttrScopeName(ScopeName->getName(), SyntaxUsed); |
Aaron Ballman | c698809 | 2013-12-11 22:27:44 +0000 | [diff] [blame] | 144 | |
David Majnemer | a94e7b6 | 2015-08-25 16:44:38 +0000 | [diff] [blame] | 145 | AttrName = normalizeAttrName(AttrName, FullName, SyntaxUsed); |
Aaron Ballman | c698809 | 2013-12-11 22:27:44 +0000 | [diff] [blame] | 146 | |
Alexis Hunt | a0e54d4 | 2012-06-18 16:13:52 +0000 | [diff] [blame] | 147 | // Ensure that in the case of C++11 attributes, we look for '::foo' if it is |
| 148 | // unscoped. |
Aaron Ballman | 606093a | 2017-10-15 15:01:42 +0000 | [diff] [blame] | 149 | if (ScopeName || SyntaxUsed == AS_CXX11 || SyntaxUsed == AS_C2x) |
Aaron Ballman | c698809 | 2013-12-11 22:27:44 +0000 | [diff] [blame] | 150 | FullName += "::"; |
| 151 | FullName += AttrName; |
Richard Smith | 84837d5 | 2012-05-03 18:27:39 +0000 | [diff] [blame] | 152 | |
Aaron Ballman | 09e98ff | 2014-01-13 21:42:39 +0000 | [diff] [blame] | 153 | return ::getAttrKind(FullName, SyntaxUsed); |
Chris Lattner | f18c743 | 2008-02-20 23:14:47 +0000 | [diff] [blame] | 154 | } |
Michael Han | 9931593 | 2013-01-24 16:46:58 +0000 | [diff] [blame] | 155 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 156 | unsigned ParsedAttr::getAttributeSpellingListIndex() const { |
Michael Han | 9931593 | 2013-01-24 16:46:58 +0000 | [diff] [blame] | 157 | // Both variables will be used in tablegen generated |
| 158 | // attribute spell list index matching code. |
Aaron Ballman | ad672ff | 2018-10-24 12:26:23 +0000 | [diff] [blame] | 159 | auto Syntax = static_cast<ParsedAttr::Syntax>(SyntaxUsed); |
| 160 | StringRef Scope = |
| 161 | ScopeName ? normalizeAttrScopeName(ScopeName->getName(), Syntax) : ""; |
| 162 | StringRef Name = normalizeAttrName(AttrName->getName(), Scope, Syntax); |
Michael Han | 9931593 | 2013-01-24 16:46:58 +0000 | [diff] [blame] | 163 | |
| 164 | #include "clang/Sema/AttrSpellingListIndex.inc" |
| 165 | |
| 166 | } |
| 167 | |
Aaron Ballman | 8ee40b7 | 2013-09-09 23:33:17 +0000 | [diff] [blame] | 168 | struct ParsedAttrInfo { |
| 169 | unsigned NumArgs : 4; |
| 170 | unsigned OptArgs : 4; |
| 171 | unsigned HasCustomParsing : 1; |
Aaron Ballman | ab7691c | 2014-01-09 22:48:32 +0000 | [diff] [blame] | 172 | unsigned IsTargetSpecific : 1; |
| 173 | unsigned IsType : 1; |
Richard Smith | 4f902c7 | 2016-03-08 00:32:55 +0000 | [diff] [blame] | 174 | unsigned IsStmt : 1; |
Aaron Ballman | c669cc0 | 2014-01-27 22:10:04 +0000 | [diff] [blame] | 175 | unsigned IsKnownToGCC : 1; |
Alex Lorenz | 9e7bf16 | 2017-04-18 14:33:39 +0000 | [diff] [blame] | 176 | unsigned IsSupportedByPragmaAttribute : 1; |
Aaron Ballman | 74eeeae | 2013-11-27 13:27:02 +0000 | [diff] [blame] | 177 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 178 | bool (*DiagAppertainsToDecl)(Sema &S, const ParsedAttr &Attr, const Decl *); |
| 179 | bool (*DiagLangOpts)(Sema &S, const ParsedAttr &Attr); |
Bob Wilson | 7c73083 | 2015-07-20 22:57:31 +0000 | [diff] [blame] | 180 | bool (*ExistsInTarget)(const TargetInfo &Target); |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 181 | unsigned (*SpellingIndexToSemanticSpelling)(const ParsedAttr &Attr); |
Alex Lorenz | 9e7bf16 | 2017-04-18 14:33:39 +0000 | [diff] [blame] | 182 | void (*GetPragmaAttributeMatchRules)( |
| 183 | llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &Rules, |
| 184 | const LangOptions &LangOpts); |
Aaron Ballman | 8ee40b7 | 2013-09-09 23:33:17 +0000 | [diff] [blame] | 185 | }; |
| 186 | |
| 187 | namespace { |
Eugene Zelenko | 711964d | 2018-02-20 02:16:28 +0000 | [diff] [blame] | 188 | |
| 189 | #include "clang/Sema/AttrParsedAttrImpl.inc" |
| 190 | |
| 191 | } // namespace |
Aaron Ballman | 8ee40b7 | 2013-09-09 23:33:17 +0000 | [diff] [blame] | 192 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 193 | static const ParsedAttrInfo &getInfo(const ParsedAttr &A) { |
Aaron Ballman | 8ee40b7 | 2013-09-09 23:33:17 +0000 | [diff] [blame] | 194 | return AttrInfoMap[A.getKind()]; |
| 195 | } |
| 196 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 197 | unsigned ParsedAttr::getMinArgs() const { return getInfo(*this).NumArgs; } |
Aaron Ballman | 8ee40b7 | 2013-09-09 23:33:17 +0000 | [diff] [blame] | 198 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 199 | unsigned ParsedAttr::getMaxArgs() const { |
Aaron Ballman | 8ee40b7 | 2013-09-09 23:33:17 +0000 | [diff] [blame] | 200 | return getMinArgs() + getInfo(*this).OptArgs; |
| 201 | } |
| 202 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 203 | bool ParsedAttr::hasCustomParsing() const { |
Aaron Ballman | 8ee40b7 | 2013-09-09 23:33:17 +0000 | [diff] [blame] | 204 | return getInfo(*this).HasCustomParsing; |
| 205 | } |
Aaron Ballman | 74eeeae | 2013-11-27 13:27:02 +0000 | [diff] [blame] | 206 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 207 | bool ParsedAttr::diagnoseAppertainsTo(Sema &S, const Decl *D) const { |
Aaron Ballman | 74eeeae | 2013-11-27 13:27:02 +0000 | [diff] [blame] | 208 | return getInfo(*this).DiagAppertainsToDecl(S, *this, D); |
| 209 | } |
Aaron Ballman | 3aff633 | 2013-12-02 19:30:36 +0000 | [diff] [blame] | 210 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 211 | bool ParsedAttr::appliesToDecl(const Decl *D, |
| 212 | attr::SubjectMatchRule MatchRule) const { |
Alex Lorenz | 9e7bf16 | 2017-04-18 14:33:39 +0000 | [diff] [blame] | 213 | return checkAttributeMatchRuleAppliesTo(D, MatchRule); |
| 214 | } |
| 215 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 216 | void ParsedAttr::getMatchRules( |
Alex Lorenz | 9e7bf16 | 2017-04-18 14:33:39 +0000 | [diff] [blame] | 217 | const LangOptions &LangOpts, |
| 218 | SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules) |
| 219 | const { |
| 220 | return getInfo(*this).GetPragmaAttributeMatchRules(MatchRules, LangOpts); |
| 221 | } |
| 222 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 223 | bool ParsedAttr::diagnoseLangOpts(Sema &S) const { |
Aaron Ballman | 3aff633 | 2013-12-02 19:30:36 +0000 | [diff] [blame] | 224 | return getInfo(*this).DiagLangOpts(S, *this); |
| 225 | } |
Aaron Ballman | ab7691c | 2014-01-09 22:48:32 +0000 | [diff] [blame] | 226 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 227 | bool ParsedAttr::isTargetSpecificAttr() const { |
Aaron Ballman | ab7691c | 2014-01-09 22:48:32 +0000 | [diff] [blame] | 228 | return getInfo(*this).IsTargetSpecific; |
| 229 | } |
| 230 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 231 | bool ParsedAttr::isTypeAttr() const { return getInfo(*this).IsType; } |
Aaron Ballman | ab7691c | 2014-01-09 22:48:32 +0000 | [diff] [blame] | 232 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 233 | bool ParsedAttr::isStmtAttr() const { return getInfo(*this).IsStmt; } |
Richard Smith | 4f902c7 | 2016-03-08 00:32:55 +0000 | [diff] [blame] | 234 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 235 | bool ParsedAttr::existsInTarget(const TargetInfo &Target) const { |
Bob Wilson | 7c73083 | 2015-07-20 22:57:31 +0000 | [diff] [blame] | 236 | return getInfo(*this).ExistsInTarget(Target); |
Aaron Ballman | ab7691c | 2014-01-09 22:48:32 +0000 | [diff] [blame] | 237 | } |
Aaron Ballman | 9a99e0d | 2014-01-20 17:18:35 +0000 | [diff] [blame] | 238 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 239 | bool ParsedAttr::isKnownToGCC() const { return getInfo(*this).IsKnownToGCC; } |
Aaron Ballman | 81cb8cb | 2014-01-24 21:32:49 +0000 | [diff] [blame] | 240 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 241 | bool ParsedAttr::isSupportedByPragmaAttribute() const { |
Alex Lorenz | 9e7bf16 | 2017-04-18 14:33:39 +0000 | [diff] [blame] | 242 | return getInfo(*this).IsSupportedByPragmaAttribute; |
| 243 | } |
| 244 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 245 | unsigned ParsedAttr::getSemanticSpelling() const { |
Aaron Ballman | 81cb8cb | 2014-01-24 21:32:49 +0000 | [diff] [blame] | 246 | return getInfo(*this).SpellingIndexToSemanticSpelling(*this); |
| 247 | } |
Aaron Ballman | 8ed8dbd | 2014-07-31 16:37:04 +0000 | [diff] [blame] | 248 | |
Erich Keane | e891aa9 | 2018-07-13 15:07:47 +0000 | [diff] [blame] | 249 | bool ParsedAttr::hasVariadicArg() const { |
Aaron Ballman | 8ed8dbd | 2014-07-31 16:37:04 +0000 | [diff] [blame] | 250 | // If the attribute has the maximum number of optional arguments, we will |
| 251 | // claim that as being variadic. If we someday get an attribute that |
| 252 | // legitimately bumps up against that maximum, we can use another bit to track |
| 253 | // whether it's truly variadic or not. |
| 254 | return getInfo(*this).OptArgs == 15; |
| 255 | } |