Use virtual functions in ParsedAttrInfo instead of function pointers

[john.brawn]

Summary

This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though.

[john.brawn]

Resurrecting this old patch, with the intention of trying to get it committed this time. This is the first of four patches to make it possible for clang plugins to define attributes.

[erichkeane]

clang/lib/Sema/ParsedAttr.cpp

144

I don't think you can do this. The only way to get Info as nullptr is to end up off the end of the array, which is UB.

Instead of the map lookup, this should check A.getKind against the range.

147

Currently the behavior of this is to make an invalid attribute kind be UB. Presumably the point here is to make it so that is no longer the case?

clang/utils/TableGen/ClangAttrEmitter.cpp

3410

Why does this take SS AND OS. What is the difference here? Does this actually use OS anymore?

3653

Should the instance be static? Perhaps a static variable in the class itself?

3656–3657

Is there a good reason this doesn't return references?

[john.brawn]

clang/lib/Sema/ParsedAttr.cpp

144

AttrInfoMap is declared to have size ParsedAttr::UnknownAttribute+1, so when the kind is too large we get an element that wasn't explicitly initialized so will be null.

Doing it by kind makes more sense though, so I'll do that.

clang/utils/TableGen/ClangAttrEmitter.cpp

3410

It's because of GenerateCustomAppertainsTo. That generates a function that expects to be at file scope (because emitAttributeMatchRules re-uses the same function), but at the time GenerateAppertainsTo is called SS is in the middle of the ParsedAttrInfo. Previously both the function that GenerateCustomAppertainsTo generates and that this file generates would be at file scope, so both were written to OS.

3653

Making it static makes sense, I'll do that.

3656–3657

You can't have an array of references (C++11 dcl.ref paragraph 5).

[erichkeane]

clang/utils/TableGen/ClangAttrEmitter.cpp

3410

Thanks!

3653

static class member is what I'm thinking. That way it is ParsedAttrInfoWHATEVER::Instance?

3656–3657

Ah, right... got lost in the code-that-generates-code thing.

[john.brawn]

Update based on review comments. Also fix warnings due to missing virtual destructor that I hadn't noticed before.

[aaron.ballman]

clang/lib/Sema/ParsedAttr.cpp

141

Might as well lower this variable into the function -- no real need for it to have file scope.

clang/utils/TableGen/ClangAttrEmitter.cpp

3410

I think the stream parameter names should be a bit more descriptive here (and perhaps some comments on the function would be a good idea as well). Perhaps FileScopeStream and LexicalScopeStream?

[john.brawn]

clang/lib/Sema/ParsedAttr.cpp

141

Sure.

clang/utils/TableGen/ClangAttrEmitter.cpp

3410

Actually, looking at this again there's no reason we can't generate the CustomApperatinsTo functions in a loop at the start of EmitClangAttrParsedAttrImpl. That way everything can just go to a single output stream and we don't have this problem. I'll rearrange things to do that instead.

[john.brawn]

Move DefaultParsedAttrInfo out of file scope, and move custom appertains-to function generation out of the loop in EmitClangAttrParsedAttrImpl so we only need to use one output stream.

[aaron.ballman]

LGTM aside from a minor nit and a question.

clang/lib/Sema/ParsedAttr.cpp

144

You can use llvm::array_lengthof() here instead.

clang/utils/TableGen/ClangAttrEmitter.cpp

3653

Would it make sense for this object to be const under the assumption that once we've generated a ParsedAttrInfo object, we don't want to modify its properties? I'm not certain if trying to be const-correct here would be a burden or not, so I don't insist on a change unless it's trivial to support.

[john.brawn]

clang/lib/Sema/ParsedAttr.cpp

144

Will do.

clang/utils/TableGen/ClangAttrEmitter.cpp

3653

Making this const actually is trivial, so I'll do that.

clang/lib/Sema/ParsedAttr.cpp

struct ParsedAttrInfo {
   unsigned OptArgs : 4;
   unsigned HasCustomParsing : 1;
   unsigned IsTargetSpecific : 1;
   unsigned IsType : 1;
   unsigned IsStmt : 1;
   unsigned IsKnownToGCC : 1;
   unsigned IsSupportedByPragmaAttribute : 1;
 
-  bool (*DiagAppertainsToDecl)(Sema &S, const ParsedAttr &Attr, const Decl *);
-  bool (*DiagLangOpts)(Sema &S, const ParsedAttr &Attr);
-  bool (*ExistsInTarget)(const TargetInfo &Target);
-  unsigned (*SpellingIndexToSemanticSpelling)(const ParsedAttr &Attr);
-  void (*GetPragmaAttributeMatchRules)(
-      llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &Rules,
-      const LangOptions &LangOpts);
+  virtual ~ParsedAttrInfo() = default;
+
+  virtual bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr,
+                                    const Decl *) const {
+    return true;
+  }
+  virtual bool diagLangOpts(Sema &S, const ParsedAttr &Attr) const {
+    return true;
+  }
+  virtual bool existsInTarget(const TargetInfo &Target) const {
+    return true;
+  }
+  virtual unsigned
+  spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const {
+    return UINT_MAX;
+  }
+  virtual void getPragmaAttributeMatchRules(
+    const LangOptions &LangOpts) const {
+  }
 };
 
 namespace {
 
 #include "clang/Sema/AttrParsedAttrImpl.inc"
 
 } // namespace
 
 static const ParsedAttrInfo &getInfo(const ParsedAttr &A) {
-  return AttrInfoMap[A.getKind()];
+  // If we have a ParsedAttrInfo for this ParsedAttr then return that,
+  // otherwise return a default ParsedAttrInfo.
+  if (A.getKind() < llvm::array_lengthof(AttrInfoMap))
+    return *AttrInfoMap[A.getKind()];
+
+  static ParsedAttrInfo DefaultParsedAttrInfo;
+  return DefaultParsedAttrInfo;
 }
 
 unsigned ParsedAttr::getMinArgs() const { return getInfo(*this).NumArgs; }
 
 unsigned ParsedAttr::getMaxArgs() const {
   return getMinArgs() + getInfo(*this).OptArgs;
 }
 
 bool ParsedAttr::hasCustomParsing() const {
   return getInfo(*this).HasCustomParsing;
 }
 
 bool ParsedAttr::diagnoseAppertainsTo(Sema &S, const Decl *D) const {
-  return getInfo(*this).DiagAppertainsToDecl(S, *this, D);
+  return getInfo(*this).diagAppertainsToDecl(S, *this, D);
 }
 
 bool ParsedAttr::appliesToDecl(const Decl *D,
                                attr::SubjectMatchRule MatchRule) const {
   return checkAttributeMatchRuleAppliesTo(D, MatchRule);
 }
 
 void ParsedAttr::getMatchRules(
     const LangOptions &LangOpts,
     SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules)
     const {
-  return getInfo(*this).GetPragmaAttributeMatchRules(MatchRules, LangOpts);
+  return getInfo(*this).getPragmaAttributeMatchRules(MatchRules, LangOpts);
 }
 
 bool ParsedAttr::diagnoseLangOpts(Sema &S) const {
-  return getInfo(*this).DiagLangOpts(S, *this);
+  return getInfo(*this).diagLangOpts(S, *this);
 }
 
 bool ParsedAttr::isTargetSpecificAttr() const {
   return getInfo(*this).IsTargetSpecific;
 }
 
 bool ParsedAttr::isTypeAttr() const { return getInfo(*this).IsType; }
 
 bool ParsedAttr::isStmtAttr() const { return getInfo(*this).IsStmt; }
 
 bool ParsedAttr::existsInTarget(const TargetInfo &Target) const {
-  return getInfo(*this).ExistsInTarget(Target);
+  return getInfo(*this).existsInTarget(Target);
 }
 
 bool ParsedAttr::isKnownToGCC() const { return getInfo(*this).IsKnownToGCC; }
 
 bool ParsedAttr::isSupportedByPragmaAttribute() const {
   return getInfo(*this).IsSupportedByPragmaAttribute;
 }
 
 unsigned ParsedAttr::getSemanticSpelling() const {
-  return getInfo(*this).SpellingIndexToSemanticSpelling(*this);
+  return getInfo(*this).spellingIndexToSemanticSpelling(*this);
 }
 
 bool ParsedAttr::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;
 }

clang/utils/TableGen/ClangAttrEmitter.cpp

struct PragmaClangAttributeSupport {
   llvm::DenseMap<const Record *, RuleOrAggregateRuleSet> SubjectsToRules;
 
   PragmaClangAttributeSupport(RecordKeeper &Records);
 
   bool isAttributedSupported(const Record &Attribute);
 
   void emitMatchRuleList(raw_ostream &OS);
 
-  std::string generateStrictConformsTo(const Record &Attr, raw_ostream &OS);
+  void generateStrictConformsTo(const Record &Attr, raw_ostream &OS);
 
   void generateParsingHelpers(raw_ostream &OS);
 };
 
 } // end anonymous namespace
 
 static bool doesDeclDeriveFrom(const Record *D, const Record *Base) {
   const Record *CurrentBase = D->getValueAsOptionalDef(BaseFieldName);
static std::string GenerateTestExpression(ArrayRef<Record *> LangOpts) {
   }
 
   if (Test.empty())
     return "true";
 
   return Test;
 }
 
-std::string
+void
 PragmaClangAttributeSupport::generateStrictConformsTo(const Record &Attr,
                                                       raw_ostream &OS) {
-  if (!isAttributedSupported(Attr))
-    return "nullptr";
+  if (!isAttributedSupported(Attr) || Attr.isValueUnset("Subjects"))
+    return;
   // Generate a function that constructs a set of matching rules that describe
   // to which declarations the attribute should apply to.
-  std::string FnName = "matchRulesFor" + Attr.getName().str();
-  OS << "static void " << FnName << "(llvm::SmallVectorImpl<std::pair<"
+  OS << "virtual void getPragmaAttributeMatchRules("
+     << "llvm::SmallVectorImpl<std::pair<"
      << AttributeSubjectMatchRule::EnumName
-     << ", bool>> &MatchRules, const LangOptions &LangOpts) {\n";
-  if (Attr.isValueUnset("Subjects")) {
-    OS << "}\n\n";
-    return FnName;
-  }
+     << ", bool>> &MatchRules, const LangOptions &LangOpts) const {\n";
   const Record *SubjectObj = Attr.getValueAsDef("Subjects");
   std::vector<Record *> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
   for (const auto *Subject : Subjects) {
     auto It = SubjectsToRules.find(Subject);
     assert(It != SubjectsToRules.end() &&
            "This attribute is unsupported by #pragma clang attribute");
     for (const auto &Rule : It->getSecond().getAggregateRuleSet()) {
       // The rule might be language specific, so only subtract it from the given
       // rules if the specific language options are specified.
       std::vector<Record *> LangOpts = Rule.getLangOpts();
       OS << "  MatchRules.push_back(std::make_pair(" << Rule.getEnumValue()
          << ", /*IsSupported=*/" << GenerateTestExpression(LangOpts)
          << "));\n";
     }
   }
   OS << "}\n\n";
-  return FnName;
 }
 
 void PragmaClangAttributeSupport::generateParsingHelpers(raw_ostream &OS) {
   // Generate routines that check the names of sub-rules.
   OS << "Optional<attr::SubjectMatchRule> "
         "defaultIsAttributeSubjectMatchSubRuleFor(StringRef, bool) {\n";
   OS << "  return None;\n";
   OS << "}\n\n";
if (Arg->getValueAsBit("Fake"))
       continue;
     Arg->getValueAsBit("Optional") ? ++OptCount : ++ArgCount;
     if (!HasVariadic && isArgVariadic(*Arg, R.getName()))
       HasVariadic = true;
   }
 
   // If there is a variadic argument, we will set the optional argument count
   // to its largest value. Since it's currently a 4-bit number, we set it to 15.
-  OS << ArgCount << ", " << (HasVariadic ? 15 : OptCount);
-}
-
-static void GenerateDefaultAppertainsTo(raw_ostream &OS) {
-  OS << "static bool defaultAppertainsTo(Sema &, const ParsedAttr &,";
-  OS << "const Decl *) {\n";
-  OS << "  return true;\n";
-  OS << "}\n\n";
+  OS << "    NumArgs = " << ArgCount << ";\n";
+  OS << "    OptArgs = " << (HasVariadic ? 15 : OptCount) << ";\n";
 }
 
 static std::string GetDiagnosticSpelling(const Record &R) {
   std::string Ret = std::string(R.getValueAsString("DiagSpelling"));
   if (!Ret.empty())
     return Ret;
 
   // If we couldn't find the DiagSpelling in this object, we can check to see
if (B == "DeclBase")
     return "Decl";
   return B + "Decl";
 }
 
 static std::string functionNameForCustomAppertainsTo(const Record &Subject) {
   return "is" + Subject.getName().str();
 }
 
-static std::string GenerateCustomAppertainsTo(const Record &Subject,
-                                              raw_ostream &OS) {
+static void GenerateCustomAppertainsTo(const Record &Subject, raw_ostream &OS) {
   std::string FnName = functionNameForCustomAppertainsTo(Subject);
 
-  // If this code has already been generated, simply return the previous
-  // instance of it.
+  // If this code has already been generated, we don't need to do anything.
   static std::set<std::string> CustomSubjectSet;
   auto I = CustomSubjectSet.find(FnName);
   if (I != CustomSubjectSet.end())
-    return *I;
+    return;
 
   // This only works with non-root Decls.
   Record *Base = Subject.getValueAsDef(BaseFieldName);
 
   // Not currently support custom subjects within custom subjects.
   if (Base->isSubClassOf("SubsetSubject")) {
     PrintFatalError(Subject.getLoc(),
                     "SubsetSubjects within SubsetSubjects is not supported");
-    return "";
+    return;
   }
 
   OS << "static bool " << FnName << "(const Decl *D) {\n";
   OS << "  if (const auto *S = dyn_cast<";
   OS << GetSubjectWithSuffix(Base);
   OS << ">(D))\n";
   OS << "    return " << Subject.getValueAsString("CheckCode") << ";\n";
   OS << "  return false;\n";
   OS << "}\n\n";
 
   CustomSubjectSet.insert(FnName);
-  return FnName;
 }
 
-static std::string GenerateAppertainsTo(const Record &Attr, raw_ostream &OS) {
+static void GenerateAppertainsTo(const Record &Attr, raw_ostream &OS) {
   // If the attribute does not contain a Subjects definition, then use the
   // default appertainsTo logic.
   if (Attr.isValueUnset("Subjects"))
-    return "defaultAppertainsTo";
+    return;
 
   const Record *SubjectObj = Attr.getValueAsDef("Subjects");
   std::vector<Record*> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
 
   // If the list of subjects is empty, it is assumed that the attribute
   // appertains to everything.
   if (Subjects.empty())
-    return "defaultAppertainsTo";
+    return;
 
   bool Warn = SubjectObj->getValueAsDef("Diag")->getValueAsBit("Warn");
 
   // Otherwise, generate an appertainsTo check specific to this attribute which
-  // checks all of the given subjects against the Decl passed in. Return the
-  // name of that check to the caller.
+  // checks all of the given subjects against the Decl passed in.
   //
   // If D is null, that means the attribute was not applied to a declaration
   // at all (for instance because it was applied to a type), or that the caller
   // has determined that the check should fail (perhaps prior to the creation
   // of the declaration).
-  std::string FnName = "check" + Attr.getName().str() + "AppertainsTo";
-  std::stringstream SS;
-  SS << "static bool " << FnName << "(Sema &S, const ParsedAttr &Attr, ";
-  SS << "const Decl *D) {\n";
-  SS << "  if (!D || (";
+  OS << "virtual bool diagAppertainsToDecl(Sema &S, ";
+  OS << "const ParsedAttr &Attr, const Decl *D) const {\n";
+  OS << "  if (!D || (";
   for (auto I = Subjects.begin(), E = Subjects.end(); I != E; ++I) {
-    // If the subject has custom code associated with it, generate a function
-    // for it. The function cannot be inlined into this check (yet) because it
-    // requires the subject to be of a specific type, and were that information
-    // inlined here, it would not support an attribute with multiple custom
-    // subjects.
+    // If the subject has custom code associated with it, use the generated
+    // function for it. The function cannot be inlined into this check (yet)
+    // because it requires the subject to be of a specific type, and were that
+    // information inlined here, it would not support an attribute with multiple
+    // custom subjects.
     if ((*I)->isSubClassOf("SubsetSubject")) {
-      SS << "!" << GenerateCustomAppertainsTo(**I, OS) << "(D)";
+      OS << "!" << functionNameForCustomAppertainsTo(**I) << "(D)";
     } else {
-      SS << "!isa<" << GetSubjectWithSuffix(*I) << ">(D)";
+      OS << "!isa<" << GetSubjectWithSuffix(*I) << ">(D)";
     }
 
     if (I + 1 != E)
-      SS << " && ";
+      OS << " && ";
   }
-  SS << ")) {\n";
-  SS << "    S.Diag(Attr.getLoc(), diag::";
-  SS << (Warn ? "warn_attribute_wrong_decl_type_str" :
+  OS << ")) {\n";
+  OS << "    S.Diag(Attr.getLoc(), diag::";
+  OS << (Warn ? "warn_attribute_wrong_decl_type_str" :
                "err_attribute_wrong_decl_type_str");
-  SS << ")\n";
-  SS << "      << Attr << ";
-  SS << CalculateDiagnostic(*SubjectObj) << ";\n";
-  SS << "    return false;\n";
-  SS << "  }\n";
-  SS << "  return true;\n";
-  SS << "}\n\n";
-
-  OS << SS.str();
-  return FnName;
+  OS << ")\n";
+  OS << "      << Attr << ";
+  OS << CalculateDiagnostic(*SubjectObj) << ";\n";
+  OS << "    return false;\n";
+  OS << "  }\n";
+  OS << "  return true;\n";
+  OS << "}\n\n";
 }
 
 static void
 emitAttributeMatchRules(PragmaClangAttributeSupport &PragmaAttributeSupport,
                         raw_ostream &OS) {
   OS << "static bool checkAttributeMatchRuleAppliesTo(const Decl *D, "
      << AttributeSubjectMatchRule::EnumName << " rule) {\n";
   OS << "  switch (rule) {\n";
for (const auto &Rule : PragmaAttributeSupport.Rules) {
     }
     OS << ";\n";
   }
   OS << "  }\n";
   OS << "  llvm_unreachable(\"Invalid match rule\");\nreturn false;\n";
   OS << "}\n\n";
 }
 
-static void GenerateDefaultLangOptRequirements(raw_ostream &OS) {
-  OS << "static bool defaultDiagnoseLangOpts(Sema &, ";
-  OS << "const ParsedAttr &) {\n";
-  OS << "  return true;\n";
-  OS << "}\n\n";
-}
-
-static std::string GenerateLangOptRequirements(const Record &R,
-                                               raw_ostream &OS) {
+static void GenerateLangOptRequirements(const Record &R,
   // If the attribute has an empty or unset list of language requirements,
-  // return the default handler.
+  // use the default handler.
   std::vector<Record *> LangOpts = R.getValueAsListOfDefs("LangOpts");
   if (LangOpts.empty())
-    return "defaultDiagnoseLangOpts";
-
-  // Generate a unique function name for the diagnostic test. The list of
-  // options should usually be short (one or two options), and the
-  // uniqueness isn't strictly necessary (it is just for codegen efficiency).
-  std::string FnName = "check";
-  for (auto I = LangOpts.begin(), E = LangOpts.end(); I != E; ++I)
-    FnName += (*I)->getValueAsString("Name");
-  FnName += "LangOpts";
-
-  // If this code has already been generated, simply return the previous
-  // instance of it.
-  static std::set<std::string> CustomLangOptsSet;
-  auto I = CustomLangOptsSet.find(FnName);
-  if (I != CustomLangOptsSet.end())
-    return *I;
+    return;
 
-  OS << "static bool " << FnName << "(Sema &S, const ParsedAttr &Attr) {\n";
+  OS << "virtual bool diagLangOpts(Sema &S, const ParsedAttr &Attr) ";
+  OS << "const {\n";
   OS << "  auto &LangOpts = S.LangOpts;\n";
   OS << "  if (" << GenerateTestExpression(LangOpts) << ")\n";
   OS << "    return true;\n\n";
   OS << "  S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) ";
   OS << "<< Attr;\n";
   OS << "  return false;\n";
   OS << "}\n\n";
-
-  CustomLangOptsSet.insert(FnName);
-  return FnName;
-}
-
-static void GenerateDefaultTargetRequirements(raw_ostream &OS) {
-  OS << "static bool defaultTargetRequirements(const TargetInfo &) {\n";
-  OS << "  return true;\n";
-  OS << "}\n\n";
 }
 
-static std::string GenerateTargetRequirements(const Record &Attr,
-                                              const ParsedAttrMap &Dupes,
-                                              raw_ostream &OS) {
-  // If the attribute is not a target specific attribute, return the default
+static void GenerateTargetRequirements(const Record &Attr,
+  // If the attribute is not a target specific attribute, use the default
   // target handler.
   if (!Attr.isSubClassOf("TargetSpecificAttr"))
-    return "defaultTargetRequirements";
+    return;
 
   // Get the list of architectures to be tested for.
   const Record *R = Attr.getValueAsDef("Target");
   std::vector<StringRef> Arches = R->getValueAsListOfStrings("Arches");
 
   // If there are other attributes which share the same parsed attribute kind,
   // such as target-specific attributes with a shared spelling, collapse the
   // duplicate architectures. This is required because a shared target-specific
for (const auto &I : Dupes) {
       }
     }
   }
 
   std::string FnName = "isTarget";
   std::string Test;
   bool UsesT = GenerateTargetSpecificAttrChecks(R, Arches, Test, &FnName);
 
-  // If this code has already been generated, simply return the previous
-  // instance of it.
-  static std::set<std::string> CustomTargetSet;
-  auto I = CustomTargetSet.find(FnName);
-  if (I != CustomTargetSet.end())
-    return *I;
-
-  OS << "static bool " << FnName << "(const TargetInfo &Target) {\n";
+  OS << "virtual bool existsInTarget(const TargetInfo &Target) const {\n";
   if (UsesT)
     OS << "  const llvm::Triple &T = Target.getTriple(); (void)T;\n";
   OS << "  return " << Test << ";\n";
   OS << "}\n\n";
-
-  CustomTargetSet.insert(FnName);
-  return FnName;
-}
-
-static void GenerateDefaultSpellingIndexToSemanticSpelling(raw_ostream &OS) {
-  OS << "static unsigned defaultSpellingIndexToSemanticSpelling("
-     << "const ParsedAttr &Attr) {\n";
-  OS << "  return UINT_MAX;\n";
-  OS << "}\n\n";
 }
 
-static std::string GenerateSpellingIndexToSemanticSpelling(const Record &Attr,
-                                                           raw_ostream &OS) {
+static void GenerateSpellingIndexToSemanticSpelling(const Record &Attr,
   // If the attribute does not have a semantic form, we can bail out early.
   if (!Attr.getValueAsBit("ASTNode"))
-    return "defaultSpellingIndexToSemanticSpelling";
+    return;
 
   std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
 
   // If there are zero or one spellings, or all of the spellings share the same
   // name, we can also bail out early.
   if (Spellings.size() <= 1 || SpellingNamesAreCommon(Spellings))
-    return "defaultSpellingIndexToSemanticSpelling";
+    return;
 
   // Generate the enumeration we will use for the mapping.
   SemanticSpellingMap SemanticToSyntacticMap;
   std::string Enum = CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
   std::string Name = Attr.getName().str() + "AttrSpellingMap";
 
-  OS << "static unsigned " << Name << "(const ParsedAttr &Attr) {\n";
+  OS << "virtual unsigned spellingIndexToSemanticSpelling(";
+  OS << "const ParsedAttr &Attr) const {\n";
   OS << Enum;
   OS << "  unsigned Idx = Attr.getAttributeSpellingListIndex();\n";
   WriteSemanticSpellingSwitch("Idx", SemanticToSyntacticMap, OS);
   OS << "}\n\n";
-
-  return Name;
 }
 
 static bool IsKnownToGCC(const Record &Attr) {
   // Look at the spellings for this subject; if there are any spellings which
   // claim to be known to GCC, the attribute is known to GCC.
   return llvm::any_of(
       GetFlattenedSpellings(Attr),
       [](const FlattenedSpelling &S) { return S.knownToGCC(); });
 }
 
 /// Emits the parsed attribute helpers
 void EmitClangAttrParsedAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
   emitSourceFileHeader("Parsed attribute helpers", OS);
 
   PragmaClangAttributeSupport &PragmaAttributeSupport =
       getPragmaAttributeSupport(Records);
 
   // Get the list of parsed attributes, and accept the optional list of
   // duplicates due to the ParseKind.
   ParsedAttrMap Dupes;
   ParsedAttrMap Attrs = getParsedAttrList(Records, &Dupes);
 
-  // Generate the default appertainsTo, target and language option diagnostic,
-  // and spelling list index mapping methods.
-  GenerateDefaultAppertainsTo(OS);
-  GenerateDefaultLangOptRequirements(OS);
-  GenerateDefaultTargetRequirements(OS);
-  GenerateDefaultSpellingIndexToSemanticSpelling(OS);
-
-  // 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.
-  std::string Buffer;
-  raw_string_ostream SS {Buffer};
+  // Generate all of the custom appertainsTo functions that the attributes
+  // will be using.
+  for (auto I : Attrs) {
+    const Record &Attr = *I.second;
+    if (Attr.isValueUnset("Subjects"))
+      continue;
+    const Record *SubjectObj = Attr.getValueAsDef("Subjects");
+    for (auto Subject : SubjectObj->getValueAsListOfDefs("Subjects"))
+      if (Subject->isSubClassOf("SubsetSubject"))
+        GenerateCustomAppertainsTo(*Subject, OS);
+  }
+
+  // Generate a ParsedAttrInfo struct for each of the attributes.
   for (auto I = Attrs.begin(), E = Attrs.end(); I != E; ++I) {
     // 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
     // ParsedAttr.cpp.
-    SS << "  { ";
-    emitArgInfo(*I->second, SS);
-    SS << ", " << I->second->getValueAsBit("HasCustomParsing");
-    SS << ", " << I->second->isSubClassOf("TargetSpecificAttr");
-    SS << ", "
-       << (I->second->isSubClassOf("TypeAttr") ||
-           I->second->isSubClassOf("DeclOrTypeAttr"));
-    SS << ", " << I->second->isSubClassOf("StmtAttr");
-    SS << ", " << IsKnownToGCC(*I->second);
-    SS << ", " << PragmaAttributeSupport.isAttributedSupported(*I->second);
-    SS << ", " << GenerateAppertainsTo(*I->second, OS);
-    SS << ", " << GenerateLangOptRequirements(*I->second, OS);
-    SS << ", " << GenerateTargetRequirements(*I->second, Dupes, OS);
-    SS << ", " << GenerateSpellingIndexToSemanticSpelling(*I->second, OS);
-    SS << ", "
-       << PragmaAttributeSupport.generateStrictConformsTo(*I->second, OS);
-    SS << " }";
-
-    if (I + 1 != E)
-      SS << ",";
-
-    SS << "  // AT_" << I->first << "\n";
+    const Record &Attr = *I->second;
+    OS << "struct ParsedAttrInfo" << I->first << " : public ParsedAttrInfo {\n";
+    OS << "  ParsedAttrInfo" << I->first << "() {\n";
+    emitArgInfo(Attr, OS);
+    OS << "    HasCustomParsing = ";
+    OS << Attr.getValueAsBit("HasCustomParsing") << ";\n";
+    OS << "    IsTargetSpecific = ";
+    OS << Attr.isSubClassOf("TargetSpecificAttr") << ";\n";
+    OS << "    IsType = ";
+    OS << (Attr.isSubClassOf("TypeAttr") ||
+           Attr.isSubClassOf("DeclOrTypeAttr")) << ";\n";
+    OS << "    IsStmt = ";
+    OS << Attr.isSubClassOf("StmtAttr") << ";\n";
+    OS << "    IsKnownToGCC = ";
+    OS << IsKnownToGCC(Attr) << ";\n";
+    OS << "    IsSupportedByPragmaAttribute = ";
+    OS << PragmaAttributeSupport.isAttributedSupported(*I->second) << ";\n";
+    OS << "  }\n";
+    GenerateAppertainsTo(Attr, OS);
+    GenerateLangOptRequirements(Attr, OS);
+    GenerateTargetRequirements(Attr, Dupes, OS);
+    GenerateSpellingIndexToSemanticSpelling(Attr, OS);
+    PragmaAttributeSupport.generateStrictConformsTo(*I->second, OS);
+    OS << "static const ParsedAttrInfo" << I->first << " Instance;\n";
+    OS << "};\n";
+    OS << "const ParsedAttrInfo" << I->first << " ParsedAttrInfo" << I->first
+       << "::Instance;\n";
   }
 
-  OS << "static const ParsedAttrInfo AttrInfoMap[ParsedAttr::UnknownAttribute "
-        "+ 1] = {\n";
-  OS << SS.str();
+  OS << "static const ParsedAttrInfo *AttrInfoMap[] = {\n";
+  for (auto I = Attrs.begin(), E = Attrs.end(); I != E; ++I) {
+    OS << "&ParsedAttrInfo" << I->first << "::Instance,\n";
+  }
   OS << "};\n\n";
 
   // Generate the attribute match rules.
   emitAttributeMatchRules(PragmaAttributeSupport, OS);
 }
 
 // Emits the kind list of parsed attributes
 void EmitClangAttrParsedAttrKinds(RecordKeeper &Records, raw_ostream &OS) {