Move ParsedAttrInfos into a registry and point to one in ParsedAttr

[john.brawn]

Summary

This allows plugins to define an attribute and its associated ParsedAttrInfo, though the attribute won't be able to do anything. Also we end up removing AttrKinds.inc as searching through the registry replaces it.

[sylvestre.ledru]

@john.brawn Are you still working on that? We would need this change at Mozilla to improve the way we use attributes.
Thanks

[john.brawn]

Resurrecting this old patch, with a bunch of changes due to the changes around AttributeCommonInfo. This is the second of four patches to make it possible for clang plugins to define attributes.

[john.brawn]

Updated to match latest changes to D31337.

[aaron.ballman]

clang/include/clang/Sema/ParsedAttr.h

45 ↗

(On Diff #239536)

Please add a full stop to the end of all the comments (here and elsewhere).

63 ↗

(On Diff #239536)

spelt -> spelled

615 ↗

(On Diff #239536)

I think this should return a const ParsedAttrInfo& so that callers don't try to mutate it.

clang/lib/Basic/Attributes.cpp

101–103 ↗

(On Diff #239536)

Range-based for loop? Also, it and ie don't meet the usual naming conventions.

One thing I'm not keen on with this is the performance hit. We spent a decent amount of effort making this lookup fast and it's now a linear search through all of the attributes and requires memory allocations and deallocations to perform the search.

113 ↗

(On Diff #239536)

This seems surprising because it makes it harder to determine whether you have a valid result from this function or not. I think this should return a null unique_ptr.

117 ↗

(On Diff #239536)

Same concerns in this function as above.

[john.brawn]

clang/lib/Basic/Attributes.cpp

101–103 ↗

(On Diff #239536)

Yes, I've done some experiments and in the pathological case (lots of trivial functions with the xray_log_args attribute) the slowdown is noticeable. I've done some tinkering and I think the best way to resolve this is to first use a generated function (i.e. something like the current getAttrKind) to look up the attributes that are compiled into clang, then if that fails look in the registry to find a match.

[aaron.ballman]

clang/lib/Basic/Attributes.cpp

101–103 ↗

(On Diff #239536)

I think that approach makes sense and is something we should probably do up front. It doesn't seem like llvm::Registry has a way for us to mark where the plugin attributes start to allow for quickly searching for plugin attributes in the fallback case.

I don't see a particularly good way around the memory allocations, however. Ideally, this could be something that's arena allocated on the ASTContext rather than using unique_ptr, but I think that would be tricky here because of library layering. After switching the lookup functionality, I'd be curious to know if there is a noticeable performance degredation still, or if that falls out into the noise.

[john.brawn]

This has been rewritten so that the registry is only used for attributes added by plugins, and everything else continues as before. This also removes the strange dependency I'd previously introduced, where Attributes.cpp (in libclangBasic.so) declared and used the registry but ParsedAttr.cpp (in libclangSema.so) populated it - now the registry is declared and used solely within ParsedAttr.cpp.

[aaron.ballman]

I like this approach much better, thank you for working on it! LGTM

clang/include/clang/Basic/AttributeCommonInfo.h

140 ↗

(On Diff #246763)

This should probably be getNormalizedFullName() -- the full by itself implies we don't normalize, to me.

clang/include/clang/Sema/ParsedAttr.h

66 ↗

(On Diff #246763)

NormalizedFullName?

include/clang/Sema/AttributeList.h

 
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/VersionTuple.h"
 #include "clang/Sema/Ownership.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Allocator.h"
+#include "llvm/Support/Registry.h"
 #include <cassert>
 
 namespace clang {
   class ASTContext;
   class IdentifierInfo;
   class Expr;
+  class Sema;
+  class AttributeList;
 
 /// \brief Represents information about a change in availability for
 /// an entity, which is part of the encoding of the 'availability'
 /// attribute.
 struct AvailabilityChange {
   /// \brief The location of the keyword indicating the kind of change.
   SourceLocation KeywordLoc;
 
static IdentifierLoc *create(ASTContext &Ctx, SourceLocation Loc,
                                IdentifierInfo *Ident);
 };
 
 /// \brief A union of the various pointer types that can be passed to an
 /// AttributeList as an argument.
 typedef llvm::PointerUnion<Expr*, IdentifierLoc*> ArgsUnion;
 typedef llvm::SmallVector<ArgsUnion, 12U> ArgsVector;
 
+struct ParsedAttrInfo {
+  /// Corresponds to the AttributeList::Kind enum
+  unsigned AttrKind : 16;
+  /// Corresponds to the AttributeList::Syntax enum
+  unsigned Syntax : 3;
+  /// The number of required arguments of this attribute
+  unsigned NumArgs : 4;
+  /// The number of optional arguments of this attributes
+  unsigned OptArgs : 4;
+  /// True if the parsing does not match the semantic content
+  unsigned HasCustomParsing : 1;
+  /// True if this attribute is only available for certain targets
+  unsigned IsTargetSpecific : 1;
+  /// True if this attribute applies to types
+  unsigned IsType : 1;
+  /// True if this attribute applies to statements
+  unsigned IsStmt : 1;
+  /// True if this attribute has any spellings that are known to gcc
+  unsigned IsKnownToGCC : 1;
+
+  ParsedAttrInfo()
+  : AttrKind(0), Syntax(0), NumArgs(0), OptArgs(0), HasCustomParsing(0),
+    IsTargetSpecific(0), IsType(0), IsStmt(0), IsKnownToGCC(0) { }
+
+  virtual ~ParsedAttrInfo() {}
+
+  /// Check if this attribute appertains to D, and issue a diagnostic if not
+  virtual bool diagAppertainsToDecl(Sema &S, const AttributeList &Attr,
+                                    const Decl *D) const {
+    return true;
+  }
+  /// Check if this attribute is allowed by the language we are compiling, and
+  /// issue a diagnostic if not
+  virtual bool diagLangOpts(Sema &S, const AttributeList &Attr) const {
+    return true;
+  }
+  /// Check if this attribute is allowed when compiling for the given target
+  virtual bool existsInTarget(const TargetInfo &Target) const {
+    return true;
+  }
+  /// Convert the spelling index of Attr to a semantic spelling enum value
+  virtual unsigned
+  spellingIndexToSemanticSpelling(const AttributeList &Attr) const {
+    return UINT_MAX;
+  }
+};
+
 /// AttributeList - Represents a syntactic attribute.
 ///
 /// For a GNU attribute, there are four forms of this construct:
 ///
 /// 1: __attribute__(( const )). ParmName/Args/NumArgs will all be unused.
 /// 2: __attribute__(( mode(byte) )). ParmName used, Args/NumArgs unused.
 /// 3: __attribute__(( format(printf, 1, 2) )). ParmName/Args/NumArgs all used.
 /// 4: __attribute__(( aligned(16) )). ParmName is unused, Args/Num used.

 
 private:
   IdentifierInfo *AttrName;
   IdentifierInfo *ScopeName;
   SourceRange AttrRange;
   SourceLocation ScopeLoc;
   SourceLocation EllipsisLoc;
 
-  unsigned AttrKind : 16;
+  std::unique_ptr<ParsedAttrInfo> Info;
 
   /// The number of expression arguments this attribute has.
   /// The expressions themselves are stored after the object.
   unsigned NumArgs : 16;
 
   /// Corresponds to the Syntax enum.
   unsigned SyntaxUsed : 3;
 
AttributeList(IdentifierInfo *attrName, SourceRange attrRange,
                 Syntax syntaxUsed, SourceLocation ellipsisLoc)
     : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
       ScopeLoc(scopeLoc), EllipsisLoc(ellipsisLoc), NumArgs(numArgs),
       SyntaxUsed(syntaxUsed), Invalid(false), UsedAsTypeAttr(false),
       IsAvailability(false), IsTypeTagForDatatype(false), IsProperty(false),
       HasParsedType(false), HasProcessingCache(false),
       NextInPosition(nullptr), NextInPool(nullptr) {
     if (numArgs) memcpy(getArgsBuffer(), args, numArgs * sizeof(ArgsUnion));
-    AttrKind = getKind(getName(), getScopeName(), syntaxUsed);
+    Info = getInfo(getName(), getScopeName(), syntaxUsed);
   }
 
   /// Constructor for availability attributes.
   AttributeList(IdentifierInfo *attrName, SourceRange attrRange,
                 IdentifierInfo *scopeName, SourceLocation scopeLoc,
                 IdentifierLoc *Parm, const AvailabilityChange &introduced,
                 const AvailabilityChange &deprecated,
                 const AvailabilityChange &obsoleted,
                 SourceLocation unavailable, 
                 const Expr *messageExpr,
                 Syntax syntaxUsed, SourceLocation strict,
                 const Expr *replacementExpr)
     : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
       ScopeLoc(scopeLoc), EllipsisLoc(), NumArgs(1), SyntaxUsed(syntaxUsed),
       Invalid(false), UsedAsTypeAttr(false), IsAvailability(true),
       IsTypeTagForDatatype(false), IsProperty(false), HasParsedType(false),
       HasProcessingCache(false), UnavailableLoc(unavailable),
       MessageExpr(messageExpr), NextInPosition(nullptr), NextInPool(nullptr) {
     ArgsUnion PVal(Parm);
     memcpy(getArgsBuffer(), &PVal, sizeof(ArgsUnion));
     new (getAvailabilityData()) AvailabilityData(
         introduced, deprecated, obsoleted, strict, replacementExpr);
-    AttrKind = getKind(getName(), getScopeName(), syntaxUsed);
+    Info = getInfo(getName(), getScopeName(), syntaxUsed);
   }
 
   /// Constructor for objc_bridge_related attributes.
   AttributeList(IdentifierInfo *attrName, SourceRange attrRange,
                 IdentifierInfo *scopeName, SourceLocation scopeLoc,
                 IdentifierLoc *Parm1,
                 IdentifierLoc *Parm2,
                 IdentifierLoc *Parm3,
                 Syntax syntaxUsed)
   : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
     ScopeLoc(scopeLoc), EllipsisLoc(), NumArgs(3), SyntaxUsed(syntaxUsed),
     Invalid(false), UsedAsTypeAttr(false), IsAvailability(false),
     IsTypeTagForDatatype(false), IsProperty(false), HasParsedType(false),
     HasProcessingCache(false), NextInPosition(nullptr), NextInPool(nullptr) {
     ArgsUnion *Args = getArgsBuffer();
     Args[0] = Parm1;
     Args[1] = Parm2;
     Args[2] = Parm3;
-    AttrKind = getKind(getName(), getScopeName(), syntaxUsed);
+    Info = getInfo(getName(), getScopeName(), syntaxUsed);
   }
   
   /// Constructor for type_tag_for_datatype attribute.
   AttributeList(IdentifierInfo *attrName, SourceRange attrRange,
                 IdentifierInfo *scopeName, SourceLocation scopeLoc,
                 IdentifierLoc *ArgKind, ParsedType matchingCType,
                 bool layoutCompatible, bool mustBeNull, Syntax syntaxUsed)
     : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
       ScopeLoc(scopeLoc), EllipsisLoc(), NumArgs(1), SyntaxUsed(syntaxUsed),
       Invalid(false), UsedAsTypeAttr(false), IsAvailability(false),
       IsTypeTagForDatatype(true), IsProperty(false), HasParsedType(false),
       HasProcessingCache(false), NextInPosition(nullptr), NextInPool(nullptr) {
     ArgsUnion PVal(ArgKind);
     memcpy(getArgsBuffer(), &PVal, sizeof(ArgsUnion));
     TypeTagForDatatypeData &ExtraData = getTypeTagForDatatypeDataSlot();
     new (&ExtraData.MatchingCType) ParsedType(matchingCType);
     ExtraData.LayoutCompatible = layoutCompatible;
     ExtraData.MustBeNull = mustBeNull;
-    AttrKind = getKind(getName(), getScopeName(), syntaxUsed);
+    Info = getInfo(getName(), getScopeName(), syntaxUsed);
   }
 
   /// Constructor for attributes with a single type argument.
   AttributeList(IdentifierInfo *attrName, SourceRange attrRange,
                 IdentifierInfo *scopeName, SourceLocation scopeLoc,
                 ParsedType typeArg, Syntax syntaxUsed)
       : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
         ScopeLoc(scopeLoc), EllipsisLoc(), NumArgs(0), SyntaxUsed(syntaxUsed),
         Invalid(false), UsedAsTypeAttr(false), IsAvailability(false),
         IsTypeTagForDatatype(false), IsProperty(false), HasParsedType(true),
         HasProcessingCache(false), NextInPosition(nullptr), NextInPool(nullptr){
     new (&getTypeBuffer()) ParsedType(typeArg);
-    AttrKind = getKind(getName(), getScopeName(), syntaxUsed);
+    Info = getInfo(getName(), getScopeName(), syntaxUsed);
   }
 
   /// Constructor for microsoft __declspec(property) attribute.
   AttributeList(IdentifierInfo *attrName, SourceRange attrRange,
                 IdentifierInfo *scopeName, SourceLocation scopeLoc,
                 IdentifierInfo *getterId, IdentifierInfo *setterId,
                 Syntax syntaxUsed)
     : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
       ScopeLoc(scopeLoc), EllipsisLoc(), NumArgs(0), SyntaxUsed(syntaxUsed),
       Invalid(false), UsedAsTypeAttr(false), IsAvailability(false),
       IsTypeTagForDatatype(false), IsProperty(true), HasParsedType(false),
       HasProcessingCache(false), NextInPosition(nullptr), NextInPool(nullptr) {
     new (&getPropertyDataBuffer()) PropertyData(getterId, setterId);
-    AttrKind = getKind(getName(), getScopeName(), syntaxUsed);
+    Info = getInfo(getName(), getScopeName(), syntaxUsed);
   }
 
   friend class AttributePool;
   friend class AttributeFactory;
 
 public:
   enum Kind {           
     #define PARSED_ATTR(NAME) AT_##NAME,
public:
   }
 
   bool isUsedAsTypeAttr() const { return UsedAsTypeAttr; }
   void setUsedAsTypeAttr() { UsedAsTypeAttr = true; }
 
   bool isPackExpansion() const { return EllipsisLoc.isValid(); }
   SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
 
-  Kind getKind() const { return Kind(AttrKind); }
-  static Kind getKind(const IdentifierInfo *Name, const IdentifierInfo *Scope,
-                      Syntax SyntaxUsed);
+  const std::unique_ptr<ParsedAttrInfo> &getInfo() const { return Info; }
+  static std::unique_ptr<ParsedAttrInfo> getInfo(const IdentifierInfo *Name,
+      const IdentifierInfo *ScopeName, Syntax SyntaxUsed);
+
+  Kind getKind() const { return Kind(Info->AttrKind); }
 
   AttributeList *getNext() const { return NextInPosition; }
   void setNext(AttributeList *N) { NextInPosition = N; }
 
   /// getNumArgs - Return the number of actual arguments to this attribute.
   unsigned getNumArgs() const { return NumArgs; }
 
   /// getArg - Return the specified argument.
enum AttributeDeclKind {
   ExpectedVariableEnumFieldOrTypedef,
   ExpectedFunctionMethodEnumOrClass,
   ExpectedStructClassVariableFunctionOrInlineNamespace,
   ExpectedForMaybeUnused,
   ExpectedEnumOrClass,
   ExpectedNamedDecl,
 };
 
+typedef llvm::Registry<ParsedAttrInfo> AttrInfoRegistry;
+
 }  // end namespace clang
 
 #endif

include/clang/Sema/CMakeLists.txt

 clang_tablegen(AttrTemplateInstantiate.inc -gen-clang-attr-template-instantiate
   -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
   SOURCE ../Basic/Attr.td
   TARGET ClangAttrTemplateInstantiate)
   
 clang_tablegen(AttrParsedAttrList.inc -gen-clang-attr-parsed-attr-list
   -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
   SOURCE ../Basic/Attr.td
   TARGET ClangAttrParsedAttrList)
 
-clang_tablegen(AttrParsedAttrKinds.inc -gen-clang-attr-parsed-attr-kinds
-  -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
-  SOURCE ../Basic/Attr.td
-  TARGET ClangAttrParsedAttrKinds)
-
 clang_tablegen(AttrSpellingListIndex.inc -gen-clang-attr-spelling-index
   -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
   SOURCE ../Basic/Attr.td
   TARGET ClangAttrSpellingListIndex)
 
 clang_tablegen(AttrParsedAttrImpl.inc -gen-clang-attr-parsed-attr-impl
   -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
   SOURCE ../Basic/Attr.td
   TARGET ClangAttrParsedAttrImpl)

lib/Parse/ParseDecl.cpp

 
 unsigned Parser::ParseAttributeArgsCommon(
     IdentifierInfo *AttrName, SourceLocation AttrNameLoc,
     ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
     SourceLocation ScopeLoc, AttributeList::Syntax Syntax) {
   // Ignore the left paren location for now.
   ConsumeParen();
 
+  std::unique_ptr<ParsedAttrInfo> Info =
+      AttributeList::getInfo(AttrName, ScopeName, Syntax);
+
   ArgsVector ArgExprs;
   if (Tok.is(tok::identifier)) {
     // If this attribute wants an 'identifier' argument, make it so.
     bool IsIdentifierArg = attributeHasIdentifierArg(*AttrName);
-    AttributeList::Kind AttrKind =
-        AttributeList::getKind(AttrName, ScopeName, Syntax);
+    AttributeList::Kind AttrKind = AttributeList::Kind(Info->AttrKind);
 
     // If we don't know how to parse this attribute, but this is the only
     // token in this argument, assume it's meant to be an identifier.
     if (AttrKind == AttributeList::UnknownAttribute ||
         AttrKind == AttributeList::IgnoredAttribute) {
       const Token &Next = NextToken();
       IsIdentifierArg = Next.isOneOf(tok::r_paren, tok::comma);
     }
void Parser::ParseGNUAttributeArgs(IdentifierInfo *AttrName,
                                    SourceLocation *EndLoc,
                                    IdentifierInfo *ScopeName,
                                    SourceLocation ScopeLoc,
                                    AttributeList::Syntax Syntax,
                                    Declarator *D) {
 
   assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
 
-  AttributeList::Kind AttrKind =
-      AttributeList::getKind(AttrName, ScopeName, Syntax);
+  std::unique_ptr<ParsedAttrInfo> Info =
+      AttributeList::getInfo(AttrName, ScopeName, Syntax);
+  AttributeList::Kind AttrKind = AttributeList::Kind(Info->AttrKind);
 
   if (AttrKind == AttributeList::AT_Availability) {
     ParseAvailabilityAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
                                ScopeLoc, Syntax);
     return;
   } else if (AttrKind == AttributeList::AT_ExternalSourceSymbol) {
     ParseExternalSourceSymbolAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
                                        ScopeName, ScopeLoc, Syntax);

 }
 
 unsigned Parser::ParseClangAttributeArgs(
     IdentifierInfo *AttrName, SourceLocation AttrNameLoc,
     ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
     SourceLocation ScopeLoc, AttributeList::Syntax Syntax) {
   assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
 
-  AttributeList::Kind AttrKind =
-      AttributeList::getKind(AttrName, ScopeName, Syntax);
+  std::unique_ptr<ParsedAttrInfo> Info =
+      AttributeList::getInfo(AttrName, ScopeName, Syntax);
+  AttributeList::Kind AttrKind = AttributeList::Kind(Info->AttrKind);
 
   if (AttrKind == AttributeList::AT_ExternalSourceSymbol) {
     ParseExternalSourceSymbolAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
                                        ScopeName, ScopeLoc, Syntax);
     return Attrs.getList() ? Attrs.getList()->getNumArgs() : 0;
   }
 
   return ParseAttributeArgsCommon(AttrName, AttrNameLoc, Attrs, EndLoc,

lib/Parse/ParseDeclCXX.cpp

if (isLetter(Spelling[0])) {
       return &PP.getIdentifierTable().get(Spelling);
     }
     return nullptr;
   }
 }
 
 static bool IsBuiltInOrStandardCXX11Attribute(IdentifierInfo *AttrName,
                                                IdentifierInfo *ScopeName) {
-  switch (AttributeList::getKind(AttrName, ScopeName,
-                                 AttributeList::AS_CXX11)) {
+  switch (AttributeList::getInfo(AttrName, ScopeName,
+                                 AttributeList::AS_CXX11)->AttrKind) {
   case AttributeList::AT_CarriesDependency:
   case AttributeList::AT_Deprecated:
   case AttributeList::AT_FallThrough:
   case AttributeList::AT_CXX11NoReturn:
     return true;
   case AttributeList::AT_WarnUnusedResult:
     return !ScopeName && AttrName->getName().equals("nodiscard");
   case AttributeList::AT_Unused:

lib/Sema/AttributeList.cpp

 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Sema/SemaInternal.h"
 #include "llvm/ADT/SmallString.h"
 using namespace clang;
 
+LLVM_INSTANTIATE_REGISTRY(AttrInfoRegistry)
+
 IdentifierLoc *IdentifierLoc::create(ASTContext &Ctx, SourceLocation Loc,
                                      IdentifierInfo *Ident) {
   IdentifierLoc *Result = new (Ctx) IdentifierLoc;
   Result->Loc = Loc;
   Result->Ident = Ident;
   return Result;
 }
 
void AttributePool::takePool(AttributeList *pool) {
   do {
     AttributeList *next = pool->NextInPool;
     pool->NextInPool = Head;
     Head = pool;
     pool = next;
   } while (pool);
 }
 
-#include "clang/Sema/AttrParsedAttrKinds.inc"
-
 static StringRef normalizeAttrName(StringRef AttrName, StringRef ScopeName,
                                    AttributeList::Syntax SyntaxUsed) {
   // Normalize the attribute name, __foo__ becomes foo. This is only allowable
   // for GNU attributes.
   bool IsGNU = SyntaxUsed == AttributeList::AS_GNU ||
                (SyntaxUsed == AttributeList::AS_CXX11 && ScopeName == "gnu");
   if (IsGNU && AttrName.size() >= 4 && AttrName.startswith("__") &&
       AttrName.endswith("__"))
     AttrName = AttrName.slice(2, AttrName.size() - 2);
 
   return AttrName;
 }
 
-AttributeList::Kind AttributeList::getKind(const IdentifierInfo *Name,
-                                           const IdentifierInfo *ScopeName,
-                                           Syntax SyntaxUsed) {
+#include "clang/Sema/AttrParsedAttrImpl.inc"
+
+std::unique_ptr<ParsedAttrInfo>
+AttributeList::getInfo(const IdentifierInfo *Name,
+                       const IdentifierInfo *ScopeName, Syntax SyntaxUsed) {
   StringRef AttrName = Name->getName();
 
   SmallString<64> FullName;
   if (ScopeName)
     FullName += ScopeName->getName();
 
   AttrName = normalizeAttrName(AttrName, FullName, SyntaxUsed);
 
   // Ensure that in the case of C++11 attributes, we look for '::foo' if it is
   // unscoped.
   if (ScopeName || SyntaxUsed == AS_CXX11)
     FullName += "::";
   FullName += AttrName;
 
-  return ::getAttrKind(FullName, SyntaxUsed);
+  // When context-sensitive keyword syntax is used it matches keyword attributes
+  if (SyntaxUsed == AS_ContextSensitiveKeyword)
+    SyntaxUsed = AS_Keyword;
+
+  // Search for a ParsedAttrInfo whose name and syntax match
+  for (AttrInfoRegistry::iterator it = AttrInfoRegistry::begin(),
+                                  ie = AttrInfoRegistry::end();
+       it != ie; ++it) {
+    if (FullName.equals(it->getName())) {
+      std::unique_ptr<ParsedAttrInfo> P = it->instantiate();
+      if (P->Syntax == SyntaxUsed) {
+        return P;
+      }
+    }
+  }
+
+  // If we failed to find a match then the attribute is unknown
+  std::unique_ptr<ParsedAttrInfo> ret = llvm::make_unique<ParsedAttrInfo>();
+  ret->AttrKind = AttributeList::UnknownAttribute;
+  return ret;
 }
 
 unsigned AttributeList::getAttributeSpellingListIndex() const {
   // Both variables will be used in tablegen generated
   // attribute spell list index matching code.
   StringRef Scope = ScopeName ? ScopeName->getName() : "";
   StringRef Name = normalizeAttrName(AttrName->getName(), Scope,
                                      (AttributeList::Syntax)SyntaxUsed);
+  Kind AttrKind = Kind(getInfo()->AttrKind);
 
 #include "clang/Sema/AttrSpellingListIndex.inc"
 
 }
 
-struct ParsedAttrInfo {
-  unsigned NumArgs : 4;
-  unsigned OptArgs : 4;
-  unsigned HasCustomParsing : 1;
-  unsigned IsTargetSpecific : 1;
-  unsigned IsType : 1;
-  unsigned IsStmt : 1;
-  unsigned IsKnownToGCC : 1;
-
-  virtual bool diagAppertainsToDecl(Sema &S, const AttributeList &Attr,
-                                    const Decl *) const {
-    return true;
-  }
-  virtual bool diagLangOpts(Sema &S, const AttributeList &Attr) const {
-    return true;
-  }
-  virtual bool existsInTarget(const TargetInfo &Target) const {
-    return true;
-  }
-  virtual unsigned
-  spellingIndexToSemanticSpelling(const AttributeList &Attr) const {
-    return UINT_MAX;
-  }
-};
-
-namespace {
-  #include "clang/Sema/AttrParsedAttrImpl.inc"
-}
-
-static const ParsedAttrInfo &getInfo(const AttributeList &A) {
-  return *AttrInfoMap[A.getKind()];
-}
-
 unsigned AttributeList::getMinArgs() const {
-  return getInfo(*this).NumArgs;
+  return getInfo()->NumArgs;
 }
 
 unsigned AttributeList::getMaxArgs() const {
-  return getMinArgs() + getInfo(*this).OptArgs;
+  return getMinArgs() + getInfo()->OptArgs;
 }
 
 bool AttributeList::hasCustomParsing() const {
-  return getInfo(*this).HasCustomParsing;
+  return getInfo()->HasCustomParsing;
 }
 
 bool AttributeList::diagnoseAppertainsTo(Sema &S, const Decl *D) const {
-  return getInfo(*this).diagAppertainsToDecl(S, *this, D);
+  return getInfo()->diagAppertainsToDecl(S, *this, D);
 }
 
 bool AttributeList::diagnoseLangOpts(Sema &S) const {
-  return getInfo(*this).diagLangOpts(S, *this);
+  return getInfo()->diagLangOpts(S, *this);
 }
 
 bool AttributeList::isTargetSpecificAttr() const {
-  return getInfo(*this).IsTargetSpecific;
+  return getInfo()->IsTargetSpecific;
 }
 
 bool AttributeList::isTypeAttr() const {
-  return getInfo(*this).IsType;
+  return getInfo()->IsType;
 }
 
 bool AttributeList::isStmtAttr() const {
-  return getInfo(*this).IsStmt;
+  return getInfo()->IsStmt;
 }
 
 bool AttributeList::existsInTarget(const TargetInfo &Target) const {
-  return getInfo(*this).existsInTarget(Target);
+  return getInfo()->existsInTarget(Target);
 }
 
 bool AttributeList::isKnownToGCC() const {
-  return getInfo(*this).IsKnownToGCC;
+  return getInfo()->IsKnownToGCC;
 }
 
 unsigned AttributeList::getSemanticSpelling() const {
-  return getInfo(*this).spellingIndexToSemanticSpelling(*this);
+  return getInfo()->spellingIndexToSemanticSpelling(*this);
 }
 
 bool AttributeList::hasVariadicArg() const {
   // If the attribute has the maximum number of optional arguments, we will
   // claim that as being variadic. If we someday get an attribute that
   // legitimately bumps up against that maximum, we can use another bit to track
   // whether it's truly variadic or not.
-  return getInfo(*this).OptArgs == 15;
+  return getInfo()->OptArgs == 15;
 }

utils/TableGen/ClangAttrEmitter.cpp

static StringRef NormalizeGNUAttrSpelling(StringRef AttrSpelling) {
   }
 
   return AttrSpelling;
 }
 
 typedef std::vector<std::pair<std::string, const Record *>> ParsedAttrMap;
 
 static ParsedAttrMap getParsedAttrList(const RecordKeeper &Records,
+                                       bool IncludeIgnored = false,
                                        ParsedAttrMap *Dupes = nullptr) {
   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
   std::set<std::string> Seen;
   ParsedAttrMap R;
   for (const auto *Attr : Attrs) {
-    if (Attr->getValueAsBit("SemaHandler")) {
+    if (Attr->getValueAsBit("SemaHandler") ||
+        (IncludeIgnored && Attr->getValueAsBit("Ignored"))) {
       std::string AN;
       if (Attr->isSubClassOf("TargetSpecificAttr") &&
           !Attr->isValueUnset("ParseKind")) {
         AN = Attr->getValueAsString("ParseKind");
 
         // If this attribute has already been handled, it does not need to be
         // handled again.
         if (Seen.find(AN) != Seen.end()) {
return llvm::any_of(
       [](const FlattenedSpelling &S) { return S.knownToGCC(); });
 }
 
 /// Emits the parsed attribute helpers
 void EmitClangAttrParsedAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
   emitSourceFileHeader("Parsed attribute helpers", OS);
 
   // Get the list of parsed attributes, and accept the optional list of
-  // duplicates due to the ParseKind.
+  // duplicates due to the ParseKind. We also want to include ignored
+  // attributes as we want them to be successfully matched.
   ParsedAttrMap Dupes;
-  ParsedAttrMap Attrs = getParsedAttrList(Records, &Dupes);
+  ParsedAttrMap Attrs = getParsedAttrList(Records, true, &Dupes);
 
-  // Generate the appertainsTo diagnostic methods and write their names into
-  // another mapping. At the same time, generate the AttrInfoMap object
-  // contents. Due to the reliance on generated code, use separate streams so
-  // that code will not be interleaved.
-  for (auto I = Attrs.begin(), E = Attrs.end(); I != E; ++I) {
+  for (const auto &I : Attrs) {
     // TODO: If the attribute's kind appears in the list of duplicates, that is
     // because it is a target-specific attribute that appears multiple times.
     // It would be beneficial to test whether the duplicates are "similar
     // enough" to each other to not cause problems. For instance, check that
     // the spellings are identical, and custom parsing rules match, etc.
-
-    // We need to generate struct instances based off ParsedAttrInfo from
-    // AttributeList.cpp.
-    const Record &Attr = *I->second;
-    OS << "struct ParsedAttrInfo" << I->first << " : public ParsedAttrInfo {\n";
-    OS << "  ParsedAttrInfo" << I->first << "() {\n";
+    const Record &Attr = *I.second;
+    const std::string &AttrName = I.first;
+    std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
+    unsigned SpellingIdx = 0;
+    for (const auto &S : Spellings) {
+      std::string Spelling;
+      if (S.variety() == "CXX11") {
+        Spelling += S.nameSpace();
+        Spelling += "::";
+      }
+      Spelling += (S.variety() == "GNU" ? NormalizeGNUAttrSpelling(S.name()) : StringRef(S.name()));
+      std::string AttrInfoName = "AttrInfo" + std::to_string(SpellingIdx) + AttrName;
+      OS << "struct " << AttrInfoName << " : public ParsedAttrInfo {\n";
+      OS << "  " << AttrInfoName << "() {\n";
+      if (Attr.getValueAsBit("Ignored")) {
+        OS << "    AttrKind = AttributeList::IgnoredAttribute;\n";
+      } else {
+        OS << "    AttrKind = AttributeList::AT_" << AttrName << ";\n";
+      }
+      OS << "    Syntax = AttributeList::AS_" << S.variety() << ";\n";
       emitArgInfo(Attr, OS);
       OS << "    HasCustomParsing = ";
       OS << Attr.getValueAsBit("HasCustomParsing") << ";\n";
       OS << "    IsTargetSpecific = ";
       OS << Attr.isSubClassOf("TargetSpecificAttr") << ";\n";
       OS << "    IsType = ";
       OS << Attr.isSubClassOf("TypeAttr") << ";\n";
       OS << "    IsStmt = ";
       OS << Attr.isSubClassOf("StmtAttr") << ";\n";
       OS << "    IsKnownToGCC = ";
       OS << IsKnownToGCC(Attr) << ";\n";
       OS << "  }\n";
       GenerateAppertainsTo(Attr, OS);
       GenerateLangOptRequirements(Attr, OS);
       GenerateTargetRequirements(Attr, Dupes, OS);
       GenerateSpellingIndexToSemanticSpelling(Attr, OS);
       OS << "};\n";
-    OS << "ParsedAttrInfo" << I->first;
-    OS << " parsedAttrInfo" << I->first << "Instance;\n\n";
-  }
-
-  OS << "static const ParsedAttrInfo *AttrInfoMap[AttributeList::UnknownAttribute + 1] = {\n";
-  for (auto I = Attrs.begin(), E = Attrs.end(); I != E; ++I) {
-    OS << "&parsedAttrInfo" << I->first << "Instance,\n";
-  }
-  OS << "};\n\n";
-}
-
-// Emits the kind list of parsed attributes
-void EmitClangAttrParsedAttrKinds(RecordKeeper &Records, raw_ostream &OS) {
-  emitSourceFileHeader("Attribute name matcher", OS);
-
-  std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
-  std::vector<StringMatcher::StringPair> GNU, Declspec, Microsoft, CXX11,
-      Keywords, Pragma;
-  std::set<std::string> Seen;
-  for (const auto *A : Attrs) {
-    const Record &Attr = *A;
-
-    bool SemaHandler = Attr.getValueAsBit("SemaHandler");
-    bool Ignored = Attr.getValueAsBit("Ignored");
-    if (SemaHandler || Ignored) {
-      // Attribute spellings can be shared between target-specific attributes,
-      // and can be shared between syntaxes for the same attribute. For
-      // instance, an attribute can be spelled GNU<"interrupt"> for an ARM-
-      // specific attribute, or MSP430-specific attribute. Additionally, an
-      // attribute can be spelled GNU<"dllexport"> and Declspec<"dllexport">
-      // for the same semantic attribute. Ultimately, we need to map each of
-      // these to a single AttributeList::Kind value, but the StringMatcher
-      // class cannot handle duplicate match strings. So we generate a list of
-      // string to match based on the syntax, and emit multiple string matchers
-      // depending on the syntax used.
-      std::string AttrName;
-      if (Attr.isSubClassOf("TargetSpecificAttr") &&
-          !Attr.isValueUnset("ParseKind")) {
-        AttrName = Attr.getValueAsString("ParseKind");
-        if (Seen.find(AttrName) != Seen.end())
-          continue;
-        Seen.insert(AttrName);
-      } else
-        AttrName = NormalizeAttrName(StringRef(Attr.getName())).str();
-
-      std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
-      for (const auto &S : Spellings) {
-        const std::string &RawSpelling = S.name();
-        std::vector<StringMatcher::StringPair> *Matches = nullptr;
-        std::string Spelling;
-        const std::string &Variety = S.variety();
-        if (Variety == "CXX11") {
-          Matches = &CXX11;
-          Spelling += S.nameSpace();
-          Spelling += "::";
-        } else if (Variety == "GNU")
-          Matches = &GNU;
-        else if (Variety == "Declspec")
-          Matches = &Declspec;
-        else if (Variety == "Microsoft")
-          Matches = &Microsoft;
-        else if (Variety == "Keyword")
-          Matches = &Keywords;
-        else if (Variety == "Pragma")
-          Matches = &Pragma;
-
-        assert(Matches && "Unsupported spelling variety found");
-
-        if (Variety == "GNU")
-          Spelling += NormalizeGNUAttrSpelling(RawSpelling);
-        else
-          Spelling += RawSpelling;
-
-        if (SemaHandler)
-          Matches->push_back(StringMatcher::StringPair(Spelling,
-                              "return AttributeList::AT_" + AttrName + ";"));
-        else
-          Matches->push_back(StringMatcher::StringPair(Spelling,
-                              "return AttributeList::IgnoredAttribute;"));
-      }
+      OS << "static AttrInfoRegistry::Add<" << AttrInfoName << "> " << AttrInfoName << "Instance(\"" << Spelling << "\",\"\");\n";
+      ++SpellingIdx;
     }
   }
-  
-  OS << "static AttributeList::Kind getAttrKind(StringRef Name, ";
-  OS << "AttributeList::Syntax Syntax) {\n";
-  OS << "  if (AttributeList::AS_GNU == Syntax) {\n";
-  StringMatcher("Name", GNU, OS).Emit();
-  OS << "  } else if (AttributeList::AS_Declspec == Syntax) {\n";
-  StringMatcher("Name", Declspec, OS).Emit();
-  OS << "  } else if (AttributeList::AS_Microsoft == Syntax) {\n";
-  StringMatcher("Name", Microsoft, OS).Emit();
-  OS << "  } else if (AttributeList::AS_CXX11 == Syntax) {\n";
-  StringMatcher("Name", CXX11, OS).Emit();
-  OS << "  } else if (AttributeList::AS_Keyword == Syntax || ";
-  OS << "AttributeList::AS_ContextSensitiveKeyword == Syntax) {\n";
-  StringMatcher("Name", Keywords, OS).Emit();
-  OS << "  } else if (AttributeList::AS_Pragma == Syntax) {\n";
-  StringMatcher("Name", Pragma, OS).Emit();
-  OS << "  }\n";
-  OS << "  return AttributeList::UnknownAttribute;\n"
-     << "}\n";
 }
 
 // Emits the code to dump an attribute.
 void EmitClangAttrDump(RecordKeeper &Records, raw_ostream &OS) {
   emitSourceFileHeader("Attribute dumper", OS);
 
   OS << "  switch (A->getKind()) {\n";
   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;

utils/TableGen/TableGen.cpp

enum ActionType {
   GenClangAttrPCHRead,
   GenClangAttrPCHWrite,
   GenClangAttrHasAttributeImpl,
   GenClangAttrSpellingListIndex,
   GenClangAttrASTVisitor,
   GenClangAttrTemplateInstantiate,
   GenClangAttrParsedAttrList,
   GenClangAttrParsedAttrImpl,
-  GenClangAttrParsedAttrKinds,
   GenClangAttrDump,
   GenClangDiagsDefs,
   GenClangDiagGroups,
   GenClangDiagsIndexName,
   GenClangCommentNodes,
   GenClangDeclNodes,
   GenClangStmtNodes,
   GenClangSACheckers,
cl::values(
                    "gen-clang-attr-template-instantiate",
                    "Generate a clang template instantiate code"),
         clEnumValN(GenClangAttrParsedAttrList,
                    "gen-clang-attr-parsed-attr-list",
                    "Generate a clang parsed attribute list"),
         clEnumValN(GenClangAttrParsedAttrImpl,
                    "gen-clang-attr-parsed-attr-impl",
                    "Generate the clang parsed attribute helpers"),
-        clEnumValN(GenClangAttrParsedAttrKinds,
-                   "gen-clang-attr-parsed-attr-kinds",
-                   "Generate a clang parsed attribute kinds"),
         clEnumValN(GenClangAttrDump, "gen-clang-attr-dump",
                    "Generate clang attribute dumper"),
         clEnumValN(GenClangDiagsDefs, "gen-clang-diags-defs",
                    "Generate Clang diagnostics definitions"),
         clEnumValN(GenClangDiagGroups, "gen-clang-diag-groups",
                    "Generate Clang diagnostic groups"),
         clEnumValN(GenClangDiagsIndexName, "gen-clang-diags-index-name",
                    "Generate Clang diagnostic name index"),
case GenClangAttrTemplateInstantiate:
     EmitClangAttrTemplateInstantiate(Records, OS);
     break;
   case GenClangAttrParsedAttrList:
     EmitClangAttrParsedAttrList(Records, OS);
     break;
   case GenClangAttrParsedAttrImpl:
     EmitClangAttrParsedAttrImpl(Records, OS);
     break;
-  case GenClangAttrParsedAttrKinds:
-    EmitClangAttrParsedAttrKinds(Records, OS);
-    break;
   case GenClangAttrDump:
     EmitClangAttrDump(Records, OS);
     break;
   case GenClangDiagsDefs:
     EmitClangDiagsDefs(Records, OS, ClangComponent);
     break;
   case GenClangDiagGroups:
     EmitClangDiagGroups(Records, OS);

utils/TableGen/TableGenBackends.h

 void EmitClangAttrPCHRead(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrPCHWrite(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrHasAttrImpl(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrASTVisitor(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrTemplateInstantiate(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrParsedAttrList(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrParsedAttrImpl(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangAttrParsedAttrKinds(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangAttrDump(RecordKeeper &Records, raw_ostream &OS);
 
 void EmitClangDiagsDefs(RecordKeeper &Records, raw_ostream &OS,
                         const std::string &Component);
 void EmitClangDiagGroups(RecordKeeper &Records, raw_ostream &OS);
 void EmitClangDiagsIndexName(RecordKeeper &Records, raw_ostream &OS);
 
 void EmitClangSACheckers(RecordKeeper &Records, raw_ostream &OS);