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