contrib/llvm/tools/clang/utils/TableGen/ClangAttrEmitter.cpp

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