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