• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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/iterator_range.h"
16 #include "llvm/ADT/SmallString.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/ADT/StringExtras.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/ADT/StringSwitch.h"
21 #include "llvm/Support/ErrorHandling.h"
22 #include "llvm/Support/raw_ostream.h"
23 #include "llvm/TableGen/Error.h"
24 #include "llvm/TableGen/Record.h"
25 #include "llvm/TableGen/StringMatcher.h"
26 #include "llvm/TableGen/TableGenBackend.h"
27 #include <algorithm>
28 #include <cassert>
29 #include <cctype>
30 #include <cstddef>
31 #include <cstdint>
32 #include <map>
33 #include <memory>
34 #include <set>
35 #include <sstream>
36 #include <string>
37 #include <utility>
38 #include <vector>
39 
40 using namespace llvm;
41 
42 namespace {
43 
44 class FlattenedSpelling {
45   std::string V, N, NS;
46   bool K;
47 
48 public:
FlattenedSpelling(const std::string & Variety,const std::string & Name,const std::string & Namespace,bool KnownToGCC)49   FlattenedSpelling(const std::string &Variety, const std::string &Name,
50                     const std::string &Namespace, bool KnownToGCC) :
51     V(Variety), N(Name), NS(Namespace), K(KnownToGCC) {}
FlattenedSpelling(const Record & Spelling)52   explicit FlattenedSpelling(const Record &Spelling) :
53     V(Spelling.getValueAsString("Variety")),
54     N(Spelling.getValueAsString("Name")) {
55 
56     assert(V != "GCC" && "Given a GCC spelling, which means this hasn't been"
57            "flattened!");
58     if (V == "CXX11" || V == "Pragma")
59       NS = Spelling.getValueAsString("Namespace");
60     bool Unset;
61     K = Spelling.getValueAsBitOrUnset("KnownToGCC", Unset);
62   }
63 
variety() const64   const std::string &variety() const { return V; }
name() const65   const std::string &name() const { return N; }
nameSpace() const66   const std::string &nameSpace() const { return NS; }
knownToGCC() const67   bool knownToGCC() const { return K; }
68 };
69 
70 } // end anonymous namespace
71 
72 static std::vector<FlattenedSpelling>
GetFlattenedSpellings(const Record & Attr)73 GetFlattenedSpellings(const Record &Attr) {
74   std::vector<Record *> Spellings = Attr.getValueAsListOfDefs("Spellings");
75   std::vector<FlattenedSpelling> Ret;
76 
77   for (const auto &Spelling : Spellings) {
78     if (Spelling->getValueAsString("Variety") == "GCC") {
79       // Gin up two new spelling objects to add into the list.
80       Ret.emplace_back("GNU", Spelling->getValueAsString("Name"), "", true);
81       Ret.emplace_back("CXX11", Spelling->getValueAsString("Name"), "gnu",
82                        true);
83     } else
84       Ret.push_back(FlattenedSpelling(*Spelling));
85   }
86 
87   return Ret;
88 }
89 
ReadPCHRecord(StringRef type)90 static std::string ReadPCHRecord(StringRef type) {
91   return StringSwitch<std::string>(type)
92     .EndsWith("Decl *", "GetLocalDeclAs<"
93               + std::string(type, 0, type.size()-1) + ">(F, Record[Idx++])")
94     .Case("TypeSourceInfo *", "GetTypeSourceInfo(F, Record, Idx)")
95     .Case("Expr *", "ReadExpr(F)")
96     .Case("IdentifierInfo *", "GetIdentifierInfo(F, Record, Idx)")
97     .Case("StringRef", "ReadString(Record, Idx)")
98     .Default("Record[Idx++]");
99 }
100 
101 // Get a type that is suitable for storing an object of the specified type.
getStorageType(StringRef type)102 static StringRef getStorageType(StringRef type) {
103   return StringSwitch<StringRef>(type)
104     .Case("StringRef", "std::string")
105     .Default(type);
106 }
107 
108 // Assumes that the way to get the value is SA->getname()
WritePCHRecord(StringRef type,StringRef name)109 static std::string WritePCHRecord(StringRef type, StringRef name) {
110   return "Record." + StringSwitch<std::string>(type)
111     .EndsWith("Decl *", "AddDeclRef(" + std::string(name) + ");\n")
112     .Case("TypeSourceInfo *", "AddTypeSourceInfo(" + std::string(name) + ");\n")
113     .Case("Expr *", "AddStmt(" + std::string(name) + ");\n")
114     .Case("IdentifierInfo *", "AddIdentifierRef(" + std::string(name) + ");\n")
115     .Case("StringRef", "AddString(" + std::string(name) + ");\n")
116     .Default("push_back(" + std::string(name) + ");\n");
117 }
118 
119 // Normalize attribute name by removing leading and trailing
120 // underscores. For example, __foo, foo__, __foo__ would
121 // become foo.
NormalizeAttrName(StringRef AttrName)122 static StringRef NormalizeAttrName(StringRef AttrName) {
123   if (AttrName.startswith("__"))
124     AttrName = AttrName.substr(2, AttrName.size());
125 
126   if (AttrName.endswith("__"))
127     AttrName = AttrName.substr(0, AttrName.size() - 2);
128 
129   return AttrName;
130 }
131 
132 // Normalize the name by removing any and all leading and trailing underscores.
133 // This is different from NormalizeAttrName in that it also handles names like
134 // _pascal and __pascal.
NormalizeNameForSpellingComparison(StringRef Name)135 static StringRef NormalizeNameForSpellingComparison(StringRef Name) {
136   return Name.trim("_");
137 }
138 
139 // Normalize attribute spelling only if the spelling has both leading
140 // and trailing underscores. For example, __ms_struct__ will be
141 // normalized to "ms_struct"; __cdecl will remain intact.
NormalizeAttrSpelling(StringRef AttrSpelling)142 static StringRef NormalizeAttrSpelling(StringRef AttrSpelling) {
143   if (AttrSpelling.startswith("__") && AttrSpelling.endswith("__")) {
144     AttrSpelling = AttrSpelling.substr(2, AttrSpelling.size() - 4);
145   }
146 
147   return AttrSpelling;
148 }
149 
150 typedef std::vector<std::pair<std::string, const Record *>> ParsedAttrMap;
151 
getParsedAttrList(const RecordKeeper & Records,ParsedAttrMap * Dupes=nullptr)152 static ParsedAttrMap getParsedAttrList(const RecordKeeper &Records,
153                                        ParsedAttrMap *Dupes = nullptr) {
154   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
155   std::set<std::string> Seen;
156   ParsedAttrMap R;
157   for (const auto *Attr : Attrs) {
158     if (Attr->getValueAsBit("SemaHandler")) {
159       std::string AN;
160       if (Attr->isSubClassOf("TargetSpecificAttr") &&
161           !Attr->isValueUnset("ParseKind")) {
162         AN = Attr->getValueAsString("ParseKind");
163 
164         // If this attribute has already been handled, it does not need to be
165         // handled again.
166         if (Seen.find(AN) != Seen.end()) {
167           if (Dupes)
168             Dupes->push_back(std::make_pair(AN, Attr));
169           continue;
170         }
171         Seen.insert(AN);
172       } else
173         AN = NormalizeAttrName(Attr->getName()).str();
174 
175       R.push_back(std::make_pair(AN, Attr));
176     }
177   }
178   return R;
179 }
180 
181 namespace {
182 
183   class Argument {
184     std::string lowerName, upperName;
185     StringRef attrName;
186     bool isOpt;
187     bool Fake;
188 
189   public:
Argument(const Record & Arg,StringRef Attr)190     Argument(const Record &Arg, StringRef Attr)
191       : lowerName(Arg.getValueAsString("Name")), upperName(lowerName),
192         attrName(Attr), isOpt(false), Fake(false) {
193       if (!lowerName.empty()) {
194         lowerName[0] = std::tolower(lowerName[0]);
195         upperName[0] = std::toupper(upperName[0]);
196       }
197       // Work around MinGW's macro definition of 'interface' to 'struct'. We
198       // have an attribute argument called 'Interface', so only the lower case
199       // name conflicts with the macro definition.
200       if (lowerName == "interface")
201         lowerName = "interface_";
202     }
203     virtual ~Argument() = default;
204 
getLowerName() const205     StringRef getLowerName() const { return lowerName; }
getUpperName() const206     StringRef getUpperName() const { return upperName; }
getAttrName() const207     StringRef getAttrName() const { return attrName; }
208 
isOptional() const209     bool isOptional() const { return isOpt; }
setOptional(bool set)210     void setOptional(bool set) { isOpt = set; }
211 
isFake() const212     bool isFake() const { return Fake; }
setFake(bool fake)213     void setFake(bool fake) { Fake = fake; }
214 
215     // These functions print the argument contents formatted in different ways.
216     virtual void writeAccessors(raw_ostream &OS) const = 0;
writeAccessorDefinitions(raw_ostream & OS) const217     virtual void writeAccessorDefinitions(raw_ostream &OS) const {}
writeASTVisitorTraversal(raw_ostream & OS) const218     virtual void writeASTVisitorTraversal(raw_ostream &OS) const {}
219     virtual void writeCloneArgs(raw_ostream &OS) const = 0;
220     virtual void writeTemplateInstantiationArgs(raw_ostream &OS) const = 0;
writeTemplateInstantiation(raw_ostream & OS) const221     virtual void writeTemplateInstantiation(raw_ostream &OS) const {}
writeCtorBody(raw_ostream & OS) const222     virtual void writeCtorBody(raw_ostream &OS) const {}
223     virtual void writeCtorInitializers(raw_ostream &OS) const = 0;
224     virtual void writeCtorDefaultInitializers(raw_ostream &OS) const = 0;
225     virtual void writeCtorParameters(raw_ostream &OS) const = 0;
226     virtual void writeDeclarations(raw_ostream &OS) const = 0;
227     virtual void writePCHReadArgs(raw_ostream &OS) const = 0;
228     virtual void writePCHReadDecls(raw_ostream &OS) const = 0;
229     virtual void writePCHWrite(raw_ostream &OS) const = 0;
230     virtual void writeValue(raw_ostream &OS) const = 0;
231     virtual void writeDump(raw_ostream &OS) const = 0;
writeDumpChildren(raw_ostream & OS) const232     virtual void writeDumpChildren(raw_ostream &OS) const {}
writeHasChildren(raw_ostream & OS) const233     virtual void writeHasChildren(raw_ostream &OS) const { OS << "false"; }
234 
isEnumArg() const235     virtual bool isEnumArg() const { return false; }
isVariadicEnumArg() const236     virtual bool isVariadicEnumArg() const { return false; }
isVariadic() const237     virtual bool isVariadic() const { return false; }
238 
writeImplicitCtorArgs(raw_ostream & OS) const239     virtual void writeImplicitCtorArgs(raw_ostream &OS) const {
240       OS << getUpperName();
241     }
242   };
243 
244   class SimpleArgument : public Argument {
245     std::string type;
246 
247   public:
SimpleArgument(const Record & Arg,StringRef Attr,std::string T)248     SimpleArgument(const Record &Arg, StringRef Attr, std::string T)
249         : Argument(Arg, Attr), type(std::move(T)) {}
250 
getType() const251     std::string getType() const { return type; }
252 
writeAccessors(raw_ostream & OS) const253     void writeAccessors(raw_ostream &OS) const override {
254       OS << "  " << type << " get" << getUpperName() << "() const {\n";
255       OS << "    return " << getLowerName() << ";\n";
256       OS << "  }";
257     }
258 
writeCloneArgs(raw_ostream & OS) const259     void writeCloneArgs(raw_ostream &OS) const override {
260       OS << getLowerName();
261     }
262 
writeTemplateInstantiationArgs(raw_ostream & OS) const263     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
264       OS << "A->get" << getUpperName() << "()";
265     }
266 
writeCtorInitializers(raw_ostream & OS) const267     void writeCtorInitializers(raw_ostream &OS) const override {
268       OS << getLowerName() << "(" << getUpperName() << ")";
269     }
270 
writeCtorDefaultInitializers(raw_ostream & OS) const271     void writeCtorDefaultInitializers(raw_ostream &OS) const override {
272       OS << getLowerName() << "()";
273     }
274 
writeCtorParameters(raw_ostream & OS) const275     void writeCtorParameters(raw_ostream &OS) const override {
276       OS << type << " " << getUpperName();
277     }
278 
writeDeclarations(raw_ostream & OS) const279     void writeDeclarations(raw_ostream &OS) const override {
280       OS << type << " " << getLowerName() << ";";
281     }
282 
writePCHReadDecls(raw_ostream & OS) const283     void writePCHReadDecls(raw_ostream &OS) const override {
284       std::string read = ReadPCHRecord(type);
285       OS << "    " << type << " " << getLowerName() << " = " << read << ";\n";
286     }
287 
writePCHReadArgs(raw_ostream & OS) const288     void writePCHReadArgs(raw_ostream &OS) const override {
289       OS << getLowerName();
290     }
291 
writePCHWrite(raw_ostream & OS) const292     void writePCHWrite(raw_ostream &OS) const override {
293       OS << "    " << WritePCHRecord(type, "SA->get" +
294                                            std::string(getUpperName()) + "()");
295     }
296 
writeValue(raw_ostream & OS) const297     void writeValue(raw_ostream &OS) const override {
298       if (type == "FunctionDecl *") {
299         OS << "\" << get" << getUpperName()
300            << "()->getNameInfo().getAsString() << \"";
301       } else if (type == "IdentifierInfo *") {
302         OS << "\" << get" << getUpperName() << "()->getName() << \"";
303       } else if (type == "TypeSourceInfo *") {
304         OS << "\" << get" << getUpperName() << "().getAsString() << \"";
305       } else {
306         OS << "\" << get" << getUpperName() << "() << \"";
307       }
308     }
309 
writeDump(raw_ostream & OS) const310     void writeDump(raw_ostream &OS) const override {
311       if (type == "FunctionDecl *") {
312         OS << "    OS << \" \";\n";
313         OS << "    dumpBareDeclRef(SA->get" << getUpperName() << "());\n";
314       } else if (type == "IdentifierInfo *") {
315         if (isOptional())
316           OS << "    if (SA->get" << getUpperName() << "())\n  ";
317         OS << "    OS << \" \" << SA->get" << getUpperName()
318            << "()->getName();\n";
319       } else if (type == "TypeSourceInfo *") {
320         OS << "    OS << \" \" << SA->get" << getUpperName()
321            << "().getAsString();\n";
322       } else if (type == "bool") {
323         OS << "    if (SA->get" << getUpperName() << "()) OS << \" "
324            << getUpperName() << "\";\n";
325       } else if (type == "int" || type == "unsigned") {
326         OS << "    OS << \" \" << SA->get" << getUpperName() << "();\n";
327       } else {
328         llvm_unreachable("Unknown SimpleArgument type!");
329       }
330     }
331   };
332 
333   class DefaultSimpleArgument : public SimpleArgument {
334     int64_t Default;
335 
336   public:
DefaultSimpleArgument(const Record & Arg,StringRef Attr,std::string T,int64_t Default)337     DefaultSimpleArgument(const Record &Arg, StringRef Attr,
338                           std::string T, int64_t Default)
339       : SimpleArgument(Arg, Attr, T), Default(Default) {}
340 
writeAccessors(raw_ostream & OS) const341     void writeAccessors(raw_ostream &OS) const override {
342       SimpleArgument::writeAccessors(OS);
343 
344       OS << "\n\n  static const " << getType() << " Default" << getUpperName()
345          << " = ";
346       if (getType() == "bool")
347         OS << (Default != 0 ? "true" : "false");
348       else
349         OS << Default;
350       OS << ";";
351     }
352   };
353 
354   class StringArgument : public Argument {
355   public:
StringArgument(const Record & Arg,StringRef Attr)356     StringArgument(const Record &Arg, StringRef Attr)
357       : Argument(Arg, Attr)
358     {}
359 
writeAccessors(raw_ostream & OS) const360     void writeAccessors(raw_ostream &OS) const override {
361       OS << "  llvm::StringRef get" << getUpperName() << "() const {\n";
362       OS << "    return llvm::StringRef(" << getLowerName() << ", "
363          << getLowerName() << "Length);\n";
364       OS << "  }\n";
365       OS << "  unsigned get" << getUpperName() << "Length() const {\n";
366       OS << "    return " << getLowerName() << "Length;\n";
367       OS << "  }\n";
368       OS << "  void set" << getUpperName()
369          << "(ASTContext &C, llvm::StringRef S) {\n";
370       OS << "    " << getLowerName() << "Length = S.size();\n";
371       OS << "    this->" << getLowerName() << " = new (C, 1) char ["
372          << getLowerName() << "Length];\n";
373       OS << "    if (!S.empty())\n";
374       OS << "      std::memcpy(this->" << getLowerName() << ", S.data(), "
375          << getLowerName() << "Length);\n";
376       OS << "  }";
377     }
378 
writeCloneArgs(raw_ostream & OS) const379     void writeCloneArgs(raw_ostream &OS) const override {
380       OS << "get" << getUpperName() << "()";
381     }
382 
writeTemplateInstantiationArgs(raw_ostream & OS) const383     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
384       OS << "A->get" << getUpperName() << "()";
385     }
386 
writeCtorBody(raw_ostream & OS) const387     void writeCtorBody(raw_ostream &OS) const override {
388       OS << "      if (!" << getUpperName() << ".empty())\n";
389       OS << "        std::memcpy(" << getLowerName() << ", " << getUpperName()
390          << ".data(), " << getLowerName() << "Length);\n";
391     }
392 
writeCtorInitializers(raw_ostream & OS) const393     void writeCtorInitializers(raw_ostream &OS) const override {
394       OS << getLowerName() << "Length(" << getUpperName() << ".size()),"
395          << getLowerName() << "(new (Ctx, 1) char[" << getLowerName()
396          << "Length])";
397     }
398 
writeCtorDefaultInitializers(raw_ostream & OS) const399     void writeCtorDefaultInitializers(raw_ostream &OS) const override {
400       OS << getLowerName() << "Length(0)," << getLowerName() << "(nullptr)";
401     }
402 
writeCtorParameters(raw_ostream & OS) const403     void writeCtorParameters(raw_ostream &OS) const override {
404       OS << "llvm::StringRef " << getUpperName();
405     }
406 
writeDeclarations(raw_ostream & OS) const407     void writeDeclarations(raw_ostream &OS) const override {
408       OS << "unsigned " << getLowerName() << "Length;\n";
409       OS << "char *" << getLowerName() << ";";
410     }
411 
writePCHReadDecls(raw_ostream & OS) const412     void writePCHReadDecls(raw_ostream &OS) const override {
413       OS << "    std::string " << getLowerName()
414          << "= ReadString(Record, Idx);\n";
415     }
416 
writePCHReadArgs(raw_ostream & OS) const417     void writePCHReadArgs(raw_ostream &OS) const override {
418       OS << getLowerName();
419     }
420 
writePCHWrite(raw_ostream & OS) const421     void writePCHWrite(raw_ostream &OS) const override {
422       OS << "    Record.AddString(SA->get" << getUpperName() << "());\n";
423     }
424 
writeValue(raw_ostream & OS) const425     void writeValue(raw_ostream &OS) const override {
426       OS << "\\\"\" << get" << getUpperName() << "() << \"\\\"";
427     }
428 
writeDump(raw_ostream & OS) const429     void writeDump(raw_ostream &OS) const override {
430       OS << "    OS << \" \\\"\" << SA->get" << getUpperName()
431          << "() << \"\\\"\";\n";
432     }
433   };
434 
435   class AlignedArgument : public Argument {
436   public:
AlignedArgument(const Record & Arg,StringRef Attr)437     AlignedArgument(const Record &Arg, StringRef Attr)
438       : Argument(Arg, Attr)
439     {}
440 
writeAccessors(raw_ostream & OS) const441     void writeAccessors(raw_ostream &OS) const override {
442       OS << "  bool is" << getUpperName() << "Dependent() const;\n";
443 
444       OS << "  unsigned get" << getUpperName() << "(ASTContext &Ctx) const;\n";
445 
446       OS << "  bool is" << getUpperName() << "Expr() const {\n";
447       OS << "    return is" << getLowerName() << "Expr;\n";
448       OS << "  }\n";
449 
450       OS << "  Expr *get" << getUpperName() << "Expr() const {\n";
451       OS << "    assert(is" << getLowerName() << "Expr);\n";
452       OS << "    return " << getLowerName() << "Expr;\n";
453       OS << "  }\n";
454 
455       OS << "  TypeSourceInfo *get" << getUpperName() << "Type() const {\n";
456       OS << "    assert(!is" << getLowerName() << "Expr);\n";
457       OS << "    return " << getLowerName() << "Type;\n";
458       OS << "  }";
459     }
460 
writeAccessorDefinitions(raw_ostream & OS) const461     void writeAccessorDefinitions(raw_ostream &OS) const override {
462       OS << "bool " << getAttrName() << "Attr::is" << getUpperName()
463          << "Dependent() const {\n";
464       OS << "  if (is" << getLowerName() << "Expr)\n";
465       OS << "    return " << getLowerName() << "Expr && (" << getLowerName()
466          << "Expr->isValueDependent() || " << getLowerName()
467          << "Expr->isTypeDependent());\n";
468       OS << "  else\n";
469       OS << "    return " << getLowerName()
470          << "Type->getType()->isDependentType();\n";
471       OS << "}\n";
472 
473       // FIXME: Do not do the calculation here
474       // FIXME: Handle types correctly
475       // A null pointer means maximum alignment
476       OS << "unsigned " << getAttrName() << "Attr::get" << getUpperName()
477          << "(ASTContext &Ctx) const {\n";
478       OS << "  assert(!is" << getUpperName() << "Dependent());\n";
479       OS << "  if (is" << getLowerName() << "Expr)\n";
480       OS << "    return " << getLowerName() << "Expr ? " << getLowerName()
481          << "Expr->EvaluateKnownConstInt(Ctx).getZExtValue()"
482          << " * Ctx.getCharWidth() : "
483          << "Ctx.getTargetDefaultAlignForAttributeAligned();\n";
484       OS << "  else\n";
485       OS << "    return 0; // FIXME\n";
486       OS << "}\n";
487     }
488 
writeCloneArgs(raw_ostream & OS) const489     void writeCloneArgs(raw_ostream &OS) const override {
490       OS << "is" << getLowerName() << "Expr, is" << getLowerName()
491          << "Expr ? static_cast<void*>(" << getLowerName()
492          << "Expr) : " << getLowerName()
493          << "Type";
494     }
495 
writeTemplateInstantiationArgs(raw_ostream & OS) const496     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
497       // FIXME: move the definition in Sema::InstantiateAttrs to here.
498       // In the meantime, aligned attributes are cloned.
499     }
500 
writeCtorBody(raw_ostream & OS) const501     void writeCtorBody(raw_ostream &OS) const override {
502       OS << "    if (is" << getLowerName() << "Expr)\n";
503       OS << "       " << getLowerName() << "Expr = reinterpret_cast<Expr *>("
504          << getUpperName() << ");\n";
505       OS << "    else\n";
506       OS << "       " << getLowerName()
507          << "Type = reinterpret_cast<TypeSourceInfo *>(" << getUpperName()
508          << ");\n";
509     }
510 
writeCtorInitializers(raw_ostream & OS) const511     void writeCtorInitializers(raw_ostream &OS) const override {
512       OS << "is" << getLowerName() << "Expr(Is" << getUpperName() << "Expr)";
513     }
514 
writeCtorDefaultInitializers(raw_ostream & OS) const515     void writeCtorDefaultInitializers(raw_ostream &OS) const override {
516       OS << "is" << getLowerName() << "Expr(false)";
517     }
518 
writeCtorParameters(raw_ostream & OS) const519     void writeCtorParameters(raw_ostream &OS) const override {
520       OS << "bool Is" << getUpperName() << "Expr, void *" << getUpperName();
521     }
522 
writeImplicitCtorArgs(raw_ostream & OS) const523     void writeImplicitCtorArgs(raw_ostream &OS) const override {
524       OS << "Is" << getUpperName() << "Expr, " << getUpperName();
525     }
526 
writeDeclarations(raw_ostream & OS) const527     void writeDeclarations(raw_ostream &OS) const override {
528       OS << "bool is" << getLowerName() << "Expr;\n";
529       OS << "union {\n";
530       OS << "Expr *" << getLowerName() << "Expr;\n";
531       OS << "TypeSourceInfo *" << getLowerName() << "Type;\n";
532       OS << "};";
533     }
534 
writePCHReadArgs(raw_ostream & OS) const535     void writePCHReadArgs(raw_ostream &OS) const override {
536       OS << "is" << getLowerName() << "Expr, " << getLowerName() << "Ptr";
537     }
538 
writePCHReadDecls(raw_ostream & OS) const539     void writePCHReadDecls(raw_ostream &OS) const override {
540       OS << "    bool is" << getLowerName() << "Expr = Record[Idx++];\n";
541       OS << "    void *" << getLowerName() << "Ptr;\n";
542       OS << "    if (is" << getLowerName() << "Expr)\n";
543       OS << "      " << getLowerName() << "Ptr = ReadExpr(F);\n";
544       OS << "    else\n";
545       OS << "      " << getLowerName()
546          << "Ptr = GetTypeSourceInfo(F, Record, Idx);\n";
547     }
548 
writePCHWrite(raw_ostream & OS) const549     void writePCHWrite(raw_ostream &OS) const override {
550       OS << "    Record.push_back(SA->is" << getUpperName() << "Expr());\n";
551       OS << "    if (SA->is" << getUpperName() << "Expr())\n";
552       OS << "      Record.AddStmt(SA->get" << getUpperName() << "Expr());\n";
553       OS << "    else\n";
554       OS << "      Record.AddTypeSourceInfo(SA->get" << getUpperName()
555          << "Type());\n";
556     }
557 
writeValue(raw_ostream & OS) const558     void writeValue(raw_ostream &OS) const override {
559       OS << "\";\n";
560       // The aligned attribute argument expression is optional.
561       OS << "    if (is" << getLowerName() << "Expr && "
562          << getLowerName() << "Expr)\n";
563       OS << "      " << getLowerName() << "Expr->printPretty(OS, nullptr, Policy);\n";
564       OS << "    OS << \"";
565     }
566 
writeDump(raw_ostream & OS) const567     void writeDump(raw_ostream &OS) const override {}
568 
writeDumpChildren(raw_ostream & OS) const569     void writeDumpChildren(raw_ostream &OS) const override {
570       OS << "    if (SA->is" << getUpperName() << "Expr())\n";
571       OS << "      dumpStmt(SA->get" << getUpperName() << "Expr());\n";
572       OS << "    else\n";
573       OS << "      dumpType(SA->get" << getUpperName()
574          << "Type()->getType());\n";
575     }
576 
writeHasChildren(raw_ostream & OS) const577     void writeHasChildren(raw_ostream &OS) const override {
578       OS << "SA->is" << getUpperName() << "Expr()";
579     }
580   };
581 
582   class VariadicArgument : public Argument {
583     std::string Type, ArgName, ArgSizeName, RangeName;
584 
585   protected:
586     // Assumed to receive a parameter: raw_ostream OS.
writeValueImpl(raw_ostream & OS) const587     virtual void writeValueImpl(raw_ostream &OS) const {
588       OS << "    OS << Val;\n";
589     }
590 
591   public:
VariadicArgument(const Record & Arg,StringRef Attr,std::string T)592     VariadicArgument(const Record &Arg, StringRef Attr, std::string T)
593         : Argument(Arg, Attr), Type(std::move(T)),
594           ArgName(getLowerName().str() + "_"), ArgSizeName(ArgName + "Size"),
595           RangeName(getLowerName()) {}
596 
getType() const597     const std::string &getType() const { return Type; }
getArgName() const598     const std::string &getArgName() const { return ArgName; }
getArgSizeName() const599     const std::string &getArgSizeName() const { return ArgSizeName; }
isVariadic() const600     bool isVariadic() const override { return true; }
601 
writeAccessors(raw_ostream & OS) const602     void writeAccessors(raw_ostream &OS) const override {
603       std::string IteratorType = getLowerName().str() + "_iterator";
604       std::string BeginFn = getLowerName().str() + "_begin()";
605       std::string EndFn = getLowerName().str() + "_end()";
606 
607       OS << "  typedef " << Type << "* " << IteratorType << ";\n";
608       OS << "  " << IteratorType << " " << BeginFn << " const {"
609          << " return " << ArgName << "; }\n";
610       OS << "  " << IteratorType << " " << EndFn << " const {"
611          << " return " << ArgName << " + " << ArgSizeName << "; }\n";
612       OS << "  unsigned " << getLowerName() << "_size() const {"
613          << " return " << ArgSizeName << "; }\n";
614       OS << "  llvm::iterator_range<" << IteratorType << "> " << RangeName
615          << "() const { return llvm::make_range(" << BeginFn << ", " << EndFn
616          << "); }\n";
617     }
618 
writeCloneArgs(raw_ostream & OS) const619     void writeCloneArgs(raw_ostream &OS) const override {
620       OS << ArgName << ", " << ArgSizeName;
621     }
622 
writeTemplateInstantiationArgs(raw_ostream & OS) const623     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
624       // This isn't elegant, but we have to go through public methods...
625       OS << "A->" << getLowerName() << "_begin(), "
626          << "A->" << getLowerName() << "_size()";
627     }
628 
writeCtorBody(raw_ostream & OS) const629     void writeCtorBody(raw_ostream &OS) const override {
630       OS << "    std::copy(" << getUpperName() << ", " << getUpperName()
631          << " + " << ArgSizeName << ", " << ArgName << ");\n";
632     }
633 
writeCtorInitializers(raw_ostream & OS) const634     void writeCtorInitializers(raw_ostream &OS) const override {
635       OS << ArgSizeName << "(" << getUpperName() << "Size), "
636          << ArgName << "(new (Ctx, 16) " << getType() << "["
637          << ArgSizeName << "])";
638     }
639 
writeCtorDefaultInitializers(raw_ostream & OS) const640     void writeCtorDefaultInitializers(raw_ostream &OS) const override {
641       OS << ArgSizeName << "(0), " << ArgName << "(nullptr)";
642     }
643 
writeCtorParameters(raw_ostream & OS) const644     void writeCtorParameters(raw_ostream &OS) const override {
645       OS << getType() << " *" << getUpperName() << ", unsigned "
646          << getUpperName() << "Size";
647     }
648 
writeImplicitCtorArgs(raw_ostream & OS) const649     void writeImplicitCtorArgs(raw_ostream &OS) const override {
650       OS << getUpperName() << ", " << getUpperName() << "Size";
651     }
652 
writeDeclarations(raw_ostream & OS) const653     void writeDeclarations(raw_ostream &OS) const override {
654       OS << "  unsigned " << ArgSizeName << ";\n";
655       OS << "  " << getType() << " *" << ArgName << ";";
656     }
657 
writePCHReadDecls(raw_ostream & OS) const658     void writePCHReadDecls(raw_ostream &OS) const override {
659       OS << "    unsigned " << getLowerName() << "Size = Record[Idx++];\n";
660       OS << "    SmallVector<" << getType() << ", 4> "
661          << getLowerName() << ";\n";
662       OS << "    " << getLowerName() << ".reserve(" << getLowerName()
663          << "Size);\n";
664 
665       // If we can't store the values in the current type (if it's something
666       // like StringRef), store them in a different type and convert the
667       // container afterwards.
668       std::string StorageType = getStorageType(getType());
669       std::string StorageName = getLowerName();
670       if (StorageType != getType()) {
671         StorageName += "Storage";
672         OS << "    SmallVector<" << StorageType << ", 4> "
673            << StorageName << ";\n";
674         OS << "    " << StorageName << ".reserve(" << getLowerName()
675            << "Size);\n";
676       }
677 
678       OS << "    for (unsigned i = 0; i != " << getLowerName() << "Size; ++i)\n";
679       std::string read = ReadPCHRecord(Type);
680       OS << "      " << StorageName << ".push_back(" << read << ");\n";
681 
682       if (StorageType != getType()) {
683         OS << "    for (unsigned i = 0; i != " << getLowerName() << "Size; ++i)\n";
684         OS << "      " << getLowerName() << ".push_back("
685            << StorageName << "[i]);\n";
686       }
687     }
688 
writePCHReadArgs(raw_ostream & OS) const689     void writePCHReadArgs(raw_ostream &OS) const override {
690       OS << getLowerName() << ".data(), " << getLowerName() << "Size";
691     }
692 
writePCHWrite(raw_ostream & OS) const693     void writePCHWrite(raw_ostream &OS) const override {
694       OS << "    Record.push_back(SA->" << getLowerName() << "_size());\n";
695       OS << "    for (auto &Val : SA->" << RangeName << "())\n";
696       OS << "      " << WritePCHRecord(Type, "Val");
697     }
698 
writeValue(raw_ostream & OS) const699     void writeValue(raw_ostream &OS) const override {
700       OS << "\";\n";
701       OS << "  bool isFirst = true;\n"
702          << "  for (const auto &Val : " << RangeName << "()) {\n"
703          << "    if (isFirst) isFirst = false;\n"
704          << "    else OS << \", \";\n";
705       writeValueImpl(OS);
706       OS << "  }\n";
707       OS << "  OS << \"";
708     }
709 
writeDump(raw_ostream & OS) const710     void writeDump(raw_ostream &OS) const override {
711       OS << "    for (const auto &Val : SA->" << RangeName << "())\n";
712       OS << "      OS << \" \" << Val;\n";
713     }
714   };
715 
716   // Unique the enums, but maintain the original declaration ordering.
717   std::vector<std::string>
uniqueEnumsInOrder(const std::vector<std::string> & enums)718   uniqueEnumsInOrder(const std::vector<std::string> &enums) {
719     std::vector<std::string> uniques;
720     std::set<std::string> unique_set(enums.begin(), enums.end());
721     for (const auto &i : enums) {
722       auto set_i = unique_set.find(i);
723       if (set_i != unique_set.end()) {
724         uniques.push_back(i);
725         unique_set.erase(set_i);
726       }
727     }
728     return uniques;
729   }
730 
731   class EnumArgument : public Argument {
732     std::string type;
733     std::vector<std::string> values, enums, uniques;
734   public:
EnumArgument(const Record & Arg,StringRef Attr)735     EnumArgument(const Record &Arg, StringRef Attr)
736       : Argument(Arg, Attr), type(Arg.getValueAsString("Type")),
737         values(Arg.getValueAsListOfStrings("Values")),
738         enums(Arg.getValueAsListOfStrings("Enums")),
739         uniques(uniqueEnumsInOrder(enums))
740     {
741       // FIXME: Emit a proper error
742       assert(!uniques.empty());
743     }
744 
isEnumArg() const745     bool isEnumArg() const override { return true; }
746 
writeAccessors(raw_ostream & OS) const747     void writeAccessors(raw_ostream &OS) const override {
748       OS << "  " << type << " get" << getUpperName() << "() const {\n";
749       OS << "    return " << getLowerName() << ";\n";
750       OS << "  }";
751     }
752 
writeCloneArgs(raw_ostream & OS) const753     void writeCloneArgs(raw_ostream &OS) const override {
754       OS << getLowerName();
755     }
756 
writeTemplateInstantiationArgs(raw_ostream & OS) const757     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
758       OS << "A->get" << getUpperName() << "()";
759     }
writeCtorInitializers(raw_ostream & OS) const760     void writeCtorInitializers(raw_ostream &OS) const override {
761       OS << getLowerName() << "(" << getUpperName() << ")";
762     }
writeCtorDefaultInitializers(raw_ostream & OS) const763     void writeCtorDefaultInitializers(raw_ostream &OS) const override {
764       OS << getLowerName() << "(" << type << "(0))";
765     }
writeCtorParameters(raw_ostream & OS) const766     void writeCtorParameters(raw_ostream &OS) const override {
767       OS << type << " " << getUpperName();
768     }
writeDeclarations(raw_ostream & OS) const769     void writeDeclarations(raw_ostream &OS) const override {
770       auto i = uniques.cbegin(), e = uniques.cend();
771       // The last one needs to not have a comma.
772       --e;
773 
774       OS << "public:\n";
775       OS << "  enum " << type << " {\n";
776       for (; i != e; ++i)
777         OS << "    " << *i << ",\n";
778       OS << "    " << *e << "\n";
779       OS << "  };\n";
780       OS << "private:\n";
781       OS << "  " << type << " " << getLowerName() << ";";
782     }
783 
writePCHReadDecls(raw_ostream & OS) const784     void writePCHReadDecls(raw_ostream &OS) const override {
785       OS << "    " << getAttrName() << "Attr::" << type << " " << getLowerName()
786          << "(static_cast<" << getAttrName() << "Attr::" << type
787          << ">(Record[Idx++]));\n";
788     }
789 
writePCHReadArgs(raw_ostream & OS) const790     void writePCHReadArgs(raw_ostream &OS) const override {
791       OS << getLowerName();
792     }
793 
writePCHWrite(raw_ostream & OS) const794     void writePCHWrite(raw_ostream &OS) const override {
795       OS << "Record.push_back(SA->get" << getUpperName() << "());\n";
796     }
797 
writeValue(raw_ostream & OS) const798     void writeValue(raw_ostream &OS) const override {
799       // FIXME: this isn't 100% correct -- some enum arguments require printing
800       // as a string literal, while others require printing as an identifier.
801       // Tablegen currently does not distinguish between the two forms.
802       OS << "\\\"\" << " << getAttrName() << "Attr::Convert" << type << "ToStr(get"
803          << getUpperName() << "()) << \"\\\"";
804     }
805 
writeDump(raw_ostream & OS) const806     void writeDump(raw_ostream &OS) const override {
807       OS << "    switch(SA->get" << getUpperName() << "()) {\n";
808       for (const auto &I : uniques) {
809         OS << "    case " << getAttrName() << "Attr::" << I << ":\n";
810         OS << "      OS << \" " << I << "\";\n";
811         OS << "      break;\n";
812       }
813       OS << "    }\n";
814     }
815 
writeConversion(raw_ostream & OS) const816     void writeConversion(raw_ostream &OS) const {
817       OS << "  static bool ConvertStrTo" << type << "(StringRef Val, ";
818       OS << type << " &Out) {\n";
819       OS << "    Optional<" << type << "> R = llvm::StringSwitch<Optional<";
820       OS << type << ">>(Val)\n";
821       for (size_t I = 0; I < enums.size(); ++I) {
822         OS << "      .Case(\"" << values[I] << "\", ";
823         OS << getAttrName() << "Attr::" << enums[I] << ")\n";
824       }
825       OS << "      .Default(Optional<" << type << ">());\n";
826       OS << "    if (R) {\n";
827       OS << "      Out = *R;\n      return true;\n    }\n";
828       OS << "    return false;\n";
829       OS << "  }\n\n";
830 
831       // Mapping from enumeration values back to enumeration strings isn't
832       // trivial because some enumeration values have multiple named
833       // enumerators, such as type_visibility(internal) and
834       // type_visibility(hidden) both mapping to TypeVisibilityAttr::Hidden.
835       OS << "  static const char *Convert" << type << "ToStr("
836          << type << " Val) {\n"
837          << "    switch(Val) {\n";
838       std::set<std::string> Uniques;
839       for (size_t I = 0; I < enums.size(); ++I) {
840         if (Uniques.insert(enums[I]).second)
841           OS << "    case " << getAttrName() << "Attr::" << enums[I]
842              << ": return \"" << values[I] << "\";\n";
843       }
844       OS << "    }\n"
845          << "    llvm_unreachable(\"No enumerator with that value\");\n"
846          << "  }\n";
847     }
848   };
849 
850   class VariadicEnumArgument: public VariadicArgument {
851     std::string type, QualifiedTypeName;
852     std::vector<std::string> values, enums, uniques;
853 
854   protected:
writeValueImpl(raw_ostream & OS) const855     void writeValueImpl(raw_ostream &OS) const override {
856       // FIXME: this isn't 100% correct -- some enum arguments require printing
857       // as a string literal, while others require printing as an identifier.
858       // Tablegen currently does not distinguish between the two forms.
859       OS << "    OS << \"\\\"\" << " << getAttrName() << "Attr::Convert" << type
860          << "ToStr(Val)" << "<< \"\\\"\";\n";
861     }
862 
863   public:
VariadicEnumArgument(const Record & Arg,StringRef Attr)864     VariadicEnumArgument(const Record &Arg, StringRef Attr)
865       : VariadicArgument(Arg, Attr, Arg.getValueAsString("Type")),
866         type(Arg.getValueAsString("Type")),
867         values(Arg.getValueAsListOfStrings("Values")),
868         enums(Arg.getValueAsListOfStrings("Enums")),
869         uniques(uniqueEnumsInOrder(enums))
870     {
871       QualifiedTypeName = getAttrName().str() + "Attr::" + type;
872 
873       // FIXME: Emit a proper error
874       assert(!uniques.empty());
875     }
876 
isVariadicEnumArg() const877     bool isVariadicEnumArg() const override { return true; }
878 
writeDeclarations(raw_ostream & OS) const879     void writeDeclarations(raw_ostream &OS) const override {
880       auto i = uniques.cbegin(), e = uniques.cend();
881       // The last one needs to not have a comma.
882       --e;
883 
884       OS << "public:\n";
885       OS << "  enum " << type << " {\n";
886       for (; i != e; ++i)
887         OS << "    " << *i << ",\n";
888       OS << "    " << *e << "\n";
889       OS << "  };\n";
890       OS << "private:\n";
891 
892       VariadicArgument::writeDeclarations(OS);
893     }
894 
writeDump(raw_ostream & OS) const895     void writeDump(raw_ostream &OS) const override {
896       OS << "    for (" << getAttrName() << "Attr::" << getLowerName()
897          << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
898          << getLowerName() << "_end(); I != E; ++I) {\n";
899       OS << "      switch(*I) {\n";
900       for (const auto &UI : uniques) {
901         OS << "    case " << getAttrName() << "Attr::" << UI << ":\n";
902         OS << "      OS << \" " << UI << "\";\n";
903         OS << "      break;\n";
904       }
905       OS << "      }\n";
906       OS << "    }\n";
907     }
908 
writePCHReadDecls(raw_ostream & OS) const909     void writePCHReadDecls(raw_ostream &OS) const override {
910       OS << "    unsigned " << getLowerName() << "Size = Record[Idx++];\n";
911       OS << "    SmallVector<" << QualifiedTypeName << ", 4> " << getLowerName()
912          << ";\n";
913       OS << "    " << getLowerName() << ".reserve(" << getLowerName()
914          << "Size);\n";
915       OS << "    for (unsigned i = " << getLowerName() << "Size; i; --i)\n";
916       OS << "      " << getLowerName() << ".push_back(" << "static_cast<"
917          << QualifiedTypeName << ">(Record[Idx++]));\n";
918     }
919 
writePCHWrite(raw_ostream & OS) const920     void writePCHWrite(raw_ostream &OS) const override {
921       OS << "    Record.push_back(SA->" << getLowerName() << "_size());\n";
922       OS << "    for (" << getAttrName() << "Attr::" << getLowerName()
923          << "_iterator i = SA->" << getLowerName() << "_begin(), e = SA->"
924          << getLowerName() << "_end(); i != e; ++i)\n";
925       OS << "      " << WritePCHRecord(QualifiedTypeName, "(*i)");
926     }
927 
writeConversion(raw_ostream & OS) const928     void writeConversion(raw_ostream &OS) const {
929       OS << "  static bool ConvertStrTo" << type << "(StringRef Val, ";
930       OS << type << " &Out) {\n";
931       OS << "    Optional<" << type << "> R = llvm::StringSwitch<Optional<";
932       OS << type << ">>(Val)\n";
933       for (size_t I = 0; I < enums.size(); ++I) {
934         OS << "      .Case(\"" << values[I] << "\", ";
935         OS << getAttrName() << "Attr::" << enums[I] << ")\n";
936       }
937       OS << "      .Default(Optional<" << type << ">());\n";
938       OS << "    if (R) {\n";
939       OS << "      Out = *R;\n      return true;\n    }\n";
940       OS << "    return false;\n";
941       OS << "  }\n\n";
942 
943       OS << "  static const char *Convert" << type << "ToStr("
944         << type << " Val) {\n"
945         << "    switch(Val) {\n";
946       std::set<std::string> Uniques;
947       for (size_t I = 0; I < enums.size(); ++I) {
948         if (Uniques.insert(enums[I]).second)
949           OS << "    case " << getAttrName() << "Attr::" << enums[I]
950           << ": return \"" << values[I] << "\";\n";
951       }
952       OS << "    }\n"
953         << "    llvm_unreachable(\"No enumerator with that value\");\n"
954         << "  }\n";
955     }
956   };
957 
958   class VersionArgument : public Argument {
959   public:
VersionArgument(const Record & Arg,StringRef Attr)960     VersionArgument(const Record &Arg, StringRef Attr)
961       : Argument(Arg, Attr)
962     {}
963 
writeAccessors(raw_ostream & OS) const964     void writeAccessors(raw_ostream &OS) const override {
965       OS << "  VersionTuple get" << getUpperName() << "() const {\n";
966       OS << "    return " << getLowerName() << ";\n";
967       OS << "  }\n";
968       OS << "  void set" << getUpperName()
969          << "(ASTContext &C, VersionTuple V) {\n";
970       OS << "    " << getLowerName() << " = V;\n";
971       OS << "  }";
972     }
973 
writeCloneArgs(raw_ostream & OS) const974     void writeCloneArgs(raw_ostream &OS) const override {
975       OS << "get" << getUpperName() << "()";
976     }
977 
writeTemplateInstantiationArgs(raw_ostream & OS) const978     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
979       OS << "A->get" << getUpperName() << "()";
980     }
981 
writeCtorInitializers(raw_ostream & OS) const982     void writeCtorInitializers(raw_ostream &OS) const override {
983       OS << getLowerName() << "(" << getUpperName() << ")";
984     }
985 
writeCtorDefaultInitializers(raw_ostream & OS) const986     void writeCtorDefaultInitializers(raw_ostream &OS) const override {
987       OS << getLowerName() << "()";
988     }
989 
writeCtorParameters(raw_ostream & OS) const990     void writeCtorParameters(raw_ostream &OS) const override {
991       OS << "VersionTuple " << getUpperName();
992     }
993 
writeDeclarations(raw_ostream & OS) const994     void writeDeclarations(raw_ostream &OS) const override {
995       OS << "VersionTuple " << getLowerName() << ";\n";
996     }
997 
writePCHReadDecls(raw_ostream & OS) const998     void writePCHReadDecls(raw_ostream &OS) const override {
999       OS << "    VersionTuple " << getLowerName()
1000          << "= ReadVersionTuple(Record, Idx);\n";
1001     }
1002 
writePCHReadArgs(raw_ostream & OS) const1003     void writePCHReadArgs(raw_ostream &OS) const override {
1004       OS << getLowerName();
1005     }
1006 
writePCHWrite(raw_ostream & OS) const1007     void writePCHWrite(raw_ostream &OS) const override {
1008       OS << "    Record.AddVersionTuple(SA->get" << getUpperName() << "());\n";
1009     }
1010 
writeValue(raw_ostream & OS) const1011     void writeValue(raw_ostream &OS) const override {
1012       OS << getLowerName() << "=\" << get" << getUpperName() << "() << \"";
1013     }
1014 
writeDump(raw_ostream & OS) const1015     void writeDump(raw_ostream &OS) const override {
1016       OS << "    OS << \" \" << SA->get" << getUpperName() << "();\n";
1017     }
1018   };
1019 
1020   class ExprArgument : public SimpleArgument {
1021   public:
ExprArgument(const Record & Arg,StringRef Attr)1022     ExprArgument(const Record &Arg, StringRef Attr)
1023       : SimpleArgument(Arg, Attr, "Expr *")
1024     {}
1025 
writeASTVisitorTraversal(raw_ostream & OS) const1026     void writeASTVisitorTraversal(raw_ostream &OS) const override {
1027       OS << "  if (!"
1028          << "getDerived().TraverseStmt(A->get" << getUpperName() << "()))\n";
1029       OS << "    return false;\n";
1030     }
1031 
writeTemplateInstantiationArgs(raw_ostream & OS) const1032     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
1033       OS << "tempInst" << getUpperName();
1034     }
1035 
writeTemplateInstantiation(raw_ostream & OS) const1036     void writeTemplateInstantiation(raw_ostream &OS) const override {
1037       OS << "      " << getType() << " tempInst" << getUpperName() << ";\n";
1038       OS << "      {\n";
1039       OS << "        EnterExpressionEvaluationContext "
1040          << "Unevaluated(S, Sema::Unevaluated);\n";
1041       OS << "        ExprResult " << "Result = S.SubstExpr("
1042          << "A->get" << getUpperName() << "(), TemplateArgs);\n";
1043       OS << "        tempInst" << getUpperName() << " = "
1044          << "Result.getAs<Expr>();\n";
1045       OS << "      }\n";
1046     }
1047 
writeDump(raw_ostream & OS) const1048     void writeDump(raw_ostream &OS) const override {}
1049 
writeDumpChildren(raw_ostream & OS) const1050     void writeDumpChildren(raw_ostream &OS) const override {
1051       OS << "    dumpStmt(SA->get" << getUpperName() << "());\n";
1052     }
1053 
writeHasChildren(raw_ostream & OS) const1054     void writeHasChildren(raw_ostream &OS) const override { OS << "true"; }
1055   };
1056 
1057   class VariadicExprArgument : public VariadicArgument {
1058   public:
VariadicExprArgument(const Record & Arg,StringRef Attr)1059     VariadicExprArgument(const Record &Arg, StringRef Attr)
1060       : VariadicArgument(Arg, Attr, "Expr *")
1061     {}
1062 
writeASTVisitorTraversal(raw_ostream & OS) const1063     void writeASTVisitorTraversal(raw_ostream &OS) const override {
1064       OS << "  {\n";
1065       OS << "    " << getType() << " *I = A->" << getLowerName()
1066          << "_begin();\n";
1067       OS << "    " << getType() << " *E = A->" << getLowerName()
1068          << "_end();\n";
1069       OS << "    for (; I != E; ++I) {\n";
1070       OS << "      if (!getDerived().TraverseStmt(*I))\n";
1071       OS << "        return false;\n";
1072       OS << "    }\n";
1073       OS << "  }\n";
1074     }
1075 
writeTemplateInstantiationArgs(raw_ostream & OS) const1076     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
1077       OS << "tempInst" << getUpperName() << ", "
1078          << "A->" << getLowerName() << "_size()";
1079     }
1080 
writeTemplateInstantiation(raw_ostream & OS) const1081     void writeTemplateInstantiation(raw_ostream &OS) const override {
1082       OS << "      auto *tempInst" << getUpperName()
1083          << " = new (C, 16) " << getType()
1084          << "[A->" << getLowerName() << "_size()];\n";
1085       OS << "      {\n";
1086       OS << "        EnterExpressionEvaluationContext "
1087          << "Unevaluated(S, Sema::Unevaluated);\n";
1088       OS << "        " << getType() << " *TI = tempInst" << getUpperName()
1089          << ";\n";
1090       OS << "        " << getType() << " *I = A->" << getLowerName()
1091          << "_begin();\n";
1092       OS << "        " << getType() << " *E = A->" << getLowerName()
1093          << "_end();\n";
1094       OS << "        for (; I != E; ++I, ++TI) {\n";
1095       OS << "          ExprResult Result = S.SubstExpr(*I, TemplateArgs);\n";
1096       OS << "          *TI = Result.getAs<Expr>();\n";
1097       OS << "        }\n";
1098       OS << "      }\n";
1099     }
1100 
writeDump(raw_ostream & OS) const1101     void writeDump(raw_ostream &OS) const override {}
1102 
writeDumpChildren(raw_ostream & OS) const1103     void writeDumpChildren(raw_ostream &OS) const override {
1104       OS << "    for (" << getAttrName() << "Attr::" << getLowerName()
1105          << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
1106          << getLowerName() << "_end(); I != E; ++I)\n";
1107       OS << "      dumpStmt(*I);\n";
1108     }
1109 
writeHasChildren(raw_ostream & OS) const1110     void writeHasChildren(raw_ostream &OS) const override {
1111       OS << "SA->" << getLowerName() << "_begin() != "
1112          << "SA->" << getLowerName() << "_end()";
1113     }
1114   };
1115 
1116   class VariadicStringArgument : public VariadicArgument {
1117   public:
VariadicStringArgument(const Record & Arg,StringRef Attr)1118     VariadicStringArgument(const Record &Arg, StringRef Attr)
1119       : VariadicArgument(Arg, Attr, "StringRef")
1120     {}
1121 
writeCtorBody(raw_ostream & OS) const1122     void writeCtorBody(raw_ostream &OS) const override {
1123       OS << "    for (size_t I = 0, E = " << getArgSizeName() << "; I != E;\n"
1124             "         ++I) {\n"
1125             "      StringRef Ref = " << getUpperName() << "[I];\n"
1126             "      if (!Ref.empty()) {\n"
1127             "        char *Mem = new (Ctx, 1) char[Ref.size()];\n"
1128             "        std::memcpy(Mem, Ref.data(), Ref.size());\n"
1129             "        " << getArgName() << "[I] = StringRef(Mem, Ref.size());\n"
1130             "      }\n"
1131             "    }\n";
1132     }
1133 
writeValueImpl(raw_ostream & OS) const1134     void writeValueImpl(raw_ostream &OS) const override {
1135       OS << "    OS << \"\\\"\" << Val << \"\\\"\";\n";
1136     }
1137   };
1138 
1139   class TypeArgument : public SimpleArgument {
1140   public:
TypeArgument(const Record & Arg,StringRef Attr)1141     TypeArgument(const Record &Arg, StringRef Attr)
1142       : SimpleArgument(Arg, Attr, "TypeSourceInfo *")
1143     {}
1144 
writeAccessors(raw_ostream & OS) const1145     void writeAccessors(raw_ostream &OS) const override {
1146       OS << "  QualType get" << getUpperName() << "() const {\n";
1147       OS << "    return " << getLowerName() << "->getType();\n";
1148       OS << "  }";
1149       OS << "  " << getType() << " get" << getUpperName() << "Loc() const {\n";
1150       OS << "    return " << getLowerName() << ";\n";
1151       OS << "  }";
1152     }
1153 
writeTemplateInstantiationArgs(raw_ostream & OS) const1154     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
1155       OS << "A->get" << getUpperName() << "Loc()";
1156     }
1157 
writePCHWrite(raw_ostream & OS) const1158     void writePCHWrite(raw_ostream &OS) const override {
1159       OS << "    " << WritePCHRecord(
1160           getType(), "SA->get" + std::string(getUpperName()) + "Loc()");
1161     }
1162   };
1163 
1164 } // end anonymous namespace
1165 
1166 static std::unique_ptr<Argument>
createArgument(const Record & Arg,StringRef Attr,const Record * Search=nullptr)1167 createArgument(const Record &Arg, StringRef Attr,
1168                const Record *Search = nullptr) {
1169   if (!Search)
1170     Search = &Arg;
1171 
1172   std::unique_ptr<Argument> Ptr;
1173   llvm::StringRef ArgName = Search->getName();
1174 
1175   if (ArgName == "AlignedArgument")
1176     Ptr = llvm::make_unique<AlignedArgument>(Arg, Attr);
1177   else if (ArgName == "EnumArgument")
1178     Ptr = llvm::make_unique<EnumArgument>(Arg, Attr);
1179   else if (ArgName == "ExprArgument")
1180     Ptr = llvm::make_unique<ExprArgument>(Arg, Attr);
1181   else if (ArgName == "FunctionArgument")
1182     Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "FunctionDecl *");
1183   else if (ArgName == "IdentifierArgument")
1184     Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "IdentifierInfo *");
1185   else if (ArgName == "DefaultBoolArgument")
1186     Ptr = llvm::make_unique<DefaultSimpleArgument>(
1187         Arg, Attr, "bool", Arg.getValueAsBit("Default"));
1188   else if (ArgName == "BoolArgument")
1189     Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "bool");
1190   else if (ArgName == "DefaultIntArgument")
1191     Ptr = llvm::make_unique<DefaultSimpleArgument>(
1192         Arg, Attr, "int", Arg.getValueAsInt("Default"));
1193   else if (ArgName == "IntArgument")
1194     Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "int");
1195   else if (ArgName == "StringArgument")
1196     Ptr = llvm::make_unique<StringArgument>(Arg, Attr);
1197   else if (ArgName == "TypeArgument")
1198     Ptr = llvm::make_unique<TypeArgument>(Arg, Attr);
1199   else if (ArgName == "UnsignedArgument")
1200     Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "unsigned");
1201   else if (ArgName == "VariadicUnsignedArgument")
1202     Ptr = llvm::make_unique<VariadicArgument>(Arg, Attr, "unsigned");
1203   else if (ArgName == "VariadicStringArgument")
1204     Ptr = llvm::make_unique<VariadicStringArgument>(Arg, Attr);
1205   else if (ArgName == "VariadicEnumArgument")
1206     Ptr = llvm::make_unique<VariadicEnumArgument>(Arg, Attr);
1207   else if (ArgName == "VariadicExprArgument")
1208     Ptr = llvm::make_unique<VariadicExprArgument>(Arg, Attr);
1209   else if (ArgName == "VersionArgument")
1210     Ptr = llvm::make_unique<VersionArgument>(Arg, Attr);
1211 
1212   if (!Ptr) {
1213     // Search in reverse order so that the most-derived type is handled first.
1214     ArrayRef<std::pair<Record*, SMRange>> Bases = Search->getSuperClasses();
1215     for (const auto &Base : llvm::reverse(Bases)) {
1216       if ((Ptr = createArgument(Arg, Attr, Base.first)))
1217         break;
1218     }
1219   }
1220 
1221   if (Ptr && Arg.getValueAsBit("Optional"))
1222     Ptr->setOptional(true);
1223 
1224   if (Ptr && Arg.getValueAsBit("Fake"))
1225     Ptr->setFake(true);
1226 
1227   return Ptr;
1228 }
1229 
writeAvailabilityValue(raw_ostream & OS)1230 static void writeAvailabilityValue(raw_ostream &OS) {
1231   OS << "\" << getPlatform()->getName();\n"
1232      << "  if (getStrict()) OS << \", strict\";\n"
1233      << "  if (!getIntroduced().empty()) OS << \", introduced=\" << getIntroduced();\n"
1234      << "  if (!getDeprecated().empty()) OS << \", deprecated=\" << getDeprecated();\n"
1235      << "  if (!getObsoleted().empty()) OS << \", obsoleted=\" << getObsoleted();\n"
1236      << "  if (getUnavailable()) OS << \", unavailable\";\n"
1237      << "  OS << \"";
1238 }
1239 
writeDeprecatedAttrValue(raw_ostream & OS,std::string & Variety)1240 static void writeDeprecatedAttrValue(raw_ostream &OS, std::string &Variety) {
1241   OS << "\\\"\" << getMessage() << \"\\\"\";\n";
1242   // Only GNU deprecated has an optional fixit argument at the second position.
1243   if (Variety == "GNU")
1244      OS << "    if (!getReplacement().empty()) OS << \", \\\"\""
1245            " << getReplacement() << \"\\\"\";\n";
1246   OS << "    OS << \"";
1247 }
1248 
writeGetSpellingFunction(Record & R,raw_ostream & OS)1249 static void writeGetSpellingFunction(Record &R, raw_ostream &OS) {
1250   std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
1251 
1252   OS << "const char *" << R.getName() << "Attr::getSpelling() const {\n";
1253   if (Spellings.empty()) {
1254     OS << "  return \"(No spelling)\";\n}\n\n";
1255     return;
1256   }
1257 
1258   OS << "  switch (SpellingListIndex) {\n"
1259         "  default:\n"
1260         "    llvm_unreachable(\"Unknown attribute spelling!\");\n"
1261         "    return \"(No spelling)\";\n";
1262 
1263   for (unsigned I = 0; I < Spellings.size(); ++I)
1264     OS << "  case " << I << ":\n"
1265           "    return \"" << Spellings[I].name() << "\";\n";
1266   // End of the switch statement.
1267   OS << "  }\n";
1268   // End of the getSpelling function.
1269   OS << "}\n\n";
1270 }
1271 
1272 static void
writePrettyPrintFunction(Record & R,const std::vector<std::unique_ptr<Argument>> & Args,raw_ostream & OS)1273 writePrettyPrintFunction(Record &R,
1274                          const std::vector<std::unique_ptr<Argument>> &Args,
1275                          raw_ostream &OS) {
1276   std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
1277 
1278   OS << "void " << R.getName() << "Attr::printPretty("
1279     << "raw_ostream &OS, const PrintingPolicy &Policy) const {\n";
1280 
1281   if (Spellings.empty()) {
1282     OS << "}\n\n";
1283     return;
1284   }
1285 
1286   OS <<
1287     "  switch (SpellingListIndex) {\n"
1288     "  default:\n"
1289     "    llvm_unreachable(\"Unknown attribute spelling!\");\n"
1290     "    break;\n";
1291 
1292   for (unsigned I = 0; I < Spellings.size(); ++ I) {
1293     llvm::SmallString<16> Prefix;
1294     llvm::SmallString<8> Suffix;
1295     // The actual spelling of the name and namespace (if applicable)
1296     // of an attribute without considering prefix and suffix.
1297     llvm::SmallString<64> Spelling;
1298     std::string Name = Spellings[I].name();
1299     std::string Variety = Spellings[I].variety();
1300 
1301     if (Variety == "GNU") {
1302       Prefix = " __attribute__((";
1303       Suffix = "))";
1304     } else if (Variety == "CXX11") {
1305       Prefix = " [[";
1306       Suffix = "]]";
1307       std::string Namespace = Spellings[I].nameSpace();
1308       if (!Namespace.empty()) {
1309         Spelling += Namespace;
1310         Spelling += "::";
1311       }
1312     } else if (Variety == "Declspec") {
1313       Prefix = " __declspec(";
1314       Suffix = ")";
1315     } else if (Variety == "Keyword") {
1316       Prefix = " ";
1317       Suffix = "";
1318     } else if (Variety == "Pragma") {
1319       Prefix = "#pragma ";
1320       Suffix = "\n";
1321       std::string Namespace = Spellings[I].nameSpace();
1322       if (!Namespace.empty()) {
1323         Spelling += Namespace;
1324         Spelling += " ";
1325       }
1326     } else {
1327       llvm_unreachable("Unknown attribute syntax variety!");
1328     }
1329 
1330     Spelling += Name;
1331 
1332     OS <<
1333       "  case " << I << " : {\n"
1334       "    OS << \"" << Prefix << Spelling;
1335 
1336     if (Variety == "Pragma") {
1337       OS << " \";\n";
1338       OS << "    printPrettyPragma(OS, Policy);\n";
1339       OS << "    OS << \"\\n\";";
1340       OS << "    break;\n";
1341       OS << "  }\n";
1342       continue;
1343     }
1344 
1345     // Fake arguments aren't part of the parsed form and should not be
1346     // pretty-printed.
1347     bool hasNonFakeArgs = false;
1348     for (const auto &arg : Args) {
1349       if (arg->isFake()) continue;
1350       hasNonFakeArgs = true;
1351     }
1352 
1353     // FIXME: always printing the parenthesis isn't the correct behavior for
1354     // attributes which have optional arguments that were not provided. For
1355     // instance: __attribute__((aligned)) will be pretty printed as
1356     // __attribute__((aligned())). The logic should check whether there is only
1357     // a single argument, and if it is optional, whether it has been provided.
1358     if (hasNonFakeArgs)
1359       OS << "(";
1360     if (Spelling == "availability") {
1361       writeAvailabilityValue(OS);
1362     } else if (Spelling == "deprecated" || Spelling == "gnu::deprecated") {
1363         writeDeprecatedAttrValue(OS, Variety);
1364     } else {
1365       unsigned index = 0;
1366       for (const auto &arg : Args) {
1367         if (arg->isFake()) continue;
1368         if (index++) OS << ", ";
1369         arg->writeValue(OS);
1370       }
1371     }
1372 
1373     if (hasNonFakeArgs)
1374       OS << ")";
1375     OS << Suffix + "\";\n";
1376 
1377     OS <<
1378       "    break;\n"
1379       "  }\n";
1380   }
1381 
1382   // End of the switch statement.
1383   OS << "}\n";
1384   // End of the print function.
1385   OS << "}\n\n";
1386 }
1387 
1388 /// \brief Return the index of a spelling in a spelling list.
1389 static unsigned
getSpellingListIndex(const std::vector<FlattenedSpelling> & SpellingList,const FlattenedSpelling & Spelling)1390 getSpellingListIndex(const std::vector<FlattenedSpelling> &SpellingList,
1391                      const FlattenedSpelling &Spelling) {
1392   assert(!SpellingList.empty() && "Spelling list is empty!");
1393 
1394   for (unsigned Index = 0; Index < SpellingList.size(); ++Index) {
1395     const FlattenedSpelling &S = SpellingList[Index];
1396     if (S.variety() != Spelling.variety())
1397       continue;
1398     if (S.nameSpace() != Spelling.nameSpace())
1399       continue;
1400     if (S.name() != Spelling.name())
1401       continue;
1402 
1403     return Index;
1404   }
1405 
1406   llvm_unreachable("Unknown spelling!");
1407 }
1408 
writeAttrAccessorDefinition(const Record & R,raw_ostream & OS)1409 static void writeAttrAccessorDefinition(const Record &R, raw_ostream &OS) {
1410   std::vector<Record*> Accessors = R.getValueAsListOfDefs("Accessors");
1411   for (const auto *Accessor : Accessors) {
1412     std::string Name = Accessor->getValueAsString("Name");
1413     std::vector<FlattenedSpelling> Spellings =
1414       GetFlattenedSpellings(*Accessor);
1415     std::vector<FlattenedSpelling> SpellingList = GetFlattenedSpellings(R);
1416     assert(!SpellingList.empty() &&
1417            "Attribute with empty spelling list can't have accessors!");
1418 
1419     OS << "  bool " << Name << "() const { return SpellingListIndex == ";
1420     for (unsigned Index = 0; Index < Spellings.size(); ++Index) {
1421       OS << getSpellingListIndex(SpellingList, Spellings[Index]);
1422       if (Index != Spellings.size() -1)
1423         OS << " ||\n    SpellingListIndex == ";
1424       else
1425         OS << "; }\n";
1426     }
1427   }
1428 }
1429 
1430 static bool
SpellingNamesAreCommon(const std::vector<FlattenedSpelling> & Spellings)1431 SpellingNamesAreCommon(const std::vector<FlattenedSpelling>& Spellings) {
1432   assert(!Spellings.empty() && "An empty list of spellings was provided");
1433   std::string FirstName = NormalizeNameForSpellingComparison(
1434     Spellings.front().name());
1435   for (const auto &Spelling :
1436        llvm::make_range(std::next(Spellings.begin()), Spellings.end())) {
1437     std::string Name = NormalizeNameForSpellingComparison(Spelling.name());
1438     if (Name != FirstName)
1439       return false;
1440   }
1441   return true;
1442 }
1443 
1444 typedef std::map<unsigned, std::string> SemanticSpellingMap;
1445 static std::string
CreateSemanticSpellings(const std::vector<FlattenedSpelling> & Spellings,SemanticSpellingMap & Map)1446 CreateSemanticSpellings(const std::vector<FlattenedSpelling> &Spellings,
1447                         SemanticSpellingMap &Map) {
1448   // The enumerants are automatically generated based on the variety,
1449   // namespace (if present) and name for each attribute spelling. However,
1450   // care is taken to avoid trampling on the reserved namespace due to
1451   // underscores.
1452   std::string Ret("  enum Spelling {\n");
1453   std::set<std::string> Uniques;
1454   unsigned Idx = 0;
1455   for (auto I = Spellings.begin(), E = Spellings.end(); I != E; ++I, ++Idx) {
1456     const FlattenedSpelling &S = *I;
1457     const std::string &Variety = S.variety();
1458     const std::string &Spelling = S.name();
1459     const std::string &Namespace = S.nameSpace();
1460     std::string EnumName;
1461 
1462     EnumName += (Variety + "_");
1463     if (!Namespace.empty())
1464       EnumName += (NormalizeNameForSpellingComparison(Namespace).str() +
1465       "_");
1466     EnumName += NormalizeNameForSpellingComparison(Spelling);
1467 
1468     // Even if the name is not unique, this spelling index corresponds to a
1469     // particular enumerant name that we've calculated.
1470     Map[Idx] = EnumName;
1471 
1472     // Since we have been stripping underscores to avoid trampling on the
1473     // reserved namespace, we may have inadvertently created duplicate
1474     // enumerant names. These duplicates are not considered part of the
1475     // semantic spelling, and can be elided.
1476     if (Uniques.find(EnumName) != Uniques.end())
1477       continue;
1478 
1479     Uniques.insert(EnumName);
1480     if (I != Spellings.begin())
1481       Ret += ",\n";
1482     // Duplicate spellings are not considered part of the semantic spelling
1483     // enumeration, but the spelling index and semantic spelling values are
1484     // meant to be equivalent, so we must specify a concrete value for each
1485     // enumerator.
1486     Ret += "    " + EnumName + " = " + llvm::utostr(Idx);
1487   }
1488   Ret += "\n  };\n\n";
1489   return Ret;
1490 }
1491 
WriteSemanticSpellingSwitch(const std::string & VarName,const SemanticSpellingMap & Map,raw_ostream & OS)1492 void WriteSemanticSpellingSwitch(const std::string &VarName,
1493                                  const SemanticSpellingMap &Map,
1494                                  raw_ostream &OS) {
1495   OS << "  switch (" << VarName << ") {\n    default: "
1496     << "llvm_unreachable(\"Unknown spelling list index\");\n";
1497   for (const auto &I : Map)
1498     OS << "    case " << I.first << ": return " << I.second << ";\n";
1499   OS << "  }\n";
1500 }
1501 
1502 // Emits the LateParsed property for attributes.
emitClangAttrLateParsedList(RecordKeeper & Records,raw_ostream & OS)1503 static void emitClangAttrLateParsedList(RecordKeeper &Records, raw_ostream &OS) {
1504   OS << "#if defined(CLANG_ATTR_LATE_PARSED_LIST)\n";
1505   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1506 
1507   for (const auto *Attr : Attrs) {
1508     bool LateParsed = Attr->getValueAsBit("LateParsed");
1509 
1510     if (LateParsed) {
1511       std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
1512 
1513       // FIXME: Handle non-GNU attributes
1514       for (const auto &I : Spellings) {
1515         if (I.variety() != "GNU")
1516           continue;
1517         OS << ".Case(\"" << I.name() << "\", " << LateParsed << ")\n";
1518       }
1519     }
1520   }
1521   OS << "#endif // CLANG_ATTR_LATE_PARSED_LIST\n\n";
1522 }
1523 
1524 /// \brief Emits the first-argument-is-type property for attributes.
emitClangAttrTypeArgList(RecordKeeper & Records,raw_ostream & OS)1525 static void emitClangAttrTypeArgList(RecordKeeper &Records, raw_ostream &OS) {
1526   OS << "#if defined(CLANG_ATTR_TYPE_ARG_LIST)\n";
1527   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
1528 
1529   for (const auto *Attr : Attrs) {
1530     // Determine whether the first argument is a type.
1531     std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args");
1532     if (Args.empty())
1533       continue;
1534 
1535     if (Args[0]->getSuperClasses().back().first->getName() != "TypeArgument")
1536       continue;
1537 
1538     // All these spellings take a single type argument.
1539     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
1540     std::set<std::string> Emitted;
1541     for (const auto &S : Spellings) {
1542       if (Emitted.insert(S.name()).second)
1543         OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
1544     }
1545   }
1546   OS << "#endif // CLANG_ATTR_TYPE_ARG_LIST\n\n";
1547 }
1548 
1549 /// \brief Emits the parse-arguments-in-unevaluated-context property for
1550 /// attributes.
emitClangAttrArgContextList(RecordKeeper & Records,raw_ostream & OS)1551 static void emitClangAttrArgContextList(RecordKeeper &Records, raw_ostream &OS) {
1552   OS << "#if defined(CLANG_ATTR_ARG_CONTEXT_LIST)\n";
1553   ParsedAttrMap Attrs = getParsedAttrList(Records);
1554   for (const auto &I : Attrs) {
1555     const Record &Attr = *I.second;
1556 
1557     if (!Attr.getValueAsBit("ParseArgumentsAsUnevaluated"))
1558       continue;
1559 
1560     // All these spellings take are parsed unevaluated.
1561     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
1562     std::set<std::string> Emitted;
1563     for (const auto &S : Spellings) {
1564       if (Emitted.insert(S.name()).second)
1565         OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
1566     }
1567   }
1568   OS << "#endif // CLANG_ATTR_ARG_CONTEXT_LIST\n\n";
1569 }
1570 
isIdentifierArgument(Record * Arg)1571 static bool isIdentifierArgument(Record *Arg) {
1572   return !Arg->getSuperClasses().empty() &&
1573     llvm::StringSwitch<bool>(Arg->getSuperClasses().back().first->getName())
1574     .Case("IdentifierArgument", true)
1575     .Case("EnumArgument", true)
1576     .Case("VariadicEnumArgument", true)
1577     .Default(false);
1578 }
1579 
1580 // Emits the first-argument-is-identifier property for attributes.
emitClangAttrIdentifierArgList(RecordKeeper & Records,raw_ostream & OS)1581 static void emitClangAttrIdentifierArgList(RecordKeeper &Records, raw_ostream &OS) {
1582   OS << "#if defined(CLANG_ATTR_IDENTIFIER_ARG_LIST)\n";
1583   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1584 
1585   for (const auto *Attr : Attrs) {
1586     // Determine whether the first argument is an identifier.
1587     std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args");
1588     if (Args.empty() || !isIdentifierArgument(Args[0]))
1589       continue;
1590 
1591     // All these spellings take an identifier argument.
1592     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
1593     std::set<std::string> Emitted;
1594     for (const auto &S : Spellings) {
1595       if (Emitted.insert(S.name()).second)
1596         OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
1597     }
1598   }
1599   OS << "#endif // CLANG_ATTR_IDENTIFIER_ARG_LIST\n\n";
1600 }
1601 
1602 namespace clang {
1603 
1604 // Emits the class definitions for attributes.
EmitClangAttrClass(RecordKeeper & Records,raw_ostream & OS)1605 void EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS) {
1606   emitSourceFileHeader("Attribute classes' definitions", OS);
1607 
1608   OS << "#ifndef LLVM_CLANG_ATTR_CLASSES_INC\n";
1609   OS << "#define LLVM_CLANG_ATTR_CLASSES_INC\n\n";
1610 
1611   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1612 
1613   for (const auto *Attr : Attrs) {
1614     const Record &R = *Attr;
1615 
1616     // FIXME: Currently, documentation is generated as-needed due to the fact
1617     // that there is no way to allow a generated project "reach into" the docs
1618     // directory (for instance, it may be an out-of-tree build). However, we want
1619     // to ensure that every attribute has a Documentation field, and produce an
1620     // error if it has been neglected. Otherwise, the on-demand generation which
1621     // happens server-side will fail. This code is ensuring that functionality,
1622     // even though this Emitter doesn't technically need the documentation.
1623     // When attribute documentation can be generated as part of the build
1624     // itself, this code can be removed.
1625     (void)R.getValueAsListOfDefs("Documentation");
1626 
1627     if (!R.getValueAsBit("ASTNode"))
1628       continue;
1629 
1630     ArrayRef<std::pair<Record *, SMRange>> Supers = R.getSuperClasses();
1631     assert(!Supers.empty() && "Forgot to specify a superclass for the attr");
1632     std::string SuperName;
1633     for (const auto &Super : llvm::reverse(Supers)) {
1634       const Record *R = Super.first;
1635       if (R->getName() != "TargetSpecificAttr" && SuperName.empty())
1636         SuperName = R->getName();
1637     }
1638 
1639     OS << "class " << R.getName() << "Attr : public " << SuperName << " {\n";
1640 
1641     std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
1642     std::vector<std::unique_ptr<Argument>> Args;
1643     Args.reserve(ArgRecords.size());
1644 
1645     bool HasOptArg = false;
1646     bool HasFakeArg = false;
1647     for (const auto *ArgRecord : ArgRecords) {
1648       Args.emplace_back(createArgument(*ArgRecord, R.getName()));
1649       Args.back()->writeDeclarations(OS);
1650       OS << "\n\n";
1651 
1652       // For these purposes, fake takes priority over optional.
1653       if (Args.back()->isFake()) {
1654         HasFakeArg = true;
1655       } else if (Args.back()->isOptional()) {
1656         HasOptArg = true;
1657       }
1658     }
1659 
1660     OS << "public:\n";
1661 
1662     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
1663 
1664     // If there are zero or one spellings, all spelling-related functionality
1665     // can be elided. If all of the spellings share the same name, the spelling
1666     // functionality can also be elided.
1667     bool ElideSpelling = (Spellings.size() <= 1) ||
1668                          SpellingNamesAreCommon(Spellings);
1669 
1670     // This maps spelling index values to semantic Spelling enumerants.
1671     SemanticSpellingMap SemanticToSyntacticMap;
1672 
1673     if (!ElideSpelling)
1674       OS << CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
1675 
1676     // Emit CreateImplicit factory methods.
1677     auto emitCreateImplicit = [&](bool emitFake) {
1678       OS << "  static " << R.getName() << "Attr *CreateImplicit(";
1679       OS << "ASTContext &Ctx";
1680       if (!ElideSpelling)
1681         OS << ", Spelling S";
1682       for (auto const &ai : Args) {
1683         if (ai->isFake() && !emitFake) continue;
1684         OS << ", ";
1685         ai->writeCtorParameters(OS);
1686       }
1687       OS << ", SourceRange Loc = SourceRange()";
1688       OS << ") {\n";
1689       OS << "    auto *A = new (Ctx) " << R.getName();
1690       OS << "Attr(Loc, Ctx, ";
1691       for (auto const &ai : Args) {
1692         if (ai->isFake() && !emitFake) continue;
1693         ai->writeImplicitCtorArgs(OS);
1694         OS << ", ";
1695       }
1696       OS << (ElideSpelling ? "0" : "S") << ");\n";
1697       OS << "    A->setImplicit(true);\n";
1698       OS << "    return A;\n  }\n\n";
1699     };
1700 
1701     // Emit a CreateImplicit that takes all the arguments.
1702     emitCreateImplicit(true);
1703 
1704     // Emit a CreateImplicit that takes all the non-fake arguments.
1705     if (HasFakeArg) {
1706       emitCreateImplicit(false);
1707     }
1708 
1709     // Emit constructors.
1710     auto emitCtor = [&](bool emitOpt, bool emitFake) {
1711       auto shouldEmitArg = [=](const std::unique_ptr<Argument> &arg) {
1712         if (arg->isFake()) return emitFake;
1713         if (arg->isOptional()) return emitOpt;
1714         return true;
1715       };
1716 
1717       OS << "  " << R.getName() << "Attr(SourceRange R, ASTContext &Ctx\n";
1718       for (auto const &ai : Args) {
1719         if (!shouldEmitArg(ai)) continue;
1720         OS << "              , ";
1721         ai->writeCtorParameters(OS);
1722         OS << "\n";
1723       }
1724 
1725       OS << "              , ";
1726       OS << "unsigned SI\n";
1727 
1728       OS << "             )\n";
1729       OS << "    : " << SuperName << "(attr::" << R.getName() << ", R, SI, "
1730          << ( R.getValueAsBit("LateParsed") ? "true" : "false" ) << ", "
1731          << ( R.getValueAsBit("DuplicatesAllowedWhileMerging") ? "true" : "false" ) << ")\n";
1732 
1733       for (auto const &ai : Args) {
1734         OS << "              , ";
1735         if (!shouldEmitArg(ai)) {
1736           ai->writeCtorDefaultInitializers(OS);
1737         } else {
1738           ai->writeCtorInitializers(OS);
1739         }
1740         OS << "\n";
1741       }
1742 
1743       OS << "  {\n";
1744 
1745       for (auto const &ai : Args) {
1746         if (!shouldEmitArg(ai)) continue;
1747         ai->writeCtorBody(OS);
1748       }
1749       OS << "  }\n\n";
1750     };
1751 
1752     // Emit a constructor that includes all the arguments.
1753     // This is necessary for cloning.
1754     emitCtor(true, true);
1755 
1756     // Emit a constructor that takes all the non-fake arguments.
1757     if (HasFakeArg) {
1758       emitCtor(true, false);
1759     }
1760 
1761     // Emit a constructor that takes all the non-fake, non-optional arguments.
1762     if (HasOptArg) {
1763       emitCtor(false, false);
1764     }
1765 
1766     OS << "  " << R.getName() << "Attr *clone(ASTContext &C) const;\n";
1767     OS << "  void printPretty(raw_ostream &OS,\n"
1768        << "                   const PrintingPolicy &Policy) const;\n";
1769     OS << "  const char *getSpelling() const;\n";
1770 
1771     if (!ElideSpelling) {
1772       assert(!SemanticToSyntacticMap.empty() && "Empty semantic mapping list");
1773       OS << "  Spelling getSemanticSpelling() const {\n";
1774       WriteSemanticSpellingSwitch("SpellingListIndex", SemanticToSyntacticMap,
1775                                   OS);
1776       OS << "  }\n";
1777     }
1778 
1779     writeAttrAccessorDefinition(R, OS);
1780 
1781     for (auto const &ai : Args) {
1782       ai->writeAccessors(OS);
1783       OS << "\n\n";
1784 
1785       // Don't write conversion routines for fake arguments.
1786       if (ai->isFake()) continue;
1787 
1788       if (ai->isEnumArg())
1789         static_cast<const EnumArgument *>(ai.get())->writeConversion(OS);
1790       else if (ai->isVariadicEnumArg())
1791         static_cast<const VariadicEnumArgument *>(ai.get())
1792             ->writeConversion(OS);
1793     }
1794 
1795     OS << R.getValueAsString("AdditionalMembers");
1796     OS << "\n\n";
1797 
1798     OS << "  static bool classof(const Attr *A) { return A->getKind() == "
1799        << "attr::" << R.getName() << "; }\n";
1800 
1801     OS << "};\n\n";
1802   }
1803 
1804   OS << "#endif // LLVM_CLANG_ATTR_CLASSES_INC\n";
1805 }
1806 
1807 // Emits the class method definitions for attributes.
EmitClangAttrImpl(RecordKeeper & Records,raw_ostream & OS)1808 void EmitClangAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
1809   emitSourceFileHeader("Attribute classes' member function definitions", OS);
1810 
1811   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1812 
1813   for (auto *Attr : Attrs) {
1814     Record &R = *Attr;
1815 
1816     if (!R.getValueAsBit("ASTNode"))
1817       continue;
1818 
1819     std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
1820     std::vector<std::unique_ptr<Argument>> Args;
1821     for (const auto *Arg : ArgRecords)
1822       Args.emplace_back(createArgument(*Arg, R.getName()));
1823 
1824     for (auto const &ai : Args)
1825       ai->writeAccessorDefinitions(OS);
1826 
1827     OS << R.getName() << "Attr *" << R.getName()
1828        << "Attr::clone(ASTContext &C) const {\n";
1829     OS << "  auto *A = new (C) " << R.getName() << "Attr(getLocation(), C";
1830     for (auto const &ai : Args) {
1831       OS << ", ";
1832       ai->writeCloneArgs(OS);
1833     }
1834     OS << ", getSpellingListIndex());\n";
1835     OS << "  A->Inherited = Inherited;\n";
1836     OS << "  A->IsPackExpansion = IsPackExpansion;\n";
1837     OS << "  A->Implicit = Implicit;\n";
1838     OS << "  return A;\n}\n\n";
1839 
1840     writePrettyPrintFunction(R, Args, OS);
1841     writeGetSpellingFunction(R, OS);
1842   }
1843 
1844   // Instead of relying on virtual dispatch we just create a huge dispatch
1845   // switch. This is both smaller and faster than virtual functions.
1846   auto EmitFunc = [&](const char *Method) {
1847     OS << "  switch (getKind()) {\n";
1848     for (const auto *Attr : Attrs) {
1849       const Record &R = *Attr;
1850       if (!R.getValueAsBit("ASTNode"))
1851         continue;
1852 
1853       OS << "  case attr::" << R.getName() << ":\n";
1854       OS << "    return cast<" << R.getName() << "Attr>(this)->" << Method
1855          << ";\n";
1856     }
1857     OS << "  }\n";
1858     OS << "  llvm_unreachable(\"Unexpected attribute kind!\");\n";
1859     OS << "}\n\n";
1860   };
1861 
1862   OS << "const char *Attr::getSpelling() const {\n";
1863   EmitFunc("getSpelling()");
1864 
1865   OS << "Attr *Attr::clone(ASTContext &C) const {\n";
1866   EmitFunc("clone(C)");
1867 
1868   OS << "void Attr::printPretty(raw_ostream &OS, "
1869         "const PrintingPolicy &Policy) const {\n";
1870   EmitFunc("printPretty(OS, Policy)");
1871 }
1872 
1873 } // end namespace clang
1874 
emitAttrList(raw_ostream & OS,StringRef Class,const std::vector<Record * > & AttrList)1875 static void emitAttrList(raw_ostream &OS, StringRef Class,
1876                          const std::vector<Record*> &AttrList) {
1877   for (auto Cur : AttrList) {
1878     OS << Class << "(" << Cur->getName() << ")\n";
1879   }
1880 }
1881 
1882 // Determines if an attribute has a Pragma spelling.
AttrHasPragmaSpelling(const Record * R)1883 static bool AttrHasPragmaSpelling(const Record *R) {
1884   std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*R);
1885   return std::find_if(Spellings.begin(), Spellings.end(),
1886                       [](const FlattenedSpelling &S) {
1887            return S.variety() == "Pragma";
1888          }) != Spellings.end();
1889 }
1890 
1891 namespace {
1892 
1893   struct AttrClassDescriptor {
1894     const char * const MacroName;
1895     const char * const TableGenName;
1896   };
1897 
1898 } // end anonymous namespace
1899 
1900 static const AttrClassDescriptor AttrClassDescriptors[] = {
1901   { "ATTR", "Attr" },
1902   { "STMT_ATTR", "StmtAttr" },
1903   { "INHERITABLE_ATTR", "InheritableAttr" },
1904   { "INHERITABLE_PARAM_ATTR", "InheritableParamAttr" },
1905   { "PARAMETER_ABI_ATTR", "ParameterABIAttr" }
1906 };
1907 
emitDefaultDefine(raw_ostream & OS,StringRef name,const char * superName)1908 static void emitDefaultDefine(raw_ostream &OS, StringRef name,
1909                               const char *superName) {
1910   OS << "#ifndef " << name << "\n";
1911   OS << "#define " << name << "(NAME) ";
1912   if (superName) OS << superName << "(NAME)";
1913   OS << "\n#endif\n\n";
1914 }
1915 
1916 namespace {
1917 
1918   /// A class of attributes.
1919   struct AttrClass {
1920     const AttrClassDescriptor &Descriptor;
1921     Record *TheRecord;
1922     AttrClass *SuperClass = nullptr;
1923     std::vector<AttrClass*> SubClasses;
1924     std::vector<Record*> Attrs;
1925 
AttrClass__anonec8f106a0911::AttrClass1926     AttrClass(const AttrClassDescriptor &Descriptor, Record *R)
1927       : Descriptor(Descriptor), TheRecord(R) {}
1928 
emitDefaultDefines__anonec8f106a0911::AttrClass1929     void emitDefaultDefines(raw_ostream &OS) const {
1930       // Default the macro unless this is a root class (i.e. Attr).
1931       if (SuperClass) {
1932         emitDefaultDefine(OS, Descriptor.MacroName,
1933                           SuperClass->Descriptor.MacroName);
1934       }
1935     }
1936 
emitUndefs__anonec8f106a0911::AttrClass1937     void emitUndefs(raw_ostream &OS) const {
1938       OS << "#undef " << Descriptor.MacroName << "\n";
1939     }
1940 
emitAttrList__anonec8f106a0911::AttrClass1941     void emitAttrList(raw_ostream &OS) const {
1942       for (auto SubClass : SubClasses) {
1943         SubClass->emitAttrList(OS);
1944       }
1945 
1946       ::emitAttrList(OS, Descriptor.MacroName, Attrs);
1947     }
1948 
classifyAttrOnRoot__anonec8f106a0911::AttrClass1949     void classifyAttrOnRoot(Record *Attr) {
1950       bool result = classifyAttr(Attr);
1951       assert(result && "failed to classify on root"); (void) result;
1952     }
1953 
emitAttrRange__anonec8f106a0911::AttrClass1954     void emitAttrRange(raw_ostream &OS) const {
1955       OS << "ATTR_RANGE(" << Descriptor.TableGenName
1956          << ", " << getFirstAttr()->getName()
1957          << ", " << getLastAttr()->getName() << ")\n";
1958     }
1959 
1960   private:
classifyAttr__anonec8f106a0911::AttrClass1961     bool classifyAttr(Record *Attr) {
1962       // Check all the subclasses.
1963       for (auto SubClass : SubClasses) {
1964         if (SubClass->classifyAttr(Attr))
1965           return true;
1966       }
1967 
1968       // It's not more specific than this class, but it might still belong here.
1969       if (Attr->isSubClassOf(TheRecord)) {
1970         Attrs.push_back(Attr);
1971         return true;
1972       }
1973 
1974       return false;
1975     }
1976 
getFirstAttr__anonec8f106a0911::AttrClass1977     Record *getFirstAttr() const {
1978       if (!SubClasses.empty())
1979         return SubClasses.front()->getFirstAttr();
1980       return Attrs.front();
1981     }
1982 
getLastAttr__anonec8f106a0911::AttrClass1983     Record *getLastAttr() const {
1984       if (!Attrs.empty())
1985         return Attrs.back();
1986       return SubClasses.back()->getLastAttr();
1987     }
1988   };
1989 
1990   /// The entire hierarchy of attribute classes.
1991   class AttrClassHierarchy {
1992     std::vector<std::unique_ptr<AttrClass>> Classes;
1993 
1994   public:
AttrClassHierarchy(RecordKeeper & Records)1995     AttrClassHierarchy(RecordKeeper &Records) {
1996       // Find records for all the classes.
1997       for (auto &Descriptor : AttrClassDescriptors) {
1998         Record *ClassRecord = Records.getClass(Descriptor.TableGenName);
1999         AttrClass *Class = new AttrClass(Descriptor, ClassRecord);
2000         Classes.emplace_back(Class);
2001       }
2002 
2003       // Link up the hierarchy.
2004       for (auto &Class : Classes) {
2005         if (AttrClass *SuperClass = findSuperClass(Class->TheRecord)) {
2006           Class->SuperClass = SuperClass;
2007           SuperClass->SubClasses.push_back(Class.get());
2008         }
2009       }
2010 
2011 #ifndef NDEBUG
2012       for (auto i = Classes.begin(), e = Classes.end(); i != e; ++i) {
2013         assert((i == Classes.begin()) == ((*i)->SuperClass == nullptr) &&
2014                "only the first class should be a root class!");
2015       }
2016 #endif
2017     }
2018 
emitDefaultDefines(raw_ostream & OS) const2019     void emitDefaultDefines(raw_ostream &OS) const {
2020       for (auto &Class : Classes) {
2021         Class->emitDefaultDefines(OS);
2022       }
2023     }
2024 
emitUndefs(raw_ostream & OS) const2025     void emitUndefs(raw_ostream &OS) const {
2026       for (auto &Class : Classes) {
2027         Class->emitUndefs(OS);
2028       }
2029     }
2030 
emitAttrLists(raw_ostream & OS) const2031     void emitAttrLists(raw_ostream &OS) const {
2032       // Just start from the root class.
2033       Classes[0]->emitAttrList(OS);
2034     }
2035 
emitAttrRanges(raw_ostream & OS) const2036     void emitAttrRanges(raw_ostream &OS) const {
2037       for (auto &Class : Classes)
2038         Class->emitAttrRange(OS);
2039     }
2040 
classifyAttr(Record * Attr)2041     void classifyAttr(Record *Attr) {
2042       // Add the attribute to the root class.
2043       Classes[0]->classifyAttrOnRoot(Attr);
2044     }
2045 
2046   private:
findClassByRecord(Record * R) const2047     AttrClass *findClassByRecord(Record *R) const {
2048       for (auto &Class : Classes) {
2049         if (Class->TheRecord == R)
2050           return Class.get();
2051       }
2052       return nullptr;
2053     }
2054 
findSuperClass(Record * R) const2055     AttrClass *findSuperClass(Record *R) const {
2056       // TableGen flattens the superclass list, so we just need to walk it
2057       // in reverse.
2058       auto SuperClasses = R->getSuperClasses();
2059       for (signed i = 0, e = SuperClasses.size(); i != e; ++i) {
2060         auto SuperClass = findClassByRecord(SuperClasses[e - i - 1].first);
2061         if (SuperClass) return SuperClass;
2062       }
2063       return nullptr;
2064     }
2065   };
2066 
2067 } // end anonymous namespace
2068 
2069 namespace clang {
2070 
2071 // Emits the enumeration list for attributes.
EmitClangAttrList(RecordKeeper & Records,raw_ostream & OS)2072 void EmitClangAttrList(RecordKeeper &Records, raw_ostream &OS) {
2073   emitSourceFileHeader("List of all attributes that Clang recognizes", OS);
2074 
2075   AttrClassHierarchy Hierarchy(Records);
2076 
2077   // Add defaulting macro definitions.
2078   Hierarchy.emitDefaultDefines(OS);
2079   emitDefaultDefine(OS, "PRAGMA_SPELLING_ATTR", nullptr);
2080 
2081   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2082   std::vector<Record *> PragmaAttrs;
2083   for (auto *Attr : Attrs) {
2084     if (!Attr->getValueAsBit("ASTNode"))
2085       continue;
2086 
2087     // Add the attribute to the ad-hoc groups.
2088     if (AttrHasPragmaSpelling(Attr))
2089       PragmaAttrs.push_back(Attr);
2090 
2091     // Place it in the hierarchy.
2092     Hierarchy.classifyAttr(Attr);
2093   }
2094 
2095   // Emit the main attribute list.
2096   Hierarchy.emitAttrLists(OS);
2097 
2098   // Emit the ad hoc groups.
2099   emitAttrList(OS, "PRAGMA_SPELLING_ATTR", PragmaAttrs);
2100 
2101   // Emit the attribute ranges.
2102   OS << "#ifdef ATTR_RANGE\n";
2103   Hierarchy.emitAttrRanges(OS);
2104   OS << "#undef ATTR_RANGE\n";
2105   OS << "#endif\n";
2106 
2107   Hierarchy.emitUndefs(OS);
2108   OS << "#undef PRAGMA_SPELLING_ATTR\n";
2109 }
2110 
2111 // Emits the code to read an attribute from a precompiled header.
EmitClangAttrPCHRead(RecordKeeper & Records,raw_ostream & OS)2112 void EmitClangAttrPCHRead(RecordKeeper &Records, raw_ostream &OS) {
2113   emitSourceFileHeader("Attribute deserialization code", OS);
2114 
2115   Record *InhClass = Records.getClass("InheritableAttr");
2116   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"),
2117                        ArgRecords;
2118   std::vector<std::unique_ptr<Argument>> Args;
2119 
2120   OS << "  switch (Kind) {\n";
2121   for (const auto *Attr : Attrs) {
2122     const Record &R = *Attr;
2123     if (!R.getValueAsBit("ASTNode"))
2124       continue;
2125 
2126     OS << "  case attr::" << R.getName() << ": {\n";
2127     if (R.isSubClassOf(InhClass))
2128       OS << "    bool isInherited = Record[Idx++];\n";
2129     OS << "    bool isImplicit = Record[Idx++];\n";
2130     OS << "    unsigned Spelling = Record[Idx++];\n";
2131     ArgRecords = R.getValueAsListOfDefs("Args");
2132     Args.clear();
2133     for (const auto *Arg : ArgRecords) {
2134       Args.emplace_back(createArgument(*Arg, R.getName()));
2135       Args.back()->writePCHReadDecls(OS);
2136     }
2137     OS << "    New = new (Context) " << R.getName() << "Attr(Range, Context";
2138     for (auto const &ri : Args) {
2139       OS << ", ";
2140       ri->writePCHReadArgs(OS);
2141     }
2142     OS << ", Spelling);\n";
2143     if (R.isSubClassOf(InhClass))
2144       OS << "    cast<InheritableAttr>(New)->setInherited(isInherited);\n";
2145     OS << "    New->setImplicit(isImplicit);\n";
2146     OS << "    break;\n";
2147     OS << "  }\n";
2148   }
2149   OS << "  }\n";
2150 }
2151 
2152 // Emits the code to write an attribute to a precompiled header.
EmitClangAttrPCHWrite(RecordKeeper & Records,raw_ostream & OS)2153 void EmitClangAttrPCHWrite(RecordKeeper &Records, raw_ostream &OS) {
2154   emitSourceFileHeader("Attribute serialization code", OS);
2155 
2156   Record *InhClass = Records.getClass("InheritableAttr");
2157   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
2158 
2159   OS << "  switch (A->getKind()) {\n";
2160   for (const auto *Attr : Attrs) {
2161     const Record &R = *Attr;
2162     if (!R.getValueAsBit("ASTNode"))
2163       continue;
2164     OS << "  case attr::" << R.getName() << ": {\n";
2165     Args = R.getValueAsListOfDefs("Args");
2166     if (R.isSubClassOf(InhClass) || !Args.empty())
2167       OS << "    const auto *SA = cast<" << R.getName()
2168          << "Attr>(A);\n";
2169     if (R.isSubClassOf(InhClass))
2170       OS << "    Record.push_back(SA->isInherited());\n";
2171     OS << "    Record.push_back(A->isImplicit());\n";
2172     OS << "    Record.push_back(A->getSpellingListIndex());\n";
2173 
2174     for (const auto *Arg : Args)
2175       createArgument(*Arg, R.getName())->writePCHWrite(OS);
2176     OS << "    break;\n";
2177     OS << "  }\n";
2178   }
2179   OS << "  }\n";
2180 }
2181 
2182 // Generate a conditional expression to check if the current target satisfies
2183 // the conditions for a TargetSpecificAttr record, and append the code for
2184 // those checks to the Test string. If the FnName string pointer is non-null,
2185 // append a unique suffix to distinguish this set of target checks from other
2186 // TargetSpecificAttr records.
GenerateTargetSpecificAttrChecks(const Record * R,std::vector<std::string> & Arches,std::string & Test,std::string * FnName)2187 static void GenerateTargetSpecificAttrChecks(const Record *R,
2188                                              std::vector<std::string> &Arches,
2189                                              std::string &Test,
2190                                              std::string *FnName) {
2191   // It is assumed that there will be an llvm::Triple object
2192   // named "T" and a TargetInfo object named "Target" within
2193   // scope that can be used to determine whether the attribute exists in
2194   // a given target.
2195   Test += "(";
2196 
2197   for (auto I = Arches.begin(), E = Arches.end(); I != E; ++I) {
2198     std::string Part = *I;
2199     Test += "T.getArch() == llvm::Triple::" + Part;
2200     if (I + 1 != E)
2201       Test += " || ";
2202     if (FnName)
2203       *FnName += Part;
2204   }
2205   Test += ")";
2206 
2207   // If the attribute is specific to particular OSes, check those.
2208   if (!R->isValueUnset("OSes")) {
2209     // We know that there was at least one arch test, so we need to and in the
2210     // OS tests.
2211     Test += " && (";
2212     std::vector<std::string> OSes = R->getValueAsListOfStrings("OSes");
2213     for (auto I = OSes.begin(), E = OSes.end(); I != E; ++I) {
2214       std::string Part = *I;
2215 
2216       Test += "T.getOS() == llvm::Triple::" + Part;
2217       if (I + 1 != E)
2218         Test += " || ";
2219       if (FnName)
2220         *FnName += Part;
2221     }
2222     Test += ")";
2223   }
2224 
2225   // If one or more CXX ABIs are specified, check those as well.
2226   if (!R->isValueUnset("CXXABIs")) {
2227     Test += " && (";
2228     std::vector<std::string> CXXABIs = R->getValueAsListOfStrings("CXXABIs");
2229     for (auto I = CXXABIs.begin(), E = CXXABIs.end(); I != E; ++I) {
2230       std::string Part = *I;
2231       Test += "Target.getCXXABI().getKind() == TargetCXXABI::" + Part;
2232       if (I + 1 != E)
2233         Test += " || ";
2234       if (FnName)
2235         *FnName += Part;
2236     }
2237     Test += ")";
2238   }
2239 }
2240 
GenerateHasAttrSpellingStringSwitch(const std::vector<Record * > & Attrs,raw_ostream & OS,const std::string & Variety="",const std::string & Scope="")2241 static void GenerateHasAttrSpellingStringSwitch(
2242     const std::vector<Record *> &Attrs, raw_ostream &OS,
2243     const std::string &Variety = "", const std::string &Scope = "") {
2244   for (const auto *Attr : Attrs) {
2245     // C++11-style attributes have specific version information associated with
2246     // them. If the attribute has no scope, the version information must not
2247     // have the default value (1), as that's incorrect. Instead, the unscoped
2248     // attribute version information should be taken from the SD-6 standing
2249     // document, which can be found at:
2250     // https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations
2251     int Version = 1;
2252 
2253     if (Variety == "CXX11") {
2254         std::vector<Record *> Spellings = Attr->getValueAsListOfDefs("Spellings");
2255         for (const auto &Spelling : Spellings) {
2256           if (Spelling->getValueAsString("Variety") == "CXX11") {
2257             Version = static_cast<int>(Spelling->getValueAsInt("Version"));
2258             if (Scope.empty() && Version == 1)
2259               PrintError(Spelling->getLoc(), "C++ standard attributes must "
2260               "have valid version information.");
2261             break;
2262           }
2263       }
2264     }
2265 
2266     std::string Test;
2267     if (Attr->isSubClassOf("TargetSpecificAttr")) {
2268       const Record *R = Attr->getValueAsDef("Target");
2269       std::vector<std::string> Arches = R->getValueAsListOfStrings("Arches");
2270       GenerateTargetSpecificAttrChecks(R, Arches, Test, nullptr);
2271 
2272       // If this is the C++11 variety, also add in the LangOpts test.
2273       if (Variety == "CXX11")
2274         Test += " && LangOpts.CPlusPlus11";
2275     } else if (Variety == "CXX11")
2276       // C++11 mode should be checked against LangOpts, which is presumed to be
2277       // present in the caller.
2278       Test = "LangOpts.CPlusPlus11";
2279 
2280     std::string TestStr =
2281         !Test.empty() ? Test + " ? " + llvm::itostr(Version) + " : 0" : "1";
2282     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
2283     for (const auto &S : Spellings)
2284       if (Variety.empty() || (Variety == S.variety() &&
2285                               (Scope.empty() || Scope == S.nameSpace())))
2286         OS << "    .Case(\"" << S.name() << "\", " << TestStr << ")\n";
2287   }
2288   OS << "    .Default(0);\n";
2289 }
2290 
2291 // Emits the list of spellings for attributes.
EmitClangAttrHasAttrImpl(RecordKeeper & Records,raw_ostream & OS)2292 void EmitClangAttrHasAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
2293   emitSourceFileHeader("Code to implement the __has_attribute logic", OS);
2294 
2295   // Separate all of the attributes out into four group: generic, C++11, GNU,
2296   // and declspecs. Then generate a big switch statement for each of them.
2297   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2298   std::vector<Record *> Declspec, GNU, Pragma;
2299   std::map<std::string, std::vector<Record *>> CXX;
2300 
2301   // Walk over the list of all attributes, and split them out based on the
2302   // spelling variety.
2303   for (auto *R : Attrs) {
2304     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*R);
2305     for (const auto &SI : Spellings) {
2306       const std::string &Variety = SI.variety();
2307       if (Variety == "GNU")
2308         GNU.push_back(R);
2309       else if (Variety == "Declspec")
2310         Declspec.push_back(R);
2311       else if (Variety == "CXX11")
2312         CXX[SI.nameSpace()].push_back(R);
2313       else if (Variety == "Pragma")
2314         Pragma.push_back(R);
2315     }
2316   }
2317 
2318   OS << "const llvm::Triple &T = Target.getTriple();\n";
2319   OS << "switch (Syntax) {\n";
2320   OS << "case AttrSyntax::GNU:\n";
2321   OS << "  return llvm::StringSwitch<int>(Name)\n";
2322   GenerateHasAttrSpellingStringSwitch(GNU, OS, "GNU");
2323   OS << "case AttrSyntax::Declspec:\n";
2324   OS << "  return llvm::StringSwitch<int>(Name)\n";
2325   GenerateHasAttrSpellingStringSwitch(Declspec, OS, "Declspec");
2326   OS << "case AttrSyntax::Pragma:\n";
2327   OS << "  return llvm::StringSwitch<int>(Name)\n";
2328   GenerateHasAttrSpellingStringSwitch(Pragma, OS, "Pragma");
2329   OS << "case AttrSyntax::CXX: {\n";
2330   // C++11-style attributes are further split out based on the Scope.
2331   for (auto I = CXX.cbegin(), E = CXX.cend(); I != E; ++I) {
2332     if (I != CXX.begin())
2333       OS << " else ";
2334     if (I->first.empty())
2335       OS << "if (!Scope || Scope->getName() == \"\") {\n";
2336     else
2337       OS << "if (Scope->getName() == \"" << I->first << "\") {\n";
2338     OS << "  return llvm::StringSwitch<int>(Name)\n";
2339     GenerateHasAttrSpellingStringSwitch(I->second, OS, "CXX11", I->first);
2340     OS << "}";
2341   }
2342   OS << "\n}\n";
2343   OS << "}\n";
2344 }
2345 
EmitClangAttrSpellingListIndex(RecordKeeper & Records,raw_ostream & OS)2346 void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS) {
2347   emitSourceFileHeader("Code to translate different attribute spellings "
2348                        "into internal identifiers", OS);
2349 
2350   OS << "  switch (AttrKind) {\n";
2351 
2352   ParsedAttrMap Attrs = getParsedAttrList(Records);
2353   for (const auto &I : Attrs) {
2354     const Record &R = *I.second;
2355     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
2356     OS << "  case AT_" << I.first << ": {\n";
2357     for (unsigned I = 0; I < Spellings.size(); ++ I) {
2358       OS << "    if (Name == \"" << Spellings[I].name() << "\" && "
2359          << "SyntaxUsed == "
2360          << StringSwitch<unsigned>(Spellings[I].variety())
2361                 .Case("GNU", 0)
2362                 .Case("CXX11", 1)
2363                 .Case("Declspec", 2)
2364                 .Case("Keyword", 3)
2365                 .Case("Pragma", 4)
2366                 .Default(0)
2367          << " && Scope == \"" << Spellings[I].nameSpace() << "\")\n"
2368          << "        return " << I << ";\n";
2369     }
2370 
2371     OS << "    break;\n";
2372     OS << "  }\n";
2373   }
2374 
2375   OS << "  }\n";
2376   OS << "  return 0;\n";
2377 }
2378 
2379 // Emits code used by RecursiveASTVisitor to visit attributes
EmitClangAttrASTVisitor(RecordKeeper & Records,raw_ostream & OS)2380 void EmitClangAttrASTVisitor(RecordKeeper &Records, raw_ostream &OS) {
2381   emitSourceFileHeader("Used by RecursiveASTVisitor to visit attributes.", OS);
2382 
2383   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
2384 
2385   // Write method declarations for Traverse* methods.
2386   // We emit this here because we only generate methods for attributes that
2387   // are declared as ASTNodes.
2388   OS << "#ifdef ATTR_VISITOR_DECLS_ONLY\n\n";
2389   for (const auto *Attr : Attrs) {
2390     const Record &R = *Attr;
2391     if (!R.getValueAsBit("ASTNode"))
2392       continue;
2393     OS << "  bool Traverse"
2394        << R.getName() << "Attr(" << R.getName() << "Attr *A);\n";
2395     OS << "  bool Visit"
2396        << R.getName() << "Attr(" << R.getName() << "Attr *A) {\n"
2397        << "    return true; \n"
2398        << "  }\n";
2399   }
2400   OS << "\n#else // ATTR_VISITOR_DECLS_ONLY\n\n";
2401 
2402   // Write individual Traverse* methods for each attribute class.
2403   for (const auto *Attr : Attrs) {
2404     const Record &R = *Attr;
2405     if (!R.getValueAsBit("ASTNode"))
2406       continue;
2407 
2408     OS << "template <typename Derived>\n"
2409        << "bool VISITORCLASS<Derived>::Traverse"
2410        << R.getName() << "Attr(" << R.getName() << "Attr *A) {\n"
2411        << "  if (!getDerived().VisitAttr(A))\n"
2412        << "    return false;\n"
2413        << "  if (!getDerived().Visit" << R.getName() << "Attr(A))\n"
2414        << "    return false;\n";
2415 
2416     std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
2417     for (const auto *Arg : ArgRecords)
2418       createArgument(*Arg, R.getName())->writeASTVisitorTraversal(OS);
2419 
2420     OS << "  return true;\n";
2421     OS << "}\n\n";
2422   }
2423 
2424   // Write generic Traverse routine
2425   OS << "template <typename Derived>\n"
2426      << "bool VISITORCLASS<Derived>::TraverseAttr(Attr *A) {\n"
2427      << "  if (!A)\n"
2428      << "    return true;\n"
2429      << "\n"
2430      << "  switch (A->getKind()) {\n";
2431 
2432   for (const auto *Attr : Attrs) {
2433     const Record &R = *Attr;
2434     if (!R.getValueAsBit("ASTNode"))
2435       continue;
2436 
2437     OS << "    case attr::" << R.getName() << ":\n"
2438        << "      return getDerived().Traverse" << R.getName() << "Attr("
2439        << "cast<" << R.getName() << "Attr>(A));\n";
2440   }
2441   OS << "  }\n";  // end switch
2442   OS << "  llvm_unreachable(\"bad attribute kind\");\n";
2443   OS << "}\n";  // end function
2444   OS << "#endif  // ATTR_VISITOR_DECLS_ONLY\n";
2445 }
2446 
2447 // Emits code to instantiate dependent attributes on templates.
EmitClangAttrTemplateInstantiate(RecordKeeper & Records,raw_ostream & OS)2448 void EmitClangAttrTemplateInstantiate(RecordKeeper &Records, raw_ostream &OS) {
2449   emitSourceFileHeader("Template instantiation code for attributes", OS);
2450 
2451   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
2452 
2453   OS << "namespace clang {\n"
2454      << "namespace sema {\n\n"
2455      << "Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, "
2456      << "Sema &S,\n"
2457      << "        const MultiLevelTemplateArgumentList &TemplateArgs) {\n"
2458      << "  switch (At->getKind()) {\n";
2459 
2460   for (const auto *Attr : Attrs) {
2461     const Record &R = *Attr;
2462     if (!R.getValueAsBit("ASTNode"))
2463       continue;
2464 
2465     OS << "    case attr::" << R.getName() << ": {\n";
2466     bool ShouldClone = R.getValueAsBit("Clone");
2467 
2468     if (!ShouldClone) {
2469       OS << "      return nullptr;\n";
2470       OS << "    }\n";
2471       continue;
2472     }
2473 
2474     OS << "      const auto *A = cast<"
2475        << R.getName() << "Attr>(At);\n";
2476     bool TDependent = R.getValueAsBit("TemplateDependent");
2477 
2478     if (!TDependent) {
2479       OS << "      return A->clone(C);\n";
2480       OS << "    }\n";
2481       continue;
2482     }
2483 
2484     std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
2485     std::vector<std::unique_ptr<Argument>> Args;
2486     Args.reserve(ArgRecords.size());
2487 
2488     for (const auto *ArgRecord : ArgRecords)
2489       Args.emplace_back(createArgument(*ArgRecord, R.getName()));
2490 
2491     for (auto const &ai : Args)
2492       ai->writeTemplateInstantiation(OS);
2493 
2494     OS << "      return new (C) " << R.getName() << "Attr(A->getLocation(), C";
2495     for (auto const &ai : Args) {
2496       OS << ", ";
2497       ai->writeTemplateInstantiationArgs(OS);
2498     }
2499     OS << ", A->getSpellingListIndex());\n    }\n";
2500   }
2501   OS << "  } // end switch\n"
2502      << "  llvm_unreachable(\"Unknown attribute!\");\n"
2503      << "  return nullptr;\n"
2504      << "}\n\n"
2505      << "} // end namespace sema\n"
2506      << "} // end namespace clang\n";
2507 }
2508 
2509 // Emits the list of parsed attributes.
EmitClangAttrParsedAttrList(RecordKeeper & Records,raw_ostream & OS)2510 void EmitClangAttrParsedAttrList(RecordKeeper &Records, raw_ostream &OS) {
2511   emitSourceFileHeader("List of all attributes that Clang recognizes", OS);
2512 
2513   OS << "#ifndef PARSED_ATTR\n";
2514   OS << "#define PARSED_ATTR(NAME) NAME\n";
2515   OS << "#endif\n\n";
2516 
2517   ParsedAttrMap Names = getParsedAttrList(Records);
2518   for (const auto &I : Names) {
2519     OS << "PARSED_ATTR(" << I.first << ")\n";
2520   }
2521 }
2522 
isArgVariadic(const Record & R,StringRef AttrName)2523 static bool isArgVariadic(const Record &R, StringRef AttrName) {
2524   return createArgument(R, AttrName)->isVariadic();
2525 }
2526 
emitArgInfo(const Record & R,std::stringstream & OS)2527 static void emitArgInfo(const Record &R, std::stringstream &OS) {
2528   // This function will count the number of arguments specified for the
2529   // attribute and emit the number of required arguments followed by the
2530   // number of optional arguments.
2531   std::vector<Record *> Args = R.getValueAsListOfDefs("Args");
2532   unsigned ArgCount = 0, OptCount = 0;
2533   bool HasVariadic = false;
2534   for (const auto *Arg : Args) {
2535     Arg->getValueAsBit("Optional") ? ++OptCount : ++ArgCount;
2536     if (!HasVariadic && isArgVariadic(*Arg, R.getName()))
2537       HasVariadic = true;
2538   }
2539 
2540   // If there is a variadic argument, we will set the optional argument count
2541   // to its largest value. Since it's currently a 4-bit number, we set it to 15.
2542   OS << ArgCount << ", " << (HasVariadic ? 15 : OptCount);
2543 }
2544 
GenerateDefaultAppertainsTo(raw_ostream & OS)2545 static void GenerateDefaultAppertainsTo(raw_ostream &OS) {
2546   OS << "static bool defaultAppertainsTo(Sema &, const AttributeList &,";
2547   OS << "const Decl *) {\n";
2548   OS << "  return true;\n";
2549   OS << "}\n\n";
2550 }
2551 
CalculateDiagnostic(const Record & S)2552 static std::string CalculateDiagnostic(const Record &S) {
2553   // If the SubjectList object has a custom diagnostic associated with it,
2554   // return that directly.
2555   std::string CustomDiag = S.getValueAsString("CustomDiag");
2556   if (!CustomDiag.empty())
2557     return CustomDiag;
2558 
2559   // Given the list of subjects, determine what diagnostic best fits.
2560   enum {
2561     Func = 1U << 0,
2562     Var = 1U << 1,
2563     ObjCMethod = 1U << 2,
2564     Param = 1U << 3,
2565     Class = 1U << 4,
2566     GenericRecord = 1U << 5,
2567     Type = 1U << 6,
2568     ObjCIVar = 1U << 7,
2569     ObjCProp = 1U << 8,
2570     ObjCInterface = 1U << 9,
2571     Block = 1U << 10,
2572     Namespace = 1U << 11,
2573     Field = 1U << 12,
2574     CXXMethod = 1U << 13,
2575     ObjCProtocol = 1U << 14,
2576     Enum = 1U << 15
2577   };
2578   uint32_t SubMask = 0;
2579 
2580   std::vector<Record *> Subjects = S.getValueAsListOfDefs("Subjects");
2581   for (const auto *Subject : Subjects) {
2582     const Record &R = *Subject;
2583     std::string Name;
2584 
2585     if (R.isSubClassOf("SubsetSubject")) {
2586       PrintError(R.getLoc(), "SubsetSubjects should use a custom diagnostic");
2587       // As a fallback, look through the SubsetSubject to see what its base
2588       // type is, and use that. This needs to be updated if SubsetSubjects
2589       // are allowed within other SubsetSubjects.
2590       Name = R.getValueAsDef("Base")->getName();
2591     } else
2592       Name = R.getName();
2593 
2594     uint32_t V = StringSwitch<uint32_t>(Name)
2595                    .Case("Function", Func)
2596                    .Case("Var", Var)
2597                    .Case("ObjCMethod", ObjCMethod)
2598                    .Case("ParmVar", Param)
2599                    .Case("TypedefName", Type)
2600                    .Case("ObjCIvar", ObjCIVar)
2601                    .Case("ObjCProperty", ObjCProp)
2602                    .Case("Record", GenericRecord)
2603                    .Case("ObjCInterface", ObjCInterface)
2604                    .Case("ObjCProtocol", ObjCProtocol)
2605                    .Case("Block", Block)
2606                    .Case("CXXRecord", Class)
2607                    .Case("Namespace", Namespace)
2608                    .Case("Field", Field)
2609                    .Case("CXXMethod", CXXMethod)
2610                    .Case("Enum", Enum)
2611                    .Default(0);
2612     if (!V) {
2613       // Something wasn't in our mapping, so be helpful and let the developer
2614       // know about it.
2615       PrintFatalError(R.getLoc(), "Unknown subject type: " + R.getName());
2616       return "";
2617     }
2618 
2619     SubMask |= V;
2620   }
2621 
2622   switch (SubMask) {
2623     // For the simple cases where there's only a single entry in the mask, we
2624     // don't have to resort to bit fiddling.
2625     case Func:  return "ExpectedFunction";
2626     case Var:   return "ExpectedVariable";
2627     case Param: return "ExpectedParameter";
2628     case Class: return "ExpectedClass";
2629     case Enum:  return "ExpectedEnum";
2630     case CXXMethod:
2631       // FIXME: Currently, this maps to ExpectedMethod based on existing code,
2632       // but should map to something a bit more accurate at some point.
2633     case ObjCMethod:  return "ExpectedMethod";
2634     case Type:  return "ExpectedType";
2635     case ObjCInterface: return "ExpectedObjectiveCInterface";
2636     case ObjCProtocol: return "ExpectedObjectiveCProtocol";
2637 
2638     // "GenericRecord" means struct, union or class; check the language options
2639     // and if not compiling for C++, strip off the class part. Note that this
2640     // relies on the fact that the context for this declares "Sema &S".
2641     case GenericRecord:
2642       return "(S.getLangOpts().CPlusPlus ? ExpectedStructOrUnionOrClass : "
2643                                            "ExpectedStructOrUnion)";
2644     case Func | ObjCMethod | Block: return "ExpectedFunctionMethodOrBlock";
2645     case Func | ObjCMethod | Class: return "ExpectedFunctionMethodOrClass";
2646     case Func | Param:
2647     case Func | ObjCMethod | Param: return "ExpectedFunctionMethodOrParameter";
2648     case Func | ObjCMethod: return "ExpectedFunctionOrMethod";
2649     case Func | Var: return "ExpectedVariableOrFunction";
2650 
2651     // If not compiling for C++, the class portion does not apply.
2652     case Func | Var | Class:
2653       return "(S.getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass : "
2654                                            "ExpectedVariableOrFunction)";
2655 
2656     case ObjCMethod | ObjCProp: return "ExpectedMethodOrProperty";
2657     case ObjCProtocol | ObjCInterface:
2658       return "ExpectedObjectiveCInterfaceOrProtocol";
2659     case Field | Var: return "ExpectedFieldOrGlobalVar";
2660   }
2661 
2662   PrintFatalError(S.getLoc(),
2663                   "Could not deduce diagnostic argument for Attr subjects");
2664 
2665   return "";
2666 }
2667 
GetSubjectWithSuffix(const Record * R)2668 static std::string GetSubjectWithSuffix(const Record *R) {
2669   std::string B = R->getName();
2670   if (B == "DeclBase")
2671     return "Decl";
2672   return B + "Decl";
2673 }
2674 
GenerateCustomAppertainsTo(const Record & Subject,raw_ostream & OS)2675 static std::string GenerateCustomAppertainsTo(const Record &Subject,
2676                                               raw_ostream &OS) {
2677   std::string FnName = "is" + Subject.getName();
2678 
2679   // If this code has already been generated, simply return the previous
2680   // instance of it.
2681   static std::set<std::string> CustomSubjectSet;
2682   auto I = CustomSubjectSet.find(FnName);
2683   if (I != CustomSubjectSet.end())
2684     return *I;
2685 
2686   Record *Base = Subject.getValueAsDef("Base");
2687 
2688   // Not currently support custom subjects within custom subjects.
2689   if (Base->isSubClassOf("SubsetSubject")) {
2690     PrintFatalError(Subject.getLoc(),
2691                     "SubsetSubjects within SubsetSubjects is not supported");
2692     return "";
2693   }
2694 
2695   OS << "static bool " << FnName << "(const Decl *D) {\n";
2696   OS << "  if (const auto *S = dyn_cast<";
2697   OS << GetSubjectWithSuffix(Base);
2698   OS << ">(D))\n";
2699   OS << "    return " << Subject.getValueAsString("CheckCode") << ";\n";
2700   OS << "  return false;\n";
2701   OS << "}\n\n";
2702 
2703   CustomSubjectSet.insert(FnName);
2704   return FnName;
2705 }
2706 
GenerateAppertainsTo(const Record & Attr,raw_ostream & OS)2707 static std::string GenerateAppertainsTo(const Record &Attr, raw_ostream &OS) {
2708   // If the attribute does not contain a Subjects definition, then use the
2709   // default appertainsTo logic.
2710   if (Attr.isValueUnset("Subjects"))
2711     return "defaultAppertainsTo";
2712 
2713   const Record *SubjectObj = Attr.getValueAsDef("Subjects");
2714   std::vector<Record*> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
2715 
2716   // If the list of subjects is empty, it is assumed that the attribute
2717   // appertains to everything.
2718   if (Subjects.empty())
2719     return "defaultAppertainsTo";
2720 
2721   bool Warn = SubjectObj->getValueAsDef("Diag")->getValueAsBit("Warn");
2722 
2723   // Otherwise, generate an appertainsTo check specific to this attribute which
2724   // checks all of the given subjects against the Decl passed in. Return the
2725   // name of that check to the caller.
2726   std::string FnName = "check" + Attr.getName() + "AppertainsTo";
2727   std::stringstream SS;
2728   SS << "static bool " << FnName << "(Sema &S, const AttributeList &Attr, ";
2729   SS << "const Decl *D) {\n";
2730   SS << "  if (";
2731   for (auto I = Subjects.begin(), E = Subjects.end(); I != E; ++I) {
2732     // If the subject has custom code associated with it, generate a function
2733     // for it. The function cannot be inlined into this check (yet) because it
2734     // requires the subject to be of a specific type, and were that information
2735     // inlined here, it would not support an attribute with multiple custom
2736     // subjects.
2737     if ((*I)->isSubClassOf("SubsetSubject")) {
2738       SS << "!" << GenerateCustomAppertainsTo(**I, OS) << "(D)";
2739     } else {
2740       SS << "!isa<" << GetSubjectWithSuffix(*I) << ">(D)";
2741     }
2742 
2743     if (I + 1 != E)
2744       SS << " && ";
2745   }
2746   SS << ") {\n";
2747   SS << "    S.Diag(Attr.getLoc(), diag::";
2748   SS << (Warn ? "warn_attribute_wrong_decl_type" :
2749                "err_attribute_wrong_decl_type");
2750   SS << ")\n";
2751   SS << "      << Attr.getName() << ";
2752   SS << CalculateDiagnostic(*SubjectObj) << ";\n";
2753   SS << "    return false;\n";
2754   SS << "  }\n";
2755   SS << "  return true;\n";
2756   SS << "}\n\n";
2757 
2758   OS << SS.str();
2759   return FnName;
2760 }
2761 
GenerateDefaultLangOptRequirements(raw_ostream & OS)2762 static void GenerateDefaultLangOptRequirements(raw_ostream &OS) {
2763   OS << "static bool defaultDiagnoseLangOpts(Sema &, ";
2764   OS << "const AttributeList &) {\n";
2765   OS << "  return true;\n";
2766   OS << "}\n\n";
2767 }
2768 
GenerateLangOptRequirements(const Record & R,raw_ostream & OS)2769 static std::string GenerateLangOptRequirements(const Record &R,
2770                                                raw_ostream &OS) {
2771   // If the attribute has an empty or unset list of language requirements,
2772   // return the default handler.
2773   std::vector<Record *> LangOpts = R.getValueAsListOfDefs("LangOpts");
2774   if (LangOpts.empty())
2775     return "defaultDiagnoseLangOpts";
2776 
2777   // Generate the test condition, as well as a unique function name for the
2778   // diagnostic test. The list of options should usually be short (one or two
2779   // options), and the uniqueness isn't strictly necessary (it is just for
2780   // codegen efficiency).
2781   std::string FnName = "check", Test;
2782   for (auto I = LangOpts.begin(), E = LangOpts.end(); I != E; ++I) {
2783     std::string Part = (*I)->getValueAsString("Name");
2784     if ((*I)->getValueAsBit("Negated"))
2785       Test += "!";
2786     Test += "S.LangOpts." + Part;
2787     if (I + 1 != E)
2788       Test += " || ";
2789     FnName += Part;
2790   }
2791   FnName += "LangOpts";
2792 
2793   // If this code has already been generated, simply return the previous
2794   // instance of it.
2795   static std::set<std::string> CustomLangOptsSet;
2796   auto I = CustomLangOptsSet.find(FnName);
2797   if (I != CustomLangOptsSet.end())
2798     return *I;
2799 
2800   OS << "static bool " << FnName << "(Sema &S, const AttributeList &Attr) {\n";
2801   OS << "  if (" << Test << ")\n";
2802   OS << "    return true;\n\n";
2803   OS << "  S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) ";
2804   OS << "<< Attr.getName();\n";
2805   OS << "  return false;\n";
2806   OS << "}\n\n";
2807 
2808   CustomLangOptsSet.insert(FnName);
2809   return FnName;
2810 }
2811 
GenerateDefaultTargetRequirements(raw_ostream & OS)2812 static void GenerateDefaultTargetRequirements(raw_ostream &OS) {
2813   OS << "static bool defaultTargetRequirements(const TargetInfo &) {\n";
2814   OS << "  return true;\n";
2815   OS << "}\n\n";
2816 }
2817 
GenerateTargetRequirements(const Record & Attr,const ParsedAttrMap & Dupes,raw_ostream & OS)2818 static std::string GenerateTargetRequirements(const Record &Attr,
2819                                               const ParsedAttrMap &Dupes,
2820                                               raw_ostream &OS) {
2821   // If the attribute is not a target specific attribute, return the default
2822   // target handler.
2823   if (!Attr.isSubClassOf("TargetSpecificAttr"))
2824     return "defaultTargetRequirements";
2825 
2826   // Get the list of architectures to be tested for.
2827   const Record *R = Attr.getValueAsDef("Target");
2828   std::vector<std::string> Arches = R->getValueAsListOfStrings("Arches");
2829   if (Arches.empty()) {
2830     PrintError(Attr.getLoc(), "Empty list of target architectures for a "
2831                               "target-specific attr");
2832     return "defaultTargetRequirements";
2833   }
2834 
2835   // If there are other attributes which share the same parsed attribute kind,
2836   // such as target-specific attributes with a shared spelling, collapse the
2837   // duplicate architectures. This is required because a shared target-specific
2838   // attribute has only one AttributeList::Kind enumeration value, but it
2839   // applies to multiple target architectures. In order for the attribute to be
2840   // considered valid, all of its architectures need to be included.
2841   if (!Attr.isValueUnset("ParseKind")) {
2842     std::string APK = Attr.getValueAsString("ParseKind");
2843     for (const auto &I : Dupes) {
2844       if (I.first == APK) {
2845         std::vector<std::string> DA = I.second->getValueAsDef("Target")
2846                                           ->getValueAsListOfStrings("Arches");
2847         std::copy(DA.begin(), DA.end(), std::back_inserter(Arches));
2848       }
2849     }
2850   }
2851 
2852   std::string FnName = "isTarget";
2853   std::string Test;
2854   GenerateTargetSpecificAttrChecks(R, Arches, Test, &FnName);
2855 
2856   // If this code has already been generated, simply return the previous
2857   // instance of it.
2858   static std::set<std::string> CustomTargetSet;
2859   auto I = CustomTargetSet.find(FnName);
2860   if (I != CustomTargetSet.end())
2861     return *I;
2862 
2863   OS << "static bool " << FnName << "(const TargetInfo &Target) {\n";
2864   OS << "  const llvm::Triple &T = Target.getTriple();\n";
2865   OS << "  return " << Test << ";\n";
2866   OS << "}\n\n";
2867 
2868   CustomTargetSet.insert(FnName);
2869   return FnName;
2870 }
2871 
GenerateDefaultSpellingIndexToSemanticSpelling(raw_ostream & OS)2872 static void GenerateDefaultSpellingIndexToSemanticSpelling(raw_ostream &OS) {
2873   OS << "static unsigned defaultSpellingIndexToSemanticSpelling("
2874      << "const AttributeList &Attr) {\n";
2875   OS << "  return UINT_MAX;\n";
2876   OS << "}\n\n";
2877 }
2878 
GenerateSpellingIndexToSemanticSpelling(const Record & Attr,raw_ostream & OS)2879 static std::string GenerateSpellingIndexToSemanticSpelling(const Record &Attr,
2880                                                            raw_ostream &OS) {
2881   // If the attribute does not have a semantic form, we can bail out early.
2882   if (!Attr.getValueAsBit("ASTNode"))
2883     return "defaultSpellingIndexToSemanticSpelling";
2884 
2885   std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
2886 
2887   // If there are zero or one spellings, or all of the spellings share the same
2888   // name, we can also bail out early.
2889   if (Spellings.size() <= 1 || SpellingNamesAreCommon(Spellings))
2890     return "defaultSpellingIndexToSemanticSpelling";
2891 
2892   // Generate the enumeration we will use for the mapping.
2893   SemanticSpellingMap SemanticToSyntacticMap;
2894   std::string Enum = CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
2895   std::string Name = Attr.getName() + "AttrSpellingMap";
2896 
2897   OS << "static unsigned " << Name << "(const AttributeList &Attr) {\n";
2898   OS << Enum;
2899   OS << "  unsigned Idx = Attr.getAttributeSpellingListIndex();\n";
2900   WriteSemanticSpellingSwitch("Idx", SemanticToSyntacticMap, OS);
2901   OS << "}\n\n";
2902 
2903   return Name;
2904 }
2905 
IsKnownToGCC(const Record & Attr)2906 static bool IsKnownToGCC(const Record &Attr) {
2907   // Look at the spellings for this subject; if there are any spellings which
2908   // claim to be known to GCC, the attribute is known to GCC.
2909   std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
2910   for (const auto &I : Spellings) {
2911     if (I.knownToGCC())
2912       return true;
2913   }
2914   return false;
2915 }
2916 
2917 /// Emits the parsed attribute helpers
EmitClangAttrParsedAttrImpl(RecordKeeper & Records,raw_ostream & OS)2918 void EmitClangAttrParsedAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
2919   emitSourceFileHeader("Parsed attribute helpers", OS);
2920 
2921   // Get the list of parsed attributes, and accept the optional list of
2922   // duplicates due to the ParseKind.
2923   ParsedAttrMap Dupes;
2924   ParsedAttrMap Attrs = getParsedAttrList(Records, &Dupes);
2925 
2926   // Generate the default appertainsTo, target and language option diagnostic,
2927   // and spelling list index mapping methods.
2928   GenerateDefaultAppertainsTo(OS);
2929   GenerateDefaultLangOptRequirements(OS);
2930   GenerateDefaultTargetRequirements(OS);
2931   GenerateDefaultSpellingIndexToSemanticSpelling(OS);
2932 
2933   // Generate the appertainsTo diagnostic methods and write their names into
2934   // another mapping. At the same time, generate the AttrInfoMap object
2935   // contents. Due to the reliance on generated code, use separate streams so
2936   // that code will not be interleaved.
2937   std::stringstream SS;
2938   for (auto I = Attrs.begin(), E = Attrs.end(); I != E; ++I) {
2939     // TODO: If the attribute's kind appears in the list of duplicates, that is
2940     // because it is a target-specific attribute that appears multiple times.
2941     // It would be beneficial to test whether the duplicates are "similar
2942     // enough" to each other to not cause problems. For instance, check that
2943     // the spellings are identical, and custom parsing rules match, etc.
2944 
2945     // We need to generate struct instances based off ParsedAttrInfo from
2946     // AttributeList.cpp.
2947     SS << "  { ";
2948     emitArgInfo(*I->second, SS);
2949     SS << ", " << I->second->getValueAsBit("HasCustomParsing");
2950     SS << ", " << I->second->isSubClassOf("TargetSpecificAttr");
2951     SS << ", " << I->second->isSubClassOf("TypeAttr");
2952     SS << ", " << I->second->isSubClassOf("StmtAttr");
2953     SS << ", " << IsKnownToGCC(*I->second);
2954     SS << ", " << GenerateAppertainsTo(*I->second, OS);
2955     SS << ", " << GenerateLangOptRequirements(*I->second, OS);
2956     SS << ", " << GenerateTargetRequirements(*I->second, Dupes, OS);
2957     SS << ", " << GenerateSpellingIndexToSemanticSpelling(*I->second, OS);
2958     SS << " }";
2959 
2960     if (I + 1 != E)
2961       SS << ",";
2962 
2963     SS << "  // AT_" << I->first << "\n";
2964   }
2965 
2966   OS << "static const ParsedAttrInfo AttrInfoMap[AttributeList::UnknownAttribute + 1] = {\n";
2967   OS << SS.str();
2968   OS << "};\n\n";
2969 }
2970 
2971 // Emits the kind list of parsed attributes
EmitClangAttrParsedAttrKinds(RecordKeeper & Records,raw_ostream & OS)2972 void EmitClangAttrParsedAttrKinds(RecordKeeper &Records, raw_ostream &OS) {
2973   emitSourceFileHeader("Attribute name matcher", OS);
2974 
2975   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2976   std::vector<StringMatcher::StringPair> GNU, Declspec, CXX11, Keywords, Pragma;
2977   std::set<std::string> Seen;
2978   for (const auto *A : Attrs) {
2979     const Record &Attr = *A;
2980 
2981     bool SemaHandler = Attr.getValueAsBit("SemaHandler");
2982     bool Ignored = Attr.getValueAsBit("Ignored");
2983     if (SemaHandler || Ignored) {
2984       // Attribute spellings can be shared between target-specific attributes,
2985       // and can be shared between syntaxes for the same attribute. For
2986       // instance, an attribute can be spelled GNU<"interrupt"> for an ARM-
2987       // specific attribute, or MSP430-specific attribute. Additionally, an
2988       // attribute can be spelled GNU<"dllexport"> and Declspec<"dllexport">
2989       // for the same semantic attribute. Ultimately, we need to map each of
2990       // these to a single AttributeList::Kind value, but the StringMatcher
2991       // class cannot handle duplicate match strings. So we generate a list of
2992       // string to match based on the syntax, and emit multiple string matchers
2993       // depending on the syntax used.
2994       std::string AttrName;
2995       if (Attr.isSubClassOf("TargetSpecificAttr") &&
2996           !Attr.isValueUnset("ParseKind")) {
2997         AttrName = Attr.getValueAsString("ParseKind");
2998         if (Seen.find(AttrName) != Seen.end())
2999           continue;
3000         Seen.insert(AttrName);
3001       } else
3002         AttrName = NormalizeAttrName(StringRef(Attr.getName())).str();
3003 
3004       std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
3005       for (const auto &S : Spellings) {
3006         const std::string &RawSpelling = S.name();
3007         std::vector<StringMatcher::StringPair> *Matches = nullptr;
3008         std::string Spelling;
3009         const std::string &Variety = S.variety();
3010         if (Variety == "CXX11") {
3011           Matches = &CXX11;
3012           Spelling += S.nameSpace();
3013           Spelling += "::";
3014         } else if (Variety == "GNU")
3015           Matches = &GNU;
3016         else if (Variety == "Declspec")
3017           Matches = &Declspec;
3018         else if (Variety == "Keyword")
3019           Matches = &Keywords;
3020         else if (Variety == "Pragma")
3021           Matches = &Pragma;
3022 
3023         assert(Matches && "Unsupported spelling variety found");
3024 
3025         Spelling += NormalizeAttrSpelling(RawSpelling);
3026         if (SemaHandler)
3027           Matches->push_back(StringMatcher::StringPair(Spelling,
3028                               "return AttributeList::AT_" + AttrName + ";"));
3029         else
3030           Matches->push_back(StringMatcher::StringPair(Spelling,
3031                               "return AttributeList::IgnoredAttribute;"));
3032       }
3033     }
3034   }
3035 
3036   OS << "static AttributeList::Kind getAttrKind(StringRef Name, ";
3037   OS << "AttributeList::Syntax Syntax) {\n";
3038   OS << "  if (AttributeList::AS_GNU == Syntax) {\n";
3039   StringMatcher("Name", GNU, OS).Emit();
3040   OS << "  } else if (AttributeList::AS_Declspec == Syntax) {\n";
3041   StringMatcher("Name", Declspec, OS).Emit();
3042   OS << "  } else if (AttributeList::AS_CXX11 == Syntax) {\n";
3043   StringMatcher("Name", CXX11, OS).Emit();
3044   OS << "  } else if (AttributeList::AS_Keyword == Syntax || ";
3045   OS << "AttributeList::AS_ContextSensitiveKeyword == Syntax) {\n";
3046   StringMatcher("Name", Keywords, OS).Emit();
3047   OS << "  } else if (AttributeList::AS_Pragma == Syntax) {\n";
3048   StringMatcher("Name", Pragma, OS).Emit();
3049   OS << "  }\n";
3050   OS << "  return AttributeList::UnknownAttribute;\n"
3051      << "}\n";
3052 }
3053 
3054 // Emits the code to dump an attribute.
EmitClangAttrDump(RecordKeeper & Records,raw_ostream & OS)3055 void EmitClangAttrDump(RecordKeeper &Records, raw_ostream &OS) {
3056   emitSourceFileHeader("Attribute dumper", OS);
3057 
3058   OS << "  switch (A->getKind()) {\n";
3059   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
3060   for (const auto *Attr : Attrs) {
3061     const Record &R = *Attr;
3062     if (!R.getValueAsBit("ASTNode"))
3063       continue;
3064     OS << "  case attr::" << R.getName() << ": {\n";
3065 
3066     // If the attribute has a semantically-meaningful name (which is determined
3067     // by whether there is a Spelling enumeration for it), then write out the
3068     // spelling used for the attribute.
3069     std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
3070     if (Spellings.size() > 1 && !SpellingNamesAreCommon(Spellings))
3071       OS << "    OS << \" \" << A->getSpelling();\n";
3072 
3073     Args = R.getValueAsListOfDefs("Args");
3074     if (!Args.empty()) {
3075       OS << "    const auto *SA = cast<" << R.getName()
3076          << "Attr>(A);\n";
3077       for (const auto *Arg : Args)
3078         createArgument(*Arg, R.getName())->writeDump(OS);
3079 
3080       for (const auto *AI : Args)
3081         createArgument(*AI, R.getName())->writeDumpChildren(OS);
3082     }
3083     OS <<
3084       "    break;\n"
3085       "  }\n";
3086   }
3087   OS << "  }\n";
3088 }
3089 
EmitClangAttrParserStringSwitches(RecordKeeper & Records,raw_ostream & OS)3090 void EmitClangAttrParserStringSwitches(RecordKeeper &Records,
3091                                        raw_ostream &OS) {
3092   emitSourceFileHeader("Parser-related llvm::StringSwitch cases", OS);
3093   emitClangAttrArgContextList(Records, OS);
3094   emitClangAttrIdentifierArgList(Records, OS);
3095   emitClangAttrTypeArgList(Records, OS);
3096   emitClangAttrLateParsedList(Records, OS);
3097 }
3098 
3099 class DocumentationData {
3100 public:
3101   const Record *Documentation;
3102   const Record *Attribute;
3103 
DocumentationData(const Record & Documentation,const Record & Attribute)3104   DocumentationData(const Record &Documentation, const Record &Attribute)
3105       : Documentation(&Documentation), Attribute(&Attribute) {}
3106 };
3107 
WriteCategoryHeader(const Record * DocCategory,raw_ostream & OS)3108 static void WriteCategoryHeader(const Record *DocCategory,
3109                                 raw_ostream &OS) {
3110   const std::string &Name = DocCategory->getValueAsString("Name");
3111   OS << Name << "\n" << std::string(Name.length(), '=') << "\n";
3112 
3113   // If there is content, print that as well.
3114   std::string ContentStr = DocCategory->getValueAsString("Content");
3115   // Trim leading and trailing newlines and spaces.
3116   OS << StringRef(ContentStr).trim();
3117 
3118   OS << "\n\n";
3119 }
3120 
3121 enum SpellingKind {
3122   GNU = 1 << 0,
3123   CXX11 = 1 << 1,
3124   Declspec = 1 << 2,
3125   Keyword = 1 << 3,
3126   Pragma = 1 << 4
3127 };
3128 
WriteDocumentation(const DocumentationData & Doc,raw_ostream & OS)3129 static void WriteDocumentation(const DocumentationData &Doc,
3130                                raw_ostream &OS) {
3131   // FIXME: there is no way to have a per-spelling category for the attribute
3132   // documentation. This may not be a limiting factor since the spellings
3133   // should generally be consistently applied across the category.
3134 
3135   std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Doc.Attribute);
3136 
3137   // Determine the heading to be used for this attribute.
3138   std::string Heading = Doc.Documentation->getValueAsString("Heading");
3139   bool CustomHeading = !Heading.empty();
3140   if (Heading.empty()) {
3141     // If there's only one spelling, we can simply use that.
3142     if (Spellings.size() == 1)
3143       Heading = Spellings.begin()->name();
3144     else {
3145       std::set<std::string> Uniques;
3146       for (auto I = Spellings.begin(), E = Spellings.end();
3147            I != E && Uniques.size() <= 1; ++I) {
3148         std::string Spelling = NormalizeNameForSpellingComparison(I->name());
3149         Uniques.insert(Spelling);
3150       }
3151       // If the semantic map has only one spelling, that is sufficient for our
3152       // needs.
3153       if (Uniques.size() == 1)
3154         Heading = *Uniques.begin();
3155     }
3156   }
3157 
3158   // If the heading is still empty, it is an error.
3159   if (Heading.empty())
3160     PrintFatalError(Doc.Attribute->getLoc(),
3161                     "This attribute requires a heading to be specified");
3162 
3163   // Gather a list of unique spellings; this is not the same as the semantic
3164   // spelling for the attribute. Variations in underscores and other non-
3165   // semantic characters are still acceptable.
3166   std::vector<std::string> Names;
3167 
3168   unsigned SupportedSpellings = 0;
3169   for (const auto &I : Spellings) {
3170     SpellingKind Kind = StringSwitch<SpellingKind>(I.variety())
3171                             .Case("GNU", GNU)
3172                             .Case("CXX11", CXX11)
3173                             .Case("Declspec", Declspec)
3174                             .Case("Keyword", Keyword)
3175                             .Case("Pragma", Pragma);
3176 
3177     // Mask in the supported spelling.
3178     SupportedSpellings |= Kind;
3179 
3180     std::string Name;
3181     if (Kind == CXX11 && !I.nameSpace().empty())
3182       Name = I.nameSpace() + "::";
3183     Name += I.name();
3184 
3185     // If this name is the same as the heading, do not add it.
3186     if (Name != Heading)
3187       Names.push_back(Name);
3188   }
3189 
3190   // Print out the heading for the attribute. If there are alternate spellings,
3191   // then display those after the heading.
3192   if (!CustomHeading && !Names.empty()) {
3193     Heading += " (";
3194     for (auto I = Names.begin(), E = Names.end(); I != E; ++I) {
3195       if (I != Names.begin())
3196         Heading += ", ";
3197       Heading += *I;
3198     }
3199     Heading += ")";
3200   }
3201   OS << Heading << "\n" << std::string(Heading.length(), '-') << "\n";
3202 
3203   if (!SupportedSpellings)
3204     PrintFatalError(Doc.Attribute->getLoc(),
3205                     "Attribute has no supported spellings; cannot be "
3206                     "documented");
3207 
3208   // List what spelling syntaxes the attribute supports.
3209   OS << ".. csv-table:: Supported Syntaxes\n";
3210   OS << "   :header: \"GNU\", \"C++11\", \"__declspec\", \"Keyword\",";
3211   OS << " \"Pragma\"\n\n";
3212   OS << "   \"";
3213   if (SupportedSpellings & GNU) OS << "X";
3214   OS << "\",\"";
3215   if (SupportedSpellings & CXX11) OS << "X";
3216   OS << "\",\"";
3217   if (SupportedSpellings & Declspec) OS << "X";
3218   OS << "\",\"";
3219   if (SupportedSpellings & Keyword) OS << "X";
3220   OS << "\", \"";
3221   if (SupportedSpellings & Pragma) OS << "X";
3222   OS << "\"\n\n";
3223 
3224   // If the attribute is deprecated, print a message about it, and possibly
3225   // provide a replacement attribute.
3226   if (!Doc.Documentation->isValueUnset("Deprecated")) {
3227     OS << "This attribute has been deprecated, and may be removed in a future "
3228        << "version of Clang.";
3229     const Record &Deprecated = *Doc.Documentation->getValueAsDef("Deprecated");
3230     std::string Replacement = Deprecated.getValueAsString("Replacement");
3231     if (!Replacement.empty())
3232       OS << "  This attribute has been superseded by ``"
3233          << Replacement << "``.";
3234     OS << "\n\n";
3235   }
3236 
3237   std::string ContentStr = Doc.Documentation->getValueAsString("Content");
3238   // Trim leading and trailing newlines and spaces.
3239   OS << StringRef(ContentStr).trim();
3240 
3241   OS << "\n\n\n";
3242 }
3243 
EmitClangAttrDocs(RecordKeeper & Records,raw_ostream & OS)3244 void EmitClangAttrDocs(RecordKeeper &Records, raw_ostream &OS) {
3245   // Get the documentation introduction paragraph.
3246   const Record *Documentation = Records.getDef("GlobalDocumentation");
3247   if (!Documentation) {
3248     PrintFatalError("The Documentation top-level definition is missing, "
3249                     "no documentation will be generated.");
3250     return;
3251   }
3252 
3253   OS << Documentation->getValueAsString("Intro") << "\n";
3254 
3255   // Gather the Documentation lists from each of the attributes, based on the
3256   // category provided.
3257   std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
3258   std::map<const Record *, std::vector<DocumentationData>> SplitDocs;
3259   for (const auto *A : Attrs) {
3260     const Record &Attr = *A;
3261     std::vector<Record *> Docs = Attr.getValueAsListOfDefs("Documentation");
3262     for (const auto *D : Docs) {
3263       const Record &Doc = *D;
3264       const Record *Category = Doc.getValueAsDef("Category");
3265       // If the category is "undocumented", then there cannot be any other
3266       // documentation categories (otherwise, the attribute would become
3267       // documented).
3268       std::string Cat = Category->getValueAsString("Name");
3269       bool Undocumented = Cat == "Undocumented";
3270       if (Undocumented && Docs.size() > 1)
3271         PrintFatalError(Doc.getLoc(),
3272                         "Attribute is \"Undocumented\", but has multiple "
3273                         "documentation categories");
3274 
3275       if (!Undocumented)
3276         SplitDocs[Category].push_back(DocumentationData(Doc, Attr));
3277     }
3278   }
3279 
3280   // Having split the attributes out based on what documentation goes where,
3281   // we can begin to generate sections of documentation.
3282   for (const auto &I : SplitDocs) {
3283     WriteCategoryHeader(I.first, OS);
3284 
3285     // Walk over each of the attributes in the category and write out their
3286     // documentation.
3287     for (const auto &Doc : I.second)
3288       WriteDocumentation(Doc, OS);
3289   }
3290 }
3291 
3292 } // end namespace clang
3293