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/SmallString.h"
  15 #include "llvm/ADT/StringSwitch.h"
  16 #include "llvm/TableGen/Record.h"
  17 #include "llvm/TableGen/StringMatcher.h"
  18 #include "llvm/TableGen/TableGenBackend.h"
  19 #include <algorithm>
  20 #include <cctype>
  21
  22 using namespace llvm;
  23
  24 static const std::vector<StringRef>
  25 getValueAsListOfStrings(Record &R, StringRef FieldName) {
  26   ListInit *List = R.getValueAsListInit(FieldName);
  27   assert (List && "Got a null ListInit");
  28
  29   std::vector<StringRef> Strings;
  30   Strings.reserve(List->getSize());
  31
  32   for (ListInit::const_iterator i = List->begin(), e = List->end();
  33        i != e;
  34        ++i) {
  35     assert(*i && "Got a null element in a ListInit");
  36     if (StringInit *S = dyn_cast<StringInit>(*i))
  37       Strings.push_back(S->getValue());
  38     else
  39       assert(false && "Got a non-string, non-code element in a ListInit");
  40   }
  41
  42   return Strings;
  43 }
  44
  45 static std::string ReadPCHRecord(StringRef type) {
  46   return StringSwitch<std::string>(type)
  47     .EndsWith("Decl *", "GetLocalDeclAs<"
  48               + std::string(type, 0, type.size()-1) + ">(F, Record[Idx++])")
  49     .Case("QualType", "getLocalType(F, Record[Idx++])")
  50     .Case("Expr *", "ReadExpr(F)")
  51     .Case("IdentifierInfo *", "GetIdentifierInfo(F, Record, Idx)")
  52     .Case("SourceLocation", "ReadSourceLocation(F, Record, Idx)")
  53     .Default("Record[Idx++]");
  54 }
  55
  56 // Assumes that the way to get the value is SA->getname()
  57 static std::string WritePCHRecord(StringRef type, StringRef name) {
  58   return StringSwitch<std::string>(type)
  59     .EndsWith("Decl *", "AddDeclRef(" + std::string(name) +
  60                         ", Record);\n")
  61     .Case("QualType", "AddTypeRef(" + std::string(name) + ", Record);\n")
  62     .Case("Expr *", "AddStmt(" + std::string(name) + ");\n")
  63     .Case("IdentifierInfo *",
  64           "AddIdentifierRef(" + std::string(name) + ", Record);\n")
  65     .Case("SourceLocation",
  66           "AddSourceLocation(" + std::string(name) + ", Record);\n")
  67     .Default("Record.push_back(" + std::string(name) + ");\n");
  68 }
  69
  70 // Normalize attribute name by removing leading and trailing
  71 // underscores. For example, __foo, foo__, __foo__ would
  72 // become foo.
  73 static StringRef NormalizeAttrName(StringRef AttrName) {
  74   if (AttrName.startswith("__"))
  75     AttrName = AttrName.substr(2, AttrName.size());
  76
  77   if (AttrName.endswith("__"))
  78     AttrName = AttrName.substr(0, AttrName.size() - 2);
  79
  80   return AttrName;
  81 }
  82
  83 // Normalize attribute spelling only if the spelling has both leading
  84 // and trailing underscores. For example, __ms_struct__ will be
  85 // normalized to "ms_struct"; __cdecl will remain intact.
  86 static StringRef NormalizeAttrSpelling(StringRef AttrSpelling) {
  87   if (AttrSpelling.startswith("__") && AttrSpelling.endswith("__")) {
  88     AttrSpelling = AttrSpelling.substr(2, AttrSpelling.size() - 4);
  89   }
  90
  91   return AttrSpelling;
  92 }
  93
  94 namespace {
  95   class Argument {
  96     std::string lowerName, upperName;
  97     StringRef attrName;
  98
  99   public:
 100     Argument(Record &Arg, StringRef Attr)
 101       : lowerName(Arg.getValueAsString("Name")), upperName(lowerName),
 102         attrName(Attr) {
 103       if (!lowerName.empty()) {
 104         lowerName[0] = std::tolower(lowerName[0]);
 105         upperName[0] = std::toupper(upperName[0]);
 106       }
 107     }
 108     virtual ~Argument() {}
 109
 110     StringRef getLowerName() const { return lowerName; }
 111     StringRef getUpperName() const { return upperName; }
 112     StringRef getAttrName() const { return attrName; }
 113
 114     // These functions print the argument contents formatted in different ways.
 115     virtual void writeAccessors(raw_ostream &OS) const = 0;
 116     virtual void writeAccessorDefinitions(raw_ostream &OS) const {}
 117     virtual void writeCloneArgs(raw_ostream &OS) const = 0;
 118     virtual void writeTemplateInstantiationArgs(raw_ostream &OS) const = 0;
 119     virtual void writeTemplateInstantiation(raw_ostream &OS) const {}
 120     virtual void writeCtorBody(raw_ostream &OS) const {}
 121     virtual void writeCtorInitializers(raw_ostream &OS) const = 0;
 122     virtual void writeCtorParameters(raw_ostream &OS) const = 0;
 123     virtual void writeDeclarations(raw_ostream &OS) const = 0;
 124     virtual void writePCHReadArgs(raw_ostream &OS) const = 0;
 125     virtual void writePCHReadDecls(raw_ostream &OS) const = 0;
 126     virtual void writePCHWrite(raw_ostream &OS) const = 0;
 127     virtual void writeValue(raw_ostream &OS) const = 0;
 128     virtual void writeDump(raw_ostream &OS) const = 0;
 129     virtual void writeDumpChildren(raw_ostream &OS) const {}
 130     virtual void writeHasChildren(raw_ostream &OS) const { OS << "false"; }
 131   };
 132
 133   class SimpleArgument : public Argument {
 134     std::string type;
 135
 136   public:
 137     SimpleArgument(Record &Arg, StringRef Attr, std::string T)
 138       : Argument(Arg, Attr), type(T)
 139     {}
 140
 141     std::string getType() const { return type; }
 142
 143     void writeAccessors(raw_ostream &OS) const {
 144       OS << "  " << type << " get" << getUpperName() << "() const {\n";
 145       OS << "    return " << getLowerName() << ";\n";
 146       OS << "  }";
 147     }
 148     void writeCloneArgs(raw_ostream &OS) const {
 149       OS << getLowerName();
 150     }
 151     void writeTemplateInstantiationArgs(raw_ostream &OS) const {
 152       OS << "A->get" << getUpperName() << "()";
 153     }
 154     void writeCtorInitializers(raw_ostream &OS) const {
 155       OS << getLowerName() << "(" << getUpperName() << ")";
 156     }
 157     void writeCtorParameters(raw_ostream &OS) const {
 158       OS << type << " " << getUpperName();
 159     }
 160     void writeDeclarations(raw_ostream &OS) const {
 161       OS << type << " " << getLowerName() << ";";
 162     }
 163     void writePCHReadDecls(raw_ostream &OS) const {
 164       std::string read = ReadPCHRecord(type);
 165       OS << "    " << type << " " << getLowerName() << " = " << read << ";\n";
 166     }
 167     void writePCHReadArgs(raw_ostream &OS) const {
 168       OS << getLowerName();
 169     }
 170     void writePCHWrite(raw_ostream &OS) const {
 171       OS << "    " << WritePCHRecord(type, "SA->get" +
 172                                            std::string(getUpperName()) + "()");
 173     }
 174     void writeValue(raw_ostream &OS) const {
 175       if (type == "FunctionDecl *") {
 176         OS << "\" << get" << getUpperName() << "()->getNameInfo().getAsString() << \"";
 177       } else if (type == "IdentifierInfo *") {
 178         OS << "\" << get" << getUpperName() << "()->getName() << \"";
 179       } else if (type == "QualType") {
 180         OS << "\" << get" << getUpperName() << "().getAsString() << \"";
 181       } else if (type == "SourceLocation") {
 182         OS << "\" << get" << getUpperName() << "().getRawEncoding() << \"";
 183       } else {
 184         OS << "\" << get" << getUpperName() << "() << \"";
 185       }
 186     }
 187     void writeDump(raw_ostream &OS) const {
 188       if (type == "FunctionDecl *") {
 189         OS << "    OS << \" \";\n";
 190         OS << "    dumpBareDeclRef(SA->get" << getUpperName() << "());\n";
 191       } else if (type == "IdentifierInfo *") {
 192         OS << "    OS << \" \" << SA->get" << getUpperName()
 193            << "()->getName();\n";
 194       } else if (type == "QualType") {
 195         OS << "    OS << \" \" << SA->get" << getUpperName()
 196            << "().getAsString();\n";
 197       } else if (type == "SourceLocation") {
 198         OS << "    OS << \" \";\n";
 199         OS << "    SA->get" << getUpperName() << "().print(OS, *SM);\n";
 200       } else if (type == "bool") {
 201         OS << "    if (SA->get" << getUpperName() << "()) OS << \" "
 202            << getUpperName() << "\";\n";
 203       } else if (type == "int" || type == "unsigned") {
 204         OS << "    OS << \" \" << SA->get" << getUpperName() << "();\n";
 205       } else {
 206         llvm_unreachable("Unknown SimpleArgument type!");
 207       }
 208     }
 209   };
 210
 211   class StringArgument : public Argument {
 212   public:
 213     StringArgument(Record &Arg, StringRef Attr)
 214       : Argument(Arg, Attr)
 215     {}
 216
 217     void writeAccessors(raw_ostream &OS) const {
 218       OS << "  llvm::StringRef get" << getUpperName() << "() const {\n";
 219       OS << "    return llvm::StringRef(" << getLowerName() << ", "
 220          << getLowerName() << "Length);\n";
 221       OS << "  }\n";
 222       OS << "  unsigned get" << getUpperName() << "Length() const {\n";
 223       OS << "    return " << getLowerName() << "Length;\n";
 224       OS << "  }\n";
 225       OS << "  void set" << getUpperName()
 226          << "(ASTContext &C, llvm::StringRef S) {\n";
 227       OS << "    " << getLowerName() << "Length = S.size();\n";
 228       OS << "    this->" << getLowerName() << " = new (C, 1) char ["
 229          << getLowerName() << "Length];\n";
 230       OS << "    std::memcpy(this->" << getLowerName() << ", S.data(), "
 231          << getLowerName() << "Length);\n";
 232       OS << "  }";
 233     }
 234     void writeCloneArgs(raw_ostream &OS) const {
 235       OS << "get" << getUpperName() << "()";
 236     }
 237     void writeTemplateInstantiationArgs(raw_ostream &OS) const {
 238       OS << "A->get" << getUpperName() << "()";
 239     }
 240     void writeCtorBody(raw_ostream &OS) const {
 241       OS << "      std::memcpy(" << getLowerName() << ", " << getUpperName()
 242          << ".data(), " << getLowerName() << "Length);";
 243     }
 244     void writeCtorInitializers(raw_ostream &OS) const {
 245       OS << getLowerName() << "Length(" << getUpperName() << ".size()),"
 246          << getLowerName() << "(new (Ctx, 1) char[" << getLowerName()
 247          << "Length])";
 248     }
 249     void writeCtorParameters(raw_ostream &OS) const {
 250       OS << "llvm::StringRef " << getUpperName();
 251     }
 252     void writeDeclarations(raw_ostream &OS) const {
 253       OS << "unsigned " << getLowerName() << "Length;\n";
 254       OS << "char *" << getLowerName() << ";";
 255     }
 256     void writePCHReadDecls(raw_ostream &OS) const {
 257       OS << "    std::string " << getLowerName()
 258          << "= ReadString(Record, Idx);\n";
 259     }
 260     void writePCHReadArgs(raw_ostream &OS) const {
 261       OS << getLowerName();
 262     }
 263     void writePCHWrite(raw_ostream &OS) const {
 264       OS << "    AddString(SA->get" << getUpperName() << "(), Record);\n";
 265     }
 266     void writeValue(raw_ostream &OS) const {
 267       OS << "\\\"\" << get" << getUpperName() << "() << \"\\\"";
 268     }
 269     void writeDump(raw_ostream &OS) const {
 270       OS << "    OS << \" \\\"\" << SA->get" << getUpperName()
 271          << "() << \"\\\"\";\n";
 272     }
 273   };
 274
 275   class AlignedArgument : public Argument {
 276   public:
 277     AlignedArgument(Record &Arg, StringRef Attr)
 278       : Argument(Arg, Attr)
 279     {}
 280
 281     void writeAccessors(raw_ostream &OS) const {
 282       OS << "  bool is" << getUpperName() << "Dependent() const;\n";
 283
 284       OS << "  unsigned get" << getUpperName() << "(ASTContext &Ctx) const;\n";
 285
 286       OS << "  bool is" << getUpperName() << "Expr() const {\n";
 287       OS << "    return is" << getLowerName() << "Expr;\n";
 288       OS << "  }\n";
 289
 290       OS << "  Expr *get" << getUpperName() << "Expr() const {\n";
 291       OS << "    assert(is" << getLowerName() << "Expr);\n";
 292       OS << "    return " << getLowerName() << "Expr;\n";
 293       OS << "  }\n";
 294
 295       OS << "  TypeSourceInfo *get" << getUpperName() << "Type() const {\n";
 296       OS << "    assert(!is" << getLowerName() << "Expr);\n";
 297       OS << "    return " << getLowerName() << "Type;\n";
 298       OS << "  }";
 299     }
 300     void writeAccessorDefinitions(raw_ostream &OS) const {
 301       OS << "bool " << getAttrName() << "Attr::is" << getUpperName()
 302          << "Dependent() const {\n";
 303       OS << "  if (is" << getLowerName() << "Expr)\n";
 304       OS << "    return " << getLowerName() << "Expr && (" << getLowerName()
 305          << "Expr->isValueDependent() || " << getLowerName()
 306          << "Expr->isTypeDependent());\n";
 307       OS << "  else\n";
 308       OS << "    return " << getLowerName()
 309          << "Type->getType()->isDependentType();\n";
 310       OS << "}\n";
 311
 312       // FIXME: Do not do the calculation here
 313       // FIXME: Handle types correctly
 314       // A null pointer means maximum alignment
 315       // FIXME: Load the platform-specific maximum alignment, rather than
 316       //        16, the x86 max.
 317       OS << "unsigned " << getAttrName() << "Attr::get" << getUpperName()
 318          << "(ASTContext &Ctx) const {\n";
 319       OS << "  assert(!is" << getUpperName() << "Dependent());\n";
 320       OS << "  if (is" << getLowerName() << "Expr)\n";
 321       OS << "    return (" << getLowerName() << "Expr ? " << getLowerName()
 322          << "Expr->EvaluateKnownConstInt(Ctx).getZExtValue() : 16)"
 323          << "* Ctx.getCharWidth();\n";
 324       OS << "  else\n";
 325       OS << "    return 0; // FIXME\n";
 326       OS << "}\n";
 327     }
 328     void writeCloneArgs(raw_ostream &OS) const {
 329       OS << "is" << getLowerName() << "Expr, is" << getLowerName()
 330          << "Expr ? static_cast<void*>(" << getLowerName()
 331          << "Expr) : " << getLowerName()
 332          << "Type";
 333     }
 334     void writeTemplateInstantiationArgs(raw_ostream &OS) const {
 335       // FIXME: move the definition in Sema::InstantiateAttrs to here.
 336       // In the meantime, aligned attributes are cloned.
 337     }
 338     void writeCtorBody(raw_ostream &OS) const {
 339       OS << "    if (is" << getLowerName() << "Expr)\n";
 340       OS << "       " << getLowerName() << "Expr = reinterpret_cast<Expr *>("
 341          << getUpperName() << ");\n";
 342       OS << "    else\n";
 343       OS << "       " << getLowerName()
 344          << "Type = reinterpret_cast<TypeSourceInfo *>(" << getUpperName()
 345          << ");";
 346     }
 347     void writeCtorInitializers(raw_ostream &OS) const {
 348       OS << "is" << getLowerName() << "Expr(Is" << getUpperName() << "Expr)";
 349     }
 350     void writeCtorParameters(raw_ostream &OS) const {
 351       OS << "bool Is" << getUpperName() << "Expr, void *" << getUpperName();
 352     }
 353     void writeDeclarations(raw_ostream &OS) const {
 354       OS << "bool is" << getLowerName() << "Expr;\n";
 355       OS << "union {\n";
 356       OS << "Expr *" << getLowerName() << "Expr;\n";
 357       OS << "TypeSourceInfo *" << getLowerName() << "Type;\n";
 358       OS << "};";
 359     }
 360     void writePCHReadArgs(raw_ostream &OS) const {
 361       OS << "is" << getLowerName() << "Expr, " << getLowerName() << "Ptr";
 362     }
 363     void writePCHReadDecls(raw_ostream &OS) const {
 364       OS << "    bool is" << getLowerName() << "Expr = Record[Idx++];\n";
 365       OS << "    void *" << getLowerName() << "Ptr;\n";
 366       OS << "    if (is" << getLowerName() << "Expr)\n";
 367       OS << "      " << getLowerName() << "Ptr = ReadExpr(F);\n";
 368       OS << "    else\n";
 369       OS << "      " << getLowerName()
 370          << "Ptr = GetTypeSourceInfo(F, Record, Idx);\n";
 371     }
 372     void writePCHWrite(raw_ostream &OS) const {
 373       OS << "    Record.push_back(SA->is" << getUpperName() << "Expr());\n";
 374       OS << "    if (SA->is" << getUpperName() << "Expr())\n";
 375       OS << "      AddStmt(SA->get" << getUpperName() << "Expr());\n";
 376       OS << "    else\n";
 377       OS << "      AddTypeSourceInfo(SA->get" << getUpperName()
 378          << "Type(), Record);\n";
 379     }
 380     void writeValue(raw_ostream &OS) const {
 381       OS << "\";\n"
 382          << "  " << getLowerName() << "Expr->printPretty(OS, 0, Policy);\n"
 383          << "  OS << \"";
 384     }
 385     void writeDump(raw_ostream &OS) const {
 386     }
 387     void writeDumpChildren(raw_ostream &OS) const {
 388       OS << "    if (SA->is" << getUpperName() << "Expr()) {\n";
 389       OS << "      lastChild();\n";
 390       OS << "      dumpStmt(SA->get" << getUpperName() << "Expr());\n";
 391       OS << "    } else\n";
 392       OS << "      dumpType(SA->get" << getUpperName()
 393          << "Type()->getType());\n";
 394     }
 395     void writeHasChildren(raw_ostream &OS) const {
 396       OS << "SA->is" << getUpperName() << "Expr()";
 397     }
 398   };
 399
 400   class VariadicArgument : public Argument {
 401     std::string type;
 402
 403   public:
 404     VariadicArgument(Record &Arg, StringRef Attr, std::string T)
 405       : Argument(Arg, Attr), type(T)
 406     {}
 407
 408     std::string getType() const { return type; }
 409
 410     void writeAccessors(raw_ostream &OS) const {
 411       OS << "  typedef " << type << "* " << getLowerName() << "_iterator;\n";
 412       OS << "  " << getLowerName() << "_iterator " << getLowerName()
 413          << "_begin() const {\n";
 414       OS << "    return " << getLowerName() << ";\n";
 415       OS << "  }\n";
 416       OS << "  " << getLowerName() << "_iterator " << getLowerName()
 417          << "_end() const {\n";
 418       OS << "    return " << getLowerName() << " + " << getLowerName()
 419          << "Size;\n";
 420       OS << "  }\n";
 421       OS << "  unsigned " << getLowerName() << "_size() const {\n"
 422          << "    return " << getLowerName() << "Size;\n";
 423       OS << "  }";
 424     }
 425     void writeCloneArgs(raw_ostream &OS) const {
 426       OS << getLowerName() << ", " << getLowerName() << "Size";
 427     }
 428     void writeTemplateInstantiationArgs(raw_ostream &OS) const {
 429       // This isn't elegant, but we have to go through public methods...
 430       OS << "A->" << getLowerName() << "_begin(), "
 431          << "A->" << getLowerName() << "_size()";
 432     }
 433     void writeCtorBody(raw_ostream &OS) const {
 434       // FIXME: memcpy is not safe on non-trivial types.
 435       OS << "    std::memcpy(" << getLowerName() << ", " << getUpperName()
 436          << ", " << getLowerName() << "Size * sizeof(" << getType() << "));\n";
 437     }
 438     void writeCtorInitializers(raw_ostream &OS) const {
 439       OS << getLowerName() << "Size(" << getUpperName() << "Size), "
 440          << getLowerName() << "(new (Ctx, 16) " << getType() << "["
 441          << getLowerName() << "Size])";
 442     }
 443     void writeCtorParameters(raw_ostream &OS) const {
 444       OS << getType() << " *" << getUpperName() << ", unsigned "
 445          << getUpperName() << "Size";
 446     }
 447     void writeDeclarations(raw_ostream &OS) const {
 448       OS << "  unsigned " << getLowerName() << "Size;\n";
 449       OS << "  " << getType() << " *" << getLowerName() << ";";
 450     }
 451     void writePCHReadDecls(raw_ostream &OS) const {
 452       OS << "  unsigned " << getLowerName() << "Size = Record[Idx++];\n";
 453       OS << "  SmallVector<" << type << ", 4> " << getLowerName()
 454          << ";\n";
 455       OS << "  " << getLowerName() << ".reserve(" << getLowerName()
 456          << "Size);\n";
 457       OS << "  for (unsigned i = " << getLowerName() << "Size; i; --i)\n";
 458
 459       std::string read = ReadPCHRecord(type);
 460       OS << "    " << getLowerName() << ".push_back(" << read << ");\n";
 461     }
 462     void writePCHReadArgs(raw_ostream &OS) const {
 463       OS << getLowerName() << ".data(), " << getLowerName() << "Size";
 464     }
 465     void writePCHWrite(raw_ostream &OS) const{
 466       OS << "    Record.push_back(SA->" << getLowerName() << "_size());\n";
 467       OS << "    for (" << getAttrName() << "Attr::" << getLowerName()
 468          << "_iterator i = SA->" << getLowerName() << "_begin(), e = SA->"
 469          << getLowerName() << "_end(); i != e; ++i)\n";
 470       OS << "      " << WritePCHRecord(type, "(*i)");
 471     }
 472     void writeValue(raw_ostream &OS) const {
 473       OS << "\";\n";
 474       OS << "  bool isFirst = true;\n"
 475          << "  for (" << getAttrName() << "Attr::" << getLowerName()
 476          << "_iterator i = " << getLowerName() << "_begin(), e = "
 477          << getLowerName() << "_end(); i != e; ++i) {\n"
 478          << "    if (isFirst) isFirst = false;\n"
 479          << "    else OS << \", \";\n"
 480          << "    OS << *i;\n"
 481          << "  }\n";
 482       OS << "  OS << \"";
 483     }
 484     void writeDump(raw_ostream &OS) const {
 485       OS << "    for (" << getAttrName() << "Attr::" << getLowerName()
 486          << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
 487          << getLowerName() << "_end(); I != E; ++I)\n";
 488       OS << "      OS << \" \" << *I;\n";
 489     }
 490   };
 491
 492   class EnumArgument : public Argument {
 493     std::string type;
 494     std::vector<StringRef> values, enums, uniques;
 495   public:
 496     EnumArgument(Record &Arg, StringRef Attr)
 497       : Argument(Arg, Attr), type(Arg.getValueAsString("Type")),
 498         values(getValueAsListOfStrings(Arg, "Values")),
 499         enums(getValueAsListOfStrings(Arg, "Enums")),
 500         uniques(enums)
 501     {
 502       // Calculate the various enum values
 503       std::sort(uniques.begin(), uniques.end());
 504       uniques.erase(std::unique(uniques.begin(), uniques.end()), uniques.end());
 505       // FIXME: Emit a proper error
 506       assert(!uniques.empty());
 507     }
 508
 509     void writeAccessors(raw_ostream &OS) const {
 510       OS << "  " << type << " get" << getUpperName() << "() const {\n";
 511       OS << "    return " << getLowerName() << ";\n";
 512       OS << "  }";
 513     }
 514     void writeCloneArgs(raw_ostream &OS) const {
 515       OS << getLowerName();
 516     }
 517     void writeTemplateInstantiationArgs(raw_ostream &OS) const {
 518       OS << "A->get" << getUpperName() << "()";
 519     }
 520     void writeCtorInitializers(raw_ostream &OS) const {
 521       OS << getLowerName() << "(" << getUpperName() << ")";
 522     }
 523     void writeCtorParameters(raw_ostream &OS) const {
 524       OS << type << " " << getUpperName();
 525     }
 526     void writeDeclarations(raw_ostream &OS) const {
 527       std::vector<StringRef>::const_iterator i = uniques.begin(),
 528                                              e = uniques.end();
 529       // The last one needs to not have a comma.
 530       --e;
 531
 532       OS << "public:\n";
 533       OS << "  enum " << type << " {\n";
 534       for (; i != e; ++i)
 535         OS << "    " << *i << ",\n";
 536       OS << "    " << *e << "\n";
 537       OS << "  };\n";
 538       OS << "private:\n";
 539       OS << "  " << type << " " << getLowerName() << ";";
 540     }
 541     void writePCHReadDecls(raw_ostream &OS) const {
 542       OS << "    " << getAttrName() << "Attr::" << type << " " << getLowerName()
 543          << "(static_cast<" << getAttrName() << "Attr::" << type
 544          << ">(Record[Idx++]));\n";
 545     }
 546     void writePCHReadArgs(raw_ostream &OS) const {
 547       OS << getLowerName();
 548     }
 549     void writePCHWrite(raw_ostream &OS) const {
 550       OS << "Record.push_back(SA->get" << getUpperName() << "());\n";
 551     }
 552     void writeValue(raw_ostream &OS) const {
 553       OS << "\" << get" << getUpperName() << "() << \"";
 554     }
 555     void writeDump(raw_ostream &OS) const {
 556       OS << "    switch(SA->get" << getUpperName() << "()) {\n";
 557       for (std::vector<StringRef>::const_iterator I = uniques.begin(),
 558            E = uniques.end(); I != E; ++I) {
 559         OS << "    case " << getAttrName() << "Attr::" << *I << ":\n";
 560         OS << "      OS << \" " << *I << "\";\n";
 561         OS << "      break;\n";
 562       }
 563       OS << "    }\n";
 564     }
 565   };
 566
 567   class VersionArgument : public Argument {
 568   public:
 569     VersionArgument(Record &Arg, StringRef Attr)
 570       : Argument(Arg, Attr)
 571     {}
 572
 573     void writeAccessors(raw_ostream &OS) const {
 574       OS << "  VersionTuple get" << getUpperName() << "() const {\n";
 575       OS << "    return " << getLowerName() << ";\n";
 576       OS << "  }\n";
 577       OS << "  void set" << getUpperName()
 578          << "(ASTContext &C, VersionTuple V) {\n";
 579       OS << "    " << getLowerName() << " = V;\n";
 580       OS << "  }";
 581     }
 582     void writeCloneArgs(raw_ostream &OS) const {
 583       OS << "get" << getUpperName() << "()";
 584     }
 585     void writeTemplateInstantiationArgs(raw_ostream &OS) const {
 586       OS << "A->get" << getUpperName() << "()";
 587     }
 588     void writeCtorBody(raw_ostream &OS) const {
 589     }
 590     void writeCtorInitializers(raw_ostream &OS) const {
 591       OS << getLowerName() << "(" << getUpperName() << ")";
 592     }
 593     void writeCtorParameters(raw_ostream &OS) const {
 594       OS << "VersionTuple " << getUpperName();
 595     }
 596     void writeDeclarations(raw_ostream &OS) const {
 597       OS << "VersionTuple " << getLowerName() << ";\n";
 598     }
 599     void writePCHReadDecls(raw_ostream &OS) const {
 600       OS << "    VersionTuple " << getLowerName()
 601          << "= ReadVersionTuple(Record, Idx);\n";
 602     }
 603     void writePCHReadArgs(raw_ostream &OS) const {
 604       OS << getLowerName();
 605     }
 606     void writePCHWrite(raw_ostream &OS) const {
 607       OS << "    AddVersionTuple(SA->get" << getUpperName() << "(), Record);\n";
 608     }
 609     void writeValue(raw_ostream &OS) const {
 610       OS << getLowerName() << "=\" << get" << getUpperName() << "() << \"";
 611     }
 612     void writeDump(raw_ostream &OS) const {
 613       OS << "    OS << \" \" << SA->get" << getUpperName() << "();\n";
 614     }
 615   };
 616
 617   class ExprArgument : public SimpleArgument {
 618   public:
 619     ExprArgument(Record &Arg, StringRef Attr)
 620       : SimpleArgument(Arg, Attr, "Expr *")
 621     {}
 622
 623     void writeTemplateInstantiationArgs(raw_ostream &OS) const {
 624       OS << "tempInst" << getUpperName();
 625     }
 626
 627     void writeTemplateInstantiation(raw_ostream &OS) const {
 628       OS << "      " << getType() << " tempInst" << getUpperName() << ";\n";
 629       OS << "      {\n";
 630       OS << "        EnterExpressionEvaluationContext "
 631          << "Unevaluated(S, Sema::Unevaluated);\n";
 632       OS << "        ExprResult " << "Result = S.SubstExpr("
 633          << "A->get" << getUpperName() << "(), TemplateArgs);\n";
 634       OS << "        tempInst" << getUpperName() << " = "
 635          << "Result.takeAs<Expr>();\n";
 636       OS << "      }\n";
 637     }
 638
 639     void writeDump(raw_ostream &OS) const {
 640     }
 641
 642     void writeDumpChildren(raw_ostream &OS) const {
 643       OS << "    lastChild();\n";
 644       OS << "    dumpStmt(SA->get" << getUpperName() << "());\n";
 645     }
 646     void writeHasChildren(raw_ostream &OS) const { OS << "true"; }
 647   };
 648
 649   class VariadicExprArgument : public VariadicArgument {
 650   public:
 651     VariadicExprArgument(Record &Arg, StringRef Attr)
 652       : VariadicArgument(Arg, Attr, "Expr *")
 653     {}
 654
 655     void writeTemplateInstantiationArgs(raw_ostream &OS) const {
 656       OS << "tempInst" << getUpperName() << ", "
 657          << "A->" << getLowerName() << "_size()";
 658     }
 659
 660     void writeTemplateInstantiation(raw_ostream &OS) const {
 661       OS << "      " << getType() << " *tempInst" << getUpperName()
 662          << " = new (C, 16) " << getType()
 663          << "[A->" << getLowerName() << "_size()];\n";
 664       OS << "      {\n";
 665       OS << "        EnterExpressionEvaluationContext "
 666          << "Unevaluated(S, Sema::Unevaluated);\n";
 667       OS << "        " << getType() << " *TI = tempInst" << getUpperName()
 668          << ";\n";
 669       OS << "        " << getType() << " *I = A->" << getLowerName()
 670          << "_begin();\n";
 671       OS << "        " << getType() << " *E = A->" << getLowerName()
 672          << "_end();\n";
 673       OS << "        for (; I != E; ++I, ++TI) {\n";
 674       OS << "          ExprResult Result = S.SubstExpr(*I, TemplateArgs);\n";
 675       OS << "          *TI = Result.takeAs<Expr>();\n";
 676       OS << "        }\n";
 677       OS << "      }\n";
 678     }
 679
 680     void writeDump(raw_ostream &OS) const {
 681     }
 682
 683     void writeDumpChildren(raw_ostream &OS) const {
 684       OS << "    for (" << getAttrName() << "Attr::" << getLowerName()
 685          << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
 686          << getLowerName() << "_end(); I != E; ++I) {\n";
 687       OS << "      if (I + 1 == E)\n";
 688       OS << "        lastChild();\n";
 689       OS << "      dumpStmt(*I);\n";
 690       OS << "    }\n";
 691     }
 692
 693     void writeHasChildren(raw_ostream &OS) const {
 694       OS << "SA->" << getLowerName() << "_begin() != "
 695          << "SA->" << getLowerName() << "_end()";
 696     }
 697   };
 698 }
 699
 700 static Argument *createArgument(Record &Arg, StringRef Attr,
 701                                 Record *Search = 0) {
 702   if (!Search)
 703     Search = &Arg;
 704
 705   Argument *Ptr = 0;
 706   llvm::StringRef ArgName = Search->getName();
 707
 708   if (ArgName == "AlignedArgument") Ptr = new AlignedArgument(Arg, Attr);
 709   else if (ArgName == "EnumArgument") Ptr = new EnumArgument(Arg, Attr);
 710   else if (ArgName == "ExprArgument") Ptr = new ExprArgument(Arg, Attr);
 711   else if (ArgName == "FunctionArgument")
 712     Ptr = new SimpleArgument(Arg, Attr, "FunctionDecl *");
 713   else if (ArgName == "IdentifierArgument")
 714     Ptr = new SimpleArgument(Arg, Attr, "IdentifierInfo *");
 715   else if (ArgName == "BoolArgument") Ptr = new SimpleArgument(Arg, Attr,
 716                                                                "bool");
 717   else if (ArgName == "IntArgument") Ptr = new SimpleArgument(Arg, Attr, "int");
 718   else if (ArgName == "StringArgument") Ptr = new StringArgument(Arg, Attr);
 719   else if (ArgName == "TypeArgument")
 720     Ptr = new SimpleArgument(Arg, Attr, "QualType");
 721   else if (ArgName == "UnsignedArgument")
 722     Ptr = new SimpleArgument(Arg, Attr, "unsigned");
 723   else if (ArgName == "SourceLocArgument")
 724     Ptr = new SimpleArgument(Arg, Attr, "SourceLocation");
 725   else if (ArgName == "VariadicUnsignedArgument")
 726     Ptr = new VariadicArgument(Arg, Attr, "unsigned");
 727   else if (ArgName == "VariadicExprArgument")
 728     Ptr = new VariadicExprArgument(Arg, Attr);
 729   else if (ArgName == "VersionArgument")
 730     Ptr = new VersionArgument(Arg, Attr);
 731
 732   if (!Ptr) {
 733     std::vector<Record*> Bases = Search->getSuperClasses();
 734     for (std::vector<Record*>::iterator i = Bases.begin(), e = Bases.end();
 735          i != e; ++i) {
 736       Ptr = createArgument(Arg, Attr, *i);
 737       if (Ptr)
 738         break;
 739     }
 740   }
 741   return Ptr;
 742 }
 743
 744 static void writeAvailabilityValue(raw_ostream &OS) {
 745   OS << "\" << getPlatform()->getName();\n"
 746      << "  if (!getIntroduced().empty()) OS << \", introduced=\" << getIntroduced();\n"
 747      << "  if (!getDeprecated().empty()) OS << \", deprecated=\" << getDeprecated();\n"
 748      << "  if (!getObsoleted().empty()) OS << \", obsoleted=\" << getObsoleted();\n"
 749      << "  if (getUnavailable()) OS << \", unavailable\";\n"
 750      << "  OS << \"";
 751 }
 752
 753 static void writePrettyPrintFunction(Record &R, std::vector<Argument*> &Args,
 754                                      raw_ostream &OS) {
 755   std::vector<Record*> Spellings = R.getValueAsListOfDefs("Spellings");
 756
 757   OS << "void " << R.getName() << "Attr::printPretty("
 758     << "raw_ostream &OS, const PrintingPolicy &Policy) const {\n";
 759
 760   if (Spellings.size() == 0) {
 761     OS << "}\n\n";
 762     return;
 763   }
 764
 765   OS <<
 766     "  switch (SpellingListIndex) {\n"
 767     "  default:\n"
 768     "    llvm_unreachable(\"Unknown attribute spelling!\");\n"
 769     "    break;\n";
 770
 771   for (unsigned I = 0; I < Spellings.size(); ++ I) {
 772     llvm::SmallString<16> Prefix;
 773     llvm::SmallString<8> Suffix;
 774     // The actual spelling of the name and namespace (if applicable)
 775     // of an attribute without considering prefix and suffix.
 776     llvm::SmallString<64> Spelling;
 777     std::string Name = Spellings[I]->getValueAsString("Name");
 778     std::string Variety = Spellings[I]->getValueAsString("Variety");
 779
 780     if (Variety == "GNU") {
 781       Prefix = " __attribute__((";
 782       Suffix = "))";
 783     } else if (Variety == "CXX11") {
 784       Prefix = " [[";
 785       Suffix = "]]";
 786       std::string Namespace = Spellings[I]->getValueAsString("Namespace");
 787       if (Namespace != "") {
 788         Spelling += Namespace;
 789         Spelling += "::";
 790       }
 791     } else if (Variety == "Declspec") {
 792       Prefix = " __declspec(";
 793       Suffix = ")";
 794     } else if (Variety == "Keyword") {
 795       Prefix = " ";
 796       Suffix = "";
 797     } else {
 798       llvm_unreachable("Unknown attribute syntax variety!");
 799     }
 800
 801     Spelling += Name;
 802
 803     OS <<
 804       "  case " << I << " : {\n"
 805       "    OS << \"" + Prefix.str() + Spelling.str();
 806
 807     if (Args.size()) OS << "(";
 808     if (Spelling == "availability") {
 809       writeAvailabilityValue(OS);
 810     } else {
 811       for (std::vector<Argument*>::const_iterator I = Args.begin(),
 812            E = Args.end(); I != E; ++ I) {
 813         if (I != Args.begin()) OS << ", ";
 814         (*I)->writeValue(OS);
 815       }
 816     }
 817
 818     if (Args.size()) OS << ")";
 819     OS << Suffix.str() + "\";\n";
 820
 821     OS <<
 822       "    break;\n"
 823       "  }\n";
 824   }
 825
 826   // End of the switch statement.
 827   OS << "}\n";
 828   // End of the print function.
 829   OS << "}\n\n";
 830 }
 831
 832 /// \brief Return the index of a spelling in a spelling list.
 833 static unsigned getSpellingListIndex(const std::vector<Record*> &SpellingList,
 834                                      const Record &Spelling) {
 835   assert(SpellingList.size() && "Spelling list is empty!");
 836
 837   for (unsigned Index = 0; Index < SpellingList.size(); ++Index) {
 838     Record *S = SpellingList[Index];
 839     if (S->getValueAsString("Variety") != Spelling.getValueAsString("Variety"))
 840       continue;
 841     if (S->getValueAsString("Variety") == "CXX11" &&
 842         S->getValueAsString("Namespace") !=
 843         Spelling.getValueAsString("Namespace"))
 844       continue;
 845     if (S->getValueAsString("Name") != Spelling.getValueAsString("Name"))
 846       continue;
 847
 848     return Index;
 849   }
 850
 851   llvm_unreachable("Unknown spelling!");
 852 }
 853
 854 static void writeAttrAccessorDefinition(Record &R, raw_ostream &OS) {
 855   std::vector<Record*> Accessors = R.getValueAsListOfDefs("Accessors");
 856   for (std::vector<Record*>::const_iterator I = Accessors.begin(),
 857        E = Accessors.end(); I != E; ++I) {
 858     Record *Accessor = *I;
 859     std::string Name = Accessor->getValueAsString("Name");
 860     std::vector<Record*> Spellings = Accessor->getValueAsListOfDefs(
 861       "Spellings");
 862     std::vector<Record*> SpellingList = R.getValueAsListOfDefs("Spellings");
 863     assert(SpellingList.size() &&
 864            "Attribute with empty spelling list can't have accessors!");
 865
 866     OS << "  bool " << Name << "() const { return SpellingListIndex == ";
 867     for (unsigned Index = 0; Index < Spellings.size(); ++Index) {
 868       OS << getSpellingListIndex(SpellingList, *Spellings[Index]);
 869       if (Index != Spellings.size() -1)
 870         OS << " ||\n    SpellingListIndex == ";
 871       else
 872         OS << "; }\n";
 873     }
 874   }
 875 }
 876
 877 namespace clang {
 878
 879 // Emits the class definitions for attributes.
 880 void EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS) {
 881   emitSourceFileHeader("Attribute classes' definitions", OS);
 882
 883   OS << "#ifndef LLVM_CLANG_ATTR_CLASSES_INC\n";
 884   OS << "#define LLVM_CLANG_ATTR_CLASSES_INC\n\n";
 885
 886   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
 887
 888   for (std::vector<Record*>::iterator i = Attrs.begin(), e = Attrs.end();
 889        i != e; ++i) {
 890     Record &R = **i;
 891
 892     if (!R.getValueAsBit("ASTNode"))
 893       continue;
 894
 895     const std::string &SuperName = R.getSuperClasses().back()->getName();
 896
 897     OS << "class " << R.getName() << "Attr : public " << SuperName << " {\n";
 898
 899     std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
 900     std::vector<Argument*> Args;
 901     std::vector<Argument*>::iterator ai, ae;
 902     Args.reserve(ArgRecords.size());
 903
 904     for (std::vector<Record*>::iterator ri = ArgRecords.begin(),
 905                                         re = ArgRecords.end();
 906          ri != re; ++ri) {
 907       Record &ArgRecord = **ri;
 908       Argument *Arg = createArgument(ArgRecord, R.getName());
 909       assert(Arg);
 910       Args.push_back(Arg);
 911
 912       Arg->writeDeclarations(OS);
 913       OS << "\n\n";
 914     }
 915
 916     ae = Args.end();
 917
 918     OS << "\n public:\n";
 919     OS << "  " << R.getName() << "Attr(SourceRange R, ASTContext &Ctx\n";
 920
 921     for (ai = Args.begin(); ai != ae; ++ai) {
 922       OS << "              , ";
 923       (*ai)->writeCtorParameters(OS);
 924       OS << "\n";
 925     }
 926
 927     OS << "              , ";
 928     OS << "unsigned SI = 0\n";
 929
 930     OS << "             )\n";
 931     OS << "    : " << SuperName << "(attr::" << R.getName() << ", R, SI)\n";
 932
 933     for (ai = Args.begin(); ai != ae; ++ai) {
 934       OS << "              , ";
 935       (*ai)->writeCtorInitializers(OS);
 936       OS << "\n";
 937     }
 938
 939     OS << "  {\n";
 940
 941     for (ai = Args.begin(); ai != ae; ++ai) {
 942       (*ai)->writeCtorBody(OS);
 943       OS << "\n";
 944     }
 945     OS << "  }\n\n";
 946
 947     OS << "  virtual " << R.getName() << "Attr *clone (ASTContext &C) const;\n";
 948     OS << "  virtual void printPretty(raw_ostream &OS,\n"
 949        << "                           const PrintingPolicy &Policy) const;\n";
 950
 951     writeAttrAccessorDefinition(R, OS);
 952
 953     for (ai = Args.begin(); ai != ae; ++ai) {
 954       (*ai)->writeAccessors(OS);
 955       OS << "\n\n";
 956     }
 957
 958     OS << R.getValueAsString("AdditionalMembers");
 959     OS << "\n\n";
 960
 961     OS << "  static bool classof(const Attr *A) { return A->getKind() == "
 962        << "attr::" << R.getName() << "; }\n";
 963
 964     bool LateParsed = R.getValueAsBit("LateParsed");
 965     OS << "  virtual bool isLateParsed() const { return "
 966        << LateParsed << "; }\n";
 967
 968     OS << "};\n\n";
 969   }
 970
 971   OS << "#endif\n";
 972 }
 973
 974 // Emits the all-arguments-are-expressions property for attributes.
 975 void EmitClangAttrExprArgsList(RecordKeeper &Records, raw_ostream &OS) {
 976   emitSourceFileHeader("llvm::StringSwitch code to match attributes with "
 977                        "expression arguments", OS);
 978
 979   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
 980
 981   for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end();
 982        I != E; ++I) {
 983     Record &Attr = **I;
 984
 985     // Determine whether the first argument is something that is always
 986     // an expression.
 987     std::vector<Record *> Args = Attr.getValueAsListOfDefs("Args");
 988     if (Args.empty() || Args[0]->getSuperClasses().empty())
 989       continue;
 990
 991     // Check whether this is one of the argument kinds that implies an
 992     // expression.
 993     // FIXME: Aligned is weird.
 994     if (!llvm::StringSwitch<bool>(Args[0]->getSuperClasses().back()->getName())
 995           .Case("AlignedArgument", true)
 996           .Case("BoolArgument", true)
 997           .Case("DefaultIntArgument", true)
 998           .Case("IntArgument", true)
 999           .Case("ExprArgument", true)
1000           .Case("UnsignedArgument", true)
1001           .Case("VariadicUnsignedArgument", true)
1002           .Case("VariadicExprArgument", true)
1003           .Default(false))
1004       continue;
1005
1006     std::vector<Record*> Spellings = Attr.getValueAsListOfDefs("Spellings");
1007
1008     for (std::vector<Record*>::const_iterator I = Spellings.begin(),
1009          E = Spellings.end(); I != E; ++I) {
1010       OS << ".Case(\"" << (*I)->getValueAsString("Name") << "\", "
1011          << "true" << ")\n";
1012     }
1013   }
1014 }
1015
1016 // Emits the class method definitions for attributes.
1017 void EmitClangAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
1018   emitSourceFileHeader("Attribute classes' member function definitions", OS);
1019
1020   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1021   std::vector<Record*>::iterator i = Attrs.begin(), e = Attrs.end(), ri, re;
1022   std::vector<Argument*>::iterator ai, ae;
1023
1024   for (; i != e; ++i) {
1025     Record &R = **i;
1026
1027     if (!R.getValueAsBit("ASTNode"))
1028       continue;
1029
1030     std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
1031     std::vector<Argument*> Args;
1032     for (ri = ArgRecords.begin(), re = ArgRecords.end(); ri != re; ++ri)
1033       Args.push_back(createArgument(**ri, R.getName()));
1034
1035     for (ai = Args.begin(), ae = Args.end(); ai != ae; ++ai)
1036       (*ai)->writeAccessorDefinitions(OS);
1037
1038     OS << R.getName() << "Attr *" << R.getName()
1039        << "Attr::clone(ASTContext &C) const {\n";
1040     OS << "  return new (C) " << R.getName() << "Attr(getLocation(), C";
1041     for (ai = Args.begin(); ai != ae; ++ai) {
1042       OS << ", ";
1043       (*ai)->writeCloneArgs(OS);
1044     }
1045     OS << ", getSpellingListIndex());\n}\n\n";
1046
1047     writePrettyPrintFunction(R, Args, OS);
1048   }
1049 }
1050
1051 } // end namespace clang
1052
1053 static void EmitAttrList(raw_ostream &OS, StringRef Class,
1054                          const std::vector<Record*> &AttrList) {
1055   std::vector<Record*>::const_iterator i = AttrList.begin(), e = AttrList.end();
1056
1057   if (i != e) {
1058     // Move the end iterator back to emit the last attribute.
1059     for(--e; i != e; ++i) {
1060       if (!(*i)->getValueAsBit("ASTNode"))
1061         continue;
1062
1063       OS << Class << "(" << (*i)->getName() << ")\n";
1064     }
1065
1066     OS << "LAST_" << Class << "(" << (*i)->getName() << ")\n\n";
1067   }
1068 }
1069
1070 namespace clang {
1071
1072 // Emits the enumeration list for attributes.
1073 void EmitClangAttrList(RecordKeeper &Records, raw_ostream &OS) {
1074   emitSourceFileHeader("List of all attributes that Clang recognizes", OS);
1075
1076   OS << "#ifndef LAST_ATTR\n";
1077   OS << "#define LAST_ATTR(NAME) ATTR(NAME)\n";
1078   OS << "#endif\n\n";
1079
1080   OS << "#ifndef INHERITABLE_ATTR\n";
1081   OS << "#define INHERITABLE_ATTR(NAME) ATTR(NAME)\n";
1082   OS << "#endif\n\n";
1083
1084   OS << "#ifndef LAST_INHERITABLE_ATTR\n";
1085   OS << "#define LAST_INHERITABLE_ATTR(NAME) INHERITABLE_ATTR(NAME)\n";
1086   OS << "#endif\n\n";
1087
1088   OS << "#ifndef INHERITABLE_PARAM_ATTR\n";
1089   OS << "#define INHERITABLE_PARAM_ATTR(NAME) ATTR(NAME)\n";
1090   OS << "#endif\n\n";
1091
1092   OS << "#ifndef LAST_INHERITABLE_PARAM_ATTR\n";
1093   OS << "#define LAST_INHERITABLE_PARAM_ATTR(NAME)"
1094         " INHERITABLE_PARAM_ATTR(NAME)\n";
1095   OS << "#endif\n\n";
1096
1097   OS << "#ifndef MS_INHERITABLE_ATTR\n";
1098   OS << "#define MS_INHERITABLE_ATTR(NAME) INHERITABLE_ATTR(NAME)\n";
1099   OS << "#endif\n\n";
1100
1101   OS << "#ifndef LAST_MS_INHERITABLE_ATTR\n";
1102   OS << "#define LAST_MS_INHERITABLE_ATTR(NAME)"
1103         " MS_INHERITABLE_ATTR(NAME)\n";
1104   OS << "#endif\n\n";
1105
1106   Record *InhClass = Records.getClass("InheritableAttr");
1107   Record *InhParamClass = Records.getClass("InheritableParamAttr");
1108   Record *MSInheritanceClass = Records.getClass("MSInheritanceAttr");
1109   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"),
1110                        NonInhAttrs, InhAttrs, InhParamAttrs, MSInhAttrs;
1111   for (std::vector<Record*>::iterator i = Attrs.begin(), e = Attrs.end();
1112        i != e; ++i) {
1113     if (!(*i)->getValueAsBit("ASTNode"))
1114       continue;
1115
1116     if ((*i)->isSubClassOf(InhParamClass))
1117       InhParamAttrs.push_back(*i);
1118     else if ((*i)->isSubClassOf(MSInheritanceClass))
1119       MSInhAttrs.push_back(*i);
1120     else if ((*i)->isSubClassOf(InhClass))
1121       InhAttrs.push_back(*i);
1122     else
1123       NonInhAttrs.push_back(*i);
1124   }
1125
1126   EmitAttrList(OS, "INHERITABLE_PARAM_ATTR", InhParamAttrs);
1127   EmitAttrList(OS, "MS_INHERITABLE_ATTR", MSInhAttrs);
1128   EmitAttrList(OS, "INHERITABLE_ATTR", InhAttrs);
1129   EmitAttrList(OS, "ATTR", NonInhAttrs);
1130
1131   OS << "#undef LAST_ATTR\n";
1132   OS << "#undef INHERITABLE_ATTR\n";
1133   OS << "#undef MS_INHERITABLE_ATTR\n";
1134   OS << "#undef LAST_INHERITABLE_ATTR\n";
1135   OS << "#undef LAST_INHERITABLE_PARAM_ATTR\n";
1136   OS << "#undef LAST_MS_INHERITABLE_ATTR\n";
1137   OS << "#undef ATTR\n";
1138 }
1139
1140 // Emits the code to read an attribute from a precompiled header.
1141 void EmitClangAttrPCHRead(RecordKeeper &Records, raw_ostream &OS) {
1142   emitSourceFileHeader("Attribute deserialization code", OS);
1143
1144   Record *InhClass = Records.getClass("InheritableAttr");
1145   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"),
1146                        ArgRecords;
1147   std::vector<Record*>::iterator i = Attrs.begin(), e = Attrs.end(), ai, ae;
1148   std::vector<Argument*> Args;
1149   std::vector<Argument*>::iterator ri, re;
1150
1151   OS << "  switch (Kind) {\n";
1152   OS << "  default:\n";
1153   OS << "    assert(0 && \"Unknown attribute!\");\n";
1154   OS << "    break;\n";
1155   for (; i != e; ++i) {
1156     Record &R = **i;
1157     if (!R.getValueAsBit("ASTNode"))
1158       continue;
1159
1160     OS << "  case attr::" << R.getName() << ": {\n";
1161     if (R.isSubClassOf(InhClass))
1162       OS << "    bool isInherited = Record[Idx++];\n";
1163     ArgRecords = R.getValueAsListOfDefs("Args");
1164     Args.clear();
1165     for (ai = ArgRecords.begin(), ae = ArgRecords.end(); ai != ae; ++ai) {
1166       Argument *A = createArgument(**ai, R.getName());
1167       Args.push_back(A);
1168       A->writePCHReadDecls(OS);
1169     }
1170     OS << "    New = new (Context) " << R.getName() << "Attr(Range, Context";
1171     for (ri = Args.begin(), re = Args.end(); ri != re; ++ri) {
1172       OS << ", ";
1173       (*ri)->writePCHReadArgs(OS);
1174     }
1175     OS << ");\n";
1176     if (R.isSubClassOf(InhClass))
1177       OS << "    cast<InheritableAttr>(New)->setInherited(isInherited);\n";
1178     OS << "    break;\n";
1179     OS << "  }\n";
1180   }
1181   OS << "  }\n";
1182 }
1183
1184 // Emits the code to write an attribute to a precompiled header.
1185 void EmitClangAttrPCHWrite(RecordKeeper &Records, raw_ostream &OS) {
1186   emitSourceFileHeader("Attribute serialization code", OS);
1187
1188   Record *InhClass = Records.getClass("InheritableAttr");
1189   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
1190   std::vector<Record*>::iterator i = Attrs.begin(), e = Attrs.end(), ai, ae;
1191
1192   OS << "  switch (A->getKind()) {\n";
1193   OS << "  default:\n";
1194   OS << "    llvm_unreachable(\"Unknown attribute kind!\");\n";
1195   OS << "    break;\n";
1196   for (; i != e; ++i) {
1197     Record &R = **i;
1198     if (!R.getValueAsBit("ASTNode"))
1199       continue;
1200     OS << "  case attr::" << R.getName() << ": {\n";
1201     Args = R.getValueAsListOfDefs("Args");
1202     if (R.isSubClassOf(InhClass) || !Args.empty())
1203       OS << "    const " << R.getName() << "Attr *SA = cast<" << R.getName()
1204          << "Attr>(A);\n";
1205     if (R.isSubClassOf(InhClass))
1206       OS << "    Record.push_back(SA->isInherited());\n";
1207     for (ai = Args.begin(), ae = Args.end(); ai != ae; ++ai)
1208       createArgument(**ai, R.getName())->writePCHWrite(OS);
1209     OS << "    break;\n";
1210     OS << "  }\n";
1211   }
1212   OS << "  }\n";
1213 }
1214
1215 // Emits the list of spellings for attributes.
1216 void EmitClangAttrSpellingList(RecordKeeper &Records, raw_ostream &OS) {
1217   emitSourceFileHeader("llvm::StringSwitch code to match all known attributes",
1218                        OS);
1219
1220   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1221
1222   for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end(); I != E; ++I) {
1223     Record &Attr = **I;
1224
1225     std::vector<Record*> Spellings = Attr.getValueAsListOfDefs("Spellings");
1226
1227     for (std::vector<Record*>::const_iterator I = Spellings.begin(), E = Spellings.end(); I != E; ++I) {
1228       OS << ".Case(\"" << (*I)->getValueAsString("Name") << "\", true)\n";
1229     }
1230   }
1231
1232 }
1233
1234 void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS) {
1235   emitSourceFileHeader("Code to translate different attribute spellings "
1236                        "into internal identifiers", OS);
1237
1238   OS <<
1239     "  unsigned Index = 0;\n"
1240     "  switch (AttrKind) {\n"
1241     "  default:\n"
1242     "    llvm_unreachable(\"Unknown attribute kind!\");\n"
1243     "    break;\n";
1244
1245   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1246   for (std::vector<Record*>::const_iterator I = Attrs.begin(), E = Attrs.end();
1247        I != E; ++I) {
1248     Record &R = **I;
1249     // We only care about attributes that participate in Sema checking, so
1250     // skip those attributes that are not able to make their way to Sema.
1251     if (!R.getValueAsBit("SemaHandler"))
1252       continue;
1253
1254     std::vector<Record*> Spellings = R.getValueAsListOfDefs("Spellings");
1255     // Each distinct spelling yields an attribute kind.
1256     if (R.getValueAsBit("DistinctSpellings")) {
1257       for (unsigned I = 0; I < Spellings.size(); ++ I) {
1258         OS <<
1259           "  case AT_" << Spellings[I]->getValueAsString("Name") << ": \n"
1260           "    Index = " << I << ";\n"
1261           "  break;\n";
1262       }
1263     } else {
1264       OS << "  case AT_" << R.getName() << " : {\n";
1265       for (unsigned I = 0; I < Spellings.size(); ++ I) {
1266         SmallString<16> Namespace;
1267         if (Spellings[I]->getValueAsString("Variety") == "CXX11")
1268           Namespace = Spellings[I]->getValueAsString("Namespace");
1269         else
1270           Namespace = "";
1271
1272         OS << "    if (Name == \""
1273           << Spellings[I]->getValueAsString("Name") << "\" && "
1274           << "SyntaxUsed == "
1275           << StringSwitch<unsigned>(Spellings[I]->getValueAsString("Variety"))
1276             .Case("GNU", 0)
1277             .Case("CXX11", 1)
1278             .Case("Declspec", 2)
1279             .Case("Keyword", 3)
1280             .Default(0)
1281           << " && Scope == \"" << Namespace << "\")\n"
1282           << "        return " << I << ";\n";
1283       }
1284
1285       OS << "    break;\n";
1286       OS << "  }\n";
1287     }
1288   }
1289
1290   OS << "  }\n";
1291   OS << "  return Index;\n";
1292 }
1293
1294 // Emits the LateParsed property for attributes.
1295 void EmitClangAttrLateParsedList(RecordKeeper &Records, raw_ostream &OS) {
1296   emitSourceFileHeader("llvm::StringSwitch code to match late parsed "
1297                        "attributes", OS);
1298
1299   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1300
1301   for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end();
1302        I != E; ++I) {
1303     Record &Attr = **I;
1304
1305     bool LateParsed = Attr.getValueAsBit("LateParsed");
1306
1307     if (LateParsed) {
1308       std::vector<Record*> Spellings =
1309         Attr.getValueAsListOfDefs("Spellings");
1310
1311       // FIXME: Handle non-GNU attributes
1312       for (std::vector<Record*>::const_iterator I = Spellings.begin(),
1313            E = Spellings.end(); I != E; ++I) {
1314         if ((*I)->getValueAsString("Variety") != "GNU")
1315           continue;
1316         OS << ".Case(\"" << (*I)->getValueAsString("Name") << "\", "
1317            << LateParsed << ")\n";
1318       }
1319     }
1320   }
1321 }
1322
1323 // Emits code to instantiate dependent attributes on templates.
1324 void EmitClangAttrTemplateInstantiate(RecordKeeper &Records, raw_ostream &OS) {
1325   emitSourceFileHeader("Template instantiation code for attributes", OS);
1326
1327   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1328
1329   OS << "namespace clang {\n"
1330      << "namespace sema {\n\n"
1331      << "Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, "
1332      << "Sema &S,\n"
1333      << "        const MultiLevelTemplateArgumentList &TemplateArgs) {\n"
1334      << "  switch (At->getKind()) {\n"
1335      << "    default:\n"
1336      << "      break;\n";
1337
1338   for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end();
1339        I != E; ++I) {
1340     Record &R = **I;
1341     if (!R.getValueAsBit("ASTNode"))
1342       continue;
1343
1344     OS << "    case attr::" << R.getName() << ": {\n";
1345     bool ShouldClone = R.getValueAsBit("Clone");
1346
1347     if (!ShouldClone) {
1348       OS << "      return NULL;\n";
1349       OS << "    }\n";
1350       continue;
1351     }
1352
1353     OS << "      const " << R.getName() << "Attr *A = cast<"
1354        << R.getName() << "Attr>(At);\n";
1355     bool TDependent = R.getValueAsBit("TemplateDependent");
1356
1357     if (!TDependent) {
1358       OS << "      return A->clone(C);\n";
1359       OS << "    }\n";
1360       continue;
1361     }
1362
1363     std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
1364     std::vector<Argument*> Args;
1365     std::vector<Argument*>::iterator ai, ae;
1366     Args.reserve(ArgRecords.size());
1367
1368     for (std::vector<Record*>::iterator ri = ArgRecords.begin(),
1369                                         re = ArgRecords.end();
1370          ri != re; ++ri) {
1371       Record &ArgRecord = **ri;
1372       Argument *Arg = createArgument(ArgRecord, R.getName());
1373       assert(Arg);
1374       Args.push_back(Arg);
1375     }
1376     ae = Args.end();
1377
1378     for (ai = Args.begin(); ai != ae; ++ai) {
1379       (*ai)->writeTemplateInstantiation(OS);
1380     }
1381     OS << "      return new (C) " << R.getName() << "Attr(A->getLocation(), C";
1382     for (ai = Args.begin(); ai != ae; ++ai) {
1383       OS << ", ";
1384       (*ai)->writeTemplateInstantiationArgs(OS);
1385     }
1386     OS << ");\n    }\n";
1387   }
1388   OS << "  } // end switch\n"
1389      << "  llvm_unreachable(\"Unknown attribute!\");\n"
1390      << "  return 0;\n"
1391      << "}\n\n"
1392      << "} // end namespace sema\n"
1393      << "} // end namespace clang\n";
1394 }
1395
1396 // Emits the list of parsed attributes.
1397 void EmitClangAttrParsedAttrList(RecordKeeper &Records, raw_ostream &OS) {
1398   emitSourceFileHeader("List of all attributes that Clang recognizes", OS);
1399
1400   OS << "#ifndef PARSED_ATTR\n";
1401   OS << "#define PARSED_ATTR(NAME) NAME\n";
1402   OS << "#endif\n\n";
1403
1404   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1405
1406   for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end();
1407        I != E; ++I) {
1408     Record &Attr = **I;
1409
1410     bool SemaHandler = Attr.getValueAsBit("SemaHandler");
1411     bool DistinctSpellings = Attr.getValueAsBit("DistinctSpellings");
1412
1413     if (SemaHandler) {
1414       if (DistinctSpellings) {
1415         std::vector<Record*> Spellings = Attr.getValueAsListOfDefs("Spellings");
1416
1417         for (std::vector<Record*>::const_iterator I = Spellings.begin(),
1418              E = Spellings.end(); I != E; ++I) {
1419           std::string AttrName = (*I)->getValueAsString("Name");
1420
1421           StringRef Spelling = NormalizeAttrName(AttrName);
1422
1423           OS << "PARSED_ATTR(" << Spelling << ")\n";
1424         }
1425       } else {
1426         StringRef AttrName = Attr.getName();
1427         AttrName = NormalizeAttrName(AttrName);
1428         OS << "PARSED_ATTR(" << AttrName << ")\n";
1429       }
1430     }
1431   }
1432 }
1433
1434 // Emits the kind list of parsed attributes
1435 void EmitClangAttrParsedAttrKinds(RecordKeeper &Records, raw_ostream &OS) {
1436   emitSourceFileHeader("Attribute name matcher", OS);
1437
1438   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1439
1440   std::vector<StringMatcher::StringPair> Matches;
1441   for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end();
1442        I != E; ++I) {
1443     Record &Attr = **I;
1444
1445     bool SemaHandler = Attr.getValueAsBit("SemaHandler");
1446     bool Ignored = Attr.getValueAsBit("Ignored");
1447     bool DistinctSpellings = Attr.getValueAsBit("DistinctSpellings");
1448     if (SemaHandler || Ignored) {
1449       std::vector<Record*> Spellings = Attr.getValueAsListOfDefs("Spellings");
1450
1451       for (std::vector<Record*>::const_iterator I = Spellings.begin(),
1452            E = Spellings.end(); I != E; ++I) {
1453         std::string RawSpelling = (*I)->getValueAsString("Name");
1454         StringRef AttrName = NormalizeAttrName(DistinctSpellings
1455                                                  ? StringRef(RawSpelling)
1456                                                  : StringRef(Attr.getName()));
1457
1458         SmallString<64> Spelling;
1459         if ((*I)->getValueAsString("Variety") == "CXX11") {
1460           Spelling += (*I)->getValueAsString("Namespace");
1461           Spelling += "::";
1462         }
1463         Spelling += NormalizeAttrSpelling(RawSpelling);
1464
1465         if (SemaHandler)
1466           Matches.push_back(
1467             StringMatcher::StringPair(
1468               StringRef(Spelling),
1469               "return AttributeList::AT_" + AttrName.str() + ";"));
1470         else
1471           Matches.push_back(
1472             StringMatcher::StringPair(
1473               StringRef(Spelling),
1474               "return AttributeList::IgnoredAttribute;"));
1475       }
1476     }
1477   }
1478
1479   OS << "static AttributeList::Kind getAttrKind(StringRef Name) {\n";
1480   StringMatcher("Name", Matches, OS).Emit();
1481   OS << "return AttributeList::UnknownAttribute;\n"
1482      << "}\n";
1483 }
1484
1485 // Emits the code to dump an attribute.
1486 void EmitClangAttrDump(RecordKeeper &Records, raw_ostream &OS) {
1487   emitSourceFileHeader("Attribute dumper", OS);
1488
1489   OS <<
1490     "  switch (A->getKind()) {\n"
1491     "  default:\n"
1492     "    llvm_unreachable(\"Unknown attribute kind!\");\n"
1493     "    break;\n";
1494   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
1495   for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end();
1496        I != E; ++I) {
1497     Record &R = **I;
1498     if (!R.getValueAsBit("ASTNode"))
1499       continue;
1500     OS << "  case attr::" << R.getName() << ": {\n";
1501     Args = R.getValueAsListOfDefs("Args");
1502     if (!Args.empty()) {
1503       OS << "    const " << R.getName() << "Attr *SA = cast<" << R.getName()
1504          << "Attr>(A);\n";
1505       for (std::vector<Record*>::iterator I = Args.begin(), E = Args.end();
1506            I != E; ++I)
1507         createArgument(**I, R.getName())->writeDump(OS);
1508
1509       // Code for detecting the last child.
1510       OS << "    bool OldMoreChildren = hasMoreChildren();\n";
1511       OS << "    bool MoreChildren = OldMoreChildren;\n";
1512
1513       for (std::vector<Record*>::iterator I = Args.begin(), E = Args.end();
1514            I != E; ++I) {
1515         // More code for detecting the last child.
1516         OS << "    MoreChildren = OldMoreChildren";
1517         for (std::vector<Record*>::iterator Next = I + 1; Next != E; ++Next) {
1518           OS << " || ";
1519           createArgument(**Next, R.getName())->writeHasChildren(OS);
1520         }
1521         OS << ";\n";
1522         OS << "    setMoreChildren(MoreChildren);\n";
1523
1524         createArgument(**I, R.getName())->writeDumpChildren(OS);
1525       }
1526
1527       // Reset the last child.
1528       OS << "    setMoreChildren(OldMoreChildren);\n";
1529     }
1530     OS <<
1531       "    break;\n"
1532       "  }\n";
1533   }
1534   OS << "  }\n";
1535 }
1536
1537 } // end namespace clang