contrib/llvm-project/clang/utils/TableGen/ClangAttrEmitter.cpp

   1 //===- ClangAttrEmitter.cpp - Generate Clang attribute handling =-*- C++ -*--=//
   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 // These tablegen backends emit Clang attribute processing code
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/ADT/ArrayRef.h"
  14 #include "llvm/ADT/DenseMap.h"
  15 #include "llvm/ADT/DenseSet.h"
  16 #include "llvm/ADT/STLExtras.h"
  17 #include "llvm/ADT/SmallString.h"
  18 #include "llvm/ADT/StringExtras.h"
  19 #include "llvm/ADT/StringRef.h"
  20 #include "llvm/ADT/StringSet.h"
  21 #include "llvm/ADT/StringSwitch.h"
  22 #include "llvm/ADT/iterator_range.h"
  23 #include "llvm/Support/ErrorHandling.h"
  24 #include "llvm/Support/raw_ostream.h"
  25 #include "llvm/TableGen/Error.h"
  26 #include "llvm/TableGen/Record.h"
  27 #include "llvm/TableGen/StringMatcher.h"
  28 #include "llvm/TableGen/TableGenBackend.h"
  29 #include <algorithm>
  30 #include <cassert>
  31 #include <cctype>
  32 #include <cstddef>
  33 #include <cstdint>
  34 #include <map>
  35 #include <memory>
  36 #include <set>
  37 #include <sstream>
  38 #include <string>
  39 #include <utility>
  40 #include <vector>
  41
  42 using namespace llvm;
  43
  44 namespace {
  45
  46 class FlattenedSpelling {
  47   std::string V, N, NS;
  48   bool K;
  49
  50 public:
  51   FlattenedSpelling(const std::string &Variety, const std::string &Name,
  52                     const std::string &Namespace, bool KnownToGCC) :
  53     V(Variety), N(Name), NS(Namespace), K(KnownToGCC) {}
  54   explicit FlattenedSpelling(const Record &Spelling) :
  55     V(Spelling.getValueAsString("Variety")),
  56     N(Spelling.getValueAsString("Name")) {
  57
  58     assert(V != "GCC" && V != "Clang" &&
  59            "Given a GCC spelling, which means this hasn't been flattened!");
  60     if (V == "CXX11" || V == "C2x" || V == "Pragma")
  61       NS = Spelling.getValueAsString("Namespace");
  62     bool Unset;
  63     K = Spelling.getValueAsBitOrUnset("KnownToGCC", Unset);
  64   }
  65
  66   const std::string &variety() const { return V; }
  67   const std::string &name() const { return N; }
  68   const std::string &nameSpace() const { return NS; }
  69   bool knownToGCC() const { return K; }
  70 };
  71
  72 } // end anonymous namespace
  73
  74 static std::vector<FlattenedSpelling>
  75 GetFlattenedSpellings(const Record &Attr) {
  76   std::vector<Record *> Spellings = Attr.getValueAsListOfDefs("Spellings");
  77   std::vector<FlattenedSpelling> Ret;
  78
  79   for (const auto &Spelling : Spellings) {
  80     StringRef Variety = Spelling->getValueAsString("Variety");
  81     StringRef Name = Spelling->getValueAsString("Name");
  82     if (Variety == "GCC") {
  83       // Gin up two new spelling objects to add into the list.
  84       Ret.emplace_back("GNU", Name, "", true);
  85       Ret.emplace_back("CXX11", Name, "gnu", true);
  86     } else if (Variety == "Clang") {
  87       Ret.emplace_back("GNU", Name, "", false);
  88       Ret.emplace_back("CXX11", Name, "clang", false);
  89       if (Spelling->getValueAsBit("AllowInC"))
  90         Ret.emplace_back("C2x", Name, "clang", false);
  91     } else
  92       Ret.push_back(FlattenedSpelling(*Spelling));
  93   }
  94
  95   return Ret;
  96 }
  97
  98 static std::string ReadPCHRecord(StringRef type) {
  99   return StringSwitch<std::string>(type)
 100     .EndsWith("Decl *", "Record.GetLocalDeclAs<"
 101               + std::string(type, 0, type.size()-1) + ">(Record.readInt())")
 102     .Case("TypeSourceInfo *", "Record.getTypeSourceInfo()")
 103     .Case("Expr *", "Record.readExpr()")
 104     .Case("IdentifierInfo *", "Record.getIdentifierInfo()")
 105     .Case("StringRef", "Record.readString()")
 106     .Case("ParamIdx", "ParamIdx::deserialize(Record.readInt())")
 107     .Default("Record.readInt()");
 108 }
 109
 110 // Get a type that is suitable for storing an object of the specified type.
 111 static StringRef getStorageType(StringRef type) {
 112   return StringSwitch<StringRef>(type)
 113     .Case("StringRef", "std::string")
 114     .Default(type);
 115 }
 116
 117 // Assumes that the way to get the value is SA->getname()
 118 static std::string WritePCHRecord(StringRef type, StringRef name) {
 119   return "Record." + StringSwitch<std::string>(type)
 120     .EndsWith("Decl *", "AddDeclRef(" + std::string(name) + ");\n")
 121     .Case("TypeSourceInfo *", "AddTypeSourceInfo(" + std::string(name) + ");\n")
 122     .Case("Expr *", "AddStmt(" + std::string(name) + ");\n")
 123     .Case("IdentifierInfo *", "AddIdentifierRef(" + std::string(name) + ");\n")
 124     .Case("StringRef", "AddString(" + std::string(name) + ");\n")
 125     .Case("ParamIdx", "push_back(" + std::string(name) + ".serialize());\n")
 126     .Default("push_back(" + std::string(name) + ");\n");
 127 }
 128
 129 // Normalize attribute name by removing leading and trailing
 130 // underscores. For example, __foo, foo__, __foo__ would
 131 // become foo.
 132 static StringRef NormalizeAttrName(StringRef AttrName) {
 133   AttrName.consume_front("__");
 134   AttrName.consume_back("__");
 135   return AttrName;
 136 }
 137
 138 // Normalize the name by removing any and all leading and trailing underscores.
 139 // This is different from NormalizeAttrName in that it also handles names like
 140 // _pascal and __pascal.
 141 static StringRef NormalizeNameForSpellingComparison(StringRef Name) {
 142   return Name.trim("_");
 143 }
 144
 145 // Normalize the spelling of a GNU attribute (i.e. "x" in "__attribute__((x))"),
 146 // removing "__" if it appears at the beginning and end of the attribute's name.
 147 static StringRef NormalizeGNUAttrSpelling(StringRef AttrSpelling) {
 148   if (AttrSpelling.startswith("__") && AttrSpelling.endswith("__")) {
 149     AttrSpelling = AttrSpelling.substr(2, AttrSpelling.size() - 4);
 150   }
 151
 152   return AttrSpelling;
 153 }
 154
 155 typedef std::vector<std::pair<std::string, const Record *>> ParsedAttrMap;
 156
 157 static ParsedAttrMap getParsedAttrList(const RecordKeeper &Records,
 158                                        ParsedAttrMap *Dupes = nullptr) {
 159   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
 160   std::set<std::string> Seen;
 161   ParsedAttrMap R;
 162   for (const auto *Attr : Attrs) {
 163     if (Attr->getValueAsBit("SemaHandler")) {
 164       std::string AN;
 165       if (Attr->isSubClassOf("TargetSpecificAttr") &&
 166           !Attr->isValueUnset("ParseKind")) {
 167         AN = Attr->getValueAsString("ParseKind");
 168
 169         // If this attribute has already been handled, it does not need to be
 170         // handled again.
 171         if (Seen.find(AN) != Seen.end()) {
 172           if (Dupes)
 173             Dupes->push_back(std::make_pair(AN, Attr));
 174           continue;
 175         }
 176         Seen.insert(AN);
 177       } else
 178         AN = NormalizeAttrName(Attr->getName()).str();
 179
 180       R.push_back(std::make_pair(AN, Attr));
 181     }
 182   }
 183   return R;
 184 }
 185
 186 namespace {
 187
 188   class Argument {
 189     std::string lowerName, upperName;
 190     StringRef attrName;
 191     bool isOpt;
 192     bool Fake;
 193
 194   public:
 195     Argument(const Record &Arg, StringRef Attr)
 196       : lowerName(Arg.getValueAsString("Name")), upperName(lowerName),
 197         attrName(Attr), isOpt(false), Fake(false) {
 198       if (!lowerName.empty()) {
 199         lowerName[0] = std::tolower(lowerName[0]);
 200         upperName[0] = std::toupper(upperName[0]);
 201       }
 202       // Work around MinGW's macro definition of 'interface' to 'struct'. We
 203       // have an attribute argument called 'Interface', so only the lower case
 204       // name conflicts with the macro definition.
 205       if (lowerName == "interface")
 206         lowerName = "interface_";
 207     }
 208     virtual ~Argument() = default;
 209
 210     StringRef getLowerName() const { return lowerName; }
 211     StringRef getUpperName() const { return upperName; }
 212     StringRef getAttrName() const { return attrName; }
 213
 214     bool isOptional() const { return isOpt; }
 215     void setOptional(bool set) { isOpt = set; }
 216
 217     bool isFake() const { return Fake; }
 218     void setFake(bool fake) { Fake = fake; }
 219
 220     // These functions print the argument contents formatted in different ways.
 221     virtual void writeAccessors(raw_ostream &OS) const = 0;
 222     virtual void writeAccessorDefinitions(raw_ostream &OS) const {}
 223     virtual void writeASTVisitorTraversal(raw_ostream &OS) const {}
 224     virtual void writeCloneArgs(raw_ostream &OS) const = 0;
 225     virtual void writeTemplateInstantiationArgs(raw_ostream &OS) const = 0;
 226     virtual void writeTemplateInstantiation(raw_ostream &OS) const {}
 227     virtual void writeCtorBody(raw_ostream &OS) const {}
 228     virtual void writeCtorInitializers(raw_ostream &OS) const = 0;
 229     virtual void writeCtorDefaultInitializers(raw_ostream &OS) const = 0;
 230     virtual void writeCtorParameters(raw_ostream &OS) const = 0;
 231     virtual void writeDeclarations(raw_ostream &OS) const = 0;
 232     virtual void writePCHReadArgs(raw_ostream &OS) const = 0;
 233     virtual void writePCHReadDecls(raw_ostream &OS) const = 0;
 234     virtual void writePCHWrite(raw_ostream &OS) const = 0;
 235     virtual std::string getIsOmitted() const { return "false"; }
 236     virtual void writeValue(raw_ostream &OS) const = 0;
 237     virtual void writeDump(raw_ostream &OS) const = 0;
 238     virtual void writeDumpChildren(raw_ostream &OS) const {}
 239     virtual void writeHasChildren(raw_ostream &OS) const { OS << "false"; }
 240
 241     virtual bool isEnumArg() const { return false; }
 242     virtual bool isVariadicEnumArg() const { return false; }
 243     virtual bool isVariadic() const { return false; }
 244
 245     virtual void writeImplicitCtorArgs(raw_ostream &OS) const {
 246       OS << getUpperName();
 247     }
 248   };
 249
 250   class SimpleArgument : public Argument {
 251     std::string type;
 252
 253   public:
 254     SimpleArgument(const Record &Arg, StringRef Attr, std::string T)
 255         : Argument(Arg, Attr), type(std::move(T)) {}
 256
 257     std::string getType() const { return type; }
 258
 259     void writeAccessors(raw_ostream &OS) const override {
 260       OS << "  " << type << " get" << getUpperName() << "() const {\n";
 261       OS << "    return " << getLowerName() << ";\n";
 262       OS << "  }";
 263     }
 264
 265     void writeCloneArgs(raw_ostream &OS) const override {
 266       OS << getLowerName();
 267     }
 268
 269     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
 270       OS << "A->get" << getUpperName() << "()";
 271     }
 272
 273     void writeCtorInitializers(raw_ostream &OS) const override {
 274       OS << getLowerName() << "(" << getUpperName() << ")";
 275     }
 276
 277     void writeCtorDefaultInitializers(raw_ostream &OS) const override {
 278       OS << getLowerName() << "()";
 279     }
 280
 281     void writeCtorParameters(raw_ostream &OS) const override {
 282       OS << type << " " << getUpperName();
 283     }
 284
 285     void writeDeclarations(raw_ostream &OS) const override {
 286       OS << type << " " << getLowerName() << ";";
 287     }
 288
 289     void writePCHReadDecls(raw_ostream &OS) const override {
 290       std::string read = ReadPCHRecord(type);
 291       OS << "    " << type << " " << getLowerName() << " = " << read << ";\n";
 292     }
 293
 294     void writePCHReadArgs(raw_ostream &OS) const override {
 295       OS << getLowerName();
 296     }
 297
 298     void writePCHWrite(raw_ostream &OS) const override {
 299       OS << "    " << WritePCHRecord(type, "SA->get" +
 300                                            std::string(getUpperName()) + "()");
 301     }
 302
 303     std::string getIsOmitted() const override {
 304       if (type == "IdentifierInfo *")
 305         return "!get" + getUpperName().str() + "()";
 306       if (type == "ParamIdx")
 307         return "!get" + getUpperName().str() + "().isValid()";
 308       return "false";
 309     }
 310
 311     void writeValue(raw_ostream &OS) const override {
 312       if (type == "FunctionDecl *")
 313         OS << "\" << get" << getUpperName()
 314            << "()->getNameInfo().getAsString() << \"";
 315       else if (type == "IdentifierInfo *")
 316         // Some non-optional (comma required) identifier arguments can be the
 317         // empty string but are then recorded as a nullptr.
 318         OS << "\" << (get" << getUpperName() << "() ? get" << getUpperName()
 319            << "()->getName() : \"\") << \"";
 320       else if (type == "TypeSourceInfo *")
 321         OS << "\" << get" << getUpperName() << "().getAsString() << \"";
 322       else if (type == "ParamIdx")
 323         OS << "\" << get" << getUpperName() << "().getSourceIndex() << \"";
 324       else
 325         OS << "\" << get" << getUpperName() << "() << \"";
 326     }
 327
 328     void writeDump(raw_ostream &OS) const override {
 329       if (type == "FunctionDecl *" || type == "NamedDecl *") {
 330         OS << "    OS << \" \";\n";
 331         OS << "    dumpBareDeclRef(SA->get" << getUpperName() << "());\n";
 332       } else if (type == "IdentifierInfo *") {
 333         // Some non-optional (comma required) identifier arguments can be the
 334         // empty string but are then recorded as a nullptr.
 335         OS << "    if (SA->get" << getUpperName() << "())\n"
 336            << "      OS << \" \" << SA->get" << getUpperName()
 337            << "()->getName();\n";
 338       } else if (type == "TypeSourceInfo *") {
 339         OS << "    OS << \" \" << SA->get" << getUpperName()
 340            << "().getAsString();\n";
 341       } else if (type == "bool") {
 342         OS << "    if (SA->get" << getUpperName() << "()) OS << \" "
 343            << getUpperName() << "\";\n";
 344       } else if (type == "int" || type == "unsigned") {
 345         OS << "    OS << \" \" << SA->get" << getUpperName() << "();\n";
 346       } else if (type == "ParamIdx") {
 347         if (isOptional())
 348           OS << "    if (SA->get" << getUpperName() << "().isValid())\n  ";
 349         OS << "    OS << \" \" << SA->get" << getUpperName()
 350            << "().getSourceIndex();\n";
 351       } else {
 352         llvm_unreachable("Unknown SimpleArgument type!");
 353       }
 354     }
 355   };
 356
 357   class DefaultSimpleArgument : public SimpleArgument {
 358     int64_t Default;
 359
 360   public:
 361     DefaultSimpleArgument(const Record &Arg, StringRef Attr,
 362                           std::string T, int64_t Default)
 363       : SimpleArgument(Arg, Attr, T), Default(Default) {}
 364
 365     void writeAccessors(raw_ostream &OS) const override {
 366       SimpleArgument::writeAccessors(OS);
 367
 368       OS << "\n\n  static const " << getType() << " Default" << getUpperName()
 369          << " = ";
 370       if (getType() == "bool")
 371         OS << (Default != 0 ? "true" : "false");
 372       else
 373         OS << Default;
 374       OS << ";";
 375     }
 376   };
 377
 378   class StringArgument : public Argument {
 379   public:
 380     StringArgument(const Record &Arg, StringRef Attr)
 381       : Argument(Arg, Attr)
 382     {}
 383
 384     void writeAccessors(raw_ostream &OS) const override {
 385       OS << "  llvm::StringRef get" << getUpperName() << "() const {\n";
 386       OS << "    return llvm::StringRef(" << getLowerName() << ", "
 387          << getLowerName() << "Length);\n";
 388       OS << "  }\n";
 389       OS << "  unsigned get" << getUpperName() << "Length() const {\n";
 390       OS << "    return " << getLowerName() << "Length;\n";
 391       OS << "  }\n";
 392       OS << "  void set" << getUpperName()
 393          << "(ASTContext &C, llvm::StringRef S) {\n";
 394       OS << "    " << getLowerName() << "Length = S.size();\n";
 395       OS << "    this->" << getLowerName() << " = new (C, 1) char ["
 396          << getLowerName() << "Length];\n";
 397       OS << "    if (!S.empty())\n";
 398       OS << "      std::memcpy(this->" << getLowerName() << ", S.data(), "
 399          << getLowerName() << "Length);\n";
 400       OS << "  }";
 401     }
 402
 403     void writeCloneArgs(raw_ostream &OS) const override {
 404       OS << "get" << getUpperName() << "()";
 405     }
 406
 407     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
 408       OS << "A->get" << getUpperName() << "()";
 409     }
 410
 411     void writeCtorBody(raw_ostream &OS) const override {
 412       OS << "      if (!" << getUpperName() << ".empty())\n";
 413       OS << "        std::memcpy(" << getLowerName() << ", " << getUpperName()
 414          << ".data(), " << getLowerName() << "Length);\n";
 415     }
 416
 417     void writeCtorInitializers(raw_ostream &OS) const override {
 418       OS << getLowerName() << "Length(" << getUpperName() << ".size()),"
 419          << getLowerName() << "(new (Ctx, 1) char[" << getLowerName()
 420          << "Length])";
 421     }
 422
 423     void writeCtorDefaultInitializers(raw_ostream &OS) const override {
 424       OS << getLowerName() << "Length(0)," << getLowerName() << "(nullptr)";
 425     }
 426
 427     void writeCtorParameters(raw_ostream &OS) const override {
 428       OS << "llvm::StringRef " << getUpperName();
 429     }
 430
 431     void writeDeclarations(raw_ostream &OS) const override {
 432       OS << "unsigned " << getLowerName() << "Length;\n";
 433       OS << "char *" << getLowerName() << ";";
 434     }
 435
 436     void writePCHReadDecls(raw_ostream &OS) const override {
 437       OS << "    std::string " << getLowerName()
 438          << "= Record.readString();\n";
 439     }
 440
 441     void writePCHReadArgs(raw_ostream &OS) const override {
 442       OS << getLowerName();
 443     }
 444
 445     void writePCHWrite(raw_ostream &OS) const override {
 446       OS << "    Record.AddString(SA->get" << getUpperName() << "());\n";
 447     }
 448
 449     void writeValue(raw_ostream &OS) const override {
 450       OS << "\\\"\" << get" << getUpperName() << "() << \"\\\"";
 451     }
 452
 453     void writeDump(raw_ostream &OS) const override {
 454       OS << "    OS << \" \\\"\" << SA->get" << getUpperName()
 455          << "() << \"\\\"\";\n";
 456     }
 457   };
 458
 459   class AlignedArgument : public Argument {
 460   public:
 461     AlignedArgument(const Record &Arg, StringRef Attr)
 462       : Argument(Arg, Attr)
 463     {}
 464
 465     void writeAccessors(raw_ostream &OS) const override {
 466       OS << "  bool is" << getUpperName() << "Dependent() const;\n";
 467
 468       OS << "  unsigned get" << getUpperName() << "(ASTContext &Ctx) const;\n";
 469
 470       OS << "  bool is" << getUpperName() << "Expr() const {\n";
 471       OS << "    return is" << getLowerName() << "Expr;\n";
 472       OS << "  }\n";
 473
 474       OS << "  Expr *get" << getUpperName() << "Expr() const {\n";
 475       OS << "    assert(is" << getLowerName() << "Expr);\n";
 476       OS << "    return " << getLowerName() << "Expr;\n";
 477       OS << "  }\n";
 478
 479       OS << "  TypeSourceInfo *get" << getUpperName() << "Type() const {\n";
 480       OS << "    assert(!is" << getLowerName() << "Expr);\n";
 481       OS << "    return " << getLowerName() << "Type;\n";
 482       OS << "  }";
 483     }
 484
 485     void writeAccessorDefinitions(raw_ostream &OS) const override {
 486       OS << "bool " << getAttrName() << "Attr::is" << getUpperName()
 487          << "Dependent() const {\n";
 488       OS << "  if (is" << getLowerName() << "Expr)\n";
 489       OS << "    return " << getLowerName() << "Expr && (" << getLowerName()
 490          << "Expr->isValueDependent() || " << getLowerName()
 491          << "Expr->isTypeDependent());\n";
 492       OS << "  else\n";
 493       OS << "    return " << getLowerName()
 494          << "Type->getType()->isDependentType();\n";
 495       OS << "}\n";
 496
 497       // FIXME: Do not do the calculation here
 498       // FIXME: Handle types correctly
 499       // A null pointer means maximum alignment
 500       OS << "unsigned " << getAttrName() << "Attr::get" << getUpperName()
 501          << "(ASTContext &Ctx) const {\n";
 502       OS << "  assert(!is" << getUpperName() << "Dependent());\n";
 503       OS << "  if (is" << getLowerName() << "Expr)\n";
 504       OS << "    return " << getLowerName() << "Expr ? " << getLowerName()
 505          << "Expr->EvaluateKnownConstInt(Ctx).getZExtValue()"
 506          << " * Ctx.getCharWidth() : "
 507          << "Ctx.getTargetDefaultAlignForAttributeAligned();\n";
 508       OS << "  else\n";
 509       OS << "    return 0; // FIXME\n";
 510       OS << "}\n";
 511     }
 512
 513     void writeASTVisitorTraversal(raw_ostream &OS) const override {
 514       StringRef Name = getUpperName();
 515       OS << "  if (A->is" << Name << "Expr()) {\n"
 516          << "    if (!getDerived().TraverseStmt(A->get" << Name << "Expr()))\n"
 517          << "      return false;\n"
 518          << "  } else if (auto *TSI = A->get" << Name << "Type()) {\n"
 519          << "    if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))\n"
 520          << "      return false;\n"
 521          << "  }\n";
 522     }
 523
 524     void writeCloneArgs(raw_ostream &OS) const override {
 525       OS << "is" << getLowerName() << "Expr, is" << getLowerName()
 526          << "Expr ? static_cast<void*>(" << getLowerName()
 527          << "Expr) : " << getLowerName()
 528          << "Type";
 529     }
 530
 531     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
 532       // FIXME: move the definition in Sema::InstantiateAttrs to here.
 533       // In the meantime, aligned attributes are cloned.
 534     }
 535
 536     void writeCtorBody(raw_ostream &OS) const override {
 537       OS << "    if (is" << getLowerName() << "Expr)\n";
 538       OS << "       " << getLowerName() << "Expr = reinterpret_cast<Expr *>("
 539          << getUpperName() << ");\n";
 540       OS << "    else\n";
 541       OS << "       " << getLowerName()
 542          << "Type = reinterpret_cast<TypeSourceInfo *>(" << getUpperName()
 543          << ");\n";
 544     }
 545
 546     void writeCtorInitializers(raw_ostream &OS) const override {
 547       OS << "is" << getLowerName() << "Expr(Is" << getUpperName() << "Expr)";
 548     }
 549
 550     void writeCtorDefaultInitializers(raw_ostream &OS) const override {
 551       OS << "is" << getLowerName() << "Expr(false)";
 552     }
 553
 554     void writeCtorParameters(raw_ostream &OS) const override {
 555       OS << "bool Is" << getUpperName() << "Expr, void *" << getUpperName();
 556     }
 557
 558     void writeImplicitCtorArgs(raw_ostream &OS) const override {
 559       OS << "Is" << getUpperName() << "Expr, " << getUpperName();
 560     }
 561
 562     void writeDeclarations(raw_ostream &OS) const override {
 563       OS << "bool is" << getLowerName() << "Expr;\n";
 564       OS << "union {\n";
 565       OS << "Expr *" << getLowerName() << "Expr;\n";
 566       OS << "TypeSourceInfo *" << getLowerName() << "Type;\n";
 567       OS << "};";
 568     }
 569
 570     void writePCHReadArgs(raw_ostream &OS) const override {
 571       OS << "is" << getLowerName() << "Expr, " << getLowerName() << "Ptr";
 572     }
 573
 574     void writePCHReadDecls(raw_ostream &OS) const override {
 575       OS << "    bool is" << getLowerName() << "Expr = Record.readInt();\n";
 576       OS << "    void *" << getLowerName() << "Ptr;\n";
 577       OS << "    if (is" << getLowerName() << "Expr)\n";
 578       OS << "      " << getLowerName() << "Ptr = Record.readExpr();\n";
 579       OS << "    else\n";
 580       OS << "      " << getLowerName()
 581          << "Ptr = Record.getTypeSourceInfo();\n";
 582     }
 583
 584     void writePCHWrite(raw_ostream &OS) const override {
 585       OS << "    Record.push_back(SA->is" << getUpperName() << "Expr());\n";
 586       OS << "    if (SA->is" << getUpperName() << "Expr())\n";
 587       OS << "      Record.AddStmt(SA->get" << getUpperName() << "Expr());\n";
 588       OS << "    else\n";
 589       OS << "      Record.AddTypeSourceInfo(SA->get" << getUpperName()
 590          << "Type());\n";
 591     }
 592
 593     std::string getIsOmitted() const override {
 594       return "!is" + getLowerName().str() + "Expr || !" + getLowerName().str()
 595              + "Expr";
 596     }
 597
 598     void writeValue(raw_ostream &OS) const override {
 599       OS << "\";\n";
 600       OS << "    " << getLowerName()
 601          << "Expr->printPretty(OS, nullptr, Policy);\n";
 602       OS << "    OS << \"";
 603     }
 604
 605     void writeDump(raw_ostream &OS) const override {
 606       OS << "    if (!SA->is" << getUpperName() << "Expr())\n";
 607       OS << "      dumpType(SA->get" << getUpperName()
 608          << "Type()->getType());\n";
 609     }
 610
 611     void writeDumpChildren(raw_ostream &OS) const override {
 612       OS << "    if (SA->is" << getUpperName() << "Expr())\n";
 613       OS << "      Visit(SA->get" << getUpperName() << "Expr());\n";
 614     }
 615
 616     void writeHasChildren(raw_ostream &OS) const override {
 617       OS << "SA->is" << getUpperName() << "Expr()";
 618     }
 619   };
 620
 621   class VariadicArgument : public Argument {
 622     std::string Type, ArgName, ArgSizeName, RangeName;
 623
 624   protected:
 625     // Assumed to receive a parameter: raw_ostream OS.
 626     virtual void writeValueImpl(raw_ostream &OS) const {
 627       OS << "    OS << Val;\n";
 628     }
 629     // Assumed to receive a parameter: raw_ostream OS.
 630     virtual void writeDumpImpl(raw_ostream &OS) const {
 631       OS << "      OS << \" \" << Val;\n";
 632     }
 633
 634   public:
 635     VariadicArgument(const Record &Arg, StringRef Attr, std::string T)
 636         : Argument(Arg, Attr), Type(std::move(T)),
 637           ArgName(getLowerName().str() + "_"), ArgSizeName(ArgName + "Size"),
 638           RangeName(getLowerName()) {}
 639
 640     const std::string &getType() const { return Type; }
 641     const std::string &getArgName() const { return ArgName; }
 642     const std::string &getArgSizeName() const { return ArgSizeName; }
 643     bool isVariadic() const override { return true; }
 644
 645     void writeAccessors(raw_ostream &OS) const override {
 646       std::string IteratorType = getLowerName().str() + "_iterator";
 647       std::string BeginFn = getLowerName().str() + "_begin()";
 648       std::string EndFn = getLowerName().str() + "_end()";
 649
 650       OS << "  typedef " << Type << "* " << IteratorType << ";\n";
 651       OS << "  " << IteratorType << " " << BeginFn << " const {"
 652          << " return " << ArgName << "; }\n";
 653       OS << "  " << IteratorType << " " << EndFn << " const {"
 654          << " return " << ArgName << " + " << ArgSizeName << "; }\n";
 655       OS << "  unsigned " << getLowerName() << "_size() const {"
 656          << " return " << ArgSizeName << "; }\n";
 657       OS << "  llvm::iterator_range<" << IteratorType << "> " << RangeName
 658          << "() const { return llvm::make_range(" << BeginFn << ", " << EndFn
 659          << "); }\n";
 660     }
 661
 662     void writeCloneArgs(raw_ostream &OS) const override {
 663       OS << ArgName << ", " << ArgSizeName;
 664     }
 665
 666     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
 667       // This isn't elegant, but we have to go through public methods...
 668       OS << "A->" << getLowerName() << "_begin(), "
 669          << "A->" << getLowerName() << "_size()";
 670     }
 671
 672     void writeASTVisitorTraversal(raw_ostream &OS) const override {
 673       // FIXME: Traverse the elements.
 674     }
 675
 676     void writeCtorBody(raw_ostream &OS) const override {
 677       OS << "    std::copy(" << getUpperName() << ", " << getUpperName()
 678          << " + " << ArgSizeName << ", " << ArgName << ");\n";
 679     }
 680
 681     void writeCtorInitializers(raw_ostream &OS) const override {
 682       OS << ArgSizeName << "(" << getUpperName() << "Size), "
 683          << ArgName << "(new (Ctx, 16) " << getType() << "["
 684          << ArgSizeName << "])";
 685     }
 686
 687     void writeCtorDefaultInitializers(raw_ostream &OS) const override {
 688       OS << ArgSizeName << "(0), " << ArgName << "(nullptr)";
 689     }
 690
 691     void writeCtorParameters(raw_ostream &OS) const override {
 692       OS << getType() << " *" << getUpperName() << ", unsigned "
 693          << getUpperName() << "Size";
 694     }
 695
 696     void writeImplicitCtorArgs(raw_ostream &OS) const override {
 697       OS << getUpperName() << ", " << getUpperName() << "Size";
 698     }
 699
 700     void writeDeclarations(raw_ostream &OS) const override {
 701       OS << "  unsigned " << ArgSizeName << ";\n";
 702       OS << "  " << getType() << " *" << ArgName << ";";
 703     }
 704
 705     void writePCHReadDecls(raw_ostream &OS) const override {
 706       OS << "    unsigned " << getLowerName() << "Size = Record.readInt();\n";
 707       OS << "    SmallVector<" << getType() << ", 4> "
 708          << getLowerName() << ";\n";
 709       OS << "    " << getLowerName() << ".reserve(" << getLowerName()
 710          << "Size);\n";
 711
 712       // If we can't store the values in the current type (if it's something
 713       // like StringRef), store them in a different type and convert the
 714       // container afterwards.
 715       std::string StorageType = getStorageType(getType());
 716       std::string StorageName = getLowerName();
 717       if (StorageType != getType()) {
 718         StorageName += "Storage";
 719         OS << "    SmallVector<" << StorageType << ", 4> "
 720            << StorageName << ";\n";
 721         OS << "    " << StorageName << ".reserve(" << getLowerName()
 722            << "Size);\n";
 723       }
 724
 725       OS << "    for (unsigned i = 0; i != " << getLowerName() << "Size; ++i)\n";
 726       std::string read = ReadPCHRecord(Type);
 727       OS << "      " << StorageName << ".push_back(" << read << ");\n";
 728
 729       if (StorageType != getType()) {
 730         OS << "    for (unsigned i = 0; i != " << getLowerName() << "Size; ++i)\n";
 731         OS << "      " << getLowerName() << ".push_back("
 732            << StorageName << "[i]);\n";
 733       }
 734     }
 735
 736     void writePCHReadArgs(raw_ostream &OS) const override {
 737       OS << getLowerName() << ".data(), " << getLowerName() << "Size";
 738     }
 739
 740     void writePCHWrite(raw_ostream &OS) const override {
 741       OS << "    Record.push_back(SA->" << getLowerName() << "_size());\n";
 742       OS << "    for (auto &Val : SA->" << RangeName << "())\n";
 743       OS << "      " << WritePCHRecord(Type, "Val");
 744     }
 745
 746     void writeValue(raw_ostream &OS) const override {
 747       OS << "\";\n";
 748       OS << "  bool isFirst = true;\n"
 749          << "  for (const auto &Val : " << RangeName << "()) {\n"
 750          << "    if (isFirst) isFirst = false;\n"
 751          << "    else OS << \", \";\n";
 752       writeValueImpl(OS);
 753       OS << "  }\n";
 754       OS << "  OS << \"";
 755     }
 756
 757     void writeDump(raw_ostream &OS) const override {
 758       OS << "    for (const auto &Val : SA->" << RangeName << "())\n";
 759       writeDumpImpl(OS);
 760     }
 761   };
 762
 763   class VariadicParamIdxArgument : public VariadicArgument {
 764   public:
 765     VariadicParamIdxArgument(const Record &Arg, StringRef Attr)
 766         : VariadicArgument(Arg, Attr, "ParamIdx") {}
 767
 768   public:
 769     void writeValueImpl(raw_ostream &OS) const override {
 770       OS << "    OS << Val.getSourceIndex();\n";
 771     }
 772
 773     void writeDumpImpl(raw_ostream &OS) const override {
 774       OS << "      OS << \" \" << Val.getSourceIndex();\n";
 775     }
 776   };
 777
 778   struct VariadicParamOrParamIdxArgument : public VariadicArgument {
 779     VariadicParamOrParamIdxArgument(const Record &Arg, StringRef Attr)
 780         : VariadicArgument(Arg, Attr, "int") {}
 781   };
 782
 783   // Unique the enums, but maintain the original declaration ordering.
 784   std::vector<StringRef>
 785   uniqueEnumsInOrder(const std::vector<StringRef> &enums) {
 786     std::vector<StringRef> uniques;
 787     SmallDenseSet<StringRef, 8> unique_set;
 788     for (const auto &i : enums) {
 789       if (unique_set.insert(i).second)
 790         uniques.push_back(i);
 791     }
 792     return uniques;
 793   }
 794
 795   class EnumArgument : public Argument {
 796     std::string type;
 797     std::vector<StringRef> values, enums, uniques;
 798
 799   public:
 800     EnumArgument(const Record &Arg, StringRef Attr)
 801       : Argument(Arg, Attr), type(Arg.getValueAsString("Type")),
 802         values(Arg.getValueAsListOfStrings("Values")),
 803         enums(Arg.getValueAsListOfStrings("Enums")),
 804         uniques(uniqueEnumsInOrder(enums))
 805     {
 806       // FIXME: Emit a proper error
 807       assert(!uniques.empty());
 808     }
 809
 810     bool isEnumArg() const override { return true; }
 811
 812     void writeAccessors(raw_ostream &OS) const override {
 813       OS << "  " << type << " get" << getUpperName() << "() const {\n";
 814       OS << "    return " << getLowerName() << ";\n";
 815       OS << "  }";
 816     }
 817
 818     void writeCloneArgs(raw_ostream &OS) const override {
 819       OS << getLowerName();
 820     }
 821
 822     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
 823       OS << "A->get" << getUpperName() << "()";
 824     }
 825     void writeCtorInitializers(raw_ostream &OS) const override {
 826       OS << getLowerName() << "(" << getUpperName() << ")";
 827     }
 828     void writeCtorDefaultInitializers(raw_ostream &OS) const override {
 829       OS << getLowerName() << "(" << type << "(0))";
 830     }
 831     void writeCtorParameters(raw_ostream &OS) const override {
 832       OS << type << " " << getUpperName();
 833     }
 834     void writeDeclarations(raw_ostream &OS) const override {
 835       auto i = uniques.cbegin(), e = uniques.cend();
 836       // The last one needs to not have a comma.
 837       --e;
 838
 839       OS << "public:\n";
 840       OS << "  enum " << type << " {\n";
 841       for (; i != e; ++i)
 842         OS << "    " << *i << ",\n";
 843       OS << "    " << *e << "\n";
 844       OS << "  };\n";
 845       OS << "private:\n";
 846       OS << "  " << type << " " << getLowerName() << ";";
 847     }
 848
 849     void writePCHReadDecls(raw_ostream &OS) const override {
 850       OS << "    " << getAttrName() << "Attr::" << type << " " << getLowerName()
 851          << "(static_cast<" << getAttrName() << "Attr::" << type
 852          << ">(Record.readInt()));\n";
 853     }
 854
 855     void writePCHReadArgs(raw_ostream &OS) const override {
 856       OS << getLowerName();
 857     }
 858
 859     void writePCHWrite(raw_ostream &OS) const override {
 860       OS << "Record.push_back(SA->get" << getUpperName() << "());\n";
 861     }
 862
 863     void writeValue(raw_ostream &OS) const override {
 864       // FIXME: this isn't 100% correct -- some enum arguments require printing
 865       // as a string literal, while others require printing as an identifier.
 866       // Tablegen currently does not distinguish between the two forms.
 867       OS << "\\\"\" << " << getAttrName() << "Attr::Convert" << type << "ToStr(get"
 868          << getUpperName() << "()) << \"\\\"";
 869     }
 870
 871     void writeDump(raw_ostream &OS) const override {
 872       OS << "    switch(SA->get" << getUpperName() << "()) {\n";
 873       for (const auto &I : uniques) {
 874         OS << "    case " << getAttrName() << "Attr::" << I << ":\n";
 875         OS << "      OS << \" " << I << "\";\n";
 876         OS << "      break;\n";
 877       }
 878       OS << "    }\n";
 879     }
 880
 881     void writeConversion(raw_ostream &OS) const {
 882       OS << "  static bool ConvertStrTo" << type << "(StringRef Val, ";
 883       OS << type << " &Out) {\n";
 884       OS << "    Optional<" << type << "> R = llvm::StringSwitch<Optional<";
 885       OS << type << ">>(Val)\n";
 886       for (size_t I = 0; I < enums.size(); ++I) {
 887         OS << "      .Case(\"" << values[I] << "\", ";
 888         OS << getAttrName() << "Attr::" << enums[I] << ")\n";
 889       }
 890       OS << "      .Default(Optional<" << type << ">());\n";
 891       OS << "    if (R) {\n";
 892       OS << "      Out = *R;\n      return true;\n    }\n";
 893       OS << "    return false;\n";
 894       OS << "  }\n\n";
 895
 896       // Mapping from enumeration values back to enumeration strings isn't
 897       // trivial because some enumeration values have multiple named
 898       // enumerators, such as type_visibility(internal) and
 899       // type_visibility(hidden) both mapping to TypeVisibilityAttr::Hidden.
 900       OS << "  static const char *Convert" << type << "ToStr("
 901          << type << " Val) {\n"
 902          << "    switch(Val) {\n";
 903       SmallDenseSet<StringRef, 8> Uniques;
 904       for (size_t I = 0; I < enums.size(); ++I) {
 905         if (Uniques.insert(enums[I]).second)
 906           OS << "    case " << getAttrName() << "Attr::" << enums[I]
 907              << ": return \"" << values[I] << "\";\n";
 908       }
 909       OS << "    }\n"
 910          << "    llvm_unreachable(\"No enumerator with that value\");\n"
 911          << "  }\n";
 912     }
 913   };
 914
 915   class VariadicEnumArgument: public VariadicArgument {
 916     std::string type, QualifiedTypeName;
 917     std::vector<StringRef> values, enums, uniques;
 918
 919   protected:
 920     void writeValueImpl(raw_ostream &OS) const override {
 921       // FIXME: this isn't 100% correct -- some enum arguments require printing
 922       // as a string literal, while others require printing as an identifier.
 923       // Tablegen currently does not distinguish between the two forms.
 924       OS << "    OS << \"\\\"\" << " << getAttrName() << "Attr::Convert" << type
 925          << "ToStr(Val)" << "<< \"\\\"\";\n";
 926     }
 927
 928   public:
 929     VariadicEnumArgument(const Record &Arg, StringRef Attr)
 930       : VariadicArgument(Arg, Attr, Arg.getValueAsString("Type")),
 931         type(Arg.getValueAsString("Type")),
 932         values(Arg.getValueAsListOfStrings("Values")),
 933         enums(Arg.getValueAsListOfStrings("Enums")),
 934         uniques(uniqueEnumsInOrder(enums))
 935     {
 936       QualifiedTypeName = getAttrName().str() + "Attr::" + type;
 937
 938       // FIXME: Emit a proper error
 939       assert(!uniques.empty());
 940     }
 941
 942     bool isVariadicEnumArg() const override { return true; }
 943
 944     void writeDeclarations(raw_ostream &OS) const override {
 945       auto i = uniques.cbegin(), e = uniques.cend();
 946       // The last one needs to not have a comma.
 947       --e;
 948
 949       OS << "public:\n";
 950       OS << "  enum " << type << " {\n";
 951       for (; i != e; ++i)
 952         OS << "    " << *i << ",\n";
 953       OS << "    " << *e << "\n";
 954       OS << "  };\n";
 955       OS << "private:\n";
 956
 957       VariadicArgument::writeDeclarations(OS);
 958     }
 959
 960     void writeDump(raw_ostream &OS) const override {
 961       OS << "    for (" << getAttrName() << "Attr::" << getLowerName()
 962          << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
 963          << getLowerName() << "_end(); I != E; ++I) {\n";
 964       OS << "      switch(*I) {\n";
 965       for (const auto &UI : uniques) {
 966         OS << "    case " << getAttrName() << "Attr::" << UI << ":\n";
 967         OS << "      OS << \" " << UI << "\";\n";
 968         OS << "      break;\n";
 969       }
 970       OS << "      }\n";
 971       OS << "    }\n";
 972     }
 973
 974     void writePCHReadDecls(raw_ostream &OS) const override {
 975       OS << "    unsigned " << getLowerName() << "Size = Record.readInt();\n";
 976       OS << "    SmallVector<" << QualifiedTypeName << ", 4> " << getLowerName()
 977          << ";\n";
 978       OS << "    " << getLowerName() << ".reserve(" << getLowerName()
 979          << "Size);\n";
 980       OS << "    for (unsigned i = " << getLowerName() << "Size; i; --i)\n";
 981       OS << "      " << getLowerName() << ".push_back(" << "static_cast<"
 982          << QualifiedTypeName << ">(Record.readInt()));\n";
 983     }
 984
 985     void writePCHWrite(raw_ostream &OS) const override {
 986       OS << "    Record.push_back(SA->" << getLowerName() << "_size());\n";
 987       OS << "    for (" << getAttrName() << "Attr::" << getLowerName()
 988          << "_iterator i = SA->" << getLowerName() << "_begin(), e = SA->"
 989          << getLowerName() << "_end(); i != e; ++i)\n";
 990       OS << "      " << WritePCHRecord(QualifiedTypeName, "(*i)");
 991     }
 992
 993     void writeConversion(raw_ostream &OS) const {
 994       OS << "  static bool ConvertStrTo" << type << "(StringRef Val, ";
 995       OS << type << " &Out) {\n";
 996       OS << "    Optional<" << type << "> R = llvm::StringSwitch<Optional<";
 997       OS << type << ">>(Val)\n";
 998       for (size_t I = 0; I < enums.size(); ++I) {
 999         OS << "      .Case(\"" << values[I] << "\", ";
1000         OS << getAttrName() << "Attr::" << enums[I] << ")\n";
1001       }
1002       OS << "      .Default(Optional<" << type << ">());\n";
1003       OS << "    if (R) {\n";
1004       OS << "      Out = *R;\n      return true;\n    }\n";
1005       OS << "    return false;\n";
1006       OS << "  }\n\n";
1007
1008       OS << "  static const char *Convert" << type << "ToStr("
1009         << type << " Val) {\n"
1010         << "    switch(Val) {\n";
1011       SmallDenseSet<StringRef, 8> Uniques;
1012       for (size_t I = 0; I < enums.size(); ++I) {
1013         if (Uniques.insert(enums[I]).second)
1014           OS << "    case " << getAttrName() << "Attr::" << enums[I]
1015           << ": return \"" << values[I] << "\";\n";
1016       }
1017       OS << "    }\n"
1018         << "    llvm_unreachable(\"No enumerator with that value\");\n"
1019         << "  }\n";
1020     }
1021   };
1022
1023   class VersionArgument : public Argument {
1024   public:
1025     VersionArgument(const Record &Arg, StringRef Attr)
1026       : Argument(Arg, Attr)
1027     {}
1028
1029     void writeAccessors(raw_ostream &OS) const override {
1030       OS << "  VersionTuple get" << getUpperName() << "() const {\n";
1031       OS << "    return " << getLowerName() << ";\n";
1032       OS << "  }\n";
1033       OS << "  void set" << getUpperName()
1034          << "(ASTContext &C, VersionTuple V) {\n";
1035       OS << "    " << getLowerName() << " = V;\n";
1036       OS << "  }";
1037     }
1038
1039     void writeCloneArgs(raw_ostream &OS) const override {
1040       OS << "get" << getUpperName() << "()";
1041     }
1042
1043     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
1044       OS << "A->get" << getUpperName() << "()";
1045     }
1046
1047     void writeCtorInitializers(raw_ostream &OS) const override {
1048       OS << getLowerName() << "(" << getUpperName() << ")";
1049     }
1050
1051     void writeCtorDefaultInitializers(raw_ostream &OS) const override {
1052       OS << getLowerName() << "()";
1053     }
1054
1055     void writeCtorParameters(raw_ostream &OS) const override {
1056       OS << "VersionTuple " << getUpperName();
1057     }
1058
1059     void writeDeclarations(raw_ostream &OS) const override {
1060       OS << "VersionTuple " << getLowerName() << ";\n";
1061     }
1062
1063     void writePCHReadDecls(raw_ostream &OS) const override {
1064       OS << "    VersionTuple " << getLowerName()
1065          << "= Record.readVersionTuple();\n";
1066     }
1067
1068     void writePCHReadArgs(raw_ostream &OS) const override {
1069       OS << getLowerName();
1070     }
1071
1072     void writePCHWrite(raw_ostream &OS) const override {
1073       OS << "    Record.AddVersionTuple(SA->get" << getUpperName() << "());\n";
1074     }
1075
1076     void writeValue(raw_ostream &OS) const override {
1077       OS << getLowerName() << "=\" << get" << getUpperName() << "() << \"";
1078     }
1079
1080     void writeDump(raw_ostream &OS) const override {
1081       OS << "    OS << \" \" << SA->get" << getUpperName() << "();\n";
1082     }
1083   };
1084
1085   class ExprArgument : public SimpleArgument {
1086   public:
1087     ExprArgument(const Record &Arg, StringRef Attr)
1088       : SimpleArgument(Arg, Attr, "Expr *")
1089     {}
1090
1091     void writeASTVisitorTraversal(raw_ostream &OS) const override {
1092       OS << "  if (!"
1093          << "getDerived().TraverseStmt(A->get" << getUpperName() << "()))\n";
1094       OS << "    return false;\n";
1095     }
1096
1097     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
1098       OS << "tempInst" << getUpperName();
1099     }
1100
1101     void writeTemplateInstantiation(raw_ostream &OS) const override {
1102       OS << "      " << getType() << " tempInst" << getUpperName() << ";\n";
1103       OS << "      {\n";
1104       OS << "        EnterExpressionEvaluationContext "
1105          << "Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);\n";
1106       OS << "        ExprResult " << "Result = S.SubstExpr("
1107          << "A->get" << getUpperName() << "(), TemplateArgs);\n";
1108       OS << "        tempInst" << getUpperName() << " = "
1109          << "Result.getAs<Expr>();\n";
1110       OS << "      }\n";
1111     }
1112
1113     void writeDump(raw_ostream &OS) const override {}
1114
1115     void writeDumpChildren(raw_ostream &OS) const override {
1116       OS << "    Visit(SA->get" << getUpperName() << "());\n";
1117     }
1118
1119     void writeHasChildren(raw_ostream &OS) const override { OS << "true"; }
1120   };
1121
1122   class VariadicExprArgument : public VariadicArgument {
1123   public:
1124     VariadicExprArgument(const Record &Arg, StringRef Attr)
1125       : VariadicArgument(Arg, Attr, "Expr *")
1126     {}
1127
1128     void writeASTVisitorTraversal(raw_ostream &OS) const override {
1129       OS << "  {\n";
1130       OS << "    " << getType() << " *I = A->" << getLowerName()
1131          << "_begin();\n";
1132       OS << "    " << getType() << " *E = A->" << getLowerName()
1133          << "_end();\n";
1134       OS << "    for (; I != E; ++I) {\n";
1135       OS << "      if (!getDerived().TraverseStmt(*I))\n";
1136       OS << "        return false;\n";
1137       OS << "    }\n";
1138       OS << "  }\n";
1139     }
1140
1141     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
1142       OS << "tempInst" << getUpperName() << ", "
1143          << "A->" << getLowerName() << "_size()";
1144     }
1145
1146     void writeTemplateInstantiation(raw_ostream &OS) const override {
1147       OS << "      auto *tempInst" << getUpperName()
1148          << " = new (C, 16) " << getType()
1149          << "[A->" << getLowerName() << "_size()];\n";
1150       OS << "      {\n";
1151       OS << "        EnterExpressionEvaluationContext "
1152          << "Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);\n";
1153       OS << "        " << getType() << " *TI = tempInst" << getUpperName()
1154          << ";\n";
1155       OS << "        " << getType() << " *I = A->" << getLowerName()
1156          << "_begin();\n";
1157       OS << "        " << getType() << " *E = A->" << getLowerName()
1158          << "_end();\n";
1159       OS << "        for (; I != E; ++I, ++TI) {\n";
1160       OS << "          ExprResult Result = S.SubstExpr(*I, TemplateArgs);\n";
1161       OS << "          *TI = Result.getAs<Expr>();\n";
1162       OS << "        }\n";
1163       OS << "      }\n";
1164     }
1165
1166     void writeDump(raw_ostream &OS) const override {}
1167
1168     void writeDumpChildren(raw_ostream &OS) const override {
1169       OS << "    for (" << getAttrName() << "Attr::" << getLowerName()
1170          << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
1171          << getLowerName() << "_end(); I != E; ++I)\n";
1172       OS << "      Visit(*I);\n";
1173     }
1174
1175     void writeHasChildren(raw_ostream &OS) const override {
1176       OS << "SA->" << getLowerName() << "_begin() != "
1177          << "SA->" << getLowerName() << "_end()";
1178     }
1179   };
1180
1181   class VariadicIdentifierArgument : public VariadicArgument {
1182   public:
1183     VariadicIdentifierArgument(const Record &Arg, StringRef Attr)
1184       : VariadicArgument(Arg, Attr, "IdentifierInfo *")
1185     {}
1186   };
1187
1188   class VariadicStringArgument : public VariadicArgument {
1189   public:
1190     VariadicStringArgument(const Record &Arg, StringRef Attr)
1191       : VariadicArgument(Arg, Attr, "StringRef")
1192     {}
1193
1194     void writeCtorBody(raw_ostream &OS) const override {
1195       OS << "    for (size_t I = 0, E = " << getArgSizeName() << "; I != E;\n"
1196             "         ++I) {\n"
1197             "      StringRef Ref = " << getUpperName() << "[I];\n"
1198             "      if (!Ref.empty()) {\n"
1199             "        char *Mem = new (Ctx, 1) char[Ref.size()];\n"
1200             "        std::memcpy(Mem, Ref.data(), Ref.size());\n"
1201             "        " << getArgName() << "[I] = StringRef(Mem, Ref.size());\n"
1202             "      }\n"
1203             "    }\n";
1204     }
1205
1206     void writeValueImpl(raw_ostream &OS) const override {
1207       OS << "    OS << \"\\\"\" << Val << \"\\\"\";\n";
1208     }
1209   };
1210
1211   class TypeArgument : public SimpleArgument {
1212   public:
1213     TypeArgument(const Record &Arg, StringRef Attr)
1214       : SimpleArgument(Arg, Attr, "TypeSourceInfo *")
1215     {}
1216
1217     void writeAccessors(raw_ostream &OS) const override {
1218       OS << "  QualType get" << getUpperName() << "() const {\n";
1219       OS << "    return " << getLowerName() << "->getType();\n";
1220       OS << "  }";
1221       OS << "  " << getType() << " get" << getUpperName() << "Loc() const {\n";
1222       OS << "    return " << getLowerName() << ";\n";
1223       OS << "  }";
1224     }
1225
1226     void writeASTVisitorTraversal(raw_ostream &OS) const override {
1227       OS << "  if (auto *TSI = A->get" << getUpperName() << "Loc())\n";
1228       OS << "    if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))\n";
1229       OS << "      return false;\n";
1230     }
1231
1232     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
1233       OS << "A->get" << getUpperName() << "Loc()";
1234     }
1235
1236     void writePCHWrite(raw_ostream &OS) const override {
1237       OS << "    " << WritePCHRecord(
1238           getType(), "SA->get" + std::string(getUpperName()) + "Loc()");
1239     }
1240   };
1241
1242 } // end anonymous namespace
1243
1244 static std::unique_ptr<Argument>
1245 createArgument(const Record &Arg, StringRef Attr,
1246                const Record *Search = nullptr) {
1247   if (!Search)
1248     Search = &Arg;
1249
1250   std::unique_ptr<Argument> Ptr;
1251   llvm::StringRef ArgName = Search->getName();
1252
1253   if (ArgName == "AlignedArgument")
1254     Ptr = llvm::make_unique<AlignedArgument>(Arg, Attr);
1255   else if (ArgName == "EnumArgument")
1256     Ptr = llvm::make_unique<EnumArgument>(Arg, Attr);
1257   else if (ArgName == "ExprArgument")
1258     Ptr = llvm::make_unique<ExprArgument>(Arg, Attr);
1259   else if (ArgName == "FunctionArgument")
1260     Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "FunctionDecl *");
1261   else if (ArgName == "NamedArgument")
1262     Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "NamedDecl *");
1263   else if (ArgName == "IdentifierArgument")
1264     Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "IdentifierInfo *");
1265   else if (ArgName == "DefaultBoolArgument")
1266     Ptr = llvm::make_unique<DefaultSimpleArgument>(
1267         Arg, Attr, "bool", Arg.getValueAsBit("Default"));
1268   else if (ArgName == "BoolArgument")
1269     Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "bool");
1270   else if (ArgName == "DefaultIntArgument")
1271     Ptr = llvm::make_unique<DefaultSimpleArgument>(
1272         Arg, Attr, "int", Arg.getValueAsInt("Default"));
1273   else if (ArgName == "IntArgument")
1274     Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "int");
1275   else if (ArgName == "StringArgument")
1276     Ptr = llvm::make_unique<StringArgument>(Arg, Attr);
1277   else if (ArgName == "TypeArgument")
1278     Ptr = llvm::make_unique<TypeArgument>(Arg, Attr);
1279   else if (ArgName == "UnsignedArgument")
1280     Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "unsigned");
1281   else if (ArgName == "VariadicUnsignedArgument")
1282     Ptr = llvm::make_unique<VariadicArgument>(Arg, Attr, "unsigned");
1283   else if (ArgName == "VariadicStringArgument")
1284     Ptr = llvm::make_unique<VariadicStringArgument>(Arg, Attr);
1285   else if (ArgName == "VariadicEnumArgument")
1286     Ptr = llvm::make_unique<VariadicEnumArgument>(Arg, Attr);
1287   else if (ArgName == "VariadicExprArgument")
1288     Ptr = llvm::make_unique<VariadicExprArgument>(Arg, Attr);
1289   else if (ArgName == "VariadicParamIdxArgument")
1290     Ptr = llvm::make_unique<VariadicParamIdxArgument>(Arg, Attr);
1291   else if (ArgName == "VariadicParamOrParamIdxArgument")
1292     Ptr = llvm::make_unique<VariadicParamOrParamIdxArgument>(Arg, Attr);
1293   else if (ArgName == "ParamIdxArgument")
1294     Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "ParamIdx");
1295   else if (ArgName == "VariadicIdentifierArgument")
1296     Ptr = llvm::make_unique<VariadicIdentifierArgument>(Arg, Attr);
1297   else if (ArgName == "VersionArgument")
1298     Ptr = llvm::make_unique<VersionArgument>(Arg, Attr);
1299
1300   if (!Ptr) {
1301     // Search in reverse order so that the most-derived type is handled first.
1302     ArrayRef<std::pair<Record*, SMRange>> Bases = Search->getSuperClasses();
1303     for (const auto &Base : llvm::reverse(Bases)) {
1304       if ((Ptr = createArgument(Arg, Attr, Base.first)))
1305         break;
1306     }
1307   }
1308
1309   if (Ptr && Arg.getValueAsBit("Optional"))
1310     Ptr->setOptional(true);
1311
1312   if (Ptr && Arg.getValueAsBit("Fake"))
1313     Ptr->setFake(true);
1314
1315   return Ptr;
1316 }
1317
1318 static void writeAvailabilityValue(raw_ostream &OS) {
1319   OS << "\" << getPlatform()->getName();\n"
1320      << "  if (getStrict()) OS << \", strict\";\n"
1321      << "  if (!getIntroduced().empty()) OS << \", introduced=\" << getIntroduced();\n"
1322      << "  if (!getDeprecated().empty()) OS << \", deprecated=\" << getDeprecated();\n"
1323      << "  if (!getObsoleted().empty()) OS << \", obsoleted=\" << getObsoleted();\n"
1324      << "  if (getUnavailable()) OS << \", unavailable\";\n"
1325      << "  OS << \"";
1326 }
1327
1328 static void writeDeprecatedAttrValue(raw_ostream &OS, std::string &Variety) {
1329   OS << "\\\"\" << getMessage() << \"\\\"\";\n";
1330   // Only GNU deprecated has an optional fixit argument at the second position.
1331   if (Variety == "GNU")
1332      OS << "    if (!getReplacement().empty()) OS << \", \\\"\""
1333            " << getReplacement() << \"\\\"\";\n";
1334   OS << "    OS << \"";
1335 }
1336
1337 static void writeGetSpellingFunction(Record &R, raw_ostream &OS) {
1338   std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
1339
1340   OS << "const char *" << R.getName() << "Attr::getSpelling() const {\n";
1341   if (Spellings.empty()) {
1342     OS << "  return \"(No spelling)\";\n}\n\n";
1343     return;
1344   }
1345
1346   OS << "  switch (SpellingListIndex) {\n"
1347         "  default:\n"
1348         "    llvm_unreachable(\"Unknown attribute spelling!\");\n"
1349         "    return \"(No spelling)\";\n";
1350
1351   for (unsigned I = 0; I < Spellings.size(); ++I)
1352     OS << "  case " << I << ":\n"
1353           "    return \"" << Spellings[I].name() << "\";\n";
1354   // End of the switch statement.
1355   OS << "  }\n";
1356   // End of the getSpelling function.
1357   OS << "}\n\n";
1358 }
1359
1360 static void
1361 writePrettyPrintFunction(Record &R,
1362                          const std::vector<std::unique_ptr<Argument>> &Args,
1363                          raw_ostream &OS) {
1364   std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
1365
1366   OS << "void " << R.getName() << "Attr::printPretty("
1367     << "raw_ostream &OS, const PrintingPolicy &Policy) const {\n";
1368
1369   if (Spellings.empty()) {
1370     OS << "}\n\n";
1371     return;
1372   }
1373
1374   OS <<
1375     "  switch (SpellingListIndex) {\n"
1376     "  default:\n"
1377     "    llvm_unreachable(\"Unknown attribute spelling!\");\n"
1378     "    break;\n";
1379
1380   for (unsigned I = 0; I < Spellings.size(); ++ I) {
1381     llvm::SmallString<16> Prefix;
1382     llvm::SmallString<8> Suffix;
1383     // The actual spelling of the name and namespace (if applicable)
1384     // of an attribute without considering prefix and suffix.
1385     llvm::SmallString<64> Spelling;
1386     std::string Name = Spellings[I].name();
1387     std::string Variety = Spellings[I].variety();
1388
1389     if (Variety == "GNU") {
1390       Prefix = " __attribute__((";
1391       Suffix = "))";
1392     } else if (Variety == "CXX11" || Variety == "C2x") {
1393       Prefix = " [[";
1394       Suffix = "]]";
1395       std::string Namespace = Spellings[I].nameSpace();
1396       if (!Namespace.empty()) {
1397         Spelling += Namespace;
1398         Spelling += "::";
1399       }
1400     } else if (Variety == "Declspec") {
1401       Prefix = " __declspec(";
1402       Suffix = ")";
1403     } else if (Variety == "Microsoft") {
1404       Prefix = "[";
1405       Suffix = "]";
1406     } else if (Variety == "Keyword") {
1407       Prefix = " ";
1408       Suffix = "";
1409     } else if (Variety == "Pragma") {
1410       Prefix = "#pragma ";
1411       Suffix = "\n";
1412       std::string Namespace = Spellings[I].nameSpace();
1413       if (!Namespace.empty()) {
1414         Spelling += Namespace;
1415         Spelling += " ";
1416       }
1417     } else {
1418       llvm_unreachable("Unknown attribute syntax variety!");
1419     }
1420
1421     Spelling += Name;
1422
1423     OS <<
1424       "  case " << I << " : {\n"
1425       "    OS << \"" << Prefix << Spelling;
1426
1427     if (Variety == "Pragma") {
1428       OS << "\";\n";
1429       OS << "    printPrettyPragma(OS, Policy);\n";
1430       OS << "    OS << \"\\n\";";
1431       OS << "    break;\n";
1432       OS << "  }\n";
1433       continue;
1434     }
1435
1436     if (Spelling == "availability") {
1437       OS << "(";
1438       writeAvailabilityValue(OS);
1439       OS << ")";
1440     } else if (Spelling == "deprecated" || Spelling == "gnu::deprecated") {
1441       OS << "(";
1442       writeDeprecatedAttrValue(OS, Variety);
1443       OS << ")";
1444     } else {
1445       // To avoid printing parentheses around an empty argument list or
1446       // printing spurious commas at the end of an argument list, we need to
1447       // determine where the last provided non-fake argument is.
1448       unsigned NonFakeArgs = 0;
1449       unsigned TrailingOptArgs = 0;
1450       bool FoundNonOptArg = false;
1451       for (const auto &arg : llvm::reverse(Args)) {
1452         if (arg->isFake())
1453           continue;
1454         ++NonFakeArgs;
1455         if (FoundNonOptArg)
1456           continue;
1457         // FIXME: arg->getIsOmitted() == "false" means we haven't implemented
1458         // any way to detect whether the argument was omitted.
1459         if (!arg->isOptional() || arg->getIsOmitted() == "false") {
1460           FoundNonOptArg = true;
1461           continue;
1462         }
1463         if (!TrailingOptArgs++)
1464           OS << "\";\n"
1465              << "    unsigned TrailingOmittedArgs = 0;\n";
1466         OS << "    if (" << arg->getIsOmitted() << ")\n"
1467            << "      ++TrailingOmittedArgs;\n";
1468       }
1469       if (TrailingOptArgs)
1470         OS << "    OS << \"";
1471       if (TrailingOptArgs < NonFakeArgs)
1472         OS << "(";
1473       else if (TrailingOptArgs)
1474         OS << "\";\n"
1475            << "    if (TrailingOmittedArgs < " << NonFakeArgs << ")\n"
1476            << "       OS << \"(\";\n"
1477            << "    OS << \"";
1478       unsigned ArgIndex = 0;
1479       for (const auto &arg : Args) {
1480         if (arg->isFake())
1481           continue;
1482         if (ArgIndex) {
1483           if (ArgIndex >= NonFakeArgs - TrailingOptArgs)
1484             OS << "\";\n"
1485                << "    if (" << ArgIndex << " < " << NonFakeArgs
1486                << " - TrailingOmittedArgs)\n"
1487                << "      OS << \", \";\n"
1488                << "    OS << \"";
1489           else
1490             OS << ", ";
1491         }
1492         std::string IsOmitted = arg->getIsOmitted();
1493         if (arg->isOptional() && IsOmitted != "false")
1494           OS << "\";\n"
1495              << "    if (!(" << IsOmitted << ")) {\n"
1496              << "      OS << \"";
1497         arg->writeValue(OS);
1498         if (arg->isOptional() && IsOmitted != "false")
1499           OS << "\";\n"
1500              << "    }\n"
1501              << "    OS << \"";
1502         ++ArgIndex;
1503       }
1504       if (TrailingOptArgs < NonFakeArgs)
1505         OS << ")";
1506       else if (TrailingOptArgs)
1507         OS << "\";\n"
1508            << "    if (TrailingOmittedArgs < " << NonFakeArgs << ")\n"
1509            << "       OS << \")\";\n"
1510            << "    OS << \"";
1511     }
1512
1513     OS << Suffix + "\";\n";
1514
1515     OS <<
1516       "    break;\n"
1517       "  }\n";
1518   }
1519
1520   // End of the switch statement.
1521   OS << "}\n";
1522   // End of the print function.
1523   OS << "}\n\n";
1524 }
1525
1526 /// Return the index of a spelling in a spelling list.
1527 static unsigned
1528 getSpellingListIndex(const std::vector<FlattenedSpelling> &SpellingList,
1529                      const FlattenedSpelling &Spelling) {
1530   assert(!SpellingList.empty() && "Spelling list is empty!");
1531
1532   for (unsigned Index = 0; Index < SpellingList.size(); ++Index) {
1533     const FlattenedSpelling &S = SpellingList[Index];
1534     if (S.variety() != Spelling.variety())
1535       continue;
1536     if (S.nameSpace() != Spelling.nameSpace())
1537       continue;
1538     if (S.name() != Spelling.name())
1539       continue;
1540
1541     return Index;
1542   }
1543
1544   llvm_unreachable("Unknown spelling!");
1545 }
1546
1547 static void writeAttrAccessorDefinition(const Record &R, raw_ostream &OS) {
1548   std::vector<Record*> Accessors = R.getValueAsListOfDefs("Accessors");
1549   if (Accessors.empty())
1550     return;
1551
1552   const std::vector<FlattenedSpelling> SpellingList = GetFlattenedSpellings(R);
1553   assert(!SpellingList.empty() &&
1554          "Attribute with empty spelling list can't have accessors!");
1555   for (const auto *Accessor : Accessors) {
1556     const StringRef Name = Accessor->getValueAsString("Name");
1557     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Accessor);
1558
1559     OS << "  bool " << Name << "() const { return SpellingListIndex == ";
1560     for (unsigned Index = 0; Index < Spellings.size(); ++Index) {
1561       OS << getSpellingListIndex(SpellingList, Spellings[Index]);
1562       if (Index != Spellings.size() - 1)
1563         OS << " ||\n    SpellingListIndex == ";
1564       else
1565         OS << "; }\n";
1566     }
1567   }
1568 }
1569
1570 static bool
1571 SpellingNamesAreCommon(const std::vector<FlattenedSpelling>& Spellings) {
1572   assert(!Spellings.empty() && "An empty list of spellings was provided");
1573   std::string FirstName = NormalizeNameForSpellingComparison(
1574     Spellings.front().name());
1575   for (const auto &Spelling :
1576        llvm::make_range(std::next(Spellings.begin()), Spellings.end())) {
1577     std::string Name = NormalizeNameForSpellingComparison(Spelling.name());
1578     if (Name != FirstName)
1579       return false;
1580   }
1581   return true;
1582 }
1583
1584 typedef std::map<unsigned, std::string> SemanticSpellingMap;
1585 static std::string
1586 CreateSemanticSpellings(const std::vector<FlattenedSpelling> &Spellings,
1587                         SemanticSpellingMap &Map) {
1588   // The enumerants are automatically generated based on the variety,
1589   // namespace (if present) and name for each attribute spelling. However,
1590   // care is taken to avoid trampling on the reserved namespace due to
1591   // underscores.
1592   std::string Ret("  enum Spelling {\n");
1593   std::set<std::string> Uniques;
1594   unsigned Idx = 0;
1595   for (auto I = Spellings.begin(), E = Spellings.end(); I != E; ++I, ++Idx) {
1596     const FlattenedSpelling &S = *I;
1597     const std::string &Variety = S.variety();
1598     const std::string &Spelling = S.name();
1599     const std::string &Namespace = S.nameSpace();
1600     std::string EnumName;
1601
1602     EnumName += (Variety + "_");
1603     if (!Namespace.empty())
1604       EnumName += (NormalizeNameForSpellingComparison(Namespace).str() +
1605       "_");
1606     EnumName += NormalizeNameForSpellingComparison(Spelling);
1607
1608     // Even if the name is not unique, this spelling index corresponds to a
1609     // particular enumerant name that we've calculated.
1610     Map[Idx] = EnumName;
1611
1612     // Since we have been stripping underscores to avoid trampling on the
1613     // reserved namespace, we may have inadvertently created duplicate
1614     // enumerant names. These duplicates are not considered part of the
1615     // semantic spelling, and can be elided.
1616     if (Uniques.find(EnumName) != Uniques.end())
1617       continue;
1618
1619     Uniques.insert(EnumName);
1620     if (I != Spellings.begin())
1621       Ret += ",\n";
1622     // Duplicate spellings are not considered part of the semantic spelling
1623     // enumeration, but the spelling index and semantic spelling values are
1624     // meant to be equivalent, so we must specify a concrete value for each
1625     // enumerator.
1626     Ret += "    " + EnumName + " = " + llvm::utostr(Idx);
1627   }
1628   Ret += "\n  };\n\n";
1629   return Ret;
1630 }
1631
1632 void WriteSemanticSpellingSwitch(const std::string &VarName,
1633                                  const SemanticSpellingMap &Map,
1634                                  raw_ostream &OS) {
1635   OS << "  switch (" << VarName << ") {\n    default: "
1636     << "llvm_unreachable(\"Unknown spelling list index\");\n";
1637   for (const auto &I : Map)
1638     OS << "    case " << I.first << ": return " << I.second << ";\n";
1639   OS << "  }\n";
1640 }
1641
1642 // Emits the LateParsed property for attributes.
1643 static void emitClangAttrLateParsedList(RecordKeeper &Records, raw_ostream &OS) {
1644   OS << "#if defined(CLANG_ATTR_LATE_PARSED_LIST)\n";
1645   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1646
1647   for (const auto *Attr : Attrs) {
1648     bool LateParsed = Attr->getValueAsBit("LateParsed");
1649
1650     if (LateParsed) {
1651       std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
1652
1653       // FIXME: Handle non-GNU attributes
1654       for (const auto &I : Spellings) {
1655         if (I.variety() != "GNU")
1656           continue;
1657         OS << ".Case(\"" << I.name() << "\", " << LateParsed << ")\n";
1658       }
1659     }
1660   }
1661   OS << "#endif // CLANG_ATTR_LATE_PARSED_LIST\n\n";
1662 }
1663
1664 static bool hasGNUorCXX11Spelling(const Record &Attribute) {
1665   std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attribute);
1666   for (const auto &I : Spellings) {
1667     if (I.variety() == "GNU" || I.variety() == "CXX11")
1668       return true;
1669   }
1670   return false;
1671 }
1672
1673 namespace {
1674
1675 struct AttributeSubjectMatchRule {
1676   const Record *MetaSubject;
1677   const Record *Constraint;
1678
1679   AttributeSubjectMatchRule(const Record *MetaSubject, const Record *Constraint)
1680       : MetaSubject(MetaSubject), Constraint(Constraint) {
1681     assert(MetaSubject && "Missing subject");
1682   }
1683
1684   bool isSubRule() const { return Constraint != nullptr; }
1685
1686   std::vector<Record *> getSubjects() const {
1687     return (Constraint ? Constraint : MetaSubject)
1688         ->getValueAsListOfDefs("Subjects");
1689   }
1690
1691   std::vector<Record *> getLangOpts() const {
1692     if (Constraint) {
1693       // Lookup the options in the sub-rule first, in case the sub-rule
1694       // overrides the rules options.
1695       std::vector<Record *> Opts = Constraint->getValueAsListOfDefs("LangOpts");
1696       if (!Opts.empty())
1697         return Opts;
1698     }
1699     return MetaSubject->getValueAsListOfDefs("LangOpts");
1700   }
1701
1702   // Abstract rules are used only for sub-rules
1703   bool isAbstractRule() const { return getSubjects().empty(); }
1704
1705   StringRef getName() const {
1706     return (Constraint ? Constraint : MetaSubject)->getValueAsString("Name");
1707   }
1708
1709   bool isNegatedSubRule() const {
1710     assert(isSubRule() && "Not a sub-rule");
1711     return Constraint->getValueAsBit("Negated");
1712   }
1713
1714   std::string getSpelling() const {
1715     std::string Result = MetaSubject->getValueAsString("Name");
1716     if (isSubRule()) {
1717       Result += '(';
1718       if (isNegatedSubRule())
1719         Result += "unless(";
1720       Result += getName();
1721       if (isNegatedSubRule())
1722         Result += ')';
1723       Result += ')';
1724     }
1725     return Result;
1726   }
1727
1728   std::string getEnumValueName() const {
1729     SmallString<128> Result;
1730     Result += "SubjectMatchRule_";
1731     Result += MetaSubject->getValueAsString("Name");
1732     if (isSubRule()) {
1733       Result += "_";
1734       if (isNegatedSubRule())
1735         Result += "not_";
1736       Result += Constraint->getValueAsString("Name");
1737     }
1738     if (isAbstractRule())
1739       Result += "_abstract";
1740     return Result.str();
1741   }
1742
1743   std::string getEnumValue() const { return "attr::" + getEnumValueName(); }
1744
1745   static const char *EnumName;
1746 };
1747
1748 const char *AttributeSubjectMatchRule::EnumName = "attr::SubjectMatchRule";
1749
1750 struct PragmaClangAttributeSupport {
1751   std::vector<AttributeSubjectMatchRule> Rules;
1752
1753   class RuleOrAggregateRuleSet {
1754     std::vector<AttributeSubjectMatchRule> Rules;
1755     bool IsRule;
1756     RuleOrAggregateRuleSet(ArrayRef<AttributeSubjectMatchRule> Rules,
1757                            bool IsRule)
1758         : Rules(Rules), IsRule(IsRule) {}
1759
1760   public:
1761     bool isRule() const { return IsRule; }
1762
1763     const AttributeSubjectMatchRule &getRule() const {
1764       assert(IsRule && "not a rule!");
1765       return Rules[0];
1766     }
1767
1768     ArrayRef<AttributeSubjectMatchRule> getAggregateRuleSet() const {
1769       return Rules;
1770     }
1771
1772     static RuleOrAggregateRuleSet
1773     getRule(const AttributeSubjectMatchRule &Rule) {
1774       return RuleOrAggregateRuleSet(Rule, /*IsRule=*/true);
1775     }
1776     static RuleOrAggregateRuleSet
1777     getAggregateRuleSet(ArrayRef<AttributeSubjectMatchRule> Rules) {
1778       return RuleOrAggregateRuleSet(Rules, /*IsRule=*/false);
1779     }
1780   };
1781   llvm::DenseMap<const Record *, RuleOrAggregateRuleSet> SubjectsToRules;
1782
1783   PragmaClangAttributeSupport(RecordKeeper &Records);
1784
1785   bool isAttributedSupported(const Record &Attribute);
1786
1787   void emitMatchRuleList(raw_ostream &OS);
1788
1789   std::string generateStrictConformsTo(const Record &Attr, raw_ostream &OS);
1790
1791   void generateParsingHelpers(raw_ostream &OS);
1792 };
1793
1794 } // end anonymous namespace
1795
1796 static bool doesDeclDeriveFrom(const Record *D, const Record *Base) {
1797   const Record *CurrentBase = D->getValueAsDef("Base");
1798   if (!CurrentBase)
1799     return false;
1800   if (CurrentBase == Base)
1801     return true;
1802   return doesDeclDeriveFrom(CurrentBase, Base);
1803 }
1804
1805 PragmaClangAttributeSupport::PragmaClangAttributeSupport(
1806     RecordKeeper &Records) {
1807   std::vector<Record *> MetaSubjects =
1808       Records.getAllDerivedDefinitions("AttrSubjectMatcherRule");
1809   auto MapFromSubjectsToRules = [this](const Record *SubjectContainer,
1810                                        const Record *MetaSubject,
1811                                        const Record *Constraint) {
1812     Rules.emplace_back(MetaSubject, Constraint);
1813     std::vector<Record *> ApplicableSubjects =
1814         SubjectContainer->getValueAsListOfDefs("Subjects");
1815     for (const auto *Subject : ApplicableSubjects) {
1816       bool Inserted =
1817           SubjectsToRules
1818               .try_emplace(Subject, RuleOrAggregateRuleSet::getRule(
1819                                         AttributeSubjectMatchRule(MetaSubject,
1820                                                                   Constraint)))
1821               .second;
1822       if (!Inserted) {
1823         PrintFatalError("Attribute subject match rules should not represent"
1824                         "same attribute subjects.");
1825       }
1826     }
1827   };
1828   for (const auto *MetaSubject : MetaSubjects) {
1829     MapFromSubjectsToRules(MetaSubject, MetaSubject, /*Constraints=*/nullptr);
1830     std::vector<Record *> Constraints =
1831         MetaSubject->getValueAsListOfDefs("Constraints");
1832     for (const auto *Constraint : Constraints)
1833       MapFromSubjectsToRules(Constraint, MetaSubject, Constraint);
1834   }
1835
1836   std::vector<Record *> Aggregates =
1837       Records.getAllDerivedDefinitions("AttrSubjectMatcherAggregateRule");
1838   std::vector<Record *> DeclNodes = Records.getAllDerivedDefinitions("DDecl");
1839   for (const auto *Aggregate : Aggregates) {
1840     Record *SubjectDecl = Aggregate->getValueAsDef("Subject");
1841
1842     // Gather sub-classes of the aggregate subject that act as attribute
1843     // subject rules.
1844     std::vector<AttributeSubjectMatchRule> Rules;
1845     for (const auto *D : DeclNodes) {
1846       if (doesDeclDeriveFrom(D, SubjectDecl)) {
1847         auto It = SubjectsToRules.find(D);
1848         if (It == SubjectsToRules.end())
1849           continue;
1850         if (!It->second.isRule() || It->second.getRule().isSubRule())
1851           continue; // Assume that the rule will be included as well.
1852         Rules.push_back(It->second.getRule());
1853       }
1854     }
1855
1856     bool Inserted =
1857         SubjectsToRules
1858             .try_emplace(SubjectDecl,
1859                          RuleOrAggregateRuleSet::getAggregateRuleSet(Rules))
1860             .second;
1861     if (!Inserted) {
1862       PrintFatalError("Attribute subject match rules should not represent"
1863                       "same attribute subjects.");
1864     }
1865   }
1866 }
1867
1868 static PragmaClangAttributeSupport &
1869 getPragmaAttributeSupport(RecordKeeper &Records) {
1870   static PragmaClangAttributeSupport Instance(Records);
1871   return Instance;
1872 }
1873
1874 void PragmaClangAttributeSupport::emitMatchRuleList(raw_ostream &OS) {
1875   OS << "#ifndef ATTR_MATCH_SUB_RULE\n";
1876   OS << "#define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, "
1877         "IsNegated) "
1878      << "ATTR_MATCH_RULE(Value, Spelling, IsAbstract)\n";
1879   OS << "#endif\n";
1880   for (const auto &Rule : Rules) {
1881     OS << (Rule.isSubRule() ? "ATTR_MATCH_SUB_RULE" : "ATTR_MATCH_RULE") << '(';
1882     OS << Rule.getEnumValueName() << ", \"" << Rule.getSpelling() << "\", "
1883        << Rule.isAbstractRule();
1884     if (Rule.isSubRule())
1885       OS << ", "
1886          << AttributeSubjectMatchRule(Rule.MetaSubject, nullptr).getEnumValue()
1887          << ", " << Rule.isNegatedSubRule();
1888     OS << ")\n";
1889   }
1890   OS << "#undef ATTR_MATCH_SUB_RULE\n";
1891 }
1892
1893 bool PragmaClangAttributeSupport::isAttributedSupported(
1894     const Record &Attribute) {
1895   // If the attribute explicitly specified whether to support #pragma clang
1896   // attribute, use that setting.
1897   bool Unset;
1898   bool SpecifiedResult =
1899     Attribute.getValueAsBitOrUnset("PragmaAttributeSupport", Unset);
1900   if (!Unset)
1901     return SpecifiedResult;
1902
1903   // Opt-out rules:
1904   // An attribute requires delayed parsing (LateParsed is on)
1905   if (Attribute.getValueAsBit("LateParsed"))
1906     return false;
1907   // An attribute has no GNU/CXX11 spelling
1908   if (!hasGNUorCXX11Spelling(Attribute))
1909     return false;
1910   // An attribute subject list has a subject that isn't covered by one of the
1911   // subject match rules or has no subjects at all.
1912   if (Attribute.isValueUnset("Subjects"))
1913     return false;
1914   const Record *SubjectObj = Attribute.getValueAsDef("Subjects");
1915   std::vector<Record *> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
1916   if (Subjects.empty())
1917     return false;
1918   for (const auto *Subject : Subjects) {
1919     if (SubjectsToRules.find(Subject) == SubjectsToRules.end())
1920       return false;
1921   }
1922   return true;
1923 }
1924
1925 static std::string GenerateTestExpression(ArrayRef<Record *> LangOpts) {
1926   std::string Test;
1927
1928   for (auto *E : LangOpts) {
1929     if (!Test.empty())
1930       Test += " || ";
1931
1932     const StringRef Code = E->getValueAsString("CustomCode");
1933     if (!Code.empty()) {
1934       Test += "(";
1935       Test += Code;
1936       Test += ")";
1937     } else {
1938       Test += "LangOpts.";
1939       Test += E->getValueAsString("Name");
1940     }
1941   }
1942
1943   if (Test.empty())
1944     return "true";
1945
1946   return Test;
1947 }
1948
1949 std::string
1950 PragmaClangAttributeSupport::generateStrictConformsTo(const Record &Attr,
1951                                                       raw_ostream &OS) {
1952   if (!isAttributedSupported(Attr))
1953     return "nullptr";
1954   // Generate a function that constructs a set of matching rules that describe
1955   // to which declarations the attribute should apply to.
1956   std::string FnName = "matchRulesFor" + Attr.getName().str();
1957   OS << "static void " << FnName << "(llvm::SmallVectorImpl<std::pair<"
1958      << AttributeSubjectMatchRule::EnumName
1959      << ", bool>> &MatchRules, const LangOptions &LangOpts) {\n";
1960   if (Attr.isValueUnset("Subjects")) {
1961     OS << "}\n\n";
1962     return FnName;
1963   }
1964   const Record *SubjectObj = Attr.getValueAsDef("Subjects");
1965   std::vector<Record *> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
1966   for (const auto *Subject : Subjects) {
1967     auto It = SubjectsToRules.find(Subject);
1968     assert(It != SubjectsToRules.end() &&
1969            "This attribute is unsupported by #pragma clang attribute");
1970     for (const auto &Rule : It->getSecond().getAggregateRuleSet()) {
1971       // The rule might be language specific, so only subtract it from the given
1972       // rules if the specific language options are specified.
1973       std::vector<Record *> LangOpts = Rule.getLangOpts();
1974       OS << "  MatchRules.push_back(std::make_pair(" << Rule.getEnumValue()
1975          << ", /*IsSupported=*/" << GenerateTestExpression(LangOpts)
1976          << "));\n";
1977     }
1978   }
1979   OS << "}\n\n";
1980   return FnName;
1981 }
1982
1983 void PragmaClangAttributeSupport::generateParsingHelpers(raw_ostream &OS) {
1984   // Generate routines that check the names of sub-rules.
1985   OS << "Optional<attr::SubjectMatchRule> "
1986         "defaultIsAttributeSubjectMatchSubRuleFor(StringRef, bool) {\n";
1987   OS << "  return None;\n";
1988   OS << "}\n\n";
1989
1990   std::map<const Record *, std::vector<AttributeSubjectMatchRule>>
1991       SubMatchRules;
1992   for (const auto &Rule : Rules) {
1993     if (!Rule.isSubRule())
1994       continue;
1995     SubMatchRules[Rule.MetaSubject].push_back(Rule);
1996   }
1997
1998   for (const auto &SubMatchRule : SubMatchRules) {
1999     OS << "Optional<attr::SubjectMatchRule> isAttributeSubjectMatchSubRuleFor_"
2000        << SubMatchRule.first->getValueAsString("Name")
2001        << "(StringRef Name, bool IsUnless) {\n";
2002     OS << "  if (IsUnless)\n";
2003     OS << "    return "
2004           "llvm::StringSwitch<Optional<attr::SubjectMatchRule>>(Name).\n";
2005     for (const auto &Rule : SubMatchRule.second) {
2006       if (Rule.isNegatedSubRule())
2007         OS << "    Case(\"" << Rule.getName() << "\", " << Rule.getEnumValue()
2008            << ").\n";
2009     }
2010     OS << "    Default(None);\n";
2011     OS << "  return "
2012           "llvm::StringSwitch<Optional<attr::SubjectMatchRule>>(Name).\n";
2013     for (const auto &Rule : SubMatchRule.second) {
2014       if (!Rule.isNegatedSubRule())
2015         OS << "  Case(\"" << Rule.getName() << "\", " << Rule.getEnumValue()
2016            << ").\n";
2017     }
2018     OS << "  Default(None);\n";
2019     OS << "}\n\n";
2020   }
2021
2022   // Generate the function that checks for the top-level rules.
2023   OS << "std::pair<Optional<attr::SubjectMatchRule>, "
2024         "Optional<attr::SubjectMatchRule> (*)(StringRef, "
2025         "bool)> isAttributeSubjectMatchRule(StringRef Name) {\n";
2026   OS << "  return "
2027         "llvm::StringSwitch<std::pair<Optional<attr::SubjectMatchRule>, "
2028         "Optional<attr::SubjectMatchRule> (*) (StringRef, "
2029         "bool)>>(Name).\n";
2030   for (const auto &Rule : Rules) {
2031     if (Rule.isSubRule())
2032       continue;
2033     std::string SubRuleFunction;
2034     if (SubMatchRules.count(Rule.MetaSubject))
2035       SubRuleFunction =
2036           ("isAttributeSubjectMatchSubRuleFor_" + Rule.getName()).str();
2037     else
2038       SubRuleFunction = "defaultIsAttributeSubjectMatchSubRuleFor";
2039     OS << "  Case(\"" << Rule.getName() << "\", std::make_pair("
2040        << Rule.getEnumValue() << ", " << SubRuleFunction << ")).\n";
2041   }
2042   OS << "  Default(std::make_pair(None, "
2043         "defaultIsAttributeSubjectMatchSubRuleFor));\n";
2044   OS << "}\n\n";
2045
2046   // Generate the function that checks for the submatch rules.
2047   OS << "const char *validAttributeSubjectMatchSubRules("
2048      << AttributeSubjectMatchRule::EnumName << " Rule) {\n";
2049   OS << "  switch (Rule) {\n";
2050   for (const auto &SubMatchRule : SubMatchRules) {
2051     OS << "  case "
2052        << AttributeSubjectMatchRule(SubMatchRule.first, nullptr).getEnumValue()
2053        << ":\n";
2054     OS << "  return \"'";
2055     bool IsFirst = true;
2056     for (const auto &Rule : SubMatchRule.second) {
2057       if (!IsFirst)
2058         OS << ", '";
2059       IsFirst = false;
2060       if (Rule.isNegatedSubRule())
2061         OS << "unless(";
2062       OS << Rule.getName();
2063       if (Rule.isNegatedSubRule())
2064         OS << ')';
2065       OS << "'";
2066     }
2067     OS << "\";\n";
2068   }
2069   OS << "  default: return nullptr;\n";
2070   OS << "  }\n";
2071   OS << "}\n\n";
2072 }
2073
2074 template <typename Fn>
2075 static void forEachUniqueSpelling(const Record &Attr, Fn &&F) {
2076   std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
2077   SmallDenseSet<StringRef, 8> Seen;
2078   for (const FlattenedSpelling &S : Spellings) {
2079     if (Seen.insert(S.name()).second)
2080       F(S);
2081   }
2082 }
2083
2084 /// Emits the first-argument-is-type property for attributes.
2085 static void emitClangAttrTypeArgList(RecordKeeper &Records, raw_ostream &OS) {
2086   OS << "#if defined(CLANG_ATTR_TYPE_ARG_LIST)\n";
2087   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2088
2089   for (const auto *Attr : Attrs) {
2090     // Determine whether the first argument is a type.
2091     std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args");
2092     if (Args.empty())
2093       continue;
2094
2095     if (Args[0]->getSuperClasses().back().first->getName() != "TypeArgument")
2096       continue;
2097
2098     // All these spellings take a single type argument.
2099     forEachUniqueSpelling(*Attr, [&](const FlattenedSpelling &S) {
2100       OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
2101     });
2102   }
2103   OS << "#endif // CLANG_ATTR_TYPE_ARG_LIST\n\n";
2104 }
2105
2106 /// Emits the parse-arguments-in-unevaluated-context property for
2107 /// attributes.
2108 static void emitClangAttrArgContextList(RecordKeeper &Records, raw_ostream &OS) {
2109   OS << "#if defined(CLANG_ATTR_ARG_CONTEXT_LIST)\n";
2110   ParsedAttrMap Attrs = getParsedAttrList(Records);
2111   for (const auto &I : Attrs) {
2112     const Record &Attr = *I.second;
2113
2114     if (!Attr.getValueAsBit("ParseArgumentsAsUnevaluated"))
2115       continue;
2116
2117     // All these spellings take are parsed unevaluated.
2118     forEachUniqueSpelling(Attr, [&](const FlattenedSpelling &S) {
2119       OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
2120     });
2121   }
2122   OS << "#endif // CLANG_ATTR_ARG_CONTEXT_LIST\n\n";
2123 }
2124
2125 static bool isIdentifierArgument(Record *Arg) {
2126   return !Arg->getSuperClasses().empty() &&
2127     llvm::StringSwitch<bool>(Arg->getSuperClasses().back().first->getName())
2128     .Case("IdentifierArgument", true)
2129     .Case("EnumArgument", true)
2130     .Case("VariadicEnumArgument", true)
2131     .Default(false);
2132 }
2133
2134 static bool isVariadicIdentifierArgument(Record *Arg) {
2135   return !Arg->getSuperClasses().empty() &&
2136          llvm::StringSwitch<bool>(
2137              Arg->getSuperClasses().back().first->getName())
2138              .Case("VariadicIdentifierArgument", true)
2139              .Case("VariadicParamOrParamIdxArgument", true)
2140              .Default(false);
2141 }
2142
2143 static void emitClangAttrVariadicIdentifierArgList(RecordKeeper &Records,
2144                                                    raw_ostream &OS) {
2145   OS << "#if defined(CLANG_ATTR_VARIADIC_IDENTIFIER_ARG_LIST)\n";
2146   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2147   for (const auto *A : Attrs) {
2148     // Determine whether the first argument is a variadic identifier.
2149     std::vector<Record *> Args = A->getValueAsListOfDefs("Args");
2150     if (Args.empty() || !isVariadicIdentifierArgument(Args[0]))
2151       continue;
2152
2153     // All these spellings take an identifier argument.
2154     forEachUniqueSpelling(*A, [&](const FlattenedSpelling &S) {
2155       OS << ".Case(\"" << S.name() << "\", "
2156          << "true"
2157          << ")\n";
2158     });
2159   }
2160   OS << "#endif // CLANG_ATTR_VARIADIC_IDENTIFIER_ARG_LIST\n\n";
2161 }
2162
2163 // Emits the first-argument-is-identifier property for attributes.
2164 static void emitClangAttrIdentifierArgList(RecordKeeper &Records, raw_ostream &OS) {
2165   OS << "#if defined(CLANG_ATTR_IDENTIFIER_ARG_LIST)\n";
2166   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
2167
2168   for (const auto *Attr : Attrs) {
2169     // Determine whether the first argument is an identifier.
2170     std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args");
2171     if (Args.empty() || !isIdentifierArgument(Args[0]))
2172       continue;
2173
2174     // All these spellings take an identifier argument.
2175     forEachUniqueSpelling(*Attr, [&](const FlattenedSpelling &S) {
2176       OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
2177     });
2178   }
2179   OS << "#endif // CLANG_ATTR_IDENTIFIER_ARG_LIST\n\n";
2180 }
2181
2182 static bool keywordThisIsaIdentifierInArgument(const Record *Arg) {
2183   return !Arg->getSuperClasses().empty() &&
2184          llvm::StringSwitch<bool>(
2185              Arg->getSuperClasses().back().first->getName())
2186              .Case("VariadicParamOrParamIdxArgument", true)
2187              .Default(false);
2188 }
2189
2190 static void emitClangAttrThisIsaIdentifierArgList(RecordKeeper &Records,
2191                                                   raw_ostream &OS) {
2192   OS << "#if defined(CLANG_ATTR_THIS_ISA_IDENTIFIER_ARG_LIST)\n";
2193   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2194   for (const auto *A : Attrs) {
2195     // Determine whether the first argument is a variadic identifier.
2196     std::vector<Record *> Args = A->getValueAsListOfDefs("Args");
2197     if (Args.empty() || !keywordThisIsaIdentifierInArgument(Args[0]))
2198       continue;
2199
2200     // All these spellings take an identifier argument.
2201     forEachUniqueSpelling(*A, [&](const FlattenedSpelling &S) {
2202       OS << ".Case(\"" << S.name() << "\", "
2203          << "true"
2204          << ")\n";
2205     });
2206   }
2207   OS << "#endif // CLANG_ATTR_THIS_ISA_IDENTIFIER_ARG_LIST\n\n";
2208 }
2209
2210 namespace clang {
2211
2212 // Emits the class definitions for attributes.
2213 void EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS) {
2214   emitSourceFileHeader("Attribute classes' definitions", OS);
2215
2216   OS << "#ifndef LLVM_CLANG_ATTR_CLASSES_INC\n";
2217   OS << "#define LLVM_CLANG_ATTR_CLASSES_INC\n\n";
2218
2219   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
2220
2221   for (const auto *Attr : Attrs) {
2222     const Record &R = *Attr;
2223
2224     // FIXME: Currently, documentation is generated as-needed due to the fact
2225     // that there is no way to allow a generated project "reach into" the docs
2226     // directory (for instance, it may be an out-of-tree build). However, we want
2227     // to ensure that every attribute has a Documentation field, and produce an
2228     // error if it has been neglected. Otherwise, the on-demand generation which
2229     // happens server-side will fail. This code is ensuring that functionality,
2230     // even though this Emitter doesn't technically need the documentation.
2231     // When attribute documentation can be generated as part of the build
2232     // itself, this code can be removed.
2233     (void)R.getValueAsListOfDefs("Documentation");
2234
2235     if (!R.getValueAsBit("ASTNode"))
2236       continue;
2237
2238     ArrayRef<std::pair<Record *, SMRange>> Supers = R.getSuperClasses();
2239     assert(!Supers.empty() && "Forgot to specify a superclass for the attr");
2240     std::string SuperName;
2241     bool Inheritable = false;
2242     for (const auto &Super : llvm::reverse(Supers)) {
2243       const Record *R = Super.first;
2244       if (R->getName() != "TargetSpecificAttr" &&
2245           R->getName() != "DeclOrTypeAttr" && SuperName.empty())
2246         SuperName = R->getName();
2247       if (R->getName() == "InheritableAttr")
2248         Inheritable = true;
2249     }
2250
2251     OS << "class " << R.getName() << "Attr : public " << SuperName << " {\n";
2252
2253     std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
2254     std::vector<std::unique_ptr<Argument>> Args;
2255     Args.reserve(ArgRecords.size());
2256
2257     bool HasOptArg = false;
2258     bool HasFakeArg = false;
2259     for (const auto *ArgRecord : ArgRecords) {
2260       Args.emplace_back(createArgument(*ArgRecord, R.getName()));
2261       Args.back()->writeDeclarations(OS);
2262       OS << "\n\n";
2263
2264       // For these purposes, fake takes priority over optional.
2265       if (Args.back()->isFake()) {
2266         HasFakeArg = true;
2267       } else if (Args.back()->isOptional()) {
2268         HasOptArg = true;
2269       }
2270     }
2271
2272     OS << "public:\n";
2273
2274     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
2275
2276     // If there are zero or one spellings, all spelling-related functionality
2277     // can be elided. If all of the spellings share the same name, the spelling
2278     // functionality can also be elided.
2279     bool ElideSpelling = (Spellings.size() <= 1) ||
2280                          SpellingNamesAreCommon(Spellings);
2281
2282     // This maps spelling index values to semantic Spelling enumerants.
2283     SemanticSpellingMap SemanticToSyntacticMap;
2284
2285     if (!ElideSpelling)
2286       OS << CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
2287
2288     // Emit CreateImplicit factory methods.
2289     auto emitCreateImplicit = [&](bool emitFake) {
2290       OS << "  static " << R.getName() << "Attr *CreateImplicit(";
2291       OS << "ASTContext &Ctx";
2292       if (!ElideSpelling)
2293         OS << ", Spelling S";
2294       for (auto const &ai : Args) {
2295         if (ai->isFake() && !emitFake) continue;
2296         OS << ", ";
2297         ai->writeCtorParameters(OS);
2298       }
2299       OS << ", SourceRange Loc = SourceRange()";
2300       OS << ") {\n";
2301       OS << "    auto *A = new (Ctx) " << R.getName();
2302       OS << "Attr(Loc, Ctx, ";
2303       for (auto const &ai : Args) {
2304         if (ai->isFake() && !emitFake) continue;
2305         ai->writeImplicitCtorArgs(OS);
2306         OS << ", ";
2307       }
2308       OS << (ElideSpelling ? "0" : "S") << ");\n";
2309       OS << "    A->setImplicit(true);\n";
2310       OS << "    return A;\n  }\n\n";
2311     };
2312
2313     // Emit a CreateImplicit that takes all the arguments.
2314     emitCreateImplicit(true);
2315
2316     // Emit a CreateImplicit that takes all the non-fake arguments.
2317     if (HasFakeArg) {
2318       emitCreateImplicit(false);
2319     }
2320
2321     // Emit constructors.
2322     auto emitCtor = [&](bool emitOpt, bool emitFake) {
2323       auto shouldEmitArg = [=](const std::unique_ptr<Argument> &arg) {
2324         if (arg->isFake()) return emitFake;
2325         if (arg->isOptional()) return emitOpt;
2326         return true;
2327       };
2328
2329       OS << "  " << R.getName() << "Attr(SourceRange R, ASTContext &Ctx\n";
2330       for (auto const &ai : Args) {
2331         if (!shouldEmitArg(ai)) continue;
2332         OS << "              , ";
2333         ai->writeCtorParameters(OS);
2334         OS << "\n";
2335       }
2336
2337       OS << "              , ";
2338       OS << "unsigned SI\n";
2339
2340       OS << "             )\n";
2341       OS << "    : " << SuperName << "(attr::" << R.getName() << ", R, SI, "
2342          << ( R.getValueAsBit("LateParsed") ? "true" : "false" );
2343       if (Inheritable) {
2344         OS << ", "
2345            << (R.getValueAsBit("InheritEvenIfAlreadyPresent") ? "true"
2346                                                               : "false");
2347       }
2348       OS << ")\n";
2349
2350       for (auto const &ai : Args) {
2351         OS << "              , ";
2352         if (!shouldEmitArg(ai)) {
2353           ai->writeCtorDefaultInitializers(OS);
2354         } else {
2355           ai->writeCtorInitializers(OS);
2356         }
2357         OS << "\n";
2358       }
2359
2360       OS << "  {\n";
2361
2362       for (auto const &ai : Args) {
2363         if (!shouldEmitArg(ai)) continue;
2364         ai->writeCtorBody(OS);
2365       }
2366       OS << "  }\n\n";
2367     };
2368
2369     // Emit a constructor that includes all the arguments.
2370     // This is necessary for cloning.
2371     emitCtor(true, true);
2372
2373     // Emit a constructor that takes all the non-fake arguments.
2374     if (HasFakeArg) {
2375       emitCtor(true, false);
2376     }
2377
2378     // Emit a constructor that takes all the non-fake, non-optional arguments.
2379     if (HasOptArg) {
2380       emitCtor(false, false);
2381     }
2382
2383     OS << "  " << R.getName() << "Attr *clone(ASTContext &C) const;\n";
2384     OS << "  void printPretty(raw_ostream &OS,\n"
2385        << "                   const PrintingPolicy &Policy) const;\n";
2386     OS << "  const char *getSpelling() const;\n";
2387
2388     if (!ElideSpelling) {
2389       assert(!SemanticToSyntacticMap.empty() && "Empty semantic mapping list");
2390       OS << "  Spelling getSemanticSpelling() const {\n";
2391       WriteSemanticSpellingSwitch("SpellingListIndex", SemanticToSyntacticMap,
2392                                   OS);
2393       OS << "  }\n";
2394     }
2395
2396     writeAttrAccessorDefinition(R, OS);
2397
2398     for (auto const &ai : Args) {
2399       ai->writeAccessors(OS);
2400       OS << "\n\n";
2401
2402       // Don't write conversion routines for fake arguments.
2403       if (ai->isFake()) continue;
2404
2405       if (ai->isEnumArg())
2406         static_cast<const EnumArgument *>(ai.get())->writeConversion(OS);
2407       else if (ai->isVariadicEnumArg())
2408         static_cast<const VariadicEnumArgument *>(ai.get())
2409             ->writeConversion(OS);
2410     }
2411
2412     OS << R.getValueAsString("AdditionalMembers");
2413     OS << "\n\n";
2414
2415     OS << "  static bool classof(const Attr *A) { return A->getKind() == "
2416        << "attr::" << R.getName() << "; }\n";
2417
2418     OS << "};\n\n";
2419   }
2420
2421   OS << "#endif // LLVM_CLANG_ATTR_CLASSES_INC\n";
2422 }
2423
2424 // Emits the class method definitions for attributes.
2425 void EmitClangAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
2426   emitSourceFileHeader("Attribute classes' member function definitions", OS);
2427
2428   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
2429
2430   for (auto *Attr : Attrs) {
2431     Record &R = *Attr;
2432
2433     if (!R.getValueAsBit("ASTNode"))
2434       continue;
2435
2436     std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
2437     std::vector<std::unique_ptr<Argument>> Args;
2438     for (const auto *Arg : ArgRecords)
2439       Args.emplace_back(createArgument(*Arg, R.getName()));
2440
2441     for (auto const &ai : Args)
2442       ai->writeAccessorDefinitions(OS);
2443
2444     OS << R.getName() << "Attr *" << R.getName()
2445        << "Attr::clone(ASTContext &C) const {\n";
2446     OS << "  auto *A = new (C) " << R.getName() << "Attr(getLocation(), C";
2447     for (auto const &ai : Args) {
2448       OS << ", ";
2449       ai->writeCloneArgs(OS);
2450     }
2451     OS << ", getSpellingListIndex());\n";
2452     OS << "  A->Inherited = Inherited;\n";
2453     OS << "  A->IsPackExpansion = IsPackExpansion;\n";
2454     OS << "  A->Implicit = Implicit;\n";
2455     OS << "  return A;\n}\n\n";
2456
2457     writePrettyPrintFunction(R, Args, OS);
2458     writeGetSpellingFunction(R, OS);
2459   }
2460
2461   // Instead of relying on virtual dispatch we just create a huge dispatch
2462   // switch. This is both smaller and faster than virtual functions.
2463   auto EmitFunc = [&](const char *Method) {
2464     OS << "  switch (getKind()) {\n";
2465     for (const auto *Attr : Attrs) {
2466       const Record &R = *Attr;
2467       if (!R.getValueAsBit("ASTNode"))
2468         continue;
2469
2470       OS << "  case attr::" << R.getName() << ":\n";
2471       OS << "    return cast<" << R.getName() << "Attr>(this)->" << Method
2472          << ";\n";
2473     }
2474     OS << "  }\n";
2475     OS << "  llvm_unreachable(\"Unexpected attribute kind!\");\n";
2476     OS << "}\n\n";
2477   };
2478
2479   OS << "const char *Attr::getSpelling() const {\n";
2480   EmitFunc("getSpelling()");
2481
2482   OS << "Attr *Attr::clone(ASTContext &C) const {\n";
2483   EmitFunc("clone(C)");
2484
2485   OS << "void Attr::printPretty(raw_ostream &OS, "
2486         "const PrintingPolicy &Policy) const {\n";
2487   EmitFunc("printPretty(OS, Policy)");
2488 }
2489
2490 } // end namespace clang
2491
2492 static void emitAttrList(raw_ostream &OS, StringRef Class,
2493                          const std::vector<Record*> &AttrList) {
2494   for (auto Cur : AttrList) {
2495     OS << Class << "(" << Cur->getName() << ")\n";
2496   }
2497 }
2498
2499 // Determines if an attribute has a Pragma spelling.
2500 static bool AttrHasPragmaSpelling(const Record *R) {
2501   std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*R);
2502   return llvm::find_if(Spellings, [](const FlattenedSpelling &S) {
2503            return S.variety() == "Pragma";
2504          }) != Spellings.end();
2505 }
2506
2507 namespace {
2508
2509   struct AttrClassDescriptor {
2510     const char * const MacroName;
2511     const char * const TableGenName;
2512   };
2513
2514 } // end anonymous namespace
2515
2516 static const AttrClassDescriptor AttrClassDescriptors[] = {
2517   { "ATTR", "Attr" },
2518   { "TYPE_ATTR", "TypeAttr" },
2519   { "STMT_ATTR", "StmtAttr" },
2520   { "INHERITABLE_ATTR", "InheritableAttr" },
2521   { "DECL_OR_TYPE_ATTR", "DeclOrTypeAttr" },
2522   { "INHERITABLE_PARAM_ATTR", "InheritableParamAttr" },
2523   { "PARAMETER_ABI_ATTR", "ParameterABIAttr" }
2524 };
2525
2526 static void emitDefaultDefine(raw_ostream &OS, StringRef name,
2527                               const char *superName) {
2528   OS << "#ifndef " << name << "\n";
2529   OS << "#define " << name << "(NAME) ";
2530   if (superName) OS << superName << "(NAME)";
2531   OS << "\n#endif\n\n";
2532 }
2533
2534 namespace {
2535
2536   /// A class of attributes.
2537   struct AttrClass {
2538     const AttrClassDescriptor &Descriptor;
2539     Record *TheRecord;
2540     AttrClass *SuperClass = nullptr;
2541     std::vector<AttrClass*> SubClasses;
2542     std::vector<Record*> Attrs;
2543
2544     AttrClass(const AttrClassDescriptor &Descriptor, Record *R)
2545       : Descriptor(Descriptor), TheRecord(R) {}
2546
2547     void emitDefaultDefines(raw_ostream &OS) const {
2548       // Default the macro unless this is a root class (i.e. Attr).
2549       if (SuperClass) {
2550         emitDefaultDefine(OS, Descriptor.MacroName,
2551                           SuperClass->Descriptor.MacroName);
2552       }
2553     }
2554
2555     void emitUndefs(raw_ostream &OS) const {
2556       OS << "#undef " << Descriptor.MacroName << "\n";
2557     }
2558
2559     void emitAttrList(raw_ostream &OS) const {
2560       for (auto SubClass : SubClasses) {
2561         SubClass->emitAttrList(OS);
2562       }
2563
2564       ::emitAttrList(OS, Descriptor.MacroName, Attrs);
2565     }
2566
2567     void classifyAttrOnRoot(Record *Attr) {
2568       bool result = classifyAttr(Attr);
2569       assert(result && "failed to classify on root"); (void) result;
2570     }
2571
2572     void emitAttrRange(raw_ostream &OS) const {
2573       OS << "ATTR_RANGE(" << Descriptor.TableGenName
2574          << ", " << getFirstAttr()->getName()
2575          << ", " << getLastAttr()->getName() << ")\n";
2576     }
2577
2578   private:
2579     bool classifyAttr(Record *Attr) {
2580       // Check all the subclasses.
2581       for (auto SubClass : SubClasses) {
2582         if (SubClass->classifyAttr(Attr))
2583           return true;
2584       }
2585
2586       // It's not more specific than this class, but it might still belong here.
2587       if (Attr->isSubClassOf(TheRecord)) {
2588         Attrs.push_back(Attr);
2589         return true;
2590       }
2591
2592       return false;
2593     }
2594
2595     Record *getFirstAttr() const {
2596       if (!SubClasses.empty())
2597         return SubClasses.front()->getFirstAttr();
2598       return Attrs.front();
2599     }
2600
2601     Record *getLastAttr() const {
2602       if (!Attrs.empty())
2603         return Attrs.back();
2604       return SubClasses.back()->getLastAttr();
2605     }
2606   };
2607
2608   /// The entire hierarchy of attribute classes.
2609   class AttrClassHierarchy {
2610     std::vector<std::unique_ptr<AttrClass>> Classes;
2611
2612   public:
2613     AttrClassHierarchy(RecordKeeper &Records) {
2614       // Find records for all the classes.
2615       for (auto &Descriptor : AttrClassDescriptors) {
2616         Record *ClassRecord = Records.getClass(Descriptor.TableGenName);
2617         AttrClass *Class = new AttrClass(Descriptor, ClassRecord);
2618         Classes.emplace_back(Class);
2619       }
2620
2621       // Link up the hierarchy.
2622       for (auto &Class : Classes) {
2623         if (AttrClass *SuperClass = findSuperClass(Class->TheRecord)) {
2624           Class->SuperClass = SuperClass;
2625           SuperClass->SubClasses.push_back(Class.get());
2626         }
2627       }
2628
2629 #ifndef NDEBUG
2630       for (auto i = Classes.begin(), e = Classes.end(); i != e; ++i) {
2631         assert((i == Classes.begin()) == ((*i)->SuperClass == nullptr) &&
2632                "only the first class should be a root class!");
2633       }
2634 #endif
2635     }
2636
2637     void emitDefaultDefines(raw_ostream &OS) const {
2638       for (auto &Class : Classes) {
2639         Class->emitDefaultDefines(OS);
2640       }
2641     }
2642
2643     void emitUndefs(raw_ostream &OS) const {
2644       for (auto &Class : Classes) {
2645         Class->emitUndefs(OS);
2646       }
2647     }
2648
2649     void emitAttrLists(raw_ostream &OS) const {
2650       // Just start from the root class.
2651       Classes[0]->emitAttrList(OS);
2652     }
2653
2654     void emitAttrRanges(raw_ostream &OS) const {
2655       for (auto &Class : Classes)
2656         Class->emitAttrRange(OS);
2657     }
2658
2659     void classifyAttr(Record *Attr) {
2660       // Add the attribute to the root class.
2661       Classes[0]->classifyAttrOnRoot(Attr);
2662     }
2663
2664   private:
2665     AttrClass *findClassByRecord(Record *R) const {
2666       for (auto &Class : Classes) {
2667         if (Class->TheRecord == R)
2668           return Class.get();
2669       }
2670       return nullptr;
2671     }
2672
2673     AttrClass *findSuperClass(Record *R) const {
2674       // TableGen flattens the superclass list, so we just need to walk it
2675       // in reverse.
2676       auto SuperClasses = R->getSuperClasses();
2677       for (signed i = 0, e = SuperClasses.size(); i != e; ++i) {
2678         auto SuperClass = findClassByRecord(SuperClasses[e - i - 1].first);
2679         if (SuperClass) return SuperClass;
2680       }
2681       return nullptr;
2682     }
2683   };
2684
2685 } // end anonymous namespace
2686
2687 namespace clang {
2688
2689 // Emits the enumeration list for attributes.
2690 void EmitClangAttrList(RecordKeeper &Records, raw_ostream &OS) {
2691   emitSourceFileHeader("List of all attributes that Clang recognizes", OS);
2692
2693   AttrClassHierarchy Hierarchy(Records);
2694
2695   // Add defaulting macro definitions.
2696   Hierarchy.emitDefaultDefines(OS);
2697   emitDefaultDefine(OS, "PRAGMA_SPELLING_ATTR", nullptr);
2698
2699   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2700   std::vector<Record *> PragmaAttrs;
2701   for (auto *Attr : Attrs) {
2702     if (!Attr->getValueAsBit("ASTNode"))
2703       continue;
2704
2705     // Add the attribute to the ad-hoc groups.
2706     if (AttrHasPragmaSpelling(Attr))
2707       PragmaAttrs.push_back(Attr);
2708
2709     // Place it in the hierarchy.
2710     Hierarchy.classifyAttr(Attr);
2711   }
2712
2713   // Emit the main attribute list.
2714   Hierarchy.emitAttrLists(OS);
2715
2716   // Emit the ad hoc groups.
2717   emitAttrList(OS, "PRAGMA_SPELLING_ATTR", PragmaAttrs);
2718
2719   // Emit the attribute ranges.
2720   OS << "#ifdef ATTR_RANGE\n";
2721   Hierarchy.emitAttrRanges(OS);
2722   OS << "#undef ATTR_RANGE\n";
2723   OS << "#endif\n";
2724
2725   Hierarchy.emitUndefs(OS);
2726   OS << "#undef PRAGMA_SPELLING_ATTR\n";
2727 }
2728
2729 // Emits the enumeration list for attributes.
2730 void EmitClangAttrSubjectMatchRuleList(RecordKeeper &Records, raw_ostream &OS) {
2731   emitSourceFileHeader(
2732       "List of all attribute subject matching rules that Clang recognizes", OS);
2733   PragmaClangAttributeSupport &PragmaAttributeSupport =
2734       getPragmaAttributeSupport(Records);
2735   emitDefaultDefine(OS, "ATTR_MATCH_RULE", nullptr);
2736   PragmaAttributeSupport.emitMatchRuleList(OS);
2737   OS << "#undef ATTR_MATCH_RULE\n";
2738 }
2739
2740 // Emits the code to read an attribute from a precompiled header.
2741 void EmitClangAttrPCHRead(RecordKeeper &Records, raw_ostream &OS) {
2742   emitSourceFileHeader("Attribute deserialization code", OS);
2743
2744   Record *InhClass = Records.getClass("InheritableAttr");
2745   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"),
2746                        ArgRecords;
2747   std::vector<std::unique_ptr<Argument>> Args;
2748
2749   OS << "  switch (Kind) {\n";
2750   for (const auto *Attr : Attrs) {
2751     const Record &R = *Attr;
2752     if (!R.getValueAsBit("ASTNode"))
2753       continue;
2754
2755     OS << "  case attr::" << R.getName() << ": {\n";
2756     if (R.isSubClassOf(InhClass))
2757       OS << "    bool isInherited = Record.readInt();\n";
2758     OS << "    bool isImplicit = Record.readInt();\n";
2759     OS << "    unsigned Spelling = Record.readInt();\n";
2760     ArgRecords = R.getValueAsListOfDefs("Args");
2761     Args.clear();
2762     for (const auto *Arg : ArgRecords) {
2763       Args.emplace_back(createArgument(*Arg, R.getName()));
2764       Args.back()->writePCHReadDecls(OS);
2765     }
2766     OS << "    New = new (Context) " << R.getName() << "Attr(Range, Context";
2767     for (auto const &ri : Args) {
2768       OS << ", ";
2769       ri->writePCHReadArgs(OS);
2770     }
2771     OS << ", Spelling);\n";
2772     if (R.isSubClassOf(InhClass))
2773       OS << "    cast<InheritableAttr>(New)->setInherited(isInherited);\n";
2774     OS << "    New->setImplicit(isImplicit);\n";
2775     OS << "    break;\n";
2776     OS << "  }\n";
2777   }
2778   OS << "  }\n";
2779 }
2780
2781 // Emits the code to write an attribute to a precompiled header.
2782 void EmitClangAttrPCHWrite(RecordKeeper &Records, raw_ostream &OS) {
2783   emitSourceFileHeader("Attribute serialization code", OS);
2784
2785   Record *InhClass = Records.getClass("InheritableAttr");
2786   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
2787
2788   OS << "  switch (A->getKind()) {\n";
2789   for (const auto *Attr : Attrs) {
2790     const Record &R = *Attr;
2791     if (!R.getValueAsBit("ASTNode"))
2792       continue;
2793     OS << "  case attr::" << R.getName() << ": {\n";
2794     Args = R.getValueAsListOfDefs("Args");
2795     if (R.isSubClassOf(InhClass) || !Args.empty())
2796       OS << "    const auto *SA = cast<" << R.getName()
2797          << "Attr>(A);\n";
2798     if (R.isSubClassOf(InhClass))
2799       OS << "    Record.push_back(SA->isInherited());\n";
2800     OS << "    Record.push_back(A->isImplicit());\n";
2801     OS << "    Record.push_back(A->getSpellingListIndex());\n";
2802
2803     for (const auto *Arg : Args)
2804       createArgument(*Arg, R.getName())->writePCHWrite(OS);
2805     OS << "    break;\n";
2806     OS << "  }\n";
2807   }
2808   OS << "  }\n";
2809 }
2810
2811 // Helper function for GenerateTargetSpecificAttrChecks that alters the 'Test'
2812 // parameter with only a single check type, if applicable.
2813 static bool GenerateTargetSpecificAttrCheck(const Record *R, std::string &Test,
2814                                             std::string *FnName,
2815                                             StringRef ListName,
2816                                             StringRef CheckAgainst,
2817                                             StringRef Scope) {
2818   if (!R->isValueUnset(ListName)) {
2819     Test += " && (";
2820     std::vector<StringRef> Items = R->getValueAsListOfStrings(ListName);
2821     for (auto I = Items.begin(), E = Items.end(); I != E; ++I) {
2822       StringRef Part = *I;
2823       Test += CheckAgainst;
2824       Test += " == ";
2825       Test += Scope;
2826       Test += Part;
2827       if (I + 1 != E)
2828         Test += " || ";
2829       if (FnName)
2830         *FnName += Part;
2831     }
2832     Test += ")";
2833     return true;
2834   }
2835   return false;
2836 }
2837
2838 // Generate a conditional expression to check if the current target satisfies
2839 // the conditions for a TargetSpecificAttr record, and append the code for
2840 // those checks to the Test string. If the FnName string pointer is non-null,
2841 // append a unique suffix to distinguish this set of target checks from other
2842 // TargetSpecificAttr records.
2843 static bool GenerateTargetSpecificAttrChecks(const Record *R,
2844                                              std::vector<StringRef> &Arches,
2845                                              std::string &Test,
2846                                              std::string *FnName) {
2847   bool AnyTargetChecks = false;
2848
2849   // It is assumed that there will be an llvm::Triple object
2850   // named "T" and a TargetInfo object named "Target" within
2851   // scope that can be used to determine whether the attribute exists in
2852   // a given target.
2853   Test += "true";
2854   // If one or more architectures is specified, check those.  Arches are handled
2855   // differently because GenerateTargetRequirements needs to combine the list
2856   // with ParseKind.
2857   if (!Arches.empty()) {
2858     AnyTargetChecks = true;
2859     Test += " && (";
2860     for (auto I = Arches.begin(), E = Arches.end(); I != E; ++I) {
2861       StringRef Part = *I;
2862       Test += "T.getArch() == llvm::Triple::";
2863       Test += Part;
2864       if (I + 1 != E)
2865         Test += " || ";
2866       if (FnName)
2867         *FnName += Part;
2868     }
2869     Test += ")";
2870   }
2871
2872   // If the attribute is specific to particular OSes, check those.
2873   AnyTargetChecks |= GenerateTargetSpecificAttrCheck(
2874       R, Test, FnName, "OSes", "T.getOS()", "llvm::Triple::");
2875
2876   // If one or more object formats is specified, check those.
2877   AnyTargetChecks |=
2878       GenerateTargetSpecificAttrCheck(R, Test, FnName, "ObjectFormats",
2879                                       "T.getObjectFormat()", "llvm::Triple::");
2880
2881   // If custom code is specified, emit it.
2882   StringRef Code = R->getValueAsString("CustomCode");
2883   if (!Code.empty()) {
2884     AnyTargetChecks = true;
2885     Test += " && (";
2886     Test += Code;
2887     Test += ")";
2888   }
2889
2890   return AnyTargetChecks;
2891 }
2892
2893 static void GenerateHasAttrSpellingStringSwitch(
2894     const std::vector<Record *> &Attrs, raw_ostream &OS,
2895     const std::string &Variety = "", const std::string &Scope = "") {
2896   for (const auto *Attr : Attrs) {
2897     // C++11-style attributes have specific version information associated with
2898     // them. If the attribute has no scope, the version information must not
2899     // have the default value (1), as that's incorrect. Instead, the unscoped
2900     // attribute version information should be taken from the SD-6 standing
2901     // document, which can be found at:
2902     // https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations
2903     int Version = 1;
2904
2905     if (Variety == "CXX11") {
2906         std::vector<Record *> Spellings = Attr->getValueAsListOfDefs("Spellings");
2907         for (const auto &Spelling : Spellings) {
2908           if (Spelling->getValueAsString("Variety") == "CXX11") {
2909             Version = static_cast<int>(Spelling->getValueAsInt("Version"));
2910             if (Scope.empty() && Version == 1)
2911               PrintError(Spelling->getLoc(), "C++ standard attributes must "
2912               "have valid version information.");
2913             break;
2914           }
2915       }
2916     }
2917
2918     std::string Test;
2919     if (Attr->isSubClassOf("TargetSpecificAttr")) {
2920       const Record *R = Attr->getValueAsDef("Target");
2921       std::vector<StringRef> Arches = R->getValueAsListOfStrings("Arches");
2922       GenerateTargetSpecificAttrChecks(R, Arches, Test, nullptr);
2923
2924       // If this is the C++11 variety, also add in the LangOpts test.
2925       if (Variety == "CXX11")
2926         Test += " && LangOpts.CPlusPlus11";
2927       else if (Variety == "C2x")
2928         Test += " && LangOpts.DoubleSquareBracketAttributes";
2929     } else if (Variety == "CXX11")
2930       // C++11 mode should be checked against LangOpts, which is presumed to be
2931       // present in the caller.
2932       Test = "LangOpts.CPlusPlus11";
2933     else if (Variety == "C2x")
2934       Test = "LangOpts.DoubleSquareBracketAttributes";
2935
2936     std::string TestStr =
2937         !Test.empty() ? Test + " ? " + llvm::itostr(Version) + " : 0" : "1";
2938     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
2939     for (const auto &S : Spellings)
2940       if (Variety.empty() || (Variety == S.variety() &&
2941                               (Scope.empty() || Scope == S.nameSpace())))
2942         OS << "    .Case(\"" << S.name() << "\", " << TestStr << ")\n";
2943   }
2944   OS << "    .Default(0);\n";
2945 }
2946
2947 // Emits the list of spellings for attributes.
2948 void EmitClangAttrHasAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
2949   emitSourceFileHeader("Code to implement the __has_attribute logic", OS);
2950
2951   // Separate all of the attributes out into four group: generic, C++11, GNU,
2952   // and declspecs. Then generate a big switch statement for each of them.
2953   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2954   std::vector<Record *> Declspec, Microsoft, GNU, Pragma;
2955   std::map<std::string, std::vector<Record *>> CXX, C2x;
2956
2957   // Walk over the list of all attributes, and split them out based on the
2958   // spelling variety.
2959   for (auto *R : Attrs) {
2960     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*R);
2961     for (const auto &SI : Spellings) {
2962       const std::string &Variety = SI.variety();
2963       if (Variety == "GNU")
2964         GNU.push_back(R);
2965       else if (Variety == "Declspec")
2966         Declspec.push_back(R);
2967       else if (Variety == "Microsoft")
2968         Microsoft.push_back(R);
2969       else if (Variety == "CXX11")
2970         CXX[SI.nameSpace()].push_back(R);
2971       else if (Variety == "C2x")
2972         C2x[SI.nameSpace()].push_back(R);
2973       else if (Variety == "Pragma")
2974         Pragma.push_back(R);
2975     }
2976   }
2977
2978   OS << "const llvm::Triple &T = Target.getTriple();\n";
2979   OS << "switch (Syntax) {\n";
2980   OS << "case AttrSyntax::GNU:\n";
2981   OS << "  return llvm::StringSwitch<int>(Name)\n";
2982   GenerateHasAttrSpellingStringSwitch(GNU, OS, "GNU");
2983   OS << "case AttrSyntax::Declspec:\n";
2984   OS << "  return llvm::StringSwitch<int>(Name)\n";
2985   GenerateHasAttrSpellingStringSwitch(Declspec, OS, "Declspec");
2986   OS << "case AttrSyntax::Microsoft:\n";
2987   OS << "  return llvm::StringSwitch<int>(Name)\n";
2988   GenerateHasAttrSpellingStringSwitch(Microsoft, OS, "Microsoft");
2989   OS << "case AttrSyntax::Pragma:\n";
2990   OS << "  return llvm::StringSwitch<int>(Name)\n";
2991   GenerateHasAttrSpellingStringSwitch(Pragma, OS, "Pragma");
2992   auto fn = [&OS](const char *Spelling, const char *Variety,
2993                   const std::map<std::string, std::vector<Record *>> &List) {
2994     OS << "case AttrSyntax::" << Variety << ": {\n";
2995     // C++11-style attributes are further split out based on the Scope.
2996     for (auto I = List.cbegin(), E = List.cend(); I != E; ++I) {
2997       if (I != List.cbegin())
2998         OS << " else ";
2999       if (I->first.empty())
3000         OS << "if (ScopeName == \"\") {\n";
3001       else
3002         OS << "if (ScopeName == \"" << I->first << "\") {\n";
3003       OS << "  return llvm::StringSwitch<int>(Name)\n";
3004       GenerateHasAttrSpellingStringSwitch(I->second, OS, Spelling, I->first);
3005       OS << "}";
3006     }
3007     OS << "\n} break;\n";
3008   };
3009   fn("CXX11", "CXX", CXX);
3010   fn("C2x", "C", C2x);
3011   OS << "}\n";
3012 }
3013
3014 void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS) {
3015   emitSourceFileHeader("Code to translate different attribute spellings "
3016                        "into internal identifiers", OS);
3017
3018   OS << "  switch (AttrKind) {\n";
3019
3020   ParsedAttrMap Attrs = getParsedAttrList(Records);
3021   for (const auto &I : Attrs) {
3022     const Record &R = *I.second;
3023     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
3024     OS << "  case AT_" << I.first << ": {\n";
3025     for (unsigned I = 0; I < Spellings.size(); ++ I) {
3026       OS << "    if (Name == \"" << Spellings[I].name() << "\" && "
3027          << "SyntaxUsed == "
3028          << StringSwitch<unsigned>(Spellings[I].variety())
3029                 .Case("GNU", 0)
3030                 .Case("CXX11", 1)
3031                 .Case("C2x", 2)
3032                 .Case("Declspec", 3)
3033                 .Case("Microsoft", 4)
3034                 .Case("Keyword", 5)
3035                 .Case("Pragma", 6)
3036                 .Default(0)
3037          << " && Scope == \"" << Spellings[I].nameSpace() << "\")\n"
3038          << "        return " << I << ";\n";
3039     }
3040
3041     OS << "    break;\n";
3042     OS << "  }\n";
3043   }
3044
3045   OS << "  }\n";
3046   OS << "  return 0;\n";
3047 }
3048
3049 // Emits code used by RecursiveASTVisitor to visit attributes
3050 void EmitClangAttrASTVisitor(RecordKeeper &Records, raw_ostream &OS) {
3051   emitSourceFileHeader("Used by RecursiveASTVisitor to visit attributes.", OS);
3052
3053   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
3054
3055   // Write method declarations for Traverse* methods.
3056   // We emit this here because we only generate methods for attributes that
3057   // are declared as ASTNodes.
3058   OS << "#ifdef ATTR_VISITOR_DECLS_ONLY\n\n";
3059   for (const auto *Attr : Attrs) {
3060     const Record &R = *Attr;
3061     if (!R.getValueAsBit("ASTNode"))
3062       continue;
3063     OS << "  bool Traverse"
3064        << R.getName() << "Attr(" << R.getName() << "Attr *A);\n";
3065     OS << "  bool Visit"
3066        << R.getName() << "Attr(" << R.getName() << "Attr *A) {\n"
3067        << "    return true; \n"
3068        << "  }\n";
3069   }
3070   OS << "\n#else // ATTR_VISITOR_DECLS_ONLY\n\n";
3071
3072   // Write individual Traverse* methods for each attribute class.
3073   for (const auto *Attr : Attrs) {
3074     const Record &R = *Attr;
3075     if (!R.getValueAsBit("ASTNode"))
3076       continue;
3077
3078     OS << "template <typename Derived>\n"
3079        << "bool VISITORCLASS<Derived>::Traverse"
3080        << R.getName() << "Attr(" << R.getName() << "Attr *A) {\n"
3081        << "  if (!getDerived().VisitAttr(A))\n"
3082        << "    return false;\n"
3083        << "  if (!getDerived().Visit" << R.getName() << "Attr(A))\n"
3084        << "    return false;\n";
3085
3086     std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
3087     for (const auto *Arg : ArgRecords)
3088       createArgument(*Arg, R.getName())->writeASTVisitorTraversal(OS);
3089
3090     OS << "  return true;\n";
3091     OS << "}\n\n";
3092   }
3093
3094   // Write generic Traverse routine
3095   OS << "template <typename Derived>\n"
3096      << "bool VISITORCLASS<Derived>::TraverseAttr(Attr *A) {\n"
3097      << "  if (!A)\n"
3098      << "    return true;\n"
3099      << "\n"
3100      << "  switch (A->getKind()) {\n";
3101
3102   for (const auto *Attr : Attrs) {
3103     const Record &R = *Attr;
3104     if (!R.getValueAsBit("ASTNode"))
3105       continue;
3106
3107     OS << "    case attr::" << R.getName() << ":\n"
3108        << "      return getDerived().Traverse" << R.getName() << "Attr("
3109        << "cast<" << R.getName() << "Attr>(A));\n";
3110   }
3111   OS << "  }\n";  // end switch
3112   OS << "  llvm_unreachable(\"bad attribute kind\");\n";
3113   OS << "}\n";  // end function
3114   OS << "#endif  // ATTR_VISITOR_DECLS_ONLY\n";
3115 }
3116
3117 void EmitClangAttrTemplateInstantiateHelper(const std::vector<Record *> &Attrs,
3118                                             raw_ostream &OS,
3119                                             bool AppliesToDecl) {
3120
3121   OS << "  switch (At->getKind()) {\n";
3122   for (const auto *Attr : Attrs) {
3123     const Record &R = *Attr;
3124     if (!R.getValueAsBit("ASTNode"))
3125       continue;
3126     OS << "    case attr::" << R.getName() << ": {\n";
3127     bool ShouldClone = R.getValueAsBit("Clone") &&
3128                        (!AppliesToDecl ||
3129                         R.getValueAsBit("MeaningfulToClassTemplateDefinition"));
3130
3131     if (!ShouldClone) {
3132       OS << "      return nullptr;\n";
3133       OS << "    }\n";
3134       continue;
3135     }
3136
3137     OS << "      const auto *A = cast<"
3138        << R.getName() << "Attr>(At);\n";
3139     bool TDependent = R.getValueAsBit("TemplateDependent");
3140
3141     if (!TDependent) {
3142       OS << "      return A->clone(C);\n";
3143       OS << "    }\n";
3144       continue;
3145     }
3146
3147     std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
3148     std::vector<std::unique_ptr<Argument>> Args;
3149     Args.reserve(ArgRecords.size());
3150
3151     for (const auto *ArgRecord : ArgRecords)
3152       Args.emplace_back(createArgument(*ArgRecord, R.getName()));
3153
3154     for (auto const &ai : Args)
3155       ai->writeTemplateInstantiation(OS);
3156
3157     OS << "      return new (C) " << R.getName() << "Attr(A->getLocation(), C";
3158     for (auto const &ai : Args) {
3159       OS << ", ";
3160       ai->writeTemplateInstantiationArgs(OS);
3161     }
3162     OS << ", A->getSpellingListIndex());\n    }\n";
3163   }
3164   OS << "  } // end switch\n"
3165      << "  llvm_unreachable(\"Unknown attribute!\");\n"
3166      << "  return nullptr;\n";
3167 }
3168
3169 // Emits code to instantiate dependent attributes on templates.
3170 void EmitClangAttrTemplateInstantiate(RecordKeeper &Records, raw_ostream &OS) {
3171   emitSourceFileHeader("Template instantiation code for attributes", OS);
3172
3173   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
3174
3175   OS << "namespace clang {\n"
3176      << "namespace sema {\n\n"
3177      << "Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, "
3178      << "Sema &S,\n"
3179      << "        const MultiLevelTemplateArgumentList &TemplateArgs) {\n";
3180   EmitClangAttrTemplateInstantiateHelper(Attrs, OS, /*AppliesToDecl*/false);
3181   OS << "}\n\n"
3182      << "Attr *instantiateTemplateAttributeForDecl(const Attr *At,\n"
3183      << " ASTContext &C, Sema &S,\n"
3184      << "        const MultiLevelTemplateArgumentList &TemplateArgs) {\n";
3185   EmitClangAttrTemplateInstantiateHelper(Attrs, OS, /*AppliesToDecl*/true);
3186   OS << "}\n\n"
3187      << "} // end namespace sema\n"
3188      << "} // end namespace clang\n";
3189 }
3190
3191 // Emits the list of parsed attributes.
3192 void EmitClangAttrParsedAttrList(RecordKeeper &Records, raw_ostream &OS) {
3193   emitSourceFileHeader("List of all attributes that Clang recognizes", OS);
3194
3195   OS << "#ifndef PARSED_ATTR\n";
3196   OS << "#define PARSED_ATTR(NAME) NAME\n";
3197   OS << "#endif\n\n";
3198
3199   ParsedAttrMap Names = getParsedAttrList(Records);
3200   for (const auto &I : Names) {
3201     OS << "PARSED_ATTR(" << I.first << ")\n";
3202   }
3203 }
3204
3205 static bool isArgVariadic(const Record &R, StringRef AttrName) {
3206   return createArgument(R, AttrName)->isVariadic();
3207 }
3208
3209 static void emitArgInfo(const Record &R, raw_ostream &OS) {
3210   // This function will count the number of arguments specified for the
3211   // attribute and emit the number of required arguments followed by the
3212   // number of optional arguments.
3213   std::vector<Record *> Args = R.getValueAsListOfDefs("Args");
3214   unsigned ArgCount = 0, OptCount = 0;
3215   bool HasVariadic = false;
3216   for (const auto *Arg : Args) {
3217     // If the arg is fake, it's the user's job to supply it: general parsing
3218     // logic shouldn't need to know anything about it.
3219     if (Arg->getValueAsBit("Fake"))
3220       continue;
3221     Arg->getValueAsBit("Optional") ? ++OptCount : ++ArgCount;
3222     if (!HasVariadic && isArgVariadic(*Arg, R.getName()))
3223       HasVariadic = true;
3224   }
3225
3226   // If there is a variadic argument, we will set the optional argument count
3227   // to its largest value. Since it's currently a 4-bit number, we set it to 15.
3228   OS << ArgCount << ", " << (HasVariadic ? 15 : OptCount);
3229 }
3230
3231 static void GenerateDefaultAppertainsTo(raw_ostream &OS) {
3232   OS << "static bool defaultAppertainsTo(Sema &, const ParsedAttr &,";
3233   OS << "const Decl *) {\n";
3234   OS << "  return true;\n";
3235   OS << "}\n\n";
3236 }
3237
3238 static std::string GetDiagnosticSpelling(const Record &R) {
3239   std::string Ret = R.getValueAsString("DiagSpelling");
3240   if (!Ret.empty())
3241     return Ret;
3242
3243   // If we couldn't find the DiagSpelling in this object, we can check to see
3244   // if the object is one that has a base, and if it is, loop up to the Base
3245   // member recursively.
3246   std::string Super = R.getSuperClasses().back().first->getName();
3247   if (Super == "DDecl" || Super == "DStmt")
3248     return GetDiagnosticSpelling(*R.getValueAsDef("Base"));
3249
3250   return "";
3251 }
3252
3253 static std::string CalculateDiagnostic(const Record &S) {
3254   // If the SubjectList object has a custom diagnostic associated with it,
3255   // return that directly.
3256   const StringRef CustomDiag = S.getValueAsString("CustomDiag");
3257   if (!CustomDiag.empty())
3258     return ("\"" + Twine(CustomDiag) + "\"").str();
3259
3260   std::vector<std::string> DiagList;
3261   std::vector<Record *> Subjects = S.getValueAsListOfDefs("Subjects");
3262   for (const auto *Subject : Subjects) {
3263     const Record &R = *Subject;
3264     // Get the diagnostic text from the Decl or Stmt node given.
3265     std::string V = GetDiagnosticSpelling(R);
3266     if (V.empty()) {
3267       PrintError(R.getLoc(),
3268                  "Could not determine diagnostic spelling for the node: " +
3269                      R.getName() + "; please add one to DeclNodes.td");
3270     } else {
3271       // The node may contain a list of elements itself, so split the elements
3272       // by a comma, and trim any whitespace.
3273       SmallVector<StringRef, 2> Frags;
3274       llvm::SplitString(V, Frags, ",");
3275       for (auto Str : Frags) {
3276         DiagList.push_back(Str.trim());
3277       }
3278     }
3279   }
3280
3281   if (DiagList.empty()) {
3282     PrintFatalError(S.getLoc(),
3283                     "Could not deduce diagnostic argument for Attr subjects");
3284     return "";
3285   }
3286
3287   // FIXME: this is not particularly good for localization purposes and ideally
3288   // should be part of the diagnostics engine itself with some sort of list
3289   // specifier.
3290
3291   // A single member of the list can be returned directly.
3292   if (DiagList.size() == 1)
3293     return '"' + DiagList.front() + '"';
3294
3295   if (DiagList.size() == 2)
3296     return '"' + DiagList[0] + " and " + DiagList[1] + '"';
3297
3298   // If there are more than two in the list, we serialize the first N - 1
3299   // elements with a comma. This leaves the string in the state: foo, bar,
3300   // baz (but misses quux). We can then add ", and " for the last element
3301   // manually.
3302   std::string Diag = llvm::join(DiagList.begin(), DiagList.end() - 1, ", ");
3303   return '"' + Diag + ", and " + *(DiagList.end() - 1) + '"';
3304 }
3305
3306 static std::string GetSubjectWithSuffix(const Record *R) {
3307   const std::string &B = R->getName();
3308   if (B == "DeclBase")
3309     return "Decl";
3310   return B + "Decl";
3311 }
3312
3313 static std::string functionNameForCustomAppertainsTo(const Record &Subject) {
3314   return "is" + Subject.getName().str();
3315 }
3316
3317 static std::string GenerateCustomAppertainsTo(const Record &Subject,
3318                                               raw_ostream &OS) {
3319   std::string FnName = functionNameForCustomAppertainsTo(Subject);
3320
3321   // If this code has already been generated, simply return the previous
3322   // instance of it.
3323   static std::set<std::string> CustomSubjectSet;
3324   auto I = CustomSubjectSet.find(FnName);
3325   if (I != CustomSubjectSet.end())
3326     return *I;
3327
3328   Record *Base = Subject.getValueAsDef("Base");
3329
3330   // Not currently support custom subjects within custom subjects.
3331   if (Base->isSubClassOf("SubsetSubject")) {
3332     PrintFatalError(Subject.getLoc(),
3333                     "SubsetSubjects within SubsetSubjects is not supported");
3334     return "";
3335   }
3336
3337   OS << "static bool " << FnName << "(const Decl *D) {\n";
3338   OS << "  if (const auto *S = dyn_cast<";
3339   OS << GetSubjectWithSuffix(Base);
3340   OS << ">(D))\n";
3341   OS << "    return " << Subject.getValueAsString("CheckCode") << ";\n";
3342   OS << "  return false;\n";
3343   OS << "}\n\n";
3344
3345   CustomSubjectSet.insert(FnName);
3346   return FnName;
3347 }
3348
3349 static std::string GenerateAppertainsTo(const Record &Attr, raw_ostream &OS) {
3350   // If the attribute does not contain a Subjects definition, then use the
3351   // default appertainsTo logic.
3352   if (Attr.isValueUnset("Subjects"))
3353     return "defaultAppertainsTo";
3354
3355   const Record *SubjectObj = Attr.getValueAsDef("Subjects");
3356   std::vector<Record*> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
3357
3358   // If the list of subjects is empty, it is assumed that the attribute
3359   // appertains to everything.
3360   if (Subjects.empty())
3361     return "defaultAppertainsTo";
3362
3363   bool Warn = SubjectObj->getValueAsDef("Diag")->getValueAsBit("Warn");
3364
3365   // Otherwise, generate an appertainsTo check specific to this attribute which
3366   // checks all of the given subjects against the Decl passed in. Return the
3367   // name of that check to the caller.
3368   //
3369   // If D is null, that means the attribute was not applied to a declaration
3370   // at all (for instance because it was applied to a type), or that the caller
3371   // has determined that the check should fail (perhaps prior to the creation
3372   // of the declaration).
3373   std::string FnName = "check" + Attr.getName().str() + "AppertainsTo";
3374   std::stringstream SS;
3375   SS << "static bool " << FnName << "(Sema &S, const ParsedAttr &Attr, ";
3376   SS << "const Decl *D) {\n";
3377   SS << "  if (!D || (";
3378   for (auto I = Subjects.begin(), E = Subjects.end(); I != E; ++I) {
3379     // If the subject has custom code associated with it, generate a function
3380     // for it. The function cannot be inlined into this check (yet) because it
3381     // requires the subject to be of a specific type, and were that information
3382     // inlined here, it would not support an attribute with multiple custom
3383     // subjects.
3384     if ((*I)->isSubClassOf("SubsetSubject")) {
3385       SS << "!" << GenerateCustomAppertainsTo(**I, OS) << "(D)";
3386     } else {
3387       SS << "!isa<" << GetSubjectWithSuffix(*I) << ">(D)";
3388     }
3389
3390     if (I + 1 != E)
3391       SS << " && ";
3392   }
3393   SS << ")) {\n";
3394   SS << "    S.Diag(Attr.getLoc(), diag::";
3395   SS << (Warn ? "warn_attribute_wrong_decl_type_str" :
3396                "err_attribute_wrong_decl_type_str");
3397   SS << ")\n";
3398   SS << "      << Attr << ";
3399   SS << CalculateDiagnostic(*SubjectObj) << ";\n";
3400   SS << "    return false;\n";
3401   SS << "  }\n";
3402   SS << "  return true;\n";
3403   SS << "}\n\n";
3404
3405   OS << SS.str();
3406   return FnName;
3407 }
3408
3409 static void
3410 emitAttributeMatchRules(PragmaClangAttributeSupport &PragmaAttributeSupport,
3411                         raw_ostream &OS) {
3412   OS << "static bool checkAttributeMatchRuleAppliesTo(const Decl *D, "
3413      << AttributeSubjectMatchRule::EnumName << " rule) {\n";
3414   OS << "  switch (rule) {\n";
3415   for (const auto &Rule : PragmaAttributeSupport.Rules) {
3416     if (Rule.isAbstractRule()) {
3417       OS << "  case " << Rule.getEnumValue() << ":\n";
3418       OS << "    assert(false && \"Abstract matcher rule isn't allowed\");\n";
3419       OS << "    return false;\n";
3420       continue;
3421     }
3422     std::vector<Record *> Subjects = Rule.getSubjects();
3423     assert(!Subjects.empty() && "Missing subjects");
3424     OS << "  case " << Rule.getEnumValue() << ":\n";
3425     OS << "    return ";
3426     for (auto I = Subjects.begin(), E = Subjects.end(); I != E; ++I) {
3427       // If the subject has custom code associated with it, use the function
3428       // that was generated for GenerateAppertainsTo to check if the declaration
3429       // is valid.
3430       if ((*I)->isSubClassOf("SubsetSubject"))
3431         OS << functionNameForCustomAppertainsTo(**I) << "(D)";
3432       else
3433         OS << "isa<" << GetSubjectWithSuffix(*I) << ">(D)";
3434
3435       if (I + 1 != E)
3436         OS << " || ";
3437     }
3438     OS << ";\n";
3439   }
3440   OS << "  }\n";
3441   OS << "  llvm_unreachable(\"Invalid match rule\");\nreturn false;\n";
3442   OS << "}\n\n";
3443 }
3444
3445 static void GenerateDefaultLangOptRequirements(raw_ostream &OS) {
3446   OS << "static bool defaultDiagnoseLangOpts(Sema &, ";
3447   OS << "const ParsedAttr &) {\n";
3448   OS << "  return true;\n";
3449   OS << "}\n\n";
3450 }
3451
3452 static std::string GenerateLangOptRequirements(const Record &R,
3453                                                raw_ostream &OS) {
3454   // If the attribute has an empty or unset list of language requirements,
3455   // return the default handler.
3456   std::vector<Record *> LangOpts = R.getValueAsListOfDefs("LangOpts");
3457   if (LangOpts.empty())
3458     return "defaultDiagnoseLangOpts";
3459
3460   // Generate a unique function name for the diagnostic test. The list of
3461   // options should usually be short (one or two options), and the
3462   // uniqueness isn't strictly necessary (it is just for codegen efficiency).
3463   std::string FnName = "check";
3464   for (auto I = LangOpts.begin(), E = LangOpts.end(); I != E; ++I)
3465     FnName += (*I)->getValueAsString("Name");
3466   FnName += "LangOpts";
3467
3468   // If this code has already been generated, simply return the previous
3469   // instance of it.
3470   static std::set<std::string> CustomLangOptsSet;
3471   auto I = CustomLangOptsSet.find(FnName);
3472   if (I != CustomLangOptsSet.end())
3473     return *I;
3474
3475   OS << "static bool " << FnName << "(Sema &S, const ParsedAttr &Attr) {\n";
3476   OS << "  auto &LangOpts = S.LangOpts;\n";
3477   OS << "  if (" << GenerateTestExpression(LangOpts) << ")\n";
3478   OS << "    return true;\n\n";
3479   OS << "  S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) ";
3480   OS << "<< Attr.getName();\n";
3481   OS << "  return false;\n";
3482   OS << "}\n\n";
3483
3484   CustomLangOptsSet.insert(FnName);
3485   return FnName;
3486 }
3487
3488 static void GenerateDefaultTargetRequirements(raw_ostream &OS) {
3489   OS << "static bool defaultTargetRequirements(const TargetInfo &) {\n";
3490   OS << "  return true;\n";
3491   OS << "}\n\n";
3492 }
3493
3494 static std::string GenerateTargetRequirements(const Record &Attr,
3495                                               const ParsedAttrMap &Dupes,
3496                                               raw_ostream &OS) {
3497   // If the attribute is not a target specific attribute, return the default
3498   // target handler.
3499   if (!Attr.isSubClassOf("TargetSpecificAttr"))
3500     return "defaultTargetRequirements";
3501
3502   // Get the list of architectures to be tested for.
3503   const Record *R = Attr.getValueAsDef("Target");
3504   std::vector<StringRef> Arches = R->getValueAsListOfStrings("Arches");
3505
3506   // If there are other attributes which share the same parsed attribute kind,
3507   // such as target-specific attributes with a shared spelling, collapse the
3508   // duplicate architectures. This is required because a shared target-specific
3509   // attribute has only one ParsedAttr::Kind enumeration value, but it
3510   // applies to multiple target architectures. In order for the attribute to be
3511   // considered valid, all of its architectures need to be included.
3512   if (!Attr.isValueUnset("ParseKind")) {
3513     const StringRef APK = Attr.getValueAsString("ParseKind");
3514     for (const auto &I : Dupes) {
3515       if (I.first == APK) {
3516         std::vector<StringRef> DA =
3517             I.second->getValueAsDef("Target")->getValueAsListOfStrings(
3518                 "Arches");
3519         Arches.insert(Arches.end(), DA.begin(), DA.end());
3520       }
3521     }
3522   }
3523
3524   std::string FnName = "isTarget";
3525   std::string Test;
3526   bool UsesT = GenerateTargetSpecificAttrChecks(R, Arches, Test, &FnName);
3527
3528   // If this code has already been generated, simply return the previous
3529   // instance of it.
3530   static std::set<std::string> CustomTargetSet;
3531   auto I = CustomTargetSet.find(FnName);
3532   if (I != CustomTargetSet.end())
3533     return *I;
3534
3535   OS << "static bool " << FnName << "(const TargetInfo &Target) {\n";
3536   if (UsesT)
3537     OS << "  const llvm::Triple &T = Target.getTriple(); (void)T;\n";
3538   OS << "  return " << Test << ";\n";
3539   OS << "}\n\n";
3540
3541   CustomTargetSet.insert(FnName);
3542   return FnName;
3543 }
3544
3545 static void GenerateDefaultSpellingIndexToSemanticSpelling(raw_ostream &OS) {
3546   OS << "static unsigned defaultSpellingIndexToSemanticSpelling("
3547      << "const ParsedAttr &Attr) {\n";
3548   OS << "  return UINT_MAX;\n";
3549   OS << "}\n\n";
3550 }
3551
3552 static std::string GenerateSpellingIndexToSemanticSpelling(const Record &Attr,
3553                                                            raw_ostream &OS) {
3554   // If the attribute does not have a semantic form, we can bail out early.
3555   if (!Attr.getValueAsBit("ASTNode"))
3556     return "defaultSpellingIndexToSemanticSpelling";
3557
3558   std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
3559
3560   // If there are zero or one spellings, or all of the spellings share the same
3561   // name, we can also bail out early.
3562   if (Spellings.size() <= 1 || SpellingNamesAreCommon(Spellings))
3563     return "defaultSpellingIndexToSemanticSpelling";
3564
3565   // Generate the enumeration we will use for the mapping.
3566   SemanticSpellingMap SemanticToSyntacticMap;
3567   std::string Enum = CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
3568   std::string Name = Attr.getName().str() + "AttrSpellingMap";
3569
3570   OS << "static unsigned " << Name << "(const ParsedAttr &Attr) {\n";
3571   OS << Enum;
3572   OS << "  unsigned Idx = Attr.getAttributeSpellingListIndex();\n";
3573   WriteSemanticSpellingSwitch("Idx", SemanticToSyntacticMap, OS);
3574   OS << "}\n\n";
3575
3576   return Name;
3577 }
3578
3579 static bool IsKnownToGCC(const Record &Attr) {
3580   // Look at the spellings for this subject; if there are any spellings which
3581   // claim to be known to GCC, the attribute is known to GCC.
3582   return llvm::any_of(
3583       GetFlattenedSpellings(Attr),
3584       [](const FlattenedSpelling &S) { return S.knownToGCC(); });
3585 }
3586
3587 /// Emits the parsed attribute helpers
3588 void EmitClangAttrParsedAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
3589   emitSourceFileHeader("Parsed attribute helpers", OS);
3590
3591   PragmaClangAttributeSupport &PragmaAttributeSupport =
3592       getPragmaAttributeSupport(Records);
3593
3594   // Get the list of parsed attributes, and accept the optional list of
3595   // duplicates due to the ParseKind.
3596   ParsedAttrMap Dupes;
3597   ParsedAttrMap Attrs = getParsedAttrList(Records, &Dupes);
3598
3599   // Generate the default appertainsTo, target and language option diagnostic,
3600   // and spelling list index mapping methods.
3601   GenerateDefaultAppertainsTo(OS);
3602   GenerateDefaultLangOptRequirements(OS);
3603   GenerateDefaultTargetRequirements(OS);
3604   GenerateDefaultSpellingIndexToSemanticSpelling(OS);
3605
3606   // Generate the appertainsTo diagnostic methods and write their names into
3607   // another mapping. At the same time, generate the AttrInfoMap object
3608   // contents. Due to the reliance on generated code, use separate streams so
3609   // that code will not be interleaved.
3610   std::string Buffer;
3611   raw_string_ostream SS {Buffer};
3612   for (auto I = Attrs.begin(), E = Attrs.end(); I != E; ++I) {
3613     // TODO: If the attribute's kind appears in the list of duplicates, that is
3614     // because it is a target-specific attribute that appears multiple times.
3615     // It would be beneficial to test whether the duplicates are "similar
3616     // enough" to each other to not cause problems. For instance, check that
3617     // the spellings are identical, and custom parsing rules match, etc.
3618
3619     // We need to generate struct instances based off ParsedAttrInfo from
3620     // ParsedAttr.cpp.
3621     SS << "  { ";
3622     emitArgInfo(*I->second, SS);
3623     SS << ", " << I->second->getValueAsBit("HasCustomParsing");
3624     SS << ", " << I->second->isSubClassOf("TargetSpecificAttr");
3625     SS << ", "
3626        << (I->second->isSubClassOf("TypeAttr") ||
3627            I->second->isSubClassOf("DeclOrTypeAttr"));
3628     SS << ", " << I->second->isSubClassOf("StmtAttr");
3629     SS << ", " << IsKnownToGCC(*I->second);
3630     SS << ", " << PragmaAttributeSupport.isAttributedSupported(*I->second);
3631     SS << ", " << GenerateAppertainsTo(*I->second, OS);
3632     SS << ", " << GenerateLangOptRequirements(*I->second, OS);
3633     SS << ", " << GenerateTargetRequirements(*I->second, Dupes, OS);
3634     SS << ", " << GenerateSpellingIndexToSemanticSpelling(*I->second, OS);
3635     SS << ", "
3636        << PragmaAttributeSupport.generateStrictConformsTo(*I->second, OS);
3637     SS << " }";
3638
3639     if (I + 1 != E)
3640       SS << ",";
3641
3642     SS << "  // AT_" << I->first << "\n";
3643   }
3644
3645   OS << "static const ParsedAttrInfo AttrInfoMap[ParsedAttr::UnknownAttribute "
3646         "+ 1] = {\n";
3647   OS << SS.str();
3648   OS << "};\n\n";
3649
3650   // Generate the attribute match rules.
3651   emitAttributeMatchRules(PragmaAttributeSupport, OS);
3652 }
3653
3654 // Emits the kind list of parsed attributes
3655 void EmitClangAttrParsedAttrKinds(RecordKeeper &Records, raw_ostream &OS) {
3656   emitSourceFileHeader("Attribute name matcher", OS);
3657
3658   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
3659   std::vector<StringMatcher::StringPair> GNU, Declspec, Microsoft, CXX11,
3660       Keywords, Pragma, C2x;
3661   std::set<std::string> Seen;
3662   for (const auto *A : Attrs) {
3663     const Record &Attr = *A;
3664
3665     bool SemaHandler = Attr.getValueAsBit("SemaHandler");
3666     bool Ignored = Attr.getValueAsBit("Ignored");
3667     if (SemaHandler || Ignored) {
3668       // Attribute spellings can be shared between target-specific attributes,
3669       // and can be shared between syntaxes for the same attribute. For
3670       // instance, an attribute can be spelled GNU<"interrupt"> for an ARM-
3671       // specific attribute, or MSP430-specific attribute. Additionally, an
3672       // attribute can be spelled GNU<"dllexport"> and Declspec<"dllexport">
3673       // for the same semantic attribute. Ultimately, we need to map each of
3674       // these to a single ParsedAttr::Kind value, but the StringMatcher
3675       // class cannot handle duplicate match strings. So we generate a list of
3676       // string to match based on the syntax, and emit multiple string matchers
3677       // depending on the syntax used.
3678       std::string AttrName;
3679       if (Attr.isSubClassOf("TargetSpecificAttr") &&
3680           !Attr.isValueUnset("ParseKind")) {
3681         AttrName = Attr.getValueAsString("ParseKind");
3682         if (Seen.find(AttrName) != Seen.end())
3683           continue;
3684         Seen.insert(AttrName);
3685       } else
3686         AttrName = NormalizeAttrName(StringRef(Attr.getName())).str();
3687
3688       std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
3689       for (const auto &S : Spellings) {
3690         const std::string &RawSpelling = S.name();
3691         std::vector<StringMatcher::StringPair> *Matches = nullptr;
3692         std::string Spelling;
3693         const std::string &Variety = S.variety();
3694         if (Variety == "CXX11") {
3695           Matches = &CXX11;
3696           Spelling += S.nameSpace();
3697           Spelling += "::";
3698         } else if (Variety == "C2x") {
3699           Matches = &C2x;
3700           Spelling += S.nameSpace();
3701           Spelling += "::";
3702         } else if (Variety == "GNU")
3703           Matches = &GNU;
3704         else if (Variety == "Declspec")
3705           Matches = &Declspec;
3706         else if (Variety == "Microsoft")
3707           Matches = &Microsoft;
3708         else if (Variety == "Keyword")
3709           Matches = &Keywords;
3710         else if (Variety == "Pragma")
3711           Matches = &Pragma;
3712
3713         assert(Matches && "Unsupported spelling variety found");
3714
3715         if (Variety == "GNU")
3716           Spelling += NormalizeGNUAttrSpelling(RawSpelling);
3717         else
3718           Spelling += RawSpelling;
3719
3720         if (SemaHandler)
3721           Matches->push_back(StringMatcher::StringPair(
3722               Spelling, "return ParsedAttr::AT_" + AttrName + ";"));
3723         else
3724           Matches->push_back(StringMatcher::StringPair(
3725               Spelling, "return ParsedAttr::IgnoredAttribute;"));
3726       }
3727     }
3728   }
3729
3730   OS << "static ParsedAttr::Kind getAttrKind(StringRef Name, ";
3731   OS << "ParsedAttr::Syntax Syntax) {\n";
3732   OS << "  if (ParsedAttr::AS_GNU == Syntax) {\n";
3733   StringMatcher("Name", GNU, OS).Emit();
3734   OS << "  } else if (ParsedAttr::AS_Declspec == Syntax) {\n";
3735   StringMatcher("Name", Declspec, OS).Emit();
3736   OS << "  } else if (ParsedAttr::AS_Microsoft == Syntax) {\n";
3737   StringMatcher("Name", Microsoft, OS).Emit();
3738   OS << "  } else if (ParsedAttr::AS_CXX11 == Syntax) {\n";
3739   StringMatcher("Name", CXX11, OS).Emit();
3740   OS << "  } else if (ParsedAttr::AS_C2x == Syntax) {\n";
3741   StringMatcher("Name", C2x, OS).Emit();
3742   OS << "  } else if (ParsedAttr::AS_Keyword == Syntax || ";
3743   OS << "ParsedAttr::AS_ContextSensitiveKeyword == Syntax) {\n";
3744   StringMatcher("Name", Keywords, OS).Emit();
3745   OS << "  } else if (ParsedAttr::AS_Pragma == Syntax) {\n";
3746   StringMatcher("Name", Pragma, OS).Emit();
3747   OS << "  }\n";
3748   OS << "  return ParsedAttr::UnknownAttribute;\n"
3749      << "}\n";
3750 }
3751
3752 // Emits the code to dump an attribute.
3753 void EmitClangAttrTextNodeDump(RecordKeeper &Records, raw_ostream &OS) {
3754   emitSourceFileHeader("Attribute text node dumper", OS);
3755
3756   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
3757   for (const auto *Attr : Attrs) {
3758     const Record &R = *Attr;
3759     if (!R.getValueAsBit("ASTNode"))
3760       continue;
3761
3762     // If the attribute has a semantically-meaningful name (which is determined
3763     // by whether there is a Spelling enumeration for it), then write out the
3764     // spelling used for the attribute.
3765
3766     std::string FunctionContent;
3767     llvm::raw_string_ostream SS(FunctionContent);
3768
3769     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
3770     if (Spellings.size() > 1 && !SpellingNamesAreCommon(Spellings))
3771       SS << "    OS << \" \" << A->getSpelling();\n";
3772
3773     Args = R.getValueAsListOfDefs("Args");
3774     for (const auto *Arg : Args)
3775       createArgument(*Arg, R.getName())->writeDump(SS);
3776
3777     if (SS.tell()) {
3778       OS << "  void Visit" << R.getName() << "Attr(const " << R.getName()
3779          << "Attr *A) {\n";
3780       if (!Args.empty())
3781         OS << "    const auto *SA = cast<" << R.getName()
3782            << "Attr>(A); (void)SA;\n";
3783       OS << SS.str();
3784       OS << "  }\n";
3785     }
3786   }
3787 }
3788
3789 void EmitClangAttrNodeTraverse(RecordKeeper &Records, raw_ostream &OS) {
3790   emitSourceFileHeader("Attribute text node traverser", OS);
3791
3792   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
3793   for (const auto *Attr : Attrs) {
3794     const Record &R = *Attr;
3795     if (!R.getValueAsBit("ASTNode"))
3796       continue;
3797
3798     std::string FunctionContent;
3799     llvm::raw_string_ostream SS(FunctionContent);
3800
3801     Args = R.getValueAsListOfDefs("Args");
3802     for (const auto *Arg : Args)
3803       createArgument(*Arg, R.getName())->writeDumpChildren(SS);
3804     if (SS.tell()) {
3805       OS << "  void Visit" << R.getName() << "Attr(const " << R.getName()
3806          << "Attr *A) {\n";
3807       if (!Args.empty())
3808         OS << "    const auto *SA = cast<" << R.getName()
3809            << "Attr>(A); (void)SA;\n";
3810       OS << SS.str();
3811       OS << "  }\n";
3812     }
3813   }
3814 }
3815
3816 void EmitClangAttrParserStringSwitches(RecordKeeper &Records,
3817                                        raw_ostream &OS) {
3818   emitSourceFileHeader("Parser-related llvm::StringSwitch cases", OS);
3819   emitClangAttrArgContextList(Records, OS);
3820   emitClangAttrIdentifierArgList(Records, OS);
3821   emitClangAttrVariadicIdentifierArgList(Records, OS);
3822   emitClangAttrThisIsaIdentifierArgList(Records, OS);
3823   emitClangAttrTypeArgList(Records, OS);
3824   emitClangAttrLateParsedList(Records, OS);
3825 }
3826
3827 void EmitClangAttrSubjectMatchRulesParserStringSwitches(RecordKeeper &Records,
3828                                                         raw_ostream &OS) {
3829   getPragmaAttributeSupport(Records).generateParsingHelpers(OS);
3830 }
3831
3832 enum class SpellingKind {
3833   GNU,
3834   CXX11,
3835   C2x,
3836   Declspec,
3837   Microsoft,
3838   Keyword,
3839   Pragma,
3840 };
3841 static const size_t NumSpellingKinds = (size_t)SpellingKind::Pragma + 1;
3842
3843 class SpellingList {
3844   std::vector<std::string> Spellings[NumSpellingKinds];
3845
3846 public:
3847   ArrayRef<std::string> operator[](SpellingKind K) const {
3848     return Spellings[(size_t)K];
3849   }
3850
3851   void add(const Record &Attr, FlattenedSpelling Spelling) {
3852     SpellingKind Kind = StringSwitch<SpellingKind>(Spelling.variety())
3853                             .Case("GNU", SpellingKind::GNU)
3854                             .Case("CXX11", SpellingKind::CXX11)
3855                             .Case("C2x", SpellingKind::C2x)
3856                             .Case("Declspec", SpellingKind::Declspec)
3857                             .Case("Microsoft", SpellingKind::Microsoft)
3858                             .Case("Keyword", SpellingKind::Keyword)
3859                             .Case("Pragma", SpellingKind::Pragma);
3860     std::string Name;
3861     if (!Spelling.nameSpace().empty()) {
3862       switch (Kind) {
3863       case SpellingKind::CXX11:
3864       case SpellingKind::C2x:
3865         Name = Spelling.nameSpace() + "::";
3866         break;
3867       case SpellingKind::Pragma:
3868         Name = Spelling.nameSpace() + " ";
3869         break;
3870       default:
3871         PrintFatalError(Attr.getLoc(), "Unexpected namespace in spelling");
3872       }
3873     }
3874     Name += Spelling.name();
3875
3876     Spellings[(size_t)Kind].push_back(Name);
3877   }
3878 };
3879
3880 class DocumentationData {
3881 public:
3882   const Record *Documentation;
3883   const Record *Attribute;
3884   std::string Heading;
3885   SpellingList SupportedSpellings;
3886
3887   DocumentationData(const Record &Documentation, const Record &Attribute,
3888                     std::pair<std::string, SpellingList> HeadingAndSpellings)
3889       : Documentation(&Documentation), Attribute(&Attribute),
3890         Heading(std::move(HeadingAndSpellings.first)),
3891         SupportedSpellings(std::move(HeadingAndSpellings.second)) {}
3892 };
3893
3894 static void WriteCategoryHeader(const Record *DocCategory,
3895                                 raw_ostream &OS) {
3896   const StringRef Name = DocCategory->getValueAsString("Name");
3897   OS << Name << "\n" << std::string(Name.size(), '=') << "\n";
3898
3899   // If there is content, print that as well.
3900   const StringRef ContentStr = DocCategory->getValueAsString("Content");
3901   // Trim leading and trailing newlines and spaces.
3902   OS << ContentStr.trim();
3903
3904   OS << "\n\n";
3905 }
3906
3907 static std::pair<std::string, SpellingList>
3908 GetAttributeHeadingAndSpellings(const Record &Documentation,
3909                                 const Record &Attribute) {
3910   // FIXME: there is no way to have a per-spelling category for the attribute
3911   // documentation. This may not be a limiting factor since the spellings
3912   // should generally be consistently applied across the category.
3913
3914   std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attribute);
3915   if (Spellings.empty())
3916     PrintFatalError(Attribute.getLoc(),
3917                     "Attribute has no supported spellings; cannot be "
3918                     "documented");
3919
3920   // Determine the heading to be used for this attribute.
3921   std::string Heading = Documentation.getValueAsString("Heading");
3922   if (Heading.empty()) {
3923     // If there's only one spelling, we can simply use that.
3924     if (Spellings.size() == 1)
3925       Heading = Spellings.begin()->name();
3926     else {
3927       std::set<std::string> Uniques;
3928       for (auto I = Spellings.begin(), E = Spellings.end();
3929            I != E && Uniques.size() <= 1; ++I) {
3930         std::string Spelling = NormalizeNameForSpellingComparison(I->name());
3931         Uniques.insert(Spelling);
3932       }
3933       // If the semantic map has only one spelling, that is sufficient for our
3934       // needs.
3935       if (Uniques.size() == 1)
3936         Heading = *Uniques.begin();
3937     }
3938   }
3939
3940   // If the heading is still empty, it is an error.
3941   if (Heading.empty())
3942     PrintFatalError(Attribute.getLoc(),
3943                     "This attribute requires a heading to be specified");
3944
3945   SpellingList SupportedSpellings;
3946   for (const auto &I : Spellings)
3947     SupportedSpellings.add(Attribute, I);
3948
3949   return std::make_pair(std::move(Heading), std::move(SupportedSpellings));
3950 }
3951
3952 static void WriteDocumentation(RecordKeeper &Records,
3953                                const DocumentationData &Doc, raw_ostream &OS) {
3954   OS << Doc.Heading << "\n" << std::string(Doc.Heading.length(), '-') << "\n";
3955
3956   // List what spelling syntaxes the attribute supports.
3957   OS << ".. csv-table:: Supported Syntaxes\n";
3958   OS << "   :header: \"GNU\", \"C++11\", \"C2x\", \"``__declspec``\",";
3959   OS << " \"Keyword\", \"``#pragma``\", \"``#pragma clang attribute``\"\n\n";
3960   OS << "   \"";
3961   for (size_t Kind = 0; Kind != NumSpellingKinds; ++Kind) {
3962     SpellingKind K = (SpellingKind)Kind;
3963     // TODO: List Microsoft (IDL-style attribute) spellings once we fully
3964     // support them.
3965     if (K == SpellingKind::Microsoft)
3966       continue;
3967
3968     bool PrintedAny = false;
3969     for (StringRef Spelling : Doc.SupportedSpellings[K]) {
3970       if (PrintedAny)
3971         OS << " |br| ";
3972       OS << "``" << Spelling << "``";
3973       PrintedAny = true;
3974     }
3975
3976     OS << "\",\"";
3977   }
3978
3979   if (getPragmaAttributeSupport(Records).isAttributedSupported(
3980           *Doc.Attribute))
3981     OS << "Yes";
3982   OS << "\"\n\n";
3983
3984   // If the attribute is deprecated, print a message about it, and possibly
3985   // provide a replacement attribute.
3986   if (!Doc.Documentation->isValueUnset("Deprecated")) {
3987     OS << "This attribute has been deprecated, and may be removed in a future "
3988        << "version of Clang.";
3989     const Record &Deprecated = *Doc.Documentation->getValueAsDef("Deprecated");
3990     const StringRef Replacement = Deprecated.getValueAsString("Replacement");
3991     if (!Replacement.empty())
3992       OS << "  This attribute has been superseded by ``" << Replacement
3993          << "``.";
3994     OS << "\n\n";
3995   }
3996
3997   const StringRef ContentStr = Doc.Documentation->getValueAsString("Content");
3998   // Trim leading and trailing newlines and spaces.
3999   OS << ContentStr.trim();
4000
4001   OS << "\n\n\n";
4002 }
4003
4004 void EmitClangAttrDocs(RecordKeeper &Records, raw_ostream &OS) {
4005   // Get the documentation introduction paragraph.
4006   const Record *Documentation = Records.getDef("GlobalDocumentation");
4007   if (!Documentation) {
4008     PrintFatalError("The Documentation top-level definition is missing, "
4009                     "no documentation will be generated.");
4010     return;
4011   }
4012
4013   OS << Documentation->getValueAsString("Intro") << "\n";
4014
4015   // Gather the Documentation lists from each of the attributes, based on the
4016   // category provided.
4017   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
4018   std::map<const Record *, std::vector<DocumentationData>> SplitDocs;
4019   for (const auto *A : Attrs) {
4020     const Record &Attr = *A;
4021     std::vector<Record *> Docs = Attr.getValueAsListOfDefs("Documentation");
4022     for (const auto *D : Docs) {
4023       const Record &Doc = *D;
4024       const Record *Category = Doc.getValueAsDef("Category");
4025       // If the category is "undocumented", then there cannot be any other
4026       // documentation categories (otherwise, the attribute would become
4027       // documented).
4028       const StringRef Cat = Category->getValueAsString("Name");
4029       bool Undocumented = Cat == "Undocumented";
4030       if (Undocumented && Docs.size() > 1)
4031         PrintFatalError(Doc.getLoc(),
4032                         "Attribute is \"Undocumented\", but has multiple "
4033                         "documentation categories");
4034
4035       if (!Undocumented)
4036         SplitDocs[Category].push_back(DocumentationData(
4037             Doc, Attr, GetAttributeHeadingAndSpellings(Doc, Attr)));
4038     }
4039   }
4040
4041   // Having split the attributes out based on what documentation goes where,
4042   // we can begin to generate sections of documentation.
4043   for (auto &I : SplitDocs) {
4044     WriteCategoryHeader(I.first, OS);
4045
4046     llvm::sort(I.second,
4047                [](const DocumentationData &D1, const DocumentationData &D2) {
4048                  return D1.Heading < D2.Heading;
4049                });
4050
4051     // Walk over each of the attributes in the category and write out their
4052     // documentation.
4053     for (const auto &Doc : I.second)
4054       WriteDocumentation(Records, Doc, OS);
4055   }
4056 }
4057
4058 void EmitTestPragmaAttributeSupportedAttributes(RecordKeeper &Records,
4059                                                 raw_ostream &OS) {
4060   PragmaClangAttributeSupport Support = getPragmaAttributeSupport(Records);
4061   ParsedAttrMap Attrs = getParsedAttrList(Records);
4062   OS << "#pragma clang attribute supports the following attributes:\n";
4063   for (const auto &I : Attrs) {
4064     if (!Support.isAttributedSupported(*I.second))
4065       continue;
4066     OS << I.first;
4067     if (I.second->isValueUnset("Subjects")) {
4068       OS << " ()\n";
4069       continue;
4070     }
4071     const Record *SubjectObj = I.second->getValueAsDef("Subjects");
4072     std::vector<Record *> Subjects =
4073         SubjectObj->getValueAsListOfDefs("Subjects");
4074     OS << " (";
4075     for (const auto &Subject : llvm::enumerate(Subjects)) {
4076       if (Subject.index())
4077         OS << ", ";
4078       PragmaClangAttributeSupport::RuleOrAggregateRuleSet &RuleSet =
4079           Support.SubjectsToRules.find(Subject.value())->getSecond();
4080       if (RuleSet.isRule()) {
4081         OS << RuleSet.getRule().getEnumValueName();
4082         continue;
4083       }
4084       OS << "(";
4085       for (const auto &Rule : llvm::enumerate(RuleSet.getAggregateRuleSet())) {
4086         if (Rule.index())
4087           OS << ", ";
4088         OS << Rule.value().getEnumValueName();
4089       }
4090       OS << ")";
4091     }
4092     OS << ")\n";
4093   }
4094   OS << "End of supported attributes.\n";
4095 }
4096
4097 } // end namespace clang