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