1 //===- ClangAttrEmitter.cpp - Generate Clang attribute handling =-*- C++ -*--=//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // These tablegen backends emit Clang attribute processing code
12 //===----------------------------------------------------------------------===//
14 #include "llvm/ADT/SmallString.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/ADT/SmallSet.h"
17 #include "llvm/ADT/StringExtras.h"
18 #include "llvm/ADT/StringSwitch.h"
19 #include "llvm/TableGen/Error.h"
20 #include "llvm/TableGen/Record.h"
21 #include "llvm/TableGen/StringMatcher.h"
22 #include "llvm/TableGen/TableGenBackend.h"
31 class FlattenedSpelling {
36 FlattenedSpelling(const std::string &Variety, const std::string &Name,
37 const std::string &Namespace, bool KnownToGCC) :
38 V(Variety), N(Name), NS(Namespace), K(KnownToGCC) {}
39 explicit FlattenedSpelling(const Record &Spelling) :
40 V(Spelling.getValueAsString("Variety")),
41 N(Spelling.getValueAsString("Name")) {
43 assert(V != "GCC" && "Given a GCC spelling, which means this hasn't been"
45 if (V == "CXX11" || V == "Pragma")
46 NS = Spelling.getValueAsString("Namespace");
48 K = Spelling.getValueAsBitOrUnset("KnownToGCC", Unset);
51 const std::string &variety() const { return V; }
52 const std::string &name() const { return N; }
53 const std::string &nameSpace() const { return NS; }
54 bool knownToGCC() const { return K; }
57 std::vector<FlattenedSpelling> GetFlattenedSpellings(const Record &Attr) {
58 std::vector<Record *> Spellings = Attr.getValueAsListOfDefs("Spellings");
59 std::vector<FlattenedSpelling> Ret;
61 for (const auto &Spelling : Spellings) {
62 if (Spelling->getValueAsString("Variety") == "GCC") {
63 // Gin up two new spelling objects to add into the list.
64 Ret.push_back(FlattenedSpelling("GNU", Spelling->getValueAsString("Name"),
66 Ret.push_back(FlattenedSpelling(
67 "CXX11", Spelling->getValueAsString("Name"), "gnu", true));
69 Ret.push_back(FlattenedSpelling(*Spelling));
75 static std::string ReadPCHRecord(StringRef type) {
76 return StringSwitch<std::string>(type)
77 .EndsWith("Decl *", "GetLocalDeclAs<"
78 + std::string(type, 0, type.size()-1) + ">(F, Record[Idx++])")
79 .Case("TypeSourceInfo *", "GetTypeSourceInfo(F, Record, Idx)")
80 .Case("Expr *", "ReadExpr(F)")
81 .Case("IdentifierInfo *", "GetIdentifierInfo(F, Record, Idx)")
82 .Default("Record[Idx++]");
85 // Assumes that the way to get the value is SA->getname()
86 static std::string WritePCHRecord(StringRef type, StringRef name) {
87 return StringSwitch<std::string>(type)
88 .EndsWith("Decl *", "AddDeclRef(" + std::string(name) +
90 .Case("TypeSourceInfo *",
91 "AddTypeSourceInfo(" + std::string(name) + ", Record);\n")
92 .Case("Expr *", "AddStmt(" + std::string(name) + ");\n")
93 .Case("IdentifierInfo *",
94 "AddIdentifierRef(" + std::string(name) + ", Record);\n")
95 .Default("Record.push_back(" + std::string(name) + ");\n");
98 // Normalize attribute name by removing leading and trailing
99 // underscores. For example, __foo, foo__, __foo__ would
101 static StringRef NormalizeAttrName(StringRef AttrName) {
102 if (AttrName.startswith("__"))
103 AttrName = AttrName.substr(2, AttrName.size());
105 if (AttrName.endswith("__"))
106 AttrName = AttrName.substr(0, AttrName.size() - 2);
111 // Normalize the name by removing any and all leading and trailing underscores.
112 // This is different from NormalizeAttrName in that it also handles names like
113 // _pascal and __pascal.
114 static StringRef NormalizeNameForSpellingComparison(StringRef Name) {
115 while (Name.startswith("_"))
116 Name = Name.substr(1, Name.size());
117 while (Name.endswith("_"))
118 Name = Name.substr(0, Name.size() - 1);
122 // Normalize attribute spelling only if the spelling has both leading
123 // and trailing underscores. For example, __ms_struct__ will be
124 // normalized to "ms_struct"; __cdecl will remain intact.
125 static StringRef NormalizeAttrSpelling(StringRef AttrSpelling) {
126 if (AttrSpelling.startswith("__") && AttrSpelling.endswith("__")) {
127 AttrSpelling = AttrSpelling.substr(2, AttrSpelling.size() - 4);
133 typedef std::vector<std::pair<std::string, const Record *>> ParsedAttrMap;
135 static ParsedAttrMap getParsedAttrList(const RecordKeeper &Records,
136 ParsedAttrMap *Dupes = nullptr) {
137 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
138 std::set<std::string> Seen;
140 for (const auto *Attr : Attrs) {
141 if (Attr->getValueAsBit("SemaHandler")) {
143 if (Attr->isSubClassOf("TargetSpecificAttr") &&
144 !Attr->isValueUnset("ParseKind")) {
145 AN = Attr->getValueAsString("ParseKind");
147 // If this attribute has already been handled, it does not need to be
149 if (Seen.find(AN) != Seen.end()) {
151 Dupes->push_back(std::make_pair(AN, Attr));
156 AN = NormalizeAttrName(Attr->getName()).str();
158 R.push_back(std::make_pair(AN, Attr));
166 std::string lowerName, upperName;
171 Argument(const Record &Arg, StringRef Attr)
172 : lowerName(Arg.getValueAsString("Name")), upperName(lowerName),
173 attrName(Attr), isOpt(false) {
174 if (!lowerName.empty()) {
175 lowerName[0] = std::tolower(lowerName[0]);
176 upperName[0] = std::toupper(upperName[0]);
179 virtual ~Argument() {}
181 StringRef getLowerName() const { return lowerName; }
182 StringRef getUpperName() const { return upperName; }
183 StringRef getAttrName() const { return attrName; }
185 bool isOptional() const { return isOpt; }
186 void setOptional(bool set) { isOpt = set; }
188 // These functions print the argument contents formatted in different ways.
189 virtual void writeAccessors(raw_ostream &OS) const = 0;
190 virtual void writeAccessorDefinitions(raw_ostream &OS) const {}
191 virtual void writeASTVisitorTraversal(raw_ostream &OS) const {}
192 virtual void writeCloneArgs(raw_ostream &OS) const = 0;
193 virtual void writeTemplateInstantiationArgs(raw_ostream &OS) const = 0;
194 virtual void writeTemplateInstantiation(raw_ostream &OS) const {}
195 virtual void writeCtorBody(raw_ostream &OS) const {}
196 virtual void writeCtorInitializers(raw_ostream &OS) const = 0;
197 virtual void writeCtorDefaultInitializers(raw_ostream &OS) const = 0;
198 virtual void writeCtorParameters(raw_ostream &OS) const = 0;
199 virtual void writeDeclarations(raw_ostream &OS) const = 0;
200 virtual void writePCHReadArgs(raw_ostream &OS) const = 0;
201 virtual void writePCHReadDecls(raw_ostream &OS) const = 0;
202 virtual void writePCHWrite(raw_ostream &OS) const = 0;
203 virtual void writeValue(raw_ostream &OS) const = 0;
204 virtual void writeDump(raw_ostream &OS) const = 0;
205 virtual void writeDumpChildren(raw_ostream &OS) const {}
206 virtual void writeHasChildren(raw_ostream &OS) const { OS << "false"; }
208 virtual bool isEnumArg() const { return false; }
209 virtual bool isVariadicEnumArg() const { return false; }
210 virtual bool isVariadic() const { return false; }
212 virtual void writeImplicitCtorArgs(raw_ostream &OS) const {
213 OS << getUpperName();
217 class SimpleArgument : public Argument {
221 SimpleArgument(const Record &Arg, StringRef Attr, std::string T)
222 : Argument(Arg, Attr), type(T)
225 std::string getType() const { return type; }
227 void writeAccessors(raw_ostream &OS) const override {
228 OS << " " << type << " get" << getUpperName() << "() const {\n";
229 OS << " return " << getLowerName() << ";\n";
232 void writeCloneArgs(raw_ostream &OS) const override {
233 OS << getLowerName();
235 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
236 OS << "A->get" << getUpperName() << "()";
238 void writeCtorInitializers(raw_ostream &OS) const override {
239 OS << getLowerName() << "(" << getUpperName() << ")";
241 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
242 OS << getLowerName() << "()";
244 void writeCtorParameters(raw_ostream &OS) const override {
245 OS << type << " " << getUpperName();
247 void writeDeclarations(raw_ostream &OS) const override {
248 OS << type << " " << getLowerName() << ";";
250 void writePCHReadDecls(raw_ostream &OS) const override {
251 std::string read = ReadPCHRecord(type);
252 OS << " " << type << " " << getLowerName() << " = " << read << ";\n";
254 void writePCHReadArgs(raw_ostream &OS) const override {
255 OS << getLowerName();
257 void writePCHWrite(raw_ostream &OS) const override {
258 OS << " " << WritePCHRecord(type, "SA->get" +
259 std::string(getUpperName()) + "()");
261 void writeValue(raw_ostream &OS) const override {
262 if (type == "FunctionDecl *") {
263 OS << "\" << get" << getUpperName()
264 << "()->getNameInfo().getAsString() << \"";
265 } else if (type == "IdentifierInfo *") {
266 OS << "\" << get" << getUpperName() << "()->getName() << \"";
267 } else if (type == "TypeSourceInfo *") {
268 OS << "\" << get" << getUpperName() << "().getAsString() << \"";
270 OS << "\" << get" << getUpperName() << "() << \"";
273 void writeDump(raw_ostream &OS) const override {
274 if (type == "FunctionDecl *") {
275 OS << " OS << \" \";\n";
276 OS << " dumpBareDeclRef(SA->get" << getUpperName() << "());\n";
277 } else if (type == "IdentifierInfo *") {
278 OS << " OS << \" \" << SA->get" << getUpperName()
279 << "()->getName();\n";
280 } else if (type == "TypeSourceInfo *") {
281 OS << " OS << \" \" << SA->get" << getUpperName()
282 << "().getAsString();\n";
283 } else if (type == "bool") {
284 OS << " if (SA->get" << getUpperName() << "()) OS << \" "
285 << getUpperName() << "\";\n";
286 } else if (type == "int" || type == "unsigned") {
287 OS << " OS << \" \" << SA->get" << getUpperName() << "();\n";
289 llvm_unreachable("Unknown SimpleArgument type!");
294 class DefaultSimpleArgument : public SimpleArgument {
298 DefaultSimpleArgument(const Record &Arg, StringRef Attr,
299 std::string T, int64_t Default)
300 : SimpleArgument(Arg, Attr, T), Default(Default) {}
302 void writeAccessors(raw_ostream &OS) const override {
303 SimpleArgument::writeAccessors(OS);
305 OS << "\n\n static const " << getType() << " Default" << getUpperName()
306 << " = " << Default << ";";
310 class StringArgument : public Argument {
312 StringArgument(const Record &Arg, StringRef Attr)
313 : Argument(Arg, Attr)
316 void writeAccessors(raw_ostream &OS) const override {
317 OS << " llvm::StringRef get" << getUpperName() << "() const {\n";
318 OS << " return llvm::StringRef(" << getLowerName() << ", "
319 << getLowerName() << "Length);\n";
321 OS << " unsigned get" << getUpperName() << "Length() const {\n";
322 OS << " return " << getLowerName() << "Length;\n";
324 OS << " void set" << getUpperName()
325 << "(ASTContext &C, llvm::StringRef S) {\n";
326 OS << " " << getLowerName() << "Length = S.size();\n";
327 OS << " this->" << getLowerName() << " = new (C, 1) char ["
328 << getLowerName() << "Length];\n";
329 OS << " std::memcpy(this->" << getLowerName() << ", S.data(), "
330 << getLowerName() << "Length);\n";
333 void writeCloneArgs(raw_ostream &OS) const override {
334 OS << "get" << getUpperName() << "()";
336 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
337 OS << "A->get" << getUpperName() << "()";
339 void writeCtorBody(raw_ostream &OS) const override {
340 OS << " std::memcpy(" << getLowerName() << ", " << getUpperName()
341 << ".data(), " << getLowerName() << "Length);";
343 void writeCtorInitializers(raw_ostream &OS) const override {
344 OS << getLowerName() << "Length(" << getUpperName() << ".size()),"
345 << getLowerName() << "(new (Ctx, 1) char[" << getLowerName()
348 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
349 OS << getLowerName() << "Length(0)," << getLowerName() << "(0)";
351 void writeCtorParameters(raw_ostream &OS) const override {
352 OS << "llvm::StringRef " << getUpperName();
354 void writeDeclarations(raw_ostream &OS) const override {
355 OS << "unsigned " << getLowerName() << "Length;\n";
356 OS << "char *" << getLowerName() << ";";
358 void writePCHReadDecls(raw_ostream &OS) const override {
359 OS << " std::string " << getLowerName()
360 << "= ReadString(Record, Idx);\n";
362 void writePCHReadArgs(raw_ostream &OS) const override {
363 OS << getLowerName();
365 void writePCHWrite(raw_ostream &OS) const override {
366 OS << " AddString(SA->get" << getUpperName() << "(), Record);\n";
368 void writeValue(raw_ostream &OS) const override {
369 OS << "\\\"\" << get" << getUpperName() << "() << \"\\\"";
371 void writeDump(raw_ostream &OS) const override {
372 OS << " OS << \" \\\"\" << SA->get" << getUpperName()
373 << "() << \"\\\"\";\n";
377 class AlignedArgument : public Argument {
379 AlignedArgument(const Record &Arg, StringRef Attr)
380 : Argument(Arg, Attr)
383 void writeAccessors(raw_ostream &OS) const override {
384 OS << " bool is" << getUpperName() << "Dependent() const;\n";
386 OS << " unsigned get" << getUpperName() << "(ASTContext &Ctx) const;\n";
388 OS << " bool is" << getUpperName() << "Expr() const {\n";
389 OS << " return is" << getLowerName() << "Expr;\n";
392 OS << " Expr *get" << getUpperName() << "Expr() const {\n";
393 OS << " assert(is" << getLowerName() << "Expr);\n";
394 OS << " return " << getLowerName() << "Expr;\n";
397 OS << " TypeSourceInfo *get" << getUpperName() << "Type() const {\n";
398 OS << " assert(!is" << getLowerName() << "Expr);\n";
399 OS << " return " << getLowerName() << "Type;\n";
402 void writeAccessorDefinitions(raw_ostream &OS) const override {
403 OS << "bool " << getAttrName() << "Attr::is" << getUpperName()
404 << "Dependent() const {\n";
405 OS << " if (is" << getLowerName() << "Expr)\n";
406 OS << " return " << getLowerName() << "Expr && (" << getLowerName()
407 << "Expr->isValueDependent() || " << getLowerName()
408 << "Expr->isTypeDependent());\n";
410 OS << " return " << getLowerName()
411 << "Type->getType()->isDependentType();\n";
414 // FIXME: Do not do the calculation here
415 // FIXME: Handle types correctly
416 // A null pointer means maximum alignment
417 // FIXME: Load the platform-specific maximum alignment, rather than
419 OS << "unsigned " << getAttrName() << "Attr::get" << getUpperName()
420 << "(ASTContext &Ctx) const {\n";
421 OS << " assert(!is" << getUpperName() << "Dependent());\n";
422 OS << " if (is" << getLowerName() << "Expr)\n";
423 OS << " return (" << getLowerName() << "Expr ? " << getLowerName()
424 << "Expr->EvaluateKnownConstInt(Ctx).getZExtValue() : 16)"
425 << "* Ctx.getCharWidth();\n";
427 OS << " return 0; // FIXME\n";
430 void writeCloneArgs(raw_ostream &OS) const override {
431 OS << "is" << getLowerName() << "Expr, is" << getLowerName()
432 << "Expr ? static_cast<void*>(" << getLowerName()
433 << "Expr) : " << getLowerName()
436 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
437 // FIXME: move the definition in Sema::InstantiateAttrs to here.
438 // In the meantime, aligned attributes are cloned.
440 void writeCtorBody(raw_ostream &OS) const override {
441 OS << " if (is" << getLowerName() << "Expr)\n";
442 OS << " " << getLowerName() << "Expr = reinterpret_cast<Expr *>("
443 << getUpperName() << ");\n";
445 OS << " " << getLowerName()
446 << "Type = reinterpret_cast<TypeSourceInfo *>(" << getUpperName()
449 void writeCtorInitializers(raw_ostream &OS) const override {
450 OS << "is" << getLowerName() << "Expr(Is" << getUpperName() << "Expr)";
452 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
453 OS << "is" << getLowerName() << "Expr(false)";
455 void writeCtorParameters(raw_ostream &OS) const override {
456 OS << "bool Is" << getUpperName() << "Expr, void *" << getUpperName();
458 void writeImplicitCtorArgs(raw_ostream &OS) const override {
459 OS << "Is" << getUpperName() << "Expr, " << getUpperName();
461 void writeDeclarations(raw_ostream &OS) const override {
462 OS << "bool is" << getLowerName() << "Expr;\n";
464 OS << "Expr *" << getLowerName() << "Expr;\n";
465 OS << "TypeSourceInfo *" << getLowerName() << "Type;\n";
468 void writePCHReadArgs(raw_ostream &OS) const override {
469 OS << "is" << getLowerName() << "Expr, " << getLowerName() << "Ptr";
471 void writePCHReadDecls(raw_ostream &OS) const override {
472 OS << " bool is" << getLowerName() << "Expr = Record[Idx++];\n";
473 OS << " void *" << getLowerName() << "Ptr;\n";
474 OS << " if (is" << getLowerName() << "Expr)\n";
475 OS << " " << getLowerName() << "Ptr = ReadExpr(F);\n";
477 OS << " " << getLowerName()
478 << "Ptr = GetTypeSourceInfo(F, Record, Idx);\n";
480 void writePCHWrite(raw_ostream &OS) const override {
481 OS << " Record.push_back(SA->is" << getUpperName() << "Expr());\n";
482 OS << " if (SA->is" << getUpperName() << "Expr())\n";
483 OS << " AddStmt(SA->get" << getUpperName() << "Expr());\n";
485 OS << " AddTypeSourceInfo(SA->get" << getUpperName()
486 << "Type(), Record);\n";
488 void writeValue(raw_ostream &OS) const override {
490 // The aligned attribute argument expression is optional.
491 OS << " if (is" << getLowerName() << "Expr && "
492 << getLowerName() << "Expr)\n";
493 OS << " " << getLowerName() << "Expr->printPretty(OS, 0, Policy);\n";
496 void writeDump(raw_ostream &OS) const override {
498 void writeDumpChildren(raw_ostream &OS) const override {
499 OS << " if (SA->is" << getUpperName() << "Expr())\n";
500 OS << " dumpStmt(SA->get" << getUpperName() << "Expr());\n";
502 OS << " dumpType(SA->get" << getUpperName()
503 << "Type()->getType());\n";
505 void writeHasChildren(raw_ostream &OS) const override {
506 OS << "SA->is" << getUpperName() << "Expr()";
510 class VariadicArgument : public Argument {
511 std::string Type, ArgName, ArgSizeName, RangeName;
514 // Assumed to receive a parameter: raw_ostream OS.
515 virtual void writeValueImpl(raw_ostream &OS) const {
516 OS << " OS << Val;\n";
520 VariadicArgument(const Record &Arg, StringRef Attr, std::string T)
521 : Argument(Arg, Attr), Type(T), ArgName(getLowerName().str() + "_"),
522 ArgSizeName(ArgName + "Size"), RangeName(getLowerName()) {}
524 std::string getType() const { return Type; }
525 bool isVariadic() const override { return true; }
527 void writeAccessors(raw_ostream &OS) const override {
528 std::string IteratorType = getLowerName().str() + "_iterator";
529 std::string BeginFn = getLowerName().str() + "_begin()";
530 std::string EndFn = getLowerName().str() + "_end()";
532 OS << " typedef " << Type << "* " << IteratorType << ";\n";
533 OS << " " << IteratorType << " " << BeginFn << " const {"
534 << " return " << ArgName << "; }\n";
535 OS << " " << IteratorType << " " << EndFn << " const {"
536 << " return " << ArgName << " + " << ArgSizeName << "; }\n";
537 OS << " unsigned " << getLowerName() << "_size() const {"
538 << " return " << ArgSizeName << "; }\n";
539 OS << " llvm::iterator_range<" << IteratorType << "> " << RangeName
540 << "() const { return llvm::make_range(" << BeginFn << ", " << EndFn
543 void writeCloneArgs(raw_ostream &OS) const override {
544 OS << ArgName << ", " << ArgSizeName;
546 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
547 // This isn't elegant, but we have to go through public methods...
548 OS << "A->" << getLowerName() << "_begin(), "
549 << "A->" << getLowerName() << "_size()";
551 void writeCtorBody(raw_ostream &OS) const override {
552 OS << " std::copy(" << getUpperName() << ", " << getUpperName()
553 << " + " << ArgSizeName << ", " << ArgName << ");";
555 void writeCtorInitializers(raw_ostream &OS) const override {
556 OS << ArgSizeName << "(" << getUpperName() << "Size), "
557 << ArgName << "(new (Ctx, 16) " << getType() << "["
558 << ArgSizeName << "])";
560 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
561 OS << ArgSizeName << "(0), " << ArgName << "(nullptr)";
563 void writeCtorParameters(raw_ostream &OS) const override {
564 OS << getType() << " *" << getUpperName() << ", unsigned "
565 << getUpperName() << "Size";
567 void writeImplicitCtorArgs(raw_ostream &OS) const override {
568 OS << getUpperName() << ", " << getUpperName() << "Size";
570 void writeDeclarations(raw_ostream &OS) const override {
571 OS << " unsigned " << ArgSizeName << ";\n";
572 OS << " " << getType() << " *" << ArgName << ";";
574 void writePCHReadDecls(raw_ostream &OS) const override {
575 OS << " unsigned " << getLowerName() << "Size = Record[Idx++];\n";
576 OS << " SmallVector<" << Type << ", 4> " << getLowerName()
578 OS << " " << getLowerName() << ".reserve(" << getLowerName()
580 OS << " for (unsigned i = " << getLowerName() << "Size; i; --i)\n";
582 std::string read = ReadPCHRecord(Type);
583 OS << " " << getLowerName() << ".push_back(" << read << ");\n";
585 void writePCHReadArgs(raw_ostream &OS) const override {
586 OS << getLowerName() << ".data(), " << getLowerName() << "Size";
588 void writePCHWrite(raw_ostream &OS) const override {
589 OS << " Record.push_back(SA->" << getLowerName() << "_size());\n";
590 OS << " for (auto &Val : SA->" << RangeName << "())\n";
591 OS << " " << WritePCHRecord(Type, "Val");
593 void writeValue(raw_ostream &OS) const override {
595 OS << " bool isFirst = true;\n"
596 << " for (const auto &Val : " << RangeName << "()) {\n"
597 << " if (isFirst) isFirst = false;\n"
598 << " else OS << \", \";\n";
603 void writeDump(raw_ostream &OS) const override {
604 OS << " for (const auto &Val : SA->" << RangeName << "())\n";
605 OS << " OS << \" \" << Val;\n";
609 // Unique the enums, but maintain the original declaration ordering.
610 std::vector<std::string>
611 uniqueEnumsInOrder(const std::vector<std::string> &enums) {
612 std::vector<std::string> uniques;
613 std::set<std::string> unique_set(enums.begin(), enums.end());
614 for (const auto &i : enums) {
615 std::set<std::string>::iterator set_i = unique_set.find(i);
616 if (set_i != unique_set.end()) {
617 uniques.push_back(i);
618 unique_set.erase(set_i);
624 class EnumArgument : public Argument {
626 std::vector<std::string> values, enums, uniques;
628 EnumArgument(const Record &Arg, StringRef Attr)
629 : Argument(Arg, Attr), type(Arg.getValueAsString("Type")),
630 values(Arg.getValueAsListOfStrings("Values")),
631 enums(Arg.getValueAsListOfStrings("Enums")),
632 uniques(uniqueEnumsInOrder(enums))
634 // FIXME: Emit a proper error
635 assert(!uniques.empty());
638 bool isEnumArg() const override { return true; }
640 void writeAccessors(raw_ostream &OS) const override {
641 OS << " " << type << " get" << getUpperName() << "() const {\n";
642 OS << " return " << getLowerName() << ";\n";
645 void writeCloneArgs(raw_ostream &OS) const override {
646 OS << getLowerName();
648 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
649 OS << "A->get" << getUpperName() << "()";
651 void writeCtorInitializers(raw_ostream &OS) const override {
652 OS << getLowerName() << "(" << getUpperName() << ")";
654 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
655 OS << getLowerName() << "(" << type << "(0))";
657 void writeCtorParameters(raw_ostream &OS) const override {
658 OS << type << " " << getUpperName();
660 void writeDeclarations(raw_ostream &OS) const override {
661 std::vector<std::string>::const_iterator i = uniques.begin(),
663 // The last one needs to not have a comma.
667 OS << " enum " << type << " {\n";
669 OS << " " << *i << ",\n";
670 OS << " " << *e << "\n";
673 OS << " " << type << " " << getLowerName() << ";";
675 void writePCHReadDecls(raw_ostream &OS) const override {
676 OS << " " << getAttrName() << "Attr::" << type << " " << getLowerName()
677 << "(static_cast<" << getAttrName() << "Attr::" << type
678 << ">(Record[Idx++]));\n";
680 void writePCHReadArgs(raw_ostream &OS) const override {
681 OS << getLowerName();
683 void writePCHWrite(raw_ostream &OS) const override {
684 OS << "Record.push_back(SA->get" << getUpperName() << "());\n";
686 void writeValue(raw_ostream &OS) const override {
687 // FIXME: this isn't 100% correct -- some enum arguments require printing
688 // as a string literal, while others require printing as an identifier.
689 // Tablegen currently does not distinguish between the two forms.
690 OS << "\\\"\" << " << getAttrName() << "Attr::Convert" << type << "ToStr(get"
691 << getUpperName() << "()) << \"\\\"";
693 void writeDump(raw_ostream &OS) const override {
694 OS << " switch(SA->get" << getUpperName() << "()) {\n";
695 for (const auto &I : uniques) {
696 OS << " case " << getAttrName() << "Attr::" << I << ":\n";
697 OS << " OS << \" " << I << "\";\n";
703 void writeConversion(raw_ostream &OS) const {
704 OS << " static bool ConvertStrTo" << type << "(StringRef Val, ";
705 OS << type << " &Out) {\n";
706 OS << " Optional<" << type << "> R = llvm::StringSwitch<Optional<";
707 OS << type << ">>(Val)\n";
708 for (size_t I = 0; I < enums.size(); ++I) {
709 OS << " .Case(\"" << values[I] << "\", ";
710 OS << getAttrName() << "Attr::" << enums[I] << ")\n";
712 OS << " .Default(Optional<" << type << ">());\n";
714 OS << " Out = *R;\n return true;\n }\n";
715 OS << " return false;\n";
718 // Mapping from enumeration values back to enumeration strings isn't
719 // trivial because some enumeration values have multiple named
720 // enumerators, such as type_visibility(internal) and
721 // type_visibility(hidden) both mapping to TypeVisibilityAttr::Hidden.
722 OS << " static const char *Convert" << type << "ToStr("
723 << type << " Val) {\n"
724 << " switch(Val) {\n";
725 std::set<std::string> Uniques;
726 for (size_t I = 0; I < enums.size(); ++I) {
727 if (Uniques.insert(enums[I]).second)
728 OS << " case " << getAttrName() << "Attr::" << enums[I]
729 << ": return \"" << values[I] << "\";\n";
732 << " llvm_unreachable(\"No enumerator with that value\");\n"
737 class VariadicEnumArgument: public VariadicArgument {
738 std::string type, QualifiedTypeName;
739 std::vector<std::string> values, enums, uniques;
742 void writeValueImpl(raw_ostream &OS) const override {
743 // FIXME: this isn't 100% correct -- some enum arguments require printing
744 // as a string literal, while others require printing as an identifier.
745 // Tablegen currently does not distinguish between the two forms.
746 OS << " OS << \"\\\"\" << " << getAttrName() << "Attr::Convert" << type
747 << "ToStr(Val)" << "<< \"\\\"\";\n";
751 VariadicEnumArgument(const Record &Arg, StringRef Attr)
752 : VariadicArgument(Arg, Attr, Arg.getValueAsString("Type")),
753 type(Arg.getValueAsString("Type")),
754 values(Arg.getValueAsListOfStrings("Values")),
755 enums(Arg.getValueAsListOfStrings("Enums")),
756 uniques(uniqueEnumsInOrder(enums))
758 QualifiedTypeName = getAttrName().str() + "Attr::" + type;
760 // FIXME: Emit a proper error
761 assert(!uniques.empty());
764 bool isVariadicEnumArg() const override { return true; }
766 void writeDeclarations(raw_ostream &OS) const override {
767 std::vector<std::string>::const_iterator i = uniques.begin(),
769 // The last one needs to not have a comma.
773 OS << " enum " << type << " {\n";
775 OS << " " << *i << ",\n";
776 OS << " " << *e << "\n";
780 VariadicArgument::writeDeclarations(OS);
782 void writeDump(raw_ostream &OS) const override {
783 OS << " for (" << getAttrName() << "Attr::" << getLowerName()
784 << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
785 << getLowerName() << "_end(); I != E; ++I) {\n";
786 OS << " switch(*I) {\n";
787 for (const auto &UI : uniques) {
788 OS << " case " << getAttrName() << "Attr::" << UI << ":\n";
789 OS << " OS << \" " << UI << "\";\n";
795 void writePCHReadDecls(raw_ostream &OS) const override {
796 OS << " unsigned " << getLowerName() << "Size = Record[Idx++];\n";
797 OS << " SmallVector<" << QualifiedTypeName << ", 4> " << getLowerName()
799 OS << " " << getLowerName() << ".reserve(" << getLowerName()
801 OS << " for (unsigned i = " << getLowerName() << "Size; i; --i)\n";
802 OS << " " << getLowerName() << ".push_back(" << "static_cast<"
803 << QualifiedTypeName << ">(Record[Idx++]));\n";
805 void writePCHWrite(raw_ostream &OS) const override {
806 OS << " Record.push_back(SA->" << getLowerName() << "_size());\n";
807 OS << " for (" << getAttrName() << "Attr::" << getLowerName()
808 << "_iterator i = SA->" << getLowerName() << "_begin(), e = SA->"
809 << getLowerName() << "_end(); i != e; ++i)\n";
810 OS << " " << WritePCHRecord(QualifiedTypeName, "(*i)");
812 void writeConversion(raw_ostream &OS) const {
813 OS << " static bool ConvertStrTo" << type << "(StringRef Val, ";
814 OS << type << " &Out) {\n";
815 OS << " Optional<" << type << "> R = llvm::StringSwitch<Optional<";
816 OS << type << ">>(Val)\n";
817 for (size_t I = 0; I < enums.size(); ++I) {
818 OS << " .Case(\"" << values[I] << "\", ";
819 OS << getAttrName() << "Attr::" << enums[I] << ")\n";
821 OS << " .Default(Optional<" << type << ">());\n";
823 OS << " Out = *R;\n return true;\n }\n";
824 OS << " return false;\n";
827 OS << " static const char *Convert" << type << "ToStr("
828 << type << " Val) {\n"
829 << " switch(Val) {\n";
830 std::set<std::string> Uniques;
831 for (size_t I = 0; I < enums.size(); ++I) {
832 if (Uniques.insert(enums[I]).second)
833 OS << " case " << getAttrName() << "Attr::" << enums[I]
834 << ": return \"" << values[I] << "\";\n";
837 << " llvm_unreachable(\"No enumerator with that value\");\n"
842 class VersionArgument : public Argument {
844 VersionArgument(const Record &Arg, StringRef Attr)
845 : Argument(Arg, Attr)
848 void writeAccessors(raw_ostream &OS) const override {
849 OS << " VersionTuple get" << getUpperName() << "() const {\n";
850 OS << " return " << getLowerName() << ";\n";
852 OS << " void set" << getUpperName()
853 << "(ASTContext &C, VersionTuple V) {\n";
854 OS << " " << getLowerName() << " = V;\n";
857 void writeCloneArgs(raw_ostream &OS) const override {
858 OS << "get" << getUpperName() << "()";
860 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
861 OS << "A->get" << getUpperName() << "()";
863 void writeCtorInitializers(raw_ostream &OS) const override {
864 OS << getLowerName() << "(" << getUpperName() << ")";
866 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
867 OS << getLowerName() << "()";
869 void writeCtorParameters(raw_ostream &OS) const override {
870 OS << "VersionTuple " << getUpperName();
872 void writeDeclarations(raw_ostream &OS) const override {
873 OS << "VersionTuple " << getLowerName() << ";\n";
875 void writePCHReadDecls(raw_ostream &OS) const override {
876 OS << " VersionTuple " << getLowerName()
877 << "= ReadVersionTuple(Record, Idx);\n";
879 void writePCHReadArgs(raw_ostream &OS) const override {
880 OS << getLowerName();
882 void writePCHWrite(raw_ostream &OS) const override {
883 OS << " AddVersionTuple(SA->get" << getUpperName() << "(), Record);\n";
885 void writeValue(raw_ostream &OS) const override {
886 OS << getLowerName() << "=\" << get" << getUpperName() << "() << \"";
888 void writeDump(raw_ostream &OS) const override {
889 OS << " OS << \" \" << SA->get" << getUpperName() << "();\n";
893 class ExprArgument : public SimpleArgument {
895 ExprArgument(const Record &Arg, StringRef Attr)
896 : SimpleArgument(Arg, Attr, "Expr *")
899 void writeASTVisitorTraversal(raw_ostream &OS) const override {
901 << "getDerived().TraverseStmt(A->get" << getUpperName() << "()))\n";
902 OS << " return false;\n";
905 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
906 OS << "tempInst" << getUpperName();
909 void writeTemplateInstantiation(raw_ostream &OS) const override {
910 OS << " " << getType() << " tempInst" << getUpperName() << ";\n";
912 OS << " EnterExpressionEvaluationContext "
913 << "Unevaluated(S, Sema::Unevaluated);\n";
914 OS << " ExprResult " << "Result = S.SubstExpr("
915 << "A->get" << getUpperName() << "(), TemplateArgs);\n";
916 OS << " tempInst" << getUpperName() << " = "
917 << "Result.getAs<Expr>();\n";
921 void writeDump(raw_ostream &OS) const override {}
923 void writeDumpChildren(raw_ostream &OS) const override {
924 OS << " dumpStmt(SA->get" << getUpperName() << "());\n";
926 void writeHasChildren(raw_ostream &OS) const override { OS << "true"; }
929 class VariadicExprArgument : public VariadicArgument {
931 VariadicExprArgument(const Record &Arg, StringRef Attr)
932 : VariadicArgument(Arg, Attr, "Expr *")
935 void writeASTVisitorTraversal(raw_ostream &OS) const override {
937 OS << " " << getType() << " *I = A->" << getLowerName()
939 OS << " " << getType() << " *E = A->" << getLowerName()
941 OS << " for (; I != E; ++I) {\n";
942 OS << " if (!getDerived().TraverseStmt(*I))\n";
943 OS << " return false;\n";
948 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
949 OS << "tempInst" << getUpperName() << ", "
950 << "A->" << getLowerName() << "_size()";
953 void writeTemplateInstantiation(raw_ostream &OS) const override {
954 OS << " " << getType() << " *tempInst" << getUpperName()
955 << " = new (C, 16) " << getType()
956 << "[A->" << getLowerName() << "_size()];\n";
958 OS << " EnterExpressionEvaluationContext "
959 << "Unevaluated(S, Sema::Unevaluated);\n";
960 OS << " " << getType() << " *TI = tempInst" << getUpperName()
962 OS << " " << getType() << " *I = A->" << getLowerName()
964 OS << " " << getType() << " *E = A->" << getLowerName()
966 OS << " for (; I != E; ++I, ++TI) {\n";
967 OS << " ExprResult Result = S.SubstExpr(*I, TemplateArgs);\n";
968 OS << " *TI = Result.getAs<Expr>();\n";
973 void writeDump(raw_ostream &OS) const override {}
975 void writeDumpChildren(raw_ostream &OS) const override {
976 OS << " for (" << getAttrName() << "Attr::" << getLowerName()
977 << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
978 << getLowerName() << "_end(); I != E; ++I)\n";
979 OS << " dumpStmt(*I);\n";
982 void writeHasChildren(raw_ostream &OS) const override {
983 OS << "SA->" << getLowerName() << "_begin() != "
984 << "SA->" << getLowerName() << "_end()";
988 class TypeArgument : public SimpleArgument {
990 TypeArgument(const Record &Arg, StringRef Attr)
991 : SimpleArgument(Arg, Attr, "TypeSourceInfo *")
994 void writeAccessors(raw_ostream &OS) const override {
995 OS << " QualType get" << getUpperName() << "() const {\n";
996 OS << " return " << getLowerName() << "->getType();\n";
998 OS << " " << getType() << " get" << getUpperName() << "Loc() const {\n";
999 OS << " return " << getLowerName() << ";\n";
1002 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
1003 OS << "A->get" << getUpperName() << "Loc()";
1005 void writePCHWrite(raw_ostream &OS) const override {
1006 OS << " " << WritePCHRecord(
1007 getType(), "SA->get" + std::string(getUpperName()) + "Loc()");
1012 static std::unique_ptr<Argument>
1013 createArgument(const Record &Arg, StringRef Attr,
1014 const Record *Search = nullptr) {
1018 std::unique_ptr<Argument> Ptr;
1019 llvm::StringRef ArgName = Search->getName();
1021 if (ArgName == "AlignedArgument")
1022 Ptr = llvm::make_unique<AlignedArgument>(Arg, Attr);
1023 else if (ArgName == "EnumArgument")
1024 Ptr = llvm::make_unique<EnumArgument>(Arg, Attr);
1025 else if (ArgName == "ExprArgument")
1026 Ptr = llvm::make_unique<ExprArgument>(Arg, Attr);
1027 else if (ArgName == "FunctionArgument")
1028 Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "FunctionDecl *");
1029 else if (ArgName == "IdentifierArgument")
1030 Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "IdentifierInfo *");
1031 else if (ArgName == "DefaultBoolArgument")
1032 Ptr = llvm::make_unique<DefaultSimpleArgument>(
1033 Arg, Attr, "bool", Arg.getValueAsBit("Default"));
1034 else if (ArgName == "BoolArgument")
1035 Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "bool");
1036 else if (ArgName == "DefaultIntArgument")
1037 Ptr = llvm::make_unique<DefaultSimpleArgument>(
1038 Arg, Attr, "int", Arg.getValueAsInt("Default"));
1039 else if (ArgName == "IntArgument")
1040 Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "int");
1041 else if (ArgName == "StringArgument")
1042 Ptr = llvm::make_unique<StringArgument>(Arg, Attr);
1043 else if (ArgName == "TypeArgument")
1044 Ptr = llvm::make_unique<TypeArgument>(Arg, Attr);
1045 else if (ArgName == "UnsignedArgument")
1046 Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "unsigned");
1047 else if (ArgName == "VariadicUnsignedArgument")
1048 Ptr = llvm::make_unique<VariadicArgument>(Arg, Attr, "unsigned");
1049 else if (ArgName == "VariadicEnumArgument")
1050 Ptr = llvm::make_unique<VariadicEnumArgument>(Arg, Attr);
1051 else if (ArgName == "VariadicExprArgument")
1052 Ptr = llvm::make_unique<VariadicExprArgument>(Arg, Attr);
1053 else if (ArgName == "VersionArgument")
1054 Ptr = llvm::make_unique<VersionArgument>(Arg, Attr);
1057 // Search in reverse order so that the most-derived type is handled first.
1058 std::vector<Record*> Bases = Search->getSuperClasses();
1059 for (const auto *Base : llvm::make_range(Bases.rbegin(), Bases.rend())) {
1060 if ((Ptr = createArgument(Arg, Attr, Base)))
1065 if (Ptr && Arg.getValueAsBit("Optional"))
1066 Ptr->setOptional(true);
1071 static void writeAvailabilityValue(raw_ostream &OS) {
1072 OS << "\" << getPlatform()->getName();\n"
1073 << " if (!getIntroduced().empty()) OS << \", introduced=\" << getIntroduced();\n"
1074 << " if (!getDeprecated().empty()) OS << \", deprecated=\" << getDeprecated();\n"
1075 << " if (!getObsoleted().empty()) OS << \", obsoleted=\" << getObsoleted();\n"
1076 << " if (getUnavailable()) OS << \", unavailable\";\n"
1080 static void writeGetSpellingFunction(Record &R, raw_ostream &OS) {
1081 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
1083 OS << "const char *" << R.getName() << "Attr::getSpelling() const {\n";
1084 if (Spellings.empty()) {
1085 OS << " return \"(No spelling)\";\n}\n\n";
1089 OS << " switch (SpellingListIndex) {\n"
1091 " llvm_unreachable(\"Unknown attribute spelling!\");\n"
1092 " return \"(No spelling)\";\n";
1094 for (unsigned I = 0; I < Spellings.size(); ++I)
1095 OS << " case " << I << ":\n"
1096 " return \"" << Spellings[I].name() << "\";\n";
1097 // End of the switch statement.
1099 // End of the getSpelling function.
1104 writePrettyPrintFunction(Record &R,
1105 const std::vector<std::unique_ptr<Argument>> &Args,
1107 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
1109 OS << "void " << R.getName() << "Attr::printPretty("
1110 << "raw_ostream &OS, const PrintingPolicy &Policy) const {\n";
1112 if (Spellings.empty()) {
1118 " switch (SpellingListIndex) {\n"
1120 " llvm_unreachable(\"Unknown attribute spelling!\");\n"
1123 for (unsigned I = 0; I < Spellings.size(); ++ I) {
1124 llvm::SmallString<16> Prefix;
1125 llvm::SmallString<8> Suffix;
1126 // The actual spelling of the name and namespace (if applicable)
1127 // of an attribute without considering prefix and suffix.
1128 llvm::SmallString<64> Spelling;
1129 std::string Name = Spellings[I].name();
1130 std::string Variety = Spellings[I].variety();
1132 if (Variety == "GNU") {
1133 Prefix = " __attribute__((";
1135 } else if (Variety == "CXX11") {
1138 std::string Namespace = Spellings[I].nameSpace();
1139 if (!Namespace.empty()) {
1140 Spelling += Namespace;
1143 } else if (Variety == "Declspec") {
1144 Prefix = " __declspec(";
1146 } else if (Variety == "Keyword") {
1149 } else if (Variety == "Pragma") {
1150 Prefix = "#pragma ";
1152 std::string Namespace = Spellings[I].nameSpace();
1153 if (!Namespace.empty()) {
1154 Spelling += Namespace;
1158 llvm_unreachable("Unknown attribute syntax variety!");
1164 " case " << I << " : {\n"
1165 " OS << \"" + Prefix.str() + Spelling.str();
1167 if (Variety == "Pragma") {
1169 OS << " printPrettyPragma(OS, Policy);\n";
1175 // FIXME: always printing the parenthesis isn't the correct behavior for
1176 // attributes which have optional arguments that were not provided. For
1177 // instance: __attribute__((aligned)) will be pretty printed as
1178 // __attribute__((aligned())). The logic should check whether there is only
1179 // a single argument, and if it is optional, whether it has been provided.
1182 if (Spelling == "availability") {
1183 writeAvailabilityValue(OS);
1185 for (auto I = Args.begin(), E = Args.end(); I != E; ++ I) {
1186 if (I != Args.begin()) OS << ", ";
1187 (*I)->writeValue(OS);
1193 OS << Suffix.str() + "\";\n";
1200 // End of the switch statement.
1202 // End of the print function.
1206 /// \brief Return the index of a spelling in a spelling list.
1208 getSpellingListIndex(const std::vector<FlattenedSpelling> &SpellingList,
1209 const FlattenedSpelling &Spelling) {
1210 assert(SpellingList.size() && "Spelling list is empty!");
1212 for (unsigned Index = 0; Index < SpellingList.size(); ++Index) {
1213 const FlattenedSpelling &S = SpellingList[Index];
1214 if (S.variety() != Spelling.variety())
1216 if (S.nameSpace() != Spelling.nameSpace())
1218 if (S.name() != Spelling.name())
1224 llvm_unreachable("Unknown spelling!");
1227 static void writeAttrAccessorDefinition(const Record &R, raw_ostream &OS) {
1228 std::vector<Record*> Accessors = R.getValueAsListOfDefs("Accessors");
1229 for (const auto *Accessor : Accessors) {
1230 std::string Name = Accessor->getValueAsString("Name");
1231 std::vector<FlattenedSpelling> Spellings =
1232 GetFlattenedSpellings(*Accessor);
1233 std::vector<FlattenedSpelling> SpellingList = GetFlattenedSpellings(R);
1234 assert(SpellingList.size() &&
1235 "Attribute with empty spelling list can't have accessors!");
1237 OS << " bool " << Name << "() const { return SpellingListIndex == ";
1238 for (unsigned Index = 0; Index < Spellings.size(); ++Index) {
1239 OS << getSpellingListIndex(SpellingList, Spellings[Index]);
1240 if (Index != Spellings.size() -1)
1241 OS << " ||\n SpellingListIndex == ";
1249 SpellingNamesAreCommon(const std::vector<FlattenedSpelling>& Spellings) {
1250 assert(!Spellings.empty() && "An empty list of spellings was provided");
1251 std::string FirstName = NormalizeNameForSpellingComparison(
1252 Spellings.front().name());
1253 for (const auto &Spelling :
1254 llvm::make_range(std::next(Spellings.begin()), Spellings.end())) {
1255 std::string Name = NormalizeNameForSpellingComparison(Spelling.name());
1256 if (Name != FirstName)
1262 typedef std::map<unsigned, std::string> SemanticSpellingMap;
1264 CreateSemanticSpellings(const std::vector<FlattenedSpelling> &Spellings,
1265 SemanticSpellingMap &Map) {
1266 // The enumerants are automatically generated based on the variety,
1267 // namespace (if present) and name for each attribute spelling. However,
1268 // care is taken to avoid trampling on the reserved namespace due to
1270 std::string Ret(" enum Spelling {\n");
1271 std::set<std::string> Uniques;
1273 for (auto I = Spellings.begin(), E = Spellings.end(); I != E; ++I, ++Idx) {
1274 const FlattenedSpelling &S = *I;
1275 std::string Variety = S.variety();
1276 std::string Spelling = S.name();
1277 std::string Namespace = S.nameSpace();
1278 std::string EnumName = "";
1280 EnumName += (Variety + "_");
1281 if (!Namespace.empty())
1282 EnumName += (NormalizeNameForSpellingComparison(Namespace).str() +
1284 EnumName += NormalizeNameForSpellingComparison(Spelling);
1286 // Even if the name is not unique, this spelling index corresponds to a
1287 // particular enumerant name that we've calculated.
1288 Map[Idx] = EnumName;
1290 // Since we have been stripping underscores to avoid trampling on the
1291 // reserved namespace, we may have inadvertently created duplicate
1292 // enumerant names. These duplicates are not considered part of the
1293 // semantic spelling, and can be elided.
1294 if (Uniques.find(EnumName) != Uniques.end())
1297 Uniques.insert(EnumName);
1298 if (I != Spellings.begin())
1300 Ret += " " + EnumName;
1306 void WriteSemanticSpellingSwitch(const std::string &VarName,
1307 const SemanticSpellingMap &Map,
1309 OS << " switch (" << VarName << ") {\n default: "
1310 << "llvm_unreachable(\"Unknown spelling list index\");\n";
1311 for (const auto &I : Map)
1312 OS << " case " << I.first << ": return " << I.second << ";\n";
1316 // Emits the LateParsed property for attributes.
1317 static void emitClangAttrLateParsedList(RecordKeeper &Records, raw_ostream &OS) {
1318 OS << "#if defined(CLANG_ATTR_LATE_PARSED_LIST)\n";
1319 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1321 for (const auto *Attr : Attrs) {
1322 bool LateParsed = Attr->getValueAsBit("LateParsed");
1325 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
1327 // FIXME: Handle non-GNU attributes
1328 for (const auto &I : Spellings) {
1329 if (I.variety() != "GNU")
1331 OS << ".Case(\"" << I.name() << "\", " << LateParsed << ")\n";
1335 OS << "#endif // CLANG_ATTR_LATE_PARSED_LIST\n\n";
1338 /// \brief Emits the first-argument-is-type property for attributes.
1339 static void emitClangAttrTypeArgList(RecordKeeper &Records, raw_ostream &OS) {
1340 OS << "#if defined(CLANG_ATTR_TYPE_ARG_LIST)\n";
1341 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
1343 for (const auto *Attr : Attrs) {
1344 // Determine whether the first argument is a type.
1345 std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args");
1349 if (Args[0]->getSuperClasses().back()->getName() != "TypeArgument")
1352 // All these spellings take a single type argument.
1353 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
1354 std::set<std::string> Emitted;
1355 for (const auto &S : Spellings) {
1356 if (Emitted.insert(S.name()).second)
1357 OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
1360 OS << "#endif // CLANG_ATTR_TYPE_ARG_LIST\n\n";
1363 /// \brief Emits the parse-arguments-in-unevaluated-context property for
1365 static void emitClangAttrArgContextList(RecordKeeper &Records, raw_ostream &OS) {
1366 OS << "#if defined(CLANG_ATTR_ARG_CONTEXT_LIST)\n";
1367 ParsedAttrMap Attrs = getParsedAttrList(Records);
1368 for (const auto &I : Attrs) {
1369 const Record &Attr = *I.second;
1371 if (!Attr.getValueAsBit("ParseArgumentsAsUnevaluated"))
1374 // All these spellings take are parsed unevaluated.
1375 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
1376 std::set<std::string> Emitted;
1377 for (const auto &S : Spellings) {
1378 if (Emitted.insert(S.name()).second)
1379 OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
1382 OS << "#endif // CLANG_ATTR_ARG_CONTEXT_LIST\n\n";
1385 static bool isIdentifierArgument(Record *Arg) {
1386 return !Arg->getSuperClasses().empty() &&
1387 llvm::StringSwitch<bool>(Arg->getSuperClasses().back()->getName())
1388 .Case("IdentifierArgument", true)
1389 .Case("EnumArgument", true)
1390 .Case("VariadicEnumArgument", true)
1394 // Emits the first-argument-is-identifier property for attributes.
1395 static void emitClangAttrIdentifierArgList(RecordKeeper &Records, raw_ostream &OS) {
1396 OS << "#if defined(CLANG_ATTR_IDENTIFIER_ARG_LIST)\n";
1397 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1399 for (const auto *Attr : Attrs) {
1400 // Determine whether the first argument is an identifier.
1401 std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args");
1402 if (Args.empty() || !isIdentifierArgument(Args[0]))
1405 // All these spellings take an identifier argument.
1406 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
1407 std::set<std::string> Emitted;
1408 for (const auto &S : Spellings) {
1409 if (Emitted.insert(S.name()).second)
1410 OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
1413 OS << "#endif // CLANG_ATTR_IDENTIFIER_ARG_LIST\n\n";
1418 // Emits the class definitions for attributes.
1419 void EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS) {
1420 emitSourceFileHeader("Attribute classes' definitions", OS);
1422 OS << "#ifndef LLVM_CLANG_ATTR_CLASSES_INC\n";
1423 OS << "#define LLVM_CLANG_ATTR_CLASSES_INC\n\n";
1425 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1427 for (const auto *Attr : Attrs) {
1428 const Record &R = *Attr;
1430 // FIXME: Currently, documentation is generated as-needed due to the fact
1431 // that there is no way to allow a generated project "reach into" the docs
1432 // directory (for instance, it may be an out-of-tree build). However, we want
1433 // to ensure that every attribute has a Documentation field, and produce an
1434 // error if it has been neglected. Otherwise, the on-demand generation which
1435 // happens server-side will fail. This code is ensuring that functionality,
1436 // even though this Emitter doesn't technically need the documentation.
1437 // When attribute documentation can be generated as part of the build
1438 // itself, this code can be removed.
1439 (void)R.getValueAsListOfDefs("Documentation");
1441 if (!R.getValueAsBit("ASTNode"))
1444 const std::vector<Record *> Supers = R.getSuperClasses();
1445 assert(!Supers.empty() && "Forgot to specify a superclass for the attr");
1446 std::string SuperName;
1447 for (const auto *Super : llvm::make_range(Supers.rbegin(), Supers.rend())) {
1448 const Record &R = *Super;
1449 if (R.getName() != "TargetSpecificAttr" && SuperName.empty())
1450 SuperName = R.getName();
1453 OS << "class " << R.getName() << "Attr : public " << SuperName << " {\n";
1455 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
1456 std::vector<std::unique_ptr<Argument>> Args;
1457 Args.reserve(ArgRecords.size());
1459 for (const auto *ArgRecord : ArgRecords) {
1460 Args.emplace_back(createArgument(*ArgRecord, R.getName()));
1461 Args.back()->writeDeclarations(OS);
1465 OS << "\npublic:\n";
1467 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
1469 // If there are zero or one spellings, all spelling-related functionality
1470 // can be elided. If all of the spellings share the same name, the spelling
1471 // functionality can also be elided.
1472 bool ElideSpelling = (Spellings.size() <= 1) ||
1473 SpellingNamesAreCommon(Spellings);
1475 // This maps spelling index values to semantic Spelling enumerants.
1476 SemanticSpellingMap SemanticToSyntacticMap;
1479 OS << CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
1481 OS << " static " << R.getName() << "Attr *CreateImplicit(";
1482 OS << "ASTContext &Ctx";
1484 OS << ", Spelling S";
1485 for (auto const &ai : Args) {
1487 ai->writeCtorParameters(OS);
1489 OS << ", SourceRange Loc = SourceRange()";
1491 OS << " " << R.getName() << "Attr *A = new (Ctx) " << R.getName();
1492 OS << "Attr(Loc, Ctx, ";
1493 for (auto const &ai : Args) {
1494 ai->writeImplicitCtorArgs(OS);
1497 OS << (ElideSpelling ? "0" : "S") << ");\n";
1498 OS << " A->setImplicit(true);\n";
1499 OS << " return A;\n }\n\n";
1501 OS << " " << R.getName() << "Attr(SourceRange R, ASTContext &Ctx\n";
1503 bool HasOpt = false;
1504 for (auto const &ai : Args) {
1506 ai->writeCtorParameters(OS);
1508 if (ai->isOptional())
1513 OS << "unsigned SI\n";
1516 OS << " : " << SuperName << "(attr::" << R.getName() << ", R, SI)\n";
1518 for (auto const &ai : Args) {
1520 ai->writeCtorInitializers(OS);
1526 for (auto const &ai : Args) {
1527 ai->writeCtorBody(OS);
1532 // If there are optional arguments, write out a constructor that elides the
1533 // optional arguments as well.
1535 OS << " " << R.getName() << "Attr(SourceRange R, ASTContext &Ctx\n";
1536 for (auto const &ai : Args) {
1537 if (!ai->isOptional()) {
1539 ai->writeCtorParameters(OS);
1545 OS << "unsigned SI\n";
1548 OS << " : " << SuperName << "(attr::" << R.getName() << ", R, SI)\n";
1550 for (auto const &ai : Args) {
1552 ai->writeCtorDefaultInitializers(OS);
1558 for (auto const &ai : Args) {
1559 if (!ai->isOptional()) {
1560 ai->writeCtorBody(OS);
1567 OS << " " << R.getName() << "Attr *clone(ASTContext &C) const override;\n";
1568 OS << " void printPretty(raw_ostream &OS,\n"
1569 << " const PrintingPolicy &Policy) const override;\n";
1570 OS << " const char *getSpelling() const override;\n";
1572 if (!ElideSpelling) {
1573 assert(!SemanticToSyntacticMap.empty() && "Empty semantic mapping list");
1574 OS << " Spelling getSemanticSpelling() const {\n";
1575 WriteSemanticSpellingSwitch("SpellingListIndex", SemanticToSyntacticMap,
1580 writeAttrAccessorDefinition(R, OS);
1582 for (auto const &ai : Args) {
1583 ai->writeAccessors(OS);
1586 if (ai->isEnumArg())
1587 static_cast<const EnumArgument *>(ai.get())->writeConversion(OS);
1588 else if (ai->isVariadicEnumArg())
1589 static_cast<const VariadicEnumArgument *>(ai.get())
1590 ->writeConversion(OS);
1593 OS << R.getValueAsString("AdditionalMembers");
1596 OS << " static bool classof(const Attr *A) { return A->getKind() == "
1597 << "attr::" << R.getName() << "; }\n";
1599 bool LateParsed = R.getValueAsBit("LateParsed");
1600 OS << " bool isLateParsed() const override { return "
1601 << LateParsed << "; }\n";
1603 if (R.getValueAsBit("DuplicatesAllowedWhileMerging"))
1604 OS << " bool duplicatesAllowed() const override { return true; }\n\n";
1612 // Emits the class method definitions for attributes.
1613 void EmitClangAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
1614 emitSourceFileHeader("Attribute classes' member function definitions", OS);
1616 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1618 for (auto *Attr : Attrs) {
1621 if (!R.getValueAsBit("ASTNode"))
1624 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
1625 std::vector<std::unique_ptr<Argument>> Args;
1626 for (const auto *Arg : ArgRecords)
1627 Args.emplace_back(createArgument(*Arg, R.getName()));
1629 for (auto const &ai : Args)
1630 ai->writeAccessorDefinitions(OS);
1632 OS << R.getName() << "Attr *" << R.getName()
1633 << "Attr::clone(ASTContext &C) const {\n";
1634 OS << " auto *A = new (C) " << R.getName() << "Attr(getLocation(), C";
1635 for (auto const &ai : Args) {
1637 ai->writeCloneArgs(OS);
1639 OS << ", getSpellingListIndex());\n";
1640 OS << " A->Inherited = Inherited;\n";
1641 OS << " A->IsPackExpansion = IsPackExpansion;\n";
1642 OS << " A->Implicit = Implicit;\n";
1643 OS << " return A;\n}\n\n";
1645 writePrettyPrintFunction(R, Args, OS);
1646 writeGetSpellingFunction(R, OS);
1650 } // end namespace clang
1652 static void EmitAttrList(raw_ostream &OS, StringRef Class,
1653 const std::vector<Record*> &AttrList) {
1654 std::vector<Record*>::const_iterator i = AttrList.begin(), e = AttrList.end();
1657 // Move the end iterator back to emit the last attribute.
1658 for(--e; i != e; ++i) {
1659 if (!(*i)->getValueAsBit("ASTNode"))
1662 OS << Class << "(" << (*i)->getName() << ")\n";
1665 OS << "LAST_" << Class << "(" << (*i)->getName() << ")\n\n";
1669 // Determines if an attribute has a Pragma spelling.
1670 static bool AttrHasPragmaSpelling(const Record *R) {
1671 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*R);
1672 return std::find_if(Spellings.begin(), Spellings.end(),
1673 [](const FlattenedSpelling &S) {
1674 return S.variety() == "Pragma";
1675 }) != Spellings.end();
1679 // Emits the enumeration list for attributes.
1680 void EmitClangAttrList(RecordKeeper &Records, raw_ostream &OS) {
1681 emitSourceFileHeader("List of all attributes that Clang recognizes", OS);
1683 OS << "#ifndef LAST_ATTR\n";
1684 OS << "#define LAST_ATTR(NAME) ATTR(NAME)\n";
1687 OS << "#ifndef INHERITABLE_ATTR\n";
1688 OS << "#define INHERITABLE_ATTR(NAME) ATTR(NAME)\n";
1691 OS << "#ifndef LAST_INHERITABLE_ATTR\n";
1692 OS << "#define LAST_INHERITABLE_ATTR(NAME) INHERITABLE_ATTR(NAME)\n";
1695 OS << "#ifndef INHERITABLE_PARAM_ATTR\n";
1696 OS << "#define INHERITABLE_PARAM_ATTR(NAME) ATTR(NAME)\n";
1699 OS << "#ifndef LAST_INHERITABLE_PARAM_ATTR\n";
1700 OS << "#define LAST_INHERITABLE_PARAM_ATTR(NAME)"
1701 " INHERITABLE_PARAM_ATTR(NAME)\n";
1704 OS << "#ifndef PRAGMA_SPELLING_ATTR\n";
1705 OS << "#define PRAGMA_SPELLING_ATTR(NAME)\n";
1708 OS << "#ifndef LAST_PRAGMA_SPELLING_ATTR\n";
1709 OS << "#define LAST_PRAGMA_SPELLING_ATTR(NAME) PRAGMA_SPELLING_ATTR(NAME)\n";
1712 Record *InhClass = Records.getClass("InheritableAttr");
1713 Record *InhParamClass = Records.getClass("InheritableParamAttr");
1714 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr"),
1715 NonInhAttrs, InhAttrs, InhParamAttrs, PragmaAttrs;
1716 for (auto *Attr : Attrs) {
1717 if (!Attr->getValueAsBit("ASTNode"))
1720 if (AttrHasPragmaSpelling(Attr))
1721 PragmaAttrs.push_back(Attr);
1723 if (Attr->isSubClassOf(InhParamClass))
1724 InhParamAttrs.push_back(Attr);
1725 else if (Attr->isSubClassOf(InhClass))
1726 InhAttrs.push_back(Attr);
1728 NonInhAttrs.push_back(Attr);
1731 EmitAttrList(OS, "PRAGMA_SPELLING_ATTR", PragmaAttrs);
1732 EmitAttrList(OS, "INHERITABLE_PARAM_ATTR", InhParamAttrs);
1733 EmitAttrList(OS, "INHERITABLE_ATTR", InhAttrs);
1734 EmitAttrList(OS, "ATTR", NonInhAttrs);
1736 OS << "#undef LAST_ATTR\n";
1737 OS << "#undef INHERITABLE_ATTR\n";
1738 OS << "#undef LAST_INHERITABLE_ATTR\n";
1739 OS << "#undef LAST_INHERITABLE_PARAM_ATTR\n";
1740 OS << "#undef LAST_PRAGMA_ATTR\n";
1741 OS << "#undef PRAGMA_SPELLING_ATTR\n";
1742 OS << "#undef ATTR\n";
1745 // Emits the code to read an attribute from a precompiled header.
1746 void EmitClangAttrPCHRead(RecordKeeper &Records, raw_ostream &OS) {
1747 emitSourceFileHeader("Attribute deserialization code", OS);
1749 Record *InhClass = Records.getClass("InheritableAttr");
1750 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"),
1752 std::vector<std::unique_ptr<Argument>> Args;
1754 OS << " switch (Kind) {\n";
1755 OS << " default:\n";
1756 OS << " llvm_unreachable(\"Unknown attribute!\");\n";
1757 for (const auto *Attr : Attrs) {
1758 const Record &R = *Attr;
1759 if (!R.getValueAsBit("ASTNode"))
1762 OS << " case attr::" << R.getName() << ": {\n";
1763 if (R.isSubClassOf(InhClass))
1764 OS << " bool isInherited = Record[Idx++];\n";
1765 OS << " bool isImplicit = Record[Idx++];\n";
1766 OS << " unsigned Spelling = Record[Idx++];\n";
1767 ArgRecords = R.getValueAsListOfDefs("Args");
1769 for (const auto *Arg : ArgRecords) {
1770 Args.emplace_back(createArgument(*Arg, R.getName()));
1771 Args.back()->writePCHReadDecls(OS);
1773 OS << " New = new (Context) " << R.getName() << "Attr(Range, Context";
1774 for (auto const &ri : Args) {
1776 ri->writePCHReadArgs(OS);
1778 OS << ", Spelling);\n";
1779 if (R.isSubClassOf(InhClass))
1780 OS << " cast<InheritableAttr>(New)->setInherited(isInherited);\n";
1781 OS << " New->setImplicit(isImplicit);\n";
1788 // Emits the code to write an attribute to a precompiled header.
1789 void EmitClangAttrPCHWrite(RecordKeeper &Records, raw_ostream &OS) {
1790 emitSourceFileHeader("Attribute serialization code", OS);
1792 Record *InhClass = Records.getClass("InheritableAttr");
1793 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
1795 OS << " switch (A->getKind()) {\n";
1796 OS << " default:\n";
1797 OS << " llvm_unreachable(\"Unknown attribute kind!\");\n";
1799 for (const auto *Attr : Attrs) {
1800 const Record &R = *Attr;
1801 if (!R.getValueAsBit("ASTNode"))
1803 OS << " case attr::" << R.getName() << ": {\n";
1804 Args = R.getValueAsListOfDefs("Args");
1805 if (R.isSubClassOf(InhClass) || !Args.empty())
1806 OS << " const " << R.getName() << "Attr *SA = cast<" << R.getName()
1808 if (R.isSubClassOf(InhClass))
1809 OS << " Record.push_back(SA->isInherited());\n";
1810 OS << " Record.push_back(A->isImplicit());\n";
1811 OS << " Record.push_back(A->getSpellingListIndex());\n";
1813 for (const auto *Arg : Args)
1814 createArgument(*Arg, R.getName())->writePCHWrite(OS);
1821 static void GenerateHasAttrSpellingStringSwitch(
1822 const std::vector<Record *> &Attrs, raw_ostream &OS,
1823 const std::string &Variety = "", const std::string &Scope = "") {
1824 for (const auto *Attr : Attrs) {
1825 // C++11-style attributes have specific version information associated with
1826 // them. If the attribute has no scope, the version information must not
1827 // have the default value (1), as that's incorrect. Instead, the unscoped
1828 // attribute version information should be taken from the SD-6 standing
1829 // document, which can be found at:
1830 // https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations
1833 if (Variety == "CXX11") {
1834 std::vector<Record *> Spellings = Attr->getValueAsListOfDefs("Spellings");
1835 for (const auto &Spelling : Spellings) {
1836 if (Spelling->getValueAsString("Variety") == "CXX11") {
1837 Version = static_cast<int>(Spelling->getValueAsInt("Version"));
1838 if (Scope.empty() && Version == 1)
1839 PrintError(Spelling->getLoc(), "C++ standard attributes must "
1840 "have valid version information.");
1846 // It is assumed that there will be an llvm::Triple object named T within
1847 // scope that can be used to determine whether the attribute exists in
1850 if (Attr->isSubClassOf("TargetSpecificAttr")) {
1851 const Record *R = Attr->getValueAsDef("Target");
1852 std::vector<std::string> Arches = R->getValueAsListOfStrings("Arches");
1855 for (auto AI = Arches.begin(), AE = Arches.end(); AI != AE; ++AI) {
1856 std::string Part = *AI;
1857 Test += "T.getArch() == llvm::Triple::" + Part;
1863 std::vector<std::string> OSes;
1864 if (!R->isValueUnset("OSes")) {
1866 std::vector<std::string> OSes = R->getValueAsListOfStrings("OSes");
1867 for (auto AI = OSes.begin(), AE = OSes.end(); AI != AE; ++AI) {
1868 std::string Part = *AI;
1870 Test += "T.getOS() == llvm::Triple::" + Part;
1877 // If this is the C++11 variety, also add in the LangOpts test.
1878 if (Variety == "CXX11")
1879 Test += " && LangOpts.CPlusPlus11";
1880 } else if (Variety == "CXX11")
1881 // C++11 mode should be checked against LangOpts, which is presumed to be
1882 // present in the caller.
1883 Test = "LangOpts.CPlusPlus11";
1885 std::string TestStr =
1886 !Test.empty() ? Test + " ? " + llvm::itostr(Version) + " : 0" : "1";
1887 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
1888 for (const auto &S : Spellings)
1889 if (Variety.empty() || (Variety == S.variety() &&
1890 (Scope.empty() || Scope == S.nameSpace())))
1891 OS << " .Case(\"" << S.name() << "\", " << TestStr << ")\n";
1893 OS << " .Default(0);\n";
1896 // Emits the list of spellings for attributes.
1897 void EmitClangAttrHasAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
1898 emitSourceFileHeader("Code to implement the __has_attribute logic", OS);
1900 // Separate all of the attributes out into four group: generic, C++11, GNU,
1901 // and declspecs. Then generate a big switch statement for each of them.
1902 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
1903 std::vector<Record *> Declspec, GNU, Pragma;
1904 std::map<std::string, std::vector<Record *>> CXX;
1906 // Walk over the list of all attributes, and split them out based on the
1907 // spelling variety.
1908 for (auto *R : Attrs) {
1909 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*R);
1910 for (const auto &SI : Spellings) {
1911 std::string Variety = SI.variety();
1912 if (Variety == "GNU")
1914 else if (Variety == "Declspec")
1915 Declspec.push_back(R);
1916 else if (Variety == "CXX11")
1917 CXX[SI.nameSpace()].push_back(R);
1918 else if (Variety == "Pragma")
1919 Pragma.push_back(R);
1923 OS << "switch (Syntax) {\n";
1924 OS << "case AttrSyntax::GNU:\n";
1925 OS << " return llvm::StringSwitch<int>(Name)\n";
1926 GenerateHasAttrSpellingStringSwitch(GNU, OS, "GNU");
1927 OS << "case AttrSyntax::Declspec:\n";
1928 OS << " return llvm::StringSwitch<int>(Name)\n";
1929 GenerateHasAttrSpellingStringSwitch(Declspec, OS, "Declspec");
1930 OS << "case AttrSyntax::Pragma:\n";
1931 OS << " return llvm::StringSwitch<int>(Name)\n";
1932 GenerateHasAttrSpellingStringSwitch(Pragma, OS, "Pragma");
1933 OS << "case AttrSyntax::CXX: {\n";
1934 // C++11-style attributes are further split out based on the Scope.
1935 for (std::map<std::string, std::vector<Record *>>::iterator I = CXX.begin(),
1938 if (I != CXX.begin())
1940 if (I->first.empty())
1941 OS << "if (!Scope || Scope->getName() == \"\") {\n";
1943 OS << "if (Scope->getName() == \"" << I->first << "\") {\n";
1944 OS << " return llvm::StringSwitch<int>(Name)\n";
1945 GenerateHasAttrSpellingStringSwitch(I->second, OS, "CXX11", I->first);
1952 void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS) {
1953 emitSourceFileHeader("Code to translate different attribute spellings "
1954 "into internal identifiers", OS);
1957 " switch (AttrKind) {\n"
1959 " llvm_unreachable(\"Unknown attribute kind!\");\n"
1962 ParsedAttrMap Attrs = getParsedAttrList(Records);
1963 for (const auto &I : Attrs) {
1964 const Record &R = *I.second;
1965 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
1966 OS << " case AT_" << I.first << ": {\n";
1967 for (unsigned I = 0; I < Spellings.size(); ++ I) {
1968 OS << " if (Name == \"" << Spellings[I].name() << "\" && "
1970 << StringSwitch<unsigned>(Spellings[I].variety())
1973 .Case("Declspec", 2)
1977 << " && Scope == \"" << Spellings[I].nameSpace() << "\")\n"
1978 << " return " << I << ";\n";
1986 OS << " return 0;\n";
1989 // Emits code used by RecursiveASTVisitor to visit attributes
1990 void EmitClangAttrASTVisitor(RecordKeeper &Records, raw_ostream &OS) {
1991 emitSourceFileHeader("Used by RecursiveASTVisitor to visit attributes.", OS);
1993 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1995 // Write method declarations for Traverse* methods.
1996 // We emit this here because we only generate methods for attributes that
1997 // are declared as ASTNodes.
1998 OS << "#ifdef ATTR_VISITOR_DECLS_ONLY\n\n";
1999 for (const auto *Attr : Attrs) {
2000 const Record &R = *Attr;
2001 if (!R.getValueAsBit("ASTNode"))
2003 OS << " bool Traverse"
2004 << R.getName() << "Attr(" << R.getName() << "Attr *A);\n";
2006 << R.getName() << "Attr(" << R.getName() << "Attr *A) {\n"
2007 << " return true; \n"
2010 OS << "\n#else // ATTR_VISITOR_DECLS_ONLY\n\n";
2012 // Write individual Traverse* methods for each attribute class.
2013 for (const auto *Attr : Attrs) {
2014 const Record &R = *Attr;
2015 if (!R.getValueAsBit("ASTNode"))
2018 OS << "template <typename Derived>\n"
2019 << "bool VISITORCLASS<Derived>::Traverse"
2020 << R.getName() << "Attr(" << R.getName() << "Attr *A) {\n"
2021 << " if (!getDerived().VisitAttr(A))\n"
2022 << " return false;\n"
2023 << " if (!getDerived().Visit" << R.getName() << "Attr(A))\n"
2024 << " return false;\n";
2026 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
2027 for (const auto *Arg : ArgRecords)
2028 createArgument(*Arg, R.getName())->writeASTVisitorTraversal(OS);
2030 OS << " return true;\n";
2034 // Write generic Traverse routine
2035 OS << "template <typename Derived>\n"
2036 << "bool VISITORCLASS<Derived>::TraverseAttr(Attr *A) {\n"
2038 << " return true;\n"
2040 << " switch (A->getKind()) {\n"
2042 << " return true;\n";
2044 for (const auto *Attr : Attrs) {
2045 const Record &R = *Attr;
2046 if (!R.getValueAsBit("ASTNode"))
2049 OS << " case attr::" << R.getName() << ":\n"
2050 << " return getDerived().Traverse" << R.getName() << "Attr("
2051 << "cast<" << R.getName() << "Attr>(A));\n";
2053 OS << " }\n"; // end case
2054 OS << "}\n"; // end function
2055 OS << "#endif // ATTR_VISITOR_DECLS_ONLY\n";
2058 // Emits code to instantiate dependent attributes on templates.
2059 void EmitClangAttrTemplateInstantiate(RecordKeeper &Records, raw_ostream &OS) {
2060 emitSourceFileHeader("Template instantiation code for attributes", OS);
2062 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
2064 OS << "namespace clang {\n"
2065 << "namespace sema {\n\n"
2066 << "Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, "
2068 << " const MultiLevelTemplateArgumentList &TemplateArgs) {\n"
2069 << " switch (At->getKind()) {\n"
2073 for (const auto *Attr : Attrs) {
2074 const Record &R = *Attr;
2075 if (!R.getValueAsBit("ASTNode"))
2078 OS << " case attr::" << R.getName() << ": {\n";
2079 bool ShouldClone = R.getValueAsBit("Clone");
2082 OS << " return NULL;\n";
2087 OS << " const " << R.getName() << "Attr *A = cast<"
2088 << R.getName() << "Attr>(At);\n";
2089 bool TDependent = R.getValueAsBit("TemplateDependent");
2092 OS << " return A->clone(C);\n";
2097 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
2098 std::vector<std::unique_ptr<Argument>> Args;
2099 Args.reserve(ArgRecords.size());
2101 for (const auto *ArgRecord : ArgRecords)
2102 Args.emplace_back(createArgument(*ArgRecord, R.getName()));
2104 for (auto const &ai : Args)
2105 ai->writeTemplateInstantiation(OS);
2107 OS << " return new (C) " << R.getName() << "Attr(A->getLocation(), C";
2108 for (auto const &ai : Args) {
2110 ai->writeTemplateInstantiationArgs(OS);
2112 OS << ", A->getSpellingListIndex());\n }\n";
2114 OS << " } // end switch\n"
2115 << " llvm_unreachable(\"Unknown attribute!\");\n"
2118 << "} // end namespace sema\n"
2119 << "} // end namespace clang\n";
2122 // Emits the list of parsed attributes.
2123 void EmitClangAttrParsedAttrList(RecordKeeper &Records, raw_ostream &OS) {
2124 emitSourceFileHeader("List of all attributes that Clang recognizes", OS);
2126 OS << "#ifndef PARSED_ATTR\n";
2127 OS << "#define PARSED_ATTR(NAME) NAME\n";
2130 ParsedAttrMap Names = getParsedAttrList(Records);
2131 for (const auto &I : Names) {
2132 OS << "PARSED_ATTR(" << I.first << ")\n";
2136 static bool isArgVariadic(const Record &R, StringRef AttrName) {
2137 return createArgument(R, AttrName)->isVariadic();
2140 static void emitArgInfo(const Record &R, std::stringstream &OS) {
2141 // This function will count the number of arguments specified for the
2142 // attribute and emit the number of required arguments followed by the
2143 // number of optional arguments.
2144 std::vector<Record *> Args = R.getValueAsListOfDefs("Args");
2145 unsigned ArgCount = 0, OptCount = 0;
2146 bool HasVariadic = false;
2147 for (const auto *Arg : Args) {
2148 Arg->getValueAsBit("Optional") ? ++OptCount : ++ArgCount;
2149 if (!HasVariadic && isArgVariadic(*Arg, R.getName()))
2153 // If there is a variadic argument, we will set the optional argument count
2154 // to its largest value. Since it's currently a 4-bit number, we set it to 15.
2155 OS << ArgCount << ", " << (HasVariadic ? 15 : OptCount);
2158 static void GenerateDefaultAppertainsTo(raw_ostream &OS) {
2159 OS << "static bool defaultAppertainsTo(Sema &, const AttributeList &,";
2160 OS << "const Decl *) {\n";
2161 OS << " return true;\n";
2165 static std::string CalculateDiagnostic(const Record &S) {
2166 // If the SubjectList object has a custom diagnostic associated with it,
2167 // return that directly.
2168 std::string CustomDiag = S.getValueAsString("CustomDiag");
2169 if (!CustomDiag.empty())
2172 // Given the list of subjects, determine what diagnostic best fits.
2176 ObjCMethod = 1U << 2,
2179 GenericRecord = 1U << 5,
2183 ObjCInterface = 1U << 9,
2185 Namespace = 1U << 11,
2187 CXXMethod = 1U << 13,
2188 ObjCProtocol = 1U << 14
2190 uint32_t SubMask = 0;
2192 std::vector<Record *> Subjects = S.getValueAsListOfDefs("Subjects");
2193 for (const auto *Subject : Subjects) {
2194 const Record &R = *Subject;
2197 if (R.isSubClassOf("SubsetSubject")) {
2198 PrintError(R.getLoc(), "SubsetSubjects should use a custom diagnostic");
2199 // As a fallback, look through the SubsetSubject to see what its base
2200 // type is, and use that. This needs to be updated if SubsetSubjects
2201 // are allowed within other SubsetSubjects.
2202 Name = R.getValueAsDef("Base")->getName();
2206 uint32_t V = StringSwitch<uint32_t>(Name)
2207 .Case("Function", Func)
2209 .Case("ObjCMethod", ObjCMethod)
2210 .Case("ParmVar", Param)
2211 .Case("TypedefName", Type)
2212 .Case("ObjCIvar", ObjCIVar)
2213 .Case("ObjCProperty", ObjCProp)
2214 .Case("Record", GenericRecord)
2215 .Case("ObjCInterface", ObjCInterface)
2216 .Case("ObjCProtocol", ObjCProtocol)
2217 .Case("Block", Block)
2218 .Case("CXXRecord", Class)
2219 .Case("Namespace", Namespace)
2220 .Case("Field", Field)
2221 .Case("CXXMethod", CXXMethod)
2224 // Something wasn't in our mapping, so be helpful and let the developer
2226 PrintFatalError(R.getLoc(), "Unknown subject type: " + R.getName());
2234 // For the simple cases where there's only a single entry in the mask, we
2235 // don't have to resort to bit fiddling.
2236 case Func: return "ExpectedFunction";
2237 case Var: return "ExpectedVariable";
2238 case Param: return "ExpectedParameter";
2239 case Class: return "ExpectedClass";
2241 // FIXME: Currently, this maps to ExpectedMethod based on existing code,
2242 // but should map to something a bit more accurate at some point.
2243 case ObjCMethod: return "ExpectedMethod";
2244 case Type: return "ExpectedType";
2245 case ObjCInterface: return "ExpectedObjectiveCInterface";
2246 case ObjCProtocol: return "ExpectedObjectiveCProtocol";
2248 // "GenericRecord" means struct, union or class; check the language options
2249 // and if not compiling for C++, strip off the class part. Note that this
2250 // relies on the fact that the context for this declares "Sema &S".
2252 return "(S.getLangOpts().CPlusPlus ? ExpectedStructOrUnionOrClass : "
2253 "ExpectedStructOrUnion)";
2254 case Func | ObjCMethod | Block: return "ExpectedFunctionMethodOrBlock";
2255 case Func | ObjCMethod | Class: return "ExpectedFunctionMethodOrClass";
2257 case Func | ObjCMethod | Param: return "ExpectedFunctionMethodOrParameter";
2258 case Func | ObjCMethod: return "ExpectedFunctionOrMethod";
2259 case Func | Var: return "ExpectedVariableOrFunction";
2261 // If not compiling for C++, the class portion does not apply.
2262 case Func | Var | Class:
2263 return "(S.getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass : "
2264 "ExpectedVariableOrFunction)";
2266 case ObjCMethod | ObjCProp: return "ExpectedMethodOrProperty";
2267 case ObjCProtocol | ObjCInterface:
2268 return "ExpectedObjectiveCInterfaceOrProtocol";
2269 case Field | Var: return "ExpectedFieldOrGlobalVar";
2272 PrintFatalError(S.getLoc(),
2273 "Could not deduce diagnostic argument for Attr subjects");
2278 static std::string GetSubjectWithSuffix(const Record *R) {
2279 std::string B = R->getName();
2280 if (B == "DeclBase")
2284 static std::string GenerateCustomAppertainsTo(const Record &Subject,
2286 std::string FnName = "is" + Subject.getName();
2288 // If this code has already been generated, simply return the previous
2290 static std::set<std::string> CustomSubjectSet;
2291 std::set<std::string>::iterator I = CustomSubjectSet.find(FnName);
2292 if (I != CustomSubjectSet.end())
2295 Record *Base = Subject.getValueAsDef("Base");
2297 // Not currently support custom subjects within custom subjects.
2298 if (Base->isSubClassOf("SubsetSubject")) {
2299 PrintFatalError(Subject.getLoc(),
2300 "SubsetSubjects within SubsetSubjects is not supported");
2304 OS << "static bool " << FnName << "(const Decl *D) {\n";
2305 OS << " if (const " << GetSubjectWithSuffix(Base) << " *S = dyn_cast<";
2306 OS << GetSubjectWithSuffix(Base);
2308 OS << " return " << Subject.getValueAsString("CheckCode") << ";\n";
2309 OS << " return false;\n";
2312 CustomSubjectSet.insert(FnName);
2316 static std::string GenerateAppertainsTo(const Record &Attr, raw_ostream &OS) {
2317 // If the attribute does not contain a Subjects definition, then use the
2318 // default appertainsTo logic.
2319 if (Attr.isValueUnset("Subjects"))
2320 return "defaultAppertainsTo";
2322 const Record *SubjectObj = Attr.getValueAsDef("Subjects");
2323 std::vector<Record*> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
2325 // If the list of subjects is empty, it is assumed that the attribute
2326 // appertains to everything.
2327 if (Subjects.empty())
2328 return "defaultAppertainsTo";
2330 bool Warn = SubjectObj->getValueAsDef("Diag")->getValueAsBit("Warn");
2332 // Otherwise, generate an appertainsTo check specific to this attribute which
2333 // checks all of the given subjects against the Decl passed in. Return the
2334 // name of that check to the caller.
2335 std::string FnName = "check" + Attr.getName() + "AppertainsTo";
2336 std::stringstream SS;
2337 SS << "static bool " << FnName << "(Sema &S, const AttributeList &Attr, ";
2338 SS << "const Decl *D) {\n";
2340 for (auto I = Subjects.begin(), E = Subjects.end(); I != E; ++I) {
2341 // If the subject has custom code associated with it, generate a function
2342 // for it. The function cannot be inlined into this check (yet) because it
2343 // requires the subject to be of a specific type, and were that information
2344 // inlined here, it would not support an attribute with multiple custom
2346 if ((*I)->isSubClassOf("SubsetSubject")) {
2347 SS << "!" << GenerateCustomAppertainsTo(**I, OS) << "(D)";
2349 SS << "!isa<" << GetSubjectWithSuffix(*I) << ">(D)";
2356 SS << " S.Diag(Attr.getLoc(), diag::";
2357 SS << (Warn ? "warn_attribute_wrong_decl_type" :
2358 "err_attribute_wrong_decl_type");
2360 SS << " << Attr.getName() << ";
2361 SS << CalculateDiagnostic(*SubjectObj) << ";\n";
2362 SS << " return false;\n";
2364 SS << " return true;\n";
2371 static void GenerateDefaultLangOptRequirements(raw_ostream &OS) {
2372 OS << "static bool defaultDiagnoseLangOpts(Sema &, ";
2373 OS << "const AttributeList &) {\n";
2374 OS << " return true;\n";
2378 static std::string GenerateLangOptRequirements(const Record &R,
2380 // If the attribute has an empty or unset list of language requirements,
2381 // return the default handler.
2382 std::vector<Record *> LangOpts = R.getValueAsListOfDefs("LangOpts");
2383 if (LangOpts.empty())
2384 return "defaultDiagnoseLangOpts";
2386 // Generate the test condition, as well as a unique function name for the
2387 // diagnostic test. The list of options should usually be short (one or two
2388 // options), and the uniqueness isn't strictly necessary (it is just for
2389 // codegen efficiency).
2390 std::string FnName = "check", Test;
2391 for (auto I = LangOpts.begin(), E = LangOpts.end(); I != E; ++I) {
2392 std::string Part = (*I)->getValueAsString("Name");
2393 Test += "S.LangOpts." + Part;
2398 FnName += "LangOpts";
2400 // If this code has already been generated, simply return the previous
2402 static std::set<std::string> CustomLangOptsSet;
2403 std::set<std::string>::iterator I = CustomLangOptsSet.find(FnName);
2404 if (I != CustomLangOptsSet.end())
2407 OS << "static bool " << FnName << "(Sema &S, const AttributeList &Attr) {\n";
2408 OS << " if (" << Test << ")\n";
2409 OS << " return true;\n\n";
2410 OS << " S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) ";
2411 OS << "<< Attr.getName();\n";
2412 OS << " return false;\n";
2415 CustomLangOptsSet.insert(FnName);
2419 static void GenerateDefaultTargetRequirements(raw_ostream &OS) {
2420 OS << "static bool defaultTargetRequirements(const llvm::Triple &) {\n";
2421 OS << " return true;\n";
2425 static std::string GenerateTargetRequirements(const Record &Attr,
2426 const ParsedAttrMap &Dupes,
2428 // If the attribute is not a target specific attribute, return the default
2430 if (!Attr.isSubClassOf("TargetSpecificAttr"))
2431 return "defaultTargetRequirements";
2433 // Get the list of architectures to be tested for.
2434 const Record *R = Attr.getValueAsDef("Target");
2435 std::vector<std::string> Arches = R->getValueAsListOfStrings("Arches");
2436 if (Arches.empty()) {
2437 PrintError(Attr.getLoc(), "Empty list of target architectures for a "
2438 "target-specific attr");
2439 return "defaultTargetRequirements";
2442 // If there are other attributes which share the same parsed attribute kind,
2443 // such as target-specific attributes with a shared spelling, collapse the
2444 // duplicate architectures. This is required because a shared target-specific
2445 // attribute has only one AttributeList::Kind enumeration value, but it
2446 // applies to multiple target architectures. In order for the attribute to be
2447 // considered valid, all of its architectures need to be included.
2448 if (!Attr.isValueUnset("ParseKind")) {
2449 std::string APK = Attr.getValueAsString("ParseKind");
2450 for (const auto &I : Dupes) {
2451 if (I.first == APK) {
2452 std::vector<std::string> DA = I.second->getValueAsDef("Target")
2453 ->getValueAsListOfStrings("Arches");
2454 std::copy(DA.begin(), DA.end(), std::back_inserter(Arches));
2459 std::string FnName = "isTarget", Test = "(";
2460 for (auto I = Arches.begin(), E = Arches.end(); I != E; ++I) {
2461 std::string Part = *I;
2462 Test += "Arch == llvm::Triple::" + Part;
2469 // If the target also requires OS testing, generate those tests as well.
2470 bool UsesOS = false;
2471 if (!R->isValueUnset("OSes")) {
2474 // We know that there was at least one arch test, so we need to and in the
2477 std::vector<std::string> OSes = R->getValueAsListOfStrings("OSes");
2478 for (auto I = OSes.begin(), E = OSes.end(); I != E; ++I) {
2479 std::string Part = *I;
2481 Test += "OS == llvm::Triple::" + Part;
2489 // If this code has already been generated, simply return the previous
2491 static std::set<std::string> CustomTargetSet;
2492 std::set<std::string>::iterator I = CustomTargetSet.find(FnName);
2493 if (I != CustomTargetSet.end())
2496 OS << "static bool " << FnName << "(const llvm::Triple &T) {\n";
2497 OS << " llvm::Triple::ArchType Arch = T.getArch();\n";
2499 OS << " llvm::Triple::OSType OS = T.getOS();\n";
2500 OS << " return " << Test << ";\n";
2503 CustomTargetSet.insert(FnName);
2507 static void GenerateDefaultSpellingIndexToSemanticSpelling(raw_ostream &OS) {
2508 OS << "static unsigned defaultSpellingIndexToSemanticSpelling("
2509 << "const AttributeList &Attr) {\n";
2510 OS << " return UINT_MAX;\n";
2514 static std::string GenerateSpellingIndexToSemanticSpelling(const Record &Attr,
2516 // If the attribute does not have a semantic form, we can bail out early.
2517 if (!Attr.getValueAsBit("ASTNode"))
2518 return "defaultSpellingIndexToSemanticSpelling";
2520 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
2522 // If there are zero or one spellings, or all of the spellings share the same
2523 // name, we can also bail out early.
2524 if (Spellings.size() <= 1 || SpellingNamesAreCommon(Spellings))
2525 return "defaultSpellingIndexToSemanticSpelling";
2527 // Generate the enumeration we will use for the mapping.
2528 SemanticSpellingMap SemanticToSyntacticMap;
2529 std::string Enum = CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
2530 std::string Name = Attr.getName() + "AttrSpellingMap";
2532 OS << "static unsigned " << Name << "(const AttributeList &Attr) {\n";
2534 OS << " unsigned Idx = Attr.getAttributeSpellingListIndex();\n";
2535 WriteSemanticSpellingSwitch("Idx", SemanticToSyntacticMap, OS);
2541 static bool IsKnownToGCC(const Record &Attr) {
2542 // Look at the spellings for this subject; if there are any spellings which
2543 // claim to be known to GCC, the attribute is known to GCC.
2544 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
2545 for (const auto &I : Spellings) {
2552 /// Emits the parsed attribute helpers
2553 void EmitClangAttrParsedAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
2554 emitSourceFileHeader("Parsed attribute helpers", OS);
2556 // Get the list of parsed attributes, and accept the optional list of
2557 // duplicates due to the ParseKind.
2558 ParsedAttrMap Dupes;
2559 ParsedAttrMap Attrs = getParsedAttrList(Records, &Dupes);
2561 // Generate the default appertainsTo, target and language option diagnostic,
2562 // and spelling list index mapping methods.
2563 GenerateDefaultAppertainsTo(OS);
2564 GenerateDefaultLangOptRequirements(OS);
2565 GenerateDefaultTargetRequirements(OS);
2566 GenerateDefaultSpellingIndexToSemanticSpelling(OS);
2568 // Generate the appertainsTo diagnostic methods and write their names into
2569 // another mapping. At the same time, generate the AttrInfoMap object
2570 // contents. Due to the reliance on generated code, use separate streams so
2571 // that code will not be interleaved.
2572 std::stringstream SS;
2573 for (auto I = Attrs.begin(), E = Attrs.end(); I != E; ++I) {
2574 // TODO: If the attribute's kind appears in the list of duplicates, that is
2575 // because it is a target-specific attribute that appears multiple times.
2576 // It would be beneficial to test whether the duplicates are "similar
2577 // enough" to each other to not cause problems. For instance, check that
2578 // the spellings are identical, and custom parsing rules match, etc.
2580 // We need to generate struct instances based off ParsedAttrInfo from
2581 // AttributeList.cpp.
2583 emitArgInfo(*I->second, SS);
2584 SS << ", " << I->second->getValueAsBit("HasCustomParsing");
2585 SS << ", " << I->second->isSubClassOf("TargetSpecificAttr");
2586 SS << ", " << I->second->isSubClassOf("TypeAttr");
2587 SS << ", " << IsKnownToGCC(*I->second);
2588 SS << ", " << GenerateAppertainsTo(*I->second, OS);
2589 SS << ", " << GenerateLangOptRequirements(*I->second, OS);
2590 SS << ", " << GenerateTargetRequirements(*I->second, Dupes, OS);
2591 SS << ", " << GenerateSpellingIndexToSemanticSpelling(*I->second, OS);
2597 SS << " // AT_" << I->first << "\n";
2600 OS << "static const ParsedAttrInfo AttrInfoMap[AttributeList::UnknownAttribute + 1] = {\n";
2605 // Emits the kind list of parsed attributes
2606 void EmitClangAttrParsedAttrKinds(RecordKeeper &Records, raw_ostream &OS) {
2607 emitSourceFileHeader("Attribute name matcher", OS);
2609 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2610 std::vector<StringMatcher::StringPair> GNU, Declspec, CXX11, Keywords, Pragma;
2611 std::set<std::string> Seen;
2612 for (const auto *A : Attrs) {
2613 const Record &Attr = *A;
2615 bool SemaHandler = Attr.getValueAsBit("SemaHandler");
2616 bool Ignored = Attr.getValueAsBit("Ignored");
2617 if (SemaHandler || Ignored) {
2618 // Attribute spellings can be shared between target-specific attributes,
2619 // and can be shared between syntaxes for the same attribute. For
2620 // instance, an attribute can be spelled GNU<"interrupt"> for an ARM-
2621 // specific attribute, or MSP430-specific attribute. Additionally, an
2622 // attribute can be spelled GNU<"dllexport"> and Declspec<"dllexport">
2623 // for the same semantic attribute. Ultimately, we need to map each of
2624 // these to a single AttributeList::Kind value, but the StringMatcher
2625 // class cannot handle duplicate match strings. So we generate a list of
2626 // string to match based on the syntax, and emit multiple string matchers
2627 // depending on the syntax used.
2628 std::string AttrName;
2629 if (Attr.isSubClassOf("TargetSpecificAttr") &&
2630 !Attr.isValueUnset("ParseKind")) {
2631 AttrName = Attr.getValueAsString("ParseKind");
2632 if (Seen.find(AttrName) != Seen.end())
2634 Seen.insert(AttrName);
2636 AttrName = NormalizeAttrName(StringRef(Attr.getName())).str();
2638 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
2639 for (const auto &S : Spellings) {
2640 std::string RawSpelling = S.name();
2641 std::vector<StringMatcher::StringPair> *Matches = nullptr;
2642 std::string Spelling, Variety = S.variety();
2643 if (Variety == "CXX11") {
2645 Spelling += S.nameSpace();
2647 } else if (Variety == "GNU")
2649 else if (Variety == "Declspec")
2650 Matches = &Declspec;
2651 else if (Variety == "Keyword")
2652 Matches = &Keywords;
2653 else if (Variety == "Pragma")
2656 assert(Matches && "Unsupported spelling variety found");
2658 Spelling += NormalizeAttrSpelling(RawSpelling);
2660 Matches->push_back(StringMatcher::StringPair(Spelling,
2661 "return AttributeList::AT_" + AttrName + ";"));
2663 Matches->push_back(StringMatcher::StringPair(Spelling,
2664 "return AttributeList::IgnoredAttribute;"));
2669 OS << "static AttributeList::Kind getAttrKind(StringRef Name, ";
2670 OS << "AttributeList::Syntax Syntax) {\n";
2671 OS << " if (AttributeList::AS_GNU == Syntax) {\n";
2672 StringMatcher("Name", GNU, OS).Emit();
2673 OS << " } else if (AttributeList::AS_Declspec == Syntax) {\n";
2674 StringMatcher("Name", Declspec, OS).Emit();
2675 OS << " } else if (AttributeList::AS_CXX11 == Syntax) {\n";
2676 StringMatcher("Name", CXX11, OS).Emit();
2677 OS << " } else if (AttributeList::AS_Keyword == Syntax) {\n";
2678 StringMatcher("Name", Keywords, OS).Emit();
2679 OS << " } else if (AttributeList::AS_Pragma == Syntax) {\n";
2680 StringMatcher("Name", Pragma, OS).Emit();
2682 OS << " return AttributeList::UnknownAttribute;\n"
2686 // Emits the code to dump an attribute.
2687 void EmitClangAttrDump(RecordKeeper &Records, raw_ostream &OS) {
2688 emitSourceFileHeader("Attribute dumper", OS);
2691 " switch (A->getKind()) {\n"
2693 " llvm_unreachable(\"Unknown attribute kind!\");\n"
2695 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
2696 for (const auto *Attr : Attrs) {
2697 const Record &R = *Attr;
2698 if (!R.getValueAsBit("ASTNode"))
2700 OS << " case attr::" << R.getName() << ": {\n";
2702 // If the attribute has a semantically-meaningful name (which is determined
2703 // by whether there is a Spelling enumeration for it), then write out the
2704 // spelling used for the attribute.
2705 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
2706 if (Spellings.size() > 1 && !SpellingNamesAreCommon(Spellings))
2707 OS << " OS << \" \" << A->getSpelling();\n";
2709 Args = R.getValueAsListOfDefs("Args");
2710 if (!Args.empty()) {
2711 OS << " const " << R.getName() << "Attr *SA = cast<" << R.getName()
2713 for (const auto *Arg : Args)
2714 createArgument(*Arg, R.getName())->writeDump(OS);
2716 for (auto AI = Args.begin(), AE = Args.end(); AI != AE; ++AI)
2717 createArgument(**AI, R.getName())->writeDumpChildren(OS);
2726 void EmitClangAttrParserStringSwitches(RecordKeeper &Records,
2728 emitSourceFileHeader("Parser-related llvm::StringSwitch cases", OS);
2729 emitClangAttrArgContextList(Records, OS);
2730 emitClangAttrIdentifierArgList(Records, OS);
2731 emitClangAttrTypeArgList(Records, OS);
2732 emitClangAttrLateParsedList(Records, OS);
2735 class DocumentationData {
2737 const Record *Documentation;
2738 const Record *Attribute;
2740 DocumentationData(const Record &Documentation, const Record &Attribute)
2741 : Documentation(&Documentation), Attribute(&Attribute) {}
2744 static void WriteCategoryHeader(const Record *DocCategory,
2746 const std::string &Name = DocCategory->getValueAsString("Name");
2747 OS << Name << "\n" << std::string(Name.length(), '=') << "\n";
2749 // If there is content, print that as well.
2750 std::string ContentStr = DocCategory->getValueAsString("Content");
2751 if (!ContentStr.empty()) {
2752 // Trim leading and trailing newlines and spaces.
2753 StringRef Content(ContentStr);
2754 while (Content.startswith("\r") || Content.startswith("\n") ||
2755 Content.startswith(" ") || Content.startswith("\t"))
2756 Content = Content.substr(1);
2757 while (Content.endswith("\r") || Content.endswith("\n") ||
2758 Content.endswith(" ") || Content.endswith("\t"))
2759 Content = Content.substr(0, Content.size() - 1);
2773 static void WriteDocumentation(const DocumentationData &Doc,
2775 // FIXME: there is no way to have a per-spelling category for the attribute
2776 // documentation. This may not be a limiting factor since the spellings
2777 // should generally be consistently applied across the category.
2779 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Doc.Attribute);
2781 // Determine the heading to be used for this attribute.
2782 std::string Heading = Doc.Documentation->getValueAsString("Heading");
2783 bool CustomHeading = !Heading.empty();
2784 if (Heading.empty()) {
2785 // If there's only one spelling, we can simply use that.
2786 if (Spellings.size() == 1)
2787 Heading = Spellings.begin()->name();
2789 std::set<std::string> Uniques;
2790 for (auto I = Spellings.begin(), E = Spellings.end();
2791 I != E && Uniques.size() <= 1; ++I) {
2792 std::string Spelling = NormalizeNameForSpellingComparison(I->name());
2793 Uniques.insert(Spelling);
2795 // If the semantic map has only one spelling, that is sufficient for our
2797 if (Uniques.size() == 1)
2798 Heading = *Uniques.begin();
2802 // If the heading is still empty, it is an error.
2803 if (Heading.empty())
2804 PrintFatalError(Doc.Attribute->getLoc(),
2805 "This attribute requires a heading to be specified");
2807 // Gather a list of unique spellings; this is not the same as the semantic
2808 // spelling for the attribute. Variations in underscores and other non-
2809 // semantic characters are still acceptable.
2810 std::vector<std::string> Names;
2812 unsigned SupportedSpellings = 0;
2813 for (const auto &I : Spellings) {
2814 SpellingKind Kind = StringSwitch<SpellingKind>(I.variety())
2816 .Case("CXX11", CXX11)
2817 .Case("Declspec", Declspec)
2818 .Case("Keyword", Keyword)
2819 .Case("Pragma", Pragma);
2821 // Mask in the supported spelling.
2822 SupportedSpellings |= Kind;
2825 if (Kind == CXX11 && !I.nameSpace().empty())
2826 Name = I.nameSpace() + "::";
2829 // If this name is the same as the heading, do not add it.
2830 if (Name != Heading)
2831 Names.push_back(Name);
2834 // Print out the heading for the attribute. If there are alternate spellings,
2835 // then display those after the heading.
2836 if (!CustomHeading && !Names.empty()) {
2838 for (auto I = Names.begin(), E = Names.end(); I != E; ++I) {
2839 if (I != Names.begin())
2845 OS << Heading << "\n" << std::string(Heading.length(), '-') << "\n";
2847 if (!SupportedSpellings)
2848 PrintFatalError(Doc.Attribute->getLoc(),
2849 "Attribute has no supported spellings; cannot be "
2852 // List what spelling syntaxes the attribute supports.
2853 OS << ".. csv-table:: Supported Syntaxes\n";
2854 OS << " :header: \"GNU\", \"C++11\", \"__declspec\", \"Keyword\",";
2855 OS << " \"Pragma\"\n\n";
2857 if (SupportedSpellings & GNU) OS << "X";
2859 if (SupportedSpellings & CXX11) OS << "X";
2861 if (SupportedSpellings & Declspec) OS << "X";
2863 if (SupportedSpellings & Keyword) OS << "X";
2865 if (SupportedSpellings & Pragma) OS << "X";
2868 // If the attribute is deprecated, print a message about it, and possibly
2869 // provide a replacement attribute.
2870 if (!Doc.Documentation->isValueUnset("Deprecated")) {
2871 OS << "This attribute has been deprecated, and may be removed in a future "
2872 << "version of Clang.";
2873 const Record &Deprecated = *Doc.Documentation->getValueAsDef("Deprecated");
2874 std::string Replacement = Deprecated.getValueAsString("Replacement");
2875 if (!Replacement.empty())
2876 OS << " This attribute has been superseded by ``"
2877 << Replacement << "``.";
2881 std::string ContentStr = Doc.Documentation->getValueAsString("Content");
2882 // Trim leading and trailing newlines and spaces.
2883 StringRef Content(ContentStr);
2884 while (Content.startswith("\r") || Content.startswith("\n") ||
2885 Content.startswith(" ") || Content.startswith("\t"))
2886 Content = Content.substr(1);
2887 while (Content.endswith("\r") || Content.endswith("\n") ||
2888 Content.endswith(" ") || Content.endswith("\t"))
2889 Content = Content.substr(0, Content.size() - 1);
2895 void EmitClangAttrDocs(RecordKeeper &Records, raw_ostream &OS) {
2896 // Get the documentation introduction paragraph.
2897 const Record *Documentation = Records.getDef("GlobalDocumentation");
2898 if (!Documentation) {
2899 PrintFatalError("The Documentation top-level definition is missing, "
2900 "no documentation will be generated.");
2904 OS << Documentation->getValueAsString("Intro") << "\n";
2906 // Gather the Documentation lists from each of the attributes, based on the
2907 // category provided.
2908 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2909 std::map<const Record *, std::vector<DocumentationData>> SplitDocs;
2910 for (const auto *A : Attrs) {
2911 const Record &Attr = *A;
2912 std::vector<Record *> Docs = Attr.getValueAsListOfDefs("Documentation");
2913 for (const auto *D : Docs) {
2914 const Record &Doc = *D;
2915 const Record *Category = Doc.getValueAsDef("Category");
2916 // If the category is "undocumented", then there cannot be any other
2917 // documentation categories (otherwise, the attribute would become
2919 std::string Cat = Category->getValueAsString("Name");
2920 bool Undocumented = Cat == "Undocumented";
2921 if (Undocumented && Docs.size() > 1)
2922 PrintFatalError(Doc.getLoc(),
2923 "Attribute is \"Undocumented\", but has multiple "
2924 "documentation categories");
2927 SplitDocs[Category].push_back(DocumentationData(Doc, Attr));
2931 // Having split the attributes out based on what documentation goes where,
2932 // we can begin to generate sections of documentation.
2933 for (const auto &I : SplitDocs) {
2934 WriteCategoryHeader(I.first, OS);
2936 // Walk over each of the attributes in the category and write out their
2938 for (const auto &Doc : I.second)
2939 WriteDocumentation(Doc, OS);
2943 } // end namespace clang