1 //===- ClangAttrEmitter.cpp - Generate Clang attribute handling =-*- C++ -*--=//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // These tablegen backends emit Clang attribute processing code
11 //===----------------------------------------------------------------------===//
13 #include "llvm/ADT/ArrayRef.h"
14 #include "llvm/ADT/DenseMap.h"
15 #include "llvm/ADT/DenseSet.h"
16 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/ADT/SmallString.h"
18 #include "llvm/ADT/StringExtras.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/ADT/StringSet.h"
21 #include "llvm/ADT/StringSwitch.h"
22 #include "llvm/ADT/iterator_range.h"
23 #include "llvm/Support/ErrorHandling.h"
24 #include "llvm/Support/raw_ostream.h"
25 #include "llvm/TableGen/Error.h"
26 #include "llvm/TableGen/Record.h"
27 #include "llvm/TableGen/StringMatcher.h"
28 #include "llvm/TableGen/TableGenBackend.h"
46 class FlattenedSpelling {
51 FlattenedSpelling(const std::string &Variety, const std::string &Name,
52 const std::string &Namespace, bool KnownToGCC) :
53 V(Variety), N(Name), NS(Namespace), K(KnownToGCC) {}
54 explicit FlattenedSpelling(const Record &Spelling) :
55 V(Spelling.getValueAsString("Variety")),
56 N(Spelling.getValueAsString("Name")) {
58 assert(V != "GCC" && V != "Clang" &&
59 "Given a GCC spelling, which means this hasn't been flattened!");
60 if (V == "CXX11" || V == "C2x" || V == "Pragma")
61 NS = Spelling.getValueAsString("Namespace");
63 K = Spelling.getValueAsBitOrUnset("KnownToGCC", Unset);
66 const std::string &variety() const { return V; }
67 const std::string &name() const { return N; }
68 const std::string &nameSpace() const { return NS; }
69 bool knownToGCC() const { return K; }
72 } // end anonymous namespace
74 static std::vector<FlattenedSpelling>
75 GetFlattenedSpellings(const Record &Attr) {
76 std::vector<Record *> Spellings = Attr.getValueAsListOfDefs("Spellings");
77 std::vector<FlattenedSpelling> Ret;
79 for (const auto &Spelling : Spellings) {
80 StringRef Variety = Spelling->getValueAsString("Variety");
81 StringRef Name = Spelling->getValueAsString("Name");
82 if (Variety == "GCC") {
83 // Gin up two new spelling objects to add into the list.
84 Ret.emplace_back("GNU", Name, "", true);
85 Ret.emplace_back("CXX11", Name, "gnu", true);
86 } else if (Variety == "Clang") {
87 Ret.emplace_back("GNU", Name, "", false);
88 Ret.emplace_back("CXX11", Name, "clang", false);
89 if (Spelling->getValueAsBit("AllowInC"))
90 Ret.emplace_back("C2x", Name, "clang", false);
92 Ret.push_back(FlattenedSpelling(*Spelling));
98 static std::string ReadPCHRecord(StringRef type) {
99 return StringSwitch<std::string>(type)
100 .EndsWith("Decl *", "Record.GetLocalDeclAs<"
101 + std::string(type, 0, type.size()-1) + ">(Record.readInt())")
102 .Case("TypeSourceInfo *", "Record.getTypeSourceInfo()")
103 .Case("Expr *", "Record.readExpr()")
104 .Case("IdentifierInfo *", "Record.getIdentifierInfo()")
105 .Case("StringRef", "Record.readString()")
106 .Case("ParamIdx", "ParamIdx::deserialize(Record.readInt())")
107 .Default("Record.readInt()");
110 // Get a type that is suitable for storing an object of the specified type.
111 static StringRef getStorageType(StringRef type) {
112 return StringSwitch<StringRef>(type)
113 .Case("StringRef", "std::string")
117 // Assumes that the way to get the value is SA->getname()
118 static std::string WritePCHRecord(StringRef type, StringRef name) {
119 return "Record." + StringSwitch<std::string>(type)
120 .EndsWith("Decl *", "AddDeclRef(" + std::string(name) + ");\n")
121 .Case("TypeSourceInfo *", "AddTypeSourceInfo(" + std::string(name) + ");\n")
122 .Case("Expr *", "AddStmt(" + std::string(name) + ");\n")
123 .Case("IdentifierInfo *", "AddIdentifierRef(" + std::string(name) + ");\n")
124 .Case("StringRef", "AddString(" + std::string(name) + ");\n")
125 .Case("ParamIdx", "push_back(" + std::string(name) + ".serialize());\n")
126 .Default("push_back(" + std::string(name) + ");\n");
129 // Normalize attribute name by removing leading and trailing
130 // underscores. For example, __foo, foo__, __foo__ would
132 static StringRef NormalizeAttrName(StringRef AttrName) {
133 AttrName.consume_front("__");
134 AttrName.consume_back("__");
138 // Normalize the name by removing any and all leading and trailing underscores.
139 // This is different from NormalizeAttrName in that it also handles names like
140 // _pascal and __pascal.
141 static StringRef NormalizeNameForSpellingComparison(StringRef Name) {
142 return Name.trim("_");
145 // Normalize the spelling of a GNU attribute (i.e. "x" in "__attribute__((x))"),
146 // removing "__" if it appears at the beginning and end of the attribute's name.
147 static StringRef NormalizeGNUAttrSpelling(StringRef AttrSpelling) {
148 if (AttrSpelling.startswith("__") && AttrSpelling.endswith("__")) {
149 AttrSpelling = AttrSpelling.substr(2, AttrSpelling.size() - 4);
155 typedef std::vector<std::pair<std::string, const Record *>> ParsedAttrMap;
157 static ParsedAttrMap getParsedAttrList(const RecordKeeper &Records,
158 ParsedAttrMap *Dupes = nullptr) {
159 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
160 std::set<std::string> Seen;
162 for (const auto *Attr : Attrs) {
163 if (Attr->getValueAsBit("SemaHandler")) {
165 if (Attr->isSubClassOf("TargetSpecificAttr") &&
166 !Attr->isValueUnset("ParseKind")) {
167 AN = Attr->getValueAsString("ParseKind");
169 // If this attribute has already been handled, it does not need to be
171 if (Seen.find(AN) != Seen.end()) {
173 Dupes->push_back(std::make_pair(AN, Attr));
178 AN = NormalizeAttrName(Attr->getName()).str();
180 R.push_back(std::make_pair(AN, Attr));
189 std::string lowerName, upperName;
195 Argument(const Record &Arg, StringRef Attr)
196 : lowerName(Arg.getValueAsString("Name")), upperName(lowerName),
197 attrName(Attr), isOpt(false), Fake(false) {
198 if (!lowerName.empty()) {
199 lowerName[0] = std::tolower(lowerName[0]);
200 upperName[0] = std::toupper(upperName[0]);
202 // Work around MinGW's macro definition of 'interface' to 'struct'. We
203 // have an attribute argument called 'Interface', so only the lower case
204 // name conflicts with the macro definition.
205 if (lowerName == "interface")
206 lowerName = "interface_";
208 virtual ~Argument() = default;
210 StringRef getLowerName() const { return lowerName; }
211 StringRef getUpperName() const { return upperName; }
212 StringRef getAttrName() const { return attrName; }
214 bool isOptional() const { return isOpt; }
215 void setOptional(bool set) { isOpt = set; }
217 bool isFake() const { return Fake; }
218 void setFake(bool fake) { Fake = fake; }
220 // These functions print the argument contents formatted in different ways.
221 virtual void writeAccessors(raw_ostream &OS) const = 0;
222 virtual void writeAccessorDefinitions(raw_ostream &OS) const {}
223 virtual void writeASTVisitorTraversal(raw_ostream &OS) const {}
224 virtual void writeCloneArgs(raw_ostream &OS) const = 0;
225 virtual void writeTemplateInstantiationArgs(raw_ostream &OS) const = 0;
226 virtual void writeTemplateInstantiation(raw_ostream &OS) const {}
227 virtual void writeCtorBody(raw_ostream &OS) const {}
228 virtual void writeCtorInitializers(raw_ostream &OS) const = 0;
229 virtual void writeCtorDefaultInitializers(raw_ostream &OS) const = 0;
230 virtual void writeCtorParameters(raw_ostream &OS) const = 0;
231 virtual void writeDeclarations(raw_ostream &OS) const = 0;
232 virtual void writePCHReadArgs(raw_ostream &OS) const = 0;
233 virtual void writePCHReadDecls(raw_ostream &OS) const = 0;
234 virtual void writePCHWrite(raw_ostream &OS) const = 0;
235 virtual std::string getIsOmitted() const { return "false"; }
236 virtual void writeValue(raw_ostream &OS) const = 0;
237 virtual void writeDump(raw_ostream &OS) const = 0;
238 virtual void writeDumpChildren(raw_ostream &OS) const {}
239 virtual void writeHasChildren(raw_ostream &OS) const { OS << "false"; }
241 virtual bool isEnumArg() const { return false; }
242 virtual bool isVariadicEnumArg() const { return false; }
243 virtual bool isVariadic() const { return false; }
245 virtual void writeImplicitCtorArgs(raw_ostream &OS) const {
246 OS << getUpperName();
250 class SimpleArgument : public Argument {
254 SimpleArgument(const Record &Arg, StringRef Attr, std::string T)
255 : Argument(Arg, Attr), type(std::move(T)) {}
257 std::string getType() const { return type; }
259 void writeAccessors(raw_ostream &OS) const override {
260 OS << " " << type << " get" << getUpperName() << "() const {\n";
261 OS << " return " << getLowerName() << ";\n";
265 void writeCloneArgs(raw_ostream &OS) const override {
266 OS << getLowerName();
269 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
270 OS << "A->get" << getUpperName() << "()";
273 void writeCtorInitializers(raw_ostream &OS) const override {
274 OS << getLowerName() << "(" << getUpperName() << ")";
277 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
278 OS << getLowerName() << "()";
281 void writeCtorParameters(raw_ostream &OS) const override {
282 OS << type << " " << getUpperName();
285 void writeDeclarations(raw_ostream &OS) const override {
286 OS << type << " " << getLowerName() << ";";
289 void writePCHReadDecls(raw_ostream &OS) const override {
290 std::string read = ReadPCHRecord(type);
291 OS << " " << type << " " << getLowerName() << " = " << read << ";\n";
294 void writePCHReadArgs(raw_ostream &OS) const override {
295 OS << getLowerName();
298 void writePCHWrite(raw_ostream &OS) const override {
299 OS << " " << WritePCHRecord(type, "SA->get" +
300 std::string(getUpperName()) + "()");
303 std::string getIsOmitted() const override {
304 if (type == "IdentifierInfo *")
305 return "!get" + getUpperName().str() + "()";
306 if (type == "ParamIdx")
307 return "!get" + getUpperName().str() + "().isValid()";
311 void writeValue(raw_ostream &OS) const override {
312 if (type == "FunctionDecl *")
313 OS << "\" << get" << getUpperName()
314 << "()->getNameInfo().getAsString() << \"";
315 else if (type == "IdentifierInfo *")
316 // Some non-optional (comma required) identifier arguments can be the
317 // empty string but are then recorded as a nullptr.
318 OS << "\" << (get" << getUpperName() << "() ? get" << getUpperName()
319 << "()->getName() : \"\") << \"";
320 else if (type == "TypeSourceInfo *")
321 OS << "\" << get" << getUpperName() << "().getAsString() << \"";
322 else if (type == "ParamIdx")
323 OS << "\" << get" << getUpperName() << "().getSourceIndex() << \"";
325 OS << "\" << get" << getUpperName() << "() << \"";
328 void writeDump(raw_ostream &OS) const override {
329 if (type == "FunctionDecl *" || type == "NamedDecl *") {
330 OS << " OS << \" \";\n";
331 OS << " dumpBareDeclRef(SA->get" << getUpperName() << "());\n";
332 } else if (type == "IdentifierInfo *") {
333 // Some non-optional (comma required) identifier arguments can be the
334 // empty string but are then recorded as a nullptr.
335 OS << " if (SA->get" << getUpperName() << "())\n"
336 << " OS << \" \" << SA->get" << getUpperName()
337 << "()->getName();\n";
338 } else if (type == "TypeSourceInfo *") {
339 OS << " OS << \" \" << SA->get" << getUpperName()
340 << "().getAsString();\n";
341 } else if (type == "bool") {
342 OS << " if (SA->get" << getUpperName() << "()) OS << \" "
343 << getUpperName() << "\";\n";
344 } else if (type == "int" || type == "unsigned") {
345 OS << " OS << \" \" << SA->get" << getUpperName() << "();\n";
346 } else if (type == "ParamIdx") {
348 OS << " if (SA->get" << getUpperName() << "().isValid())\n ";
349 OS << " OS << \" \" << SA->get" << getUpperName()
350 << "().getSourceIndex();\n";
352 llvm_unreachable("Unknown SimpleArgument type!");
357 class DefaultSimpleArgument : public SimpleArgument {
361 DefaultSimpleArgument(const Record &Arg, StringRef Attr,
362 std::string T, int64_t Default)
363 : SimpleArgument(Arg, Attr, T), Default(Default) {}
365 void writeAccessors(raw_ostream &OS) const override {
366 SimpleArgument::writeAccessors(OS);
368 OS << "\n\n static const " << getType() << " Default" << getUpperName()
370 if (getType() == "bool")
371 OS << (Default != 0 ? "true" : "false");
378 class StringArgument : public Argument {
380 StringArgument(const Record &Arg, StringRef Attr)
381 : Argument(Arg, Attr)
384 void writeAccessors(raw_ostream &OS) const override {
385 OS << " llvm::StringRef get" << getUpperName() << "() const {\n";
386 OS << " return llvm::StringRef(" << getLowerName() << ", "
387 << getLowerName() << "Length);\n";
389 OS << " unsigned get" << getUpperName() << "Length() const {\n";
390 OS << " return " << getLowerName() << "Length;\n";
392 OS << " void set" << getUpperName()
393 << "(ASTContext &C, llvm::StringRef S) {\n";
394 OS << " " << getLowerName() << "Length = S.size();\n";
395 OS << " this->" << getLowerName() << " = new (C, 1) char ["
396 << getLowerName() << "Length];\n";
397 OS << " if (!S.empty())\n";
398 OS << " std::memcpy(this->" << getLowerName() << ", S.data(), "
399 << getLowerName() << "Length);\n";
403 void writeCloneArgs(raw_ostream &OS) const override {
404 OS << "get" << getUpperName() << "()";
407 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
408 OS << "A->get" << getUpperName() << "()";
411 void writeCtorBody(raw_ostream &OS) const override {
412 OS << " if (!" << getUpperName() << ".empty())\n";
413 OS << " std::memcpy(" << getLowerName() << ", " << getUpperName()
414 << ".data(), " << getLowerName() << "Length);\n";
417 void writeCtorInitializers(raw_ostream &OS) const override {
418 OS << getLowerName() << "Length(" << getUpperName() << ".size()),"
419 << getLowerName() << "(new (Ctx, 1) char[" << getLowerName()
423 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
424 OS << getLowerName() << "Length(0)," << getLowerName() << "(nullptr)";
427 void writeCtorParameters(raw_ostream &OS) const override {
428 OS << "llvm::StringRef " << getUpperName();
431 void writeDeclarations(raw_ostream &OS) const override {
432 OS << "unsigned " << getLowerName() << "Length;\n";
433 OS << "char *" << getLowerName() << ";";
436 void writePCHReadDecls(raw_ostream &OS) const override {
437 OS << " std::string " << getLowerName()
438 << "= Record.readString();\n";
441 void writePCHReadArgs(raw_ostream &OS) const override {
442 OS << getLowerName();
445 void writePCHWrite(raw_ostream &OS) const override {
446 OS << " Record.AddString(SA->get" << getUpperName() << "());\n";
449 void writeValue(raw_ostream &OS) const override {
450 OS << "\\\"\" << get" << getUpperName() << "() << \"\\\"";
453 void writeDump(raw_ostream &OS) const override {
454 OS << " OS << \" \\\"\" << SA->get" << getUpperName()
455 << "() << \"\\\"\";\n";
459 class AlignedArgument : public Argument {
461 AlignedArgument(const Record &Arg, StringRef Attr)
462 : Argument(Arg, Attr)
465 void writeAccessors(raw_ostream &OS) const override {
466 OS << " bool is" << getUpperName() << "Dependent() const;\n";
468 OS << " unsigned get" << getUpperName() << "(ASTContext &Ctx) const;\n";
470 OS << " bool is" << getUpperName() << "Expr() const {\n";
471 OS << " return is" << getLowerName() << "Expr;\n";
474 OS << " Expr *get" << getUpperName() << "Expr() const {\n";
475 OS << " assert(is" << getLowerName() << "Expr);\n";
476 OS << " return " << getLowerName() << "Expr;\n";
479 OS << " TypeSourceInfo *get" << getUpperName() << "Type() const {\n";
480 OS << " assert(!is" << getLowerName() << "Expr);\n";
481 OS << " return " << getLowerName() << "Type;\n";
485 void writeAccessorDefinitions(raw_ostream &OS) const override {
486 OS << "bool " << getAttrName() << "Attr::is" << getUpperName()
487 << "Dependent() const {\n";
488 OS << " if (is" << getLowerName() << "Expr)\n";
489 OS << " return " << getLowerName() << "Expr && (" << getLowerName()
490 << "Expr->isValueDependent() || " << getLowerName()
491 << "Expr->isTypeDependent());\n";
493 OS << " return " << getLowerName()
494 << "Type->getType()->isDependentType();\n";
497 // FIXME: Do not do the calculation here
498 // FIXME: Handle types correctly
499 // A null pointer means maximum alignment
500 OS << "unsigned " << getAttrName() << "Attr::get" << getUpperName()
501 << "(ASTContext &Ctx) const {\n";
502 OS << " assert(!is" << getUpperName() << "Dependent());\n";
503 OS << " if (is" << getLowerName() << "Expr)\n";
504 OS << " return " << getLowerName() << "Expr ? " << getLowerName()
505 << "Expr->EvaluateKnownConstInt(Ctx).getZExtValue()"
506 << " * Ctx.getCharWidth() : "
507 << "Ctx.getTargetDefaultAlignForAttributeAligned();\n";
509 OS << " return 0; // FIXME\n";
513 void writeASTVisitorTraversal(raw_ostream &OS) const override {
514 StringRef Name = getUpperName();
515 OS << " if (A->is" << Name << "Expr()) {\n"
516 << " if (!getDerived().TraverseStmt(A->get" << Name << "Expr()))\n"
517 << " return false;\n"
518 << " } else if (auto *TSI = A->get" << Name << "Type()) {\n"
519 << " if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))\n"
520 << " return false;\n"
524 void writeCloneArgs(raw_ostream &OS) const override {
525 OS << "is" << getLowerName() << "Expr, is" << getLowerName()
526 << "Expr ? static_cast<void*>(" << getLowerName()
527 << "Expr) : " << getLowerName()
531 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
532 // FIXME: move the definition in Sema::InstantiateAttrs to here.
533 // In the meantime, aligned attributes are cloned.
536 void writeCtorBody(raw_ostream &OS) const override {
537 OS << " if (is" << getLowerName() << "Expr)\n";
538 OS << " " << getLowerName() << "Expr = reinterpret_cast<Expr *>("
539 << getUpperName() << ");\n";
541 OS << " " << getLowerName()
542 << "Type = reinterpret_cast<TypeSourceInfo *>(" << getUpperName()
546 void writeCtorInitializers(raw_ostream &OS) const override {
547 OS << "is" << getLowerName() << "Expr(Is" << getUpperName() << "Expr)";
550 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
551 OS << "is" << getLowerName() << "Expr(false)";
554 void writeCtorParameters(raw_ostream &OS) const override {
555 OS << "bool Is" << getUpperName() << "Expr, void *" << getUpperName();
558 void writeImplicitCtorArgs(raw_ostream &OS) const override {
559 OS << "Is" << getUpperName() << "Expr, " << getUpperName();
562 void writeDeclarations(raw_ostream &OS) const override {
563 OS << "bool is" << getLowerName() << "Expr;\n";
565 OS << "Expr *" << getLowerName() << "Expr;\n";
566 OS << "TypeSourceInfo *" << getLowerName() << "Type;\n";
570 void writePCHReadArgs(raw_ostream &OS) const override {
571 OS << "is" << getLowerName() << "Expr, " << getLowerName() << "Ptr";
574 void writePCHReadDecls(raw_ostream &OS) const override {
575 OS << " bool is" << getLowerName() << "Expr = Record.readInt();\n";
576 OS << " void *" << getLowerName() << "Ptr;\n";
577 OS << " if (is" << getLowerName() << "Expr)\n";
578 OS << " " << getLowerName() << "Ptr = Record.readExpr();\n";
580 OS << " " << getLowerName()
581 << "Ptr = Record.getTypeSourceInfo();\n";
584 void writePCHWrite(raw_ostream &OS) const override {
585 OS << " Record.push_back(SA->is" << getUpperName() << "Expr());\n";
586 OS << " if (SA->is" << getUpperName() << "Expr())\n";
587 OS << " Record.AddStmt(SA->get" << getUpperName() << "Expr());\n";
589 OS << " Record.AddTypeSourceInfo(SA->get" << getUpperName()
593 std::string getIsOmitted() const override {
594 return "!is" + getLowerName().str() + "Expr || !" + getLowerName().str()
598 void writeValue(raw_ostream &OS) const override {
600 OS << " " << getLowerName()
601 << "Expr->printPretty(OS, nullptr, Policy);\n";
605 void writeDump(raw_ostream &OS) const override {
606 OS << " if (!SA->is" << getUpperName() << "Expr())\n";
607 OS << " dumpType(SA->get" << getUpperName()
608 << "Type()->getType());\n";
611 void writeDumpChildren(raw_ostream &OS) const override {
612 OS << " if (SA->is" << getUpperName() << "Expr())\n";
613 OS << " Visit(SA->get" << getUpperName() << "Expr());\n";
616 void writeHasChildren(raw_ostream &OS) const override {
617 OS << "SA->is" << getUpperName() << "Expr()";
621 class VariadicArgument : public Argument {
622 std::string Type, ArgName, ArgSizeName, RangeName;
625 // Assumed to receive a parameter: raw_ostream OS.
626 virtual void writeValueImpl(raw_ostream &OS) const {
627 OS << " OS << Val;\n";
629 // Assumed to receive a parameter: raw_ostream OS.
630 virtual void writeDumpImpl(raw_ostream &OS) const {
631 OS << " OS << \" \" << Val;\n";
635 VariadicArgument(const Record &Arg, StringRef Attr, std::string T)
636 : Argument(Arg, Attr), Type(std::move(T)),
637 ArgName(getLowerName().str() + "_"), ArgSizeName(ArgName + "Size"),
638 RangeName(getLowerName()) {}
640 const std::string &getType() const { return Type; }
641 const std::string &getArgName() const { return ArgName; }
642 const std::string &getArgSizeName() const { return ArgSizeName; }
643 bool isVariadic() const override { return true; }
645 void writeAccessors(raw_ostream &OS) const override {
646 std::string IteratorType = getLowerName().str() + "_iterator";
647 std::string BeginFn = getLowerName().str() + "_begin()";
648 std::string EndFn = getLowerName().str() + "_end()";
650 OS << " typedef " << Type << "* " << IteratorType << ";\n";
651 OS << " " << IteratorType << " " << BeginFn << " const {"
652 << " return " << ArgName << "; }\n";
653 OS << " " << IteratorType << " " << EndFn << " const {"
654 << " return " << ArgName << " + " << ArgSizeName << "; }\n";
655 OS << " unsigned " << getLowerName() << "_size() const {"
656 << " return " << ArgSizeName << "; }\n";
657 OS << " llvm::iterator_range<" << IteratorType << "> " << RangeName
658 << "() const { return llvm::make_range(" << BeginFn << ", " << EndFn
662 void writeCloneArgs(raw_ostream &OS) const override {
663 OS << ArgName << ", " << ArgSizeName;
666 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
667 // This isn't elegant, but we have to go through public methods...
668 OS << "A->" << getLowerName() << "_begin(), "
669 << "A->" << getLowerName() << "_size()";
672 void writeASTVisitorTraversal(raw_ostream &OS) const override {
673 // FIXME: Traverse the elements.
676 void writeCtorBody(raw_ostream &OS) const override {
677 OS << " std::copy(" << getUpperName() << ", " << getUpperName()
678 << " + " << ArgSizeName << ", " << ArgName << ");\n";
681 void writeCtorInitializers(raw_ostream &OS) const override {
682 OS << ArgSizeName << "(" << getUpperName() << "Size), "
683 << ArgName << "(new (Ctx, 16) " << getType() << "["
684 << ArgSizeName << "])";
687 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
688 OS << ArgSizeName << "(0), " << ArgName << "(nullptr)";
691 void writeCtorParameters(raw_ostream &OS) const override {
692 OS << getType() << " *" << getUpperName() << ", unsigned "
693 << getUpperName() << "Size";
696 void writeImplicitCtorArgs(raw_ostream &OS) const override {
697 OS << getUpperName() << ", " << getUpperName() << "Size";
700 void writeDeclarations(raw_ostream &OS) const override {
701 OS << " unsigned " << ArgSizeName << ";\n";
702 OS << " " << getType() << " *" << ArgName << ";";
705 void writePCHReadDecls(raw_ostream &OS) const override {
706 OS << " unsigned " << getLowerName() << "Size = Record.readInt();\n";
707 OS << " SmallVector<" << getType() << ", 4> "
708 << getLowerName() << ";\n";
709 OS << " " << getLowerName() << ".reserve(" << getLowerName()
712 // If we can't store the values in the current type (if it's something
713 // like StringRef), store them in a different type and convert the
714 // container afterwards.
715 std::string StorageType = getStorageType(getType());
716 std::string StorageName = getLowerName();
717 if (StorageType != getType()) {
718 StorageName += "Storage";
719 OS << " SmallVector<" << StorageType << ", 4> "
720 << StorageName << ";\n";
721 OS << " " << StorageName << ".reserve(" << getLowerName()
725 OS << " for (unsigned i = 0; i != " << getLowerName() << "Size; ++i)\n";
726 std::string read = ReadPCHRecord(Type);
727 OS << " " << StorageName << ".push_back(" << read << ");\n";
729 if (StorageType != getType()) {
730 OS << " for (unsigned i = 0; i != " << getLowerName() << "Size; ++i)\n";
731 OS << " " << getLowerName() << ".push_back("
732 << StorageName << "[i]);\n";
736 void writePCHReadArgs(raw_ostream &OS) const override {
737 OS << getLowerName() << ".data(), " << getLowerName() << "Size";
740 void writePCHWrite(raw_ostream &OS) const override {
741 OS << " Record.push_back(SA->" << getLowerName() << "_size());\n";
742 OS << " for (auto &Val : SA->" << RangeName << "())\n";
743 OS << " " << WritePCHRecord(Type, "Val");
746 void writeValue(raw_ostream &OS) const override {
748 OS << " bool isFirst = true;\n"
749 << " for (const auto &Val : " << RangeName << "()) {\n"
750 << " if (isFirst) isFirst = false;\n"
751 << " else OS << \", \";\n";
757 void writeDump(raw_ostream &OS) const override {
758 OS << " for (const auto &Val : SA->" << RangeName << "())\n";
763 class VariadicParamIdxArgument : public VariadicArgument {
765 VariadicParamIdxArgument(const Record &Arg, StringRef Attr)
766 : VariadicArgument(Arg, Attr, "ParamIdx") {}
769 void writeValueImpl(raw_ostream &OS) const override {
770 OS << " OS << Val.getSourceIndex();\n";
773 void writeDumpImpl(raw_ostream &OS) const override {
774 OS << " OS << \" \" << Val.getSourceIndex();\n";
778 struct VariadicParamOrParamIdxArgument : public VariadicArgument {
779 VariadicParamOrParamIdxArgument(const Record &Arg, StringRef Attr)
780 : VariadicArgument(Arg, Attr, "int") {}
783 // Unique the enums, but maintain the original declaration ordering.
784 std::vector<StringRef>
785 uniqueEnumsInOrder(const std::vector<StringRef> &enums) {
786 std::vector<StringRef> uniques;
787 SmallDenseSet<StringRef, 8> unique_set;
788 for (const auto &i : enums) {
789 if (unique_set.insert(i).second)
790 uniques.push_back(i);
795 class EnumArgument : public Argument {
797 std::vector<StringRef> values, enums, uniques;
800 EnumArgument(const Record &Arg, StringRef Attr)
801 : Argument(Arg, Attr), type(Arg.getValueAsString("Type")),
802 values(Arg.getValueAsListOfStrings("Values")),
803 enums(Arg.getValueAsListOfStrings("Enums")),
804 uniques(uniqueEnumsInOrder(enums))
806 // FIXME: Emit a proper error
807 assert(!uniques.empty());
810 bool isEnumArg() const override { return true; }
812 void writeAccessors(raw_ostream &OS) const override {
813 OS << " " << type << " get" << getUpperName() << "() const {\n";
814 OS << " return " << getLowerName() << ";\n";
818 void writeCloneArgs(raw_ostream &OS) const override {
819 OS << getLowerName();
822 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
823 OS << "A->get" << getUpperName() << "()";
825 void writeCtorInitializers(raw_ostream &OS) const override {
826 OS << getLowerName() << "(" << getUpperName() << ")";
828 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
829 OS << getLowerName() << "(" << type << "(0))";
831 void writeCtorParameters(raw_ostream &OS) const override {
832 OS << type << " " << getUpperName();
834 void writeDeclarations(raw_ostream &OS) const override {
835 auto i = uniques.cbegin(), e = uniques.cend();
836 // The last one needs to not have a comma.
840 OS << " enum " << type << " {\n";
842 OS << " " << *i << ",\n";
843 OS << " " << *e << "\n";
846 OS << " " << type << " " << getLowerName() << ";";
849 void writePCHReadDecls(raw_ostream &OS) const override {
850 OS << " " << getAttrName() << "Attr::" << type << " " << getLowerName()
851 << "(static_cast<" << getAttrName() << "Attr::" << type
852 << ">(Record.readInt()));\n";
855 void writePCHReadArgs(raw_ostream &OS) const override {
856 OS << getLowerName();
859 void writePCHWrite(raw_ostream &OS) const override {
860 OS << "Record.push_back(SA->get" << getUpperName() << "());\n";
863 void writeValue(raw_ostream &OS) const override {
864 // FIXME: this isn't 100% correct -- some enum arguments require printing
865 // as a string literal, while others require printing as an identifier.
866 // Tablegen currently does not distinguish between the two forms.
867 OS << "\\\"\" << " << getAttrName() << "Attr::Convert" << type << "ToStr(get"
868 << getUpperName() << "()) << \"\\\"";
871 void writeDump(raw_ostream &OS) const override {
872 OS << " switch(SA->get" << getUpperName() << "()) {\n";
873 for (const auto &I : uniques) {
874 OS << " case " << getAttrName() << "Attr::" << I << ":\n";
875 OS << " OS << \" " << I << "\";\n";
881 void writeConversion(raw_ostream &OS) const {
882 OS << " static bool ConvertStrTo" << type << "(StringRef Val, ";
883 OS << type << " &Out) {\n";
884 OS << " Optional<" << type << "> R = llvm::StringSwitch<Optional<";
885 OS << type << ">>(Val)\n";
886 for (size_t I = 0; I < enums.size(); ++I) {
887 OS << " .Case(\"" << values[I] << "\", ";
888 OS << getAttrName() << "Attr::" << enums[I] << ")\n";
890 OS << " .Default(Optional<" << type << ">());\n";
892 OS << " Out = *R;\n return true;\n }\n";
893 OS << " return false;\n";
896 // Mapping from enumeration values back to enumeration strings isn't
897 // trivial because some enumeration values have multiple named
898 // enumerators, such as type_visibility(internal) and
899 // type_visibility(hidden) both mapping to TypeVisibilityAttr::Hidden.
900 OS << " static const char *Convert" << type << "ToStr("
901 << type << " Val) {\n"
902 << " switch(Val) {\n";
903 SmallDenseSet<StringRef, 8> Uniques;
904 for (size_t I = 0; I < enums.size(); ++I) {
905 if (Uniques.insert(enums[I]).second)
906 OS << " case " << getAttrName() << "Attr::" << enums[I]
907 << ": return \"" << values[I] << "\";\n";
910 << " llvm_unreachable(\"No enumerator with that value\");\n"
915 class VariadicEnumArgument: public VariadicArgument {
916 std::string type, QualifiedTypeName;
917 std::vector<StringRef> values, enums, uniques;
920 void writeValueImpl(raw_ostream &OS) const override {
921 // FIXME: this isn't 100% correct -- some enum arguments require printing
922 // as a string literal, while others require printing as an identifier.
923 // Tablegen currently does not distinguish between the two forms.
924 OS << " OS << \"\\\"\" << " << getAttrName() << "Attr::Convert" << type
925 << "ToStr(Val)" << "<< \"\\\"\";\n";
929 VariadicEnumArgument(const Record &Arg, StringRef Attr)
930 : VariadicArgument(Arg, Attr, Arg.getValueAsString("Type")),
931 type(Arg.getValueAsString("Type")),
932 values(Arg.getValueAsListOfStrings("Values")),
933 enums(Arg.getValueAsListOfStrings("Enums")),
934 uniques(uniqueEnumsInOrder(enums))
936 QualifiedTypeName = getAttrName().str() + "Attr::" + type;
938 // FIXME: Emit a proper error
939 assert(!uniques.empty());
942 bool isVariadicEnumArg() const override { return true; }
944 void writeDeclarations(raw_ostream &OS) const override {
945 auto i = uniques.cbegin(), e = uniques.cend();
946 // The last one needs to not have a comma.
950 OS << " enum " << type << " {\n";
952 OS << " " << *i << ",\n";
953 OS << " " << *e << "\n";
957 VariadicArgument::writeDeclarations(OS);
960 void writeDump(raw_ostream &OS) const override {
961 OS << " for (" << getAttrName() << "Attr::" << getLowerName()
962 << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
963 << getLowerName() << "_end(); I != E; ++I) {\n";
964 OS << " switch(*I) {\n";
965 for (const auto &UI : uniques) {
966 OS << " case " << getAttrName() << "Attr::" << UI << ":\n";
967 OS << " OS << \" " << UI << "\";\n";
974 void writePCHReadDecls(raw_ostream &OS) const override {
975 OS << " unsigned " << getLowerName() << "Size = Record.readInt();\n";
976 OS << " SmallVector<" << QualifiedTypeName << ", 4> " << getLowerName()
978 OS << " " << getLowerName() << ".reserve(" << getLowerName()
980 OS << " for (unsigned i = " << getLowerName() << "Size; i; --i)\n";
981 OS << " " << getLowerName() << ".push_back(" << "static_cast<"
982 << QualifiedTypeName << ">(Record.readInt()));\n";
985 void writePCHWrite(raw_ostream &OS) const override {
986 OS << " Record.push_back(SA->" << getLowerName() << "_size());\n";
987 OS << " for (" << getAttrName() << "Attr::" << getLowerName()
988 << "_iterator i = SA->" << getLowerName() << "_begin(), e = SA->"
989 << getLowerName() << "_end(); i != e; ++i)\n";
990 OS << " " << WritePCHRecord(QualifiedTypeName, "(*i)");
993 void writeConversion(raw_ostream &OS) const {
994 OS << " static bool ConvertStrTo" << type << "(StringRef Val, ";
995 OS << type << " &Out) {\n";
996 OS << " Optional<" << type << "> R = llvm::StringSwitch<Optional<";
997 OS << type << ">>(Val)\n";
998 for (size_t I = 0; I < enums.size(); ++I) {
999 OS << " .Case(\"" << values[I] << "\", ";
1000 OS << getAttrName() << "Attr::" << enums[I] << ")\n";
1002 OS << " .Default(Optional<" << type << ">());\n";
1003 OS << " if (R) {\n";
1004 OS << " Out = *R;\n return true;\n }\n";
1005 OS << " return false;\n";
1008 OS << " static const char *Convert" << type << "ToStr("
1009 << type << " Val) {\n"
1010 << " switch(Val) {\n";
1011 SmallDenseSet<StringRef, 8> Uniques;
1012 for (size_t I = 0; I < enums.size(); ++I) {
1013 if (Uniques.insert(enums[I]).second)
1014 OS << " case " << getAttrName() << "Attr::" << enums[I]
1015 << ": return \"" << values[I] << "\";\n";
1018 << " llvm_unreachable(\"No enumerator with that value\");\n"
1023 class VersionArgument : public Argument {
1025 VersionArgument(const Record &Arg, StringRef Attr)
1026 : Argument(Arg, Attr)
1029 void writeAccessors(raw_ostream &OS) const override {
1030 OS << " VersionTuple get" << getUpperName() << "() const {\n";
1031 OS << " return " << getLowerName() << ";\n";
1033 OS << " void set" << getUpperName()
1034 << "(ASTContext &C, VersionTuple V) {\n";
1035 OS << " " << getLowerName() << " = V;\n";
1039 void writeCloneArgs(raw_ostream &OS) const override {
1040 OS << "get" << getUpperName() << "()";
1043 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
1044 OS << "A->get" << getUpperName() << "()";
1047 void writeCtorInitializers(raw_ostream &OS) const override {
1048 OS << getLowerName() << "(" << getUpperName() << ")";
1051 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
1052 OS << getLowerName() << "()";
1055 void writeCtorParameters(raw_ostream &OS) const override {
1056 OS << "VersionTuple " << getUpperName();
1059 void writeDeclarations(raw_ostream &OS) const override {
1060 OS << "VersionTuple " << getLowerName() << ";\n";
1063 void writePCHReadDecls(raw_ostream &OS) const override {
1064 OS << " VersionTuple " << getLowerName()
1065 << "= Record.readVersionTuple();\n";
1068 void writePCHReadArgs(raw_ostream &OS) const override {
1069 OS << getLowerName();
1072 void writePCHWrite(raw_ostream &OS) const override {
1073 OS << " Record.AddVersionTuple(SA->get" << getUpperName() << "());\n";
1076 void writeValue(raw_ostream &OS) const override {
1077 OS << getLowerName() << "=\" << get" << getUpperName() << "() << \"";
1080 void writeDump(raw_ostream &OS) const override {
1081 OS << " OS << \" \" << SA->get" << getUpperName() << "();\n";
1085 class ExprArgument : public SimpleArgument {
1087 ExprArgument(const Record &Arg, StringRef Attr)
1088 : SimpleArgument(Arg, Attr, "Expr *")
1091 void writeASTVisitorTraversal(raw_ostream &OS) const override {
1093 << "getDerived().TraverseStmt(A->get" << getUpperName() << "()))\n";
1094 OS << " return false;\n";
1097 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
1098 OS << "tempInst" << getUpperName();
1101 void writeTemplateInstantiation(raw_ostream &OS) const override {
1102 OS << " " << getType() << " tempInst" << getUpperName() << ";\n";
1104 OS << " EnterExpressionEvaluationContext "
1105 << "Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);\n";
1106 OS << " ExprResult " << "Result = S.SubstExpr("
1107 << "A->get" << getUpperName() << "(), TemplateArgs);\n";
1108 OS << " tempInst" << getUpperName() << " = "
1109 << "Result.getAs<Expr>();\n";
1113 void writeDump(raw_ostream &OS) const override {}
1115 void writeDumpChildren(raw_ostream &OS) const override {
1116 OS << " Visit(SA->get" << getUpperName() << "());\n";
1119 void writeHasChildren(raw_ostream &OS) const override { OS << "true"; }
1122 class VariadicExprArgument : public VariadicArgument {
1124 VariadicExprArgument(const Record &Arg, StringRef Attr)
1125 : VariadicArgument(Arg, Attr, "Expr *")
1128 void writeASTVisitorTraversal(raw_ostream &OS) const override {
1130 OS << " " << getType() << " *I = A->" << getLowerName()
1132 OS << " " << getType() << " *E = A->" << getLowerName()
1134 OS << " for (; I != E; ++I) {\n";
1135 OS << " if (!getDerived().TraverseStmt(*I))\n";
1136 OS << " return false;\n";
1141 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
1142 OS << "tempInst" << getUpperName() << ", "
1143 << "A->" << getLowerName() << "_size()";
1146 void writeTemplateInstantiation(raw_ostream &OS) const override {
1147 OS << " auto *tempInst" << getUpperName()
1148 << " = new (C, 16) " << getType()
1149 << "[A->" << getLowerName() << "_size()];\n";
1151 OS << " EnterExpressionEvaluationContext "
1152 << "Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);\n";
1153 OS << " " << getType() << " *TI = tempInst" << getUpperName()
1155 OS << " " << getType() << " *I = A->" << getLowerName()
1157 OS << " " << getType() << " *E = A->" << getLowerName()
1159 OS << " for (; I != E; ++I, ++TI) {\n";
1160 OS << " ExprResult Result = S.SubstExpr(*I, TemplateArgs);\n";
1161 OS << " *TI = Result.getAs<Expr>();\n";
1166 void writeDump(raw_ostream &OS) const override {}
1168 void writeDumpChildren(raw_ostream &OS) const override {
1169 OS << " for (" << getAttrName() << "Attr::" << getLowerName()
1170 << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
1171 << getLowerName() << "_end(); I != E; ++I)\n";
1172 OS << " Visit(*I);\n";
1175 void writeHasChildren(raw_ostream &OS) const override {
1176 OS << "SA->" << getLowerName() << "_begin() != "
1177 << "SA->" << getLowerName() << "_end()";
1181 class VariadicIdentifierArgument : public VariadicArgument {
1183 VariadicIdentifierArgument(const Record &Arg, StringRef Attr)
1184 : VariadicArgument(Arg, Attr, "IdentifierInfo *")
1188 class VariadicStringArgument : public VariadicArgument {
1190 VariadicStringArgument(const Record &Arg, StringRef Attr)
1191 : VariadicArgument(Arg, Attr, "StringRef")
1194 void writeCtorBody(raw_ostream &OS) const override {
1195 OS << " for (size_t I = 0, E = " << getArgSizeName() << "; I != E;\n"
1197 " StringRef Ref = " << getUpperName() << "[I];\n"
1198 " if (!Ref.empty()) {\n"
1199 " char *Mem = new (Ctx, 1) char[Ref.size()];\n"
1200 " std::memcpy(Mem, Ref.data(), Ref.size());\n"
1201 " " << getArgName() << "[I] = StringRef(Mem, Ref.size());\n"
1206 void writeValueImpl(raw_ostream &OS) const override {
1207 OS << " OS << \"\\\"\" << Val << \"\\\"\";\n";
1211 class TypeArgument : public SimpleArgument {
1213 TypeArgument(const Record &Arg, StringRef Attr)
1214 : SimpleArgument(Arg, Attr, "TypeSourceInfo *")
1217 void writeAccessors(raw_ostream &OS) const override {
1218 OS << " QualType get" << getUpperName() << "() const {\n";
1219 OS << " return " << getLowerName() << "->getType();\n";
1221 OS << " " << getType() << " get" << getUpperName() << "Loc() const {\n";
1222 OS << " return " << getLowerName() << ";\n";
1226 void writeASTVisitorTraversal(raw_ostream &OS) const override {
1227 OS << " if (auto *TSI = A->get" << getUpperName() << "Loc())\n";
1228 OS << " if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))\n";
1229 OS << " return false;\n";
1232 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
1233 OS << "A->get" << getUpperName() << "Loc()";
1236 void writePCHWrite(raw_ostream &OS) const override {
1237 OS << " " << WritePCHRecord(
1238 getType(), "SA->get" + std::string(getUpperName()) + "Loc()");
1242 } // end anonymous namespace
1244 static std::unique_ptr<Argument>
1245 createArgument(const Record &Arg, StringRef Attr,
1246 const Record *Search = nullptr) {
1250 std::unique_ptr<Argument> Ptr;
1251 llvm::StringRef ArgName = Search->getName();
1253 if (ArgName == "AlignedArgument")
1254 Ptr = llvm::make_unique<AlignedArgument>(Arg, Attr);
1255 else if (ArgName == "EnumArgument")
1256 Ptr = llvm::make_unique<EnumArgument>(Arg, Attr);
1257 else if (ArgName == "ExprArgument")
1258 Ptr = llvm::make_unique<ExprArgument>(Arg, Attr);
1259 else if (ArgName == "FunctionArgument")
1260 Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "FunctionDecl *");
1261 else if (ArgName == "NamedArgument")
1262 Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "NamedDecl *");
1263 else if (ArgName == "IdentifierArgument")
1264 Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "IdentifierInfo *");
1265 else if (ArgName == "DefaultBoolArgument")
1266 Ptr = llvm::make_unique<DefaultSimpleArgument>(
1267 Arg, Attr, "bool", Arg.getValueAsBit("Default"));
1268 else if (ArgName == "BoolArgument")
1269 Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "bool");
1270 else if (ArgName == "DefaultIntArgument")
1271 Ptr = llvm::make_unique<DefaultSimpleArgument>(
1272 Arg, Attr, "int", Arg.getValueAsInt("Default"));
1273 else if (ArgName == "IntArgument")
1274 Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "int");
1275 else if (ArgName == "StringArgument")
1276 Ptr = llvm::make_unique<StringArgument>(Arg, Attr);
1277 else if (ArgName == "TypeArgument")
1278 Ptr = llvm::make_unique<TypeArgument>(Arg, Attr);
1279 else if (ArgName == "UnsignedArgument")
1280 Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "unsigned");
1281 else if (ArgName == "VariadicUnsignedArgument")
1282 Ptr = llvm::make_unique<VariadicArgument>(Arg, Attr, "unsigned");
1283 else if (ArgName == "VariadicStringArgument")
1284 Ptr = llvm::make_unique<VariadicStringArgument>(Arg, Attr);
1285 else if (ArgName == "VariadicEnumArgument")
1286 Ptr = llvm::make_unique<VariadicEnumArgument>(Arg, Attr);
1287 else if (ArgName == "VariadicExprArgument")
1288 Ptr = llvm::make_unique<VariadicExprArgument>(Arg, Attr);
1289 else if (ArgName == "VariadicParamIdxArgument")
1290 Ptr = llvm::make_unique<VariadicParamIdxArgument>(Arg, Attr);
1291 else if (ArgName == "VariadicParamOrParamIdxArgument")
1292 Ptr = llvm::make_unique<VariadicParamOrParamIdxArgument>(Arg, Attr);
1293 else if (ArgName == "ParamIdxArgument")
1294 Ptr = llvm::make_unique<SimpleArgument>(Arg, Attr, "ParamIdx");
1295 else if (ArgName == "VariadicIdentifierArgument")
1296 Ptr = llvm::make_unique<VariadicIdentifierArgument>(Arg, Attr);
1297 else if (ArgName == "VersionArgument")
1298 Ptr = llvm::make_unique<VersionArgument>(Arg, Attr);
1301 // Search in reverse order so that the most-derived type is handled first.
1302 ArrayRef<std::pair<Record*, SMRange>> Bases = Search->getSuperClasses();
1303 for (const auto &Base : llvm::reverse(Bases)) {
1304 if ((Ptr = createArgument(Arg, Attr, Base.first)))
1309 if (Ptr && Arg.getValueAsBit("Optional"))
1310 Ptr->setOptional(true);
1312 if (Ptr && Arg.getValueAsBit("Fake"))
1318 static void writeAvailabilityValue(raw_ostream &OS) {
1319 OS << "\" << getPlatform()->getName();\n"
1320 << " if (getStrict()) OS << \", strict\";\n"
1321 << " if (!getIntroduced().empty()) OS << \", introduced=\" << getIntroduced();\n"
1322 << " if (!getDeprecated().empty()) OS << \", deprecated=\" << getDeprecated();\n"
1323 << " if (!getObsoleted().empty()) OS << \", obsoleted=\" << getObsoleted();\n"
1324 << " if (getUnavailable()) OS << \", unavailable\";\n"
1328 static void writeDeprecatedAttrValue(raw_ostream &OS, std::string &Variety) {
1329 OS << "\\\"\" << getMessage() << \"\\\"\";\n";
1330 // Only GNU deprecated has an optional fixit argument at the second position.
1331 if (Variety == "GNU")
1332 OS << " if (!getReplacement().empty()) OS << \", \\\"\""
1333 " << getReplacement() << \"\\\"\";\n";
1337 static void writeGetSpellingFunction(Record &R, raw_ostream &OS) {
1338 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
1340 OS << "const char *" << R.getName() << "Attr::getSpelling() const {\n";
1341 if (Spellings.empty()) {
1342 OS << " return \"(No spelling)\";\n}\n\n";
1346 OS << " switch (SpellingListIndex) {\n"
1348 " llvm_unreachable(\"Unknown attribute spelling!\");\n"
1349 " return \"(No spelling)\";\n";
1351 for (unsigned I = 0; I < Spellings.size(); ++I)
1352 OS << " case " << I << ":\n"
1353 " return \"" << Spellings[I].name() << "\";\n";
1354 // End of the switch statement.
1356 // End of the getSpelling function.
1361 writePrettyPrintFunction(Record &R,
1362 const std::vector<std::unique_ptr<Argument>> &Args,
1364 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
1366 OS << "void " << R.getName() << "Attr::printPretty("
1367 << "raw_ostream &OS, const PrintingPolicy &Policy) const {\n";
1369 if (Spellings.empty()) {
1375 " switch (SpellingListIndex) {\n"
1377 " llvm_unreachable(\"Unknown attribute spelling!\");\n"
1380 for (unsigned I = 0; I < Spellings.size(); ++ I) {
1381 llvm::SmallString<16> Prefix;
1382 llvm::SmallString<8> Suffix;
1383 // The actual spelling of the name and namespace (if applicable)
1384 // of an attribute without considering prefix and suffix.
1385 llvm::SmallString<64> Spelling;
1386 std::string Name = Spellings[I].name();
1387 std::string Variety = Spellings[I].variety();
1389 if (Variety == "GNU") {
1390 Prefix = " __attribute__((";
1392 } else if (Variety == "CXX11" || Variety == "C2x") {
1395 std::string Namespace = Spellings[I].nameSpace();
1396 if (!Namespace.empty()) {
1397 Spelling += Namespace;
1400 } else if (Variety == "Declspec") {
1401 Prefix = " __declspec(";
1403 } else if (Variety == "Microsoft") {
1406 } else if (Variety == "Keyword") {
1409 } else if (Variety == "Pragma") {
1410 Prefix = "#pragma ";
1412 std::string Namespace = Spellings[I].nameSpace();
1413 if (!Namespace.empty()) {
1414 Spelling += Namespace;
1418 llvm_unreachable("Unknown attribute syntax variety!");
1424 " case " << I << " : {\n"
1425 " OS << \"" << Prefix << Spelling;
1427 if (Variety == "Pragma") {
1429 OS << " printPrettyPragma(OS, Policy);\n";
1430 OS << " OS << \"\\n\";";
1436 if (Spelling == "availability") {
1438 writeAvailabilityValue(OS);
1440 } else if (Spelling == "deprecated" || Spelling == "gnu::deprecated") {
1442 writeDeprecatedAttrValue(OS, Variety);
1445 // To avoid printing parentheses around an empty argument list or
1446 // printing spurious commas at the end of an argument list, we need to
1447 // determine where the last provided non-fake argument is.
1448 unsigned NonFakeArgs = 0;
1449 unsigned TrailingOptArgs = 0;
1450 bool FoundNonOptArg = false;
1451 for (const auto &arg : llvm::reverse(Args)) {
1457 // FIXME: arg->getIsOmitted() == "false" means we haven't implemented
1458 // any way to detect whether the argument was omitted.
1459 if (!arg->isOptional() || arg->getIsOmitted() == "false") {
1460 FoundNonOptArg = true;
1463 if (!TrailingOptArgs++)
1465 << " unsigned TrailingOmittedArgs = 0;\n";
1466 OS << " if (" << arg->getIsOmitted() << ")\n"
1467 << " ++TrailingOmittedArgs;\n";
1469 if (TrailingOptArgs)
1471 if (TrailingOptArgs < NonFakeArgs)
1473 else if (TrailingOptArgs)
1475 << " if (TrailingOmittedArgs < " << NonFakeArgs << ")\n"
1476 << " OS << \"(\";\n"
1478 unsigned ArgIndex = 0;
1479 for (const auto &arg : Args) {
1483 if (ArgIndex >= NonFakeArgs - TrailingOptArgs)
1485 << " if (" << ArgIndex << " < " << NonFakeArgs
1486 << " - TrailingOmittedArgs)\n"
1487 << " OS << \", \";\n"
1492 std::string IsOmitted = arg->getIsOmitted();
1493 if (arg->isOptional() && IsOmitted != "false")
1495 << " if (!(" << IsOmitted << ")) {\n"
1497 arg->writeValue(OS);
1498 if (arg->isOptional() && IsOmitted != "false")
1504 if (TrailingOptArgs < NonFakeArgs)
1506 else if (TrailingOptArgs)
1508 << " if (TrailingOmittedArgs < " << NonFakeArgs << ")\n"
1509 << " OS << \")\";\n"
1513 OS << Suffix + "\";\n";
1520 // End of the switch statement.
1522 // End of the print function.
1526 /// Return the index of a spelling in a spelling list.
1528 getSpellingListIndex(const std::vector<FlattenedSpelling> &SpellingList,
1529 const FlattenedSpelling &Spelling) {
1530 assert(!SpellingList.empty() && "Spelling list is empty!");
1532 for (unsigned Index = 0; Index < SpellingList.size(); ++Index) {
1533 const FlattenedSpelling &S = SpellingList[Index];
1534 if (S.variety() != Spelling.variety())
1536 if (S.nameSpace() != Spelling.nameSpace())
1538 if (S.name() != Spelling.name())
1544 llvm_unreachable("Unknown spelling!");
1547 static void writeAttrAccessorDefinition(const Record &R, raw_ostream &OS) {
1548 std::vector<Record*> Accessors = R.getValueAsListOfDefs("Accessors");
1549 if (Accessors.empty())
1552 const std::vector<FlattenedSpelling> SpellingList = GetFlattenedSpellings(R);
1553 assert(!SpellingList.empty() &&
1554 "Attribute with empty spelling list can't have accessors!");
1555 for (const auto *Accessor : Accessors) {
1556 const StringRef Name = Accessor->getValueAsString("Name");
1557 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Accessor);
1559 OS << " bool " << Name << "() const { return SpellingListIndex == ";
1560 for (unsigned Index = 0; Index < Spellings.size(); ++Index) {
1561 OS << getSpellingListIndex(SpellingList, Spellings[Index]);
1562 if (Index != Spellings.size() - 1)
1563 OS << " ||\n SpellingListIndex == ";
1571 SpellingNamesAreCommon(const std::vector<FlattenedSpelling>& Spellings) {
1572 assert(!Spellings.empty() && "An empty list of spellings was provided");
1573 std::string FirstName = NormalizeNameForSpellingComparison(
1574 Spellings.front().name());
1575 for (const auto &Spelling :
1576 llvm::make_range(std::next(Spellings.begin()), Spellings.end())) {
1577 std::string Name = NormalizeNameForSpellingComparison(Spelling.name());
1578 if (Name != FirstName)
1584 typedef std::map<unsigned, std::string> SemanticSpellingMap;
1586 CreateSemanticSpellings(const std::vector<FlattenedSpelling> &Spellings,
1587 SemanticSpellingMap &Map) {
1588 // The enumerants are automatically generated based on the variety,
1589 // namespace (if present) and name for each attribute spelling. However,
1590 // care is taken to avoid trampling on the reserved namespace due to
1592 std::string Ret(" enum Spelling {\n");
1593 std::set<std::string> Uniques;
1595 for (auto I = Spellings.begin(), E = Spellings.end(); I != E; ++I, ++Idx) {
1596 const FlattenedSpelling &S = *I;
1597 const std::string &Variety = S.variety();
1598 const std::string &Spelling = S.name();
1599 const std::string &Namespace = S.nameSpace();
1600 std::string EnumName;
1602 EnumName += (Variety + "_");
1603 if (!Namespace.empty())
1604 EnumName += (NormalizeNameForSpellingComparison(Namespace).str() +
1606 EnumName += NormalizeNameForSpellingComparison(Spelling);
1608 // Even if the name is not unique, this spelling index corresponds to a
1609 // particular enumerant name that we've calculated.
1610 Map[Idx] = EnumName;
1612 // Since we have been stripping underscores to avoid trampling on the
1613 // reserved namespace, we may have inadvertently created duplicate
1614 // enumerant names. These duplicates are not considered part of the
1615 // semantic spelling, and can be elided.
1616 if (Uniques.find(EnumName) != Uniques.end())
1619 Uniques.insert(EnumName);
1620 if (I != Spellings.begin())
1622 // Duplicate spellings are not considered part of the semantic spelling
1623 // enumeration, but the spelling index and semantic spelling values are
1624 // meant to be equivalent, so we must specify a concrete value for each
1626 Ret += " " + EnumName + " = " + llvm::utostr(Idx);
1632 void WriteSemanticSpellingSwitch(const std::string &VarName,
1633 const SemanticSpellingMap &Map,
1635 OS << " switch (" << VarName << ") {\n default: "
1636 << "llvm_unreachable(\"Unknown spelling list index\");\n";
1637 for (const auto &I : Map)
1638 OS << " case " << I.first << ": return " << I.second << ";\n";
1642 // Emits the LateParsed property for attributes.
1643 static void emitClangAttrLateParsedList(RecordKeeper &Records, raw_ostream &OS) {
1644 OS << "#if defined(CLANG_ATTR_LATE_PARSED_LIST)\n";
1645 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1647 for (const auto *Attr : Attrs) {
1648 bool LateParsed = Attr->getValueAsBit("LateParsed");
1651 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
1653 // FIXME: Handle non-GNU attributes
1654 for (const auto &I : Spellings) {
1655 if (I.variety() != "GNU")
1657 OS << ".Case(\"" << I.name() << "\", " << LateParsed << ")\n";
1661 OS << "#endif // CLANG_ATTR_LATE_PARSED_LIST\n\n";
1664 static bool hasGNUorCXX11Spelling(const Record &Attribute) {
1665 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attribute);
1666 for (const auto &I : Spellings) {
1667 if (I.variety() == "GNU" || I.variety() == "CXX11")
1675 struct AttributeSubjectMatchRule {
1676 const Record *MetaSubject;
1677 const Record *Constraint;
1679 AttributeSubjectMatchRule(const Record *MetaSubject, const Record *Constraint)
1680 : MetaSubject(MetaSubject), Constraint(Constraint) {
1681 assert(MetaSubject && "Missing subject");
1684 bool isSubRule() const { return Constraint != nullptr; }
1686 std::vector<Record *> getSubjects() const {
1687 return (Constraint ? Constraint : MetaSubject)
1688 ->getValueAsListOfDefs("Subjects");
1691 std::vector<Record *> getLangOpts() const {
1693 // Lookup the options in the sub-rule first, in case the sub-rule
1694 // overrides the rules options.
1695 std::vector<Record *> Opts = Constraint->getValueAsListOfDefs("LangOpts");
1699 return MetaSubject->getValueAsListOfDefs("LangOpts");
1702 // Abstract rules are used only for sub-rules
1703 bool isAbstractRule() const { return getSubjects().empty(); }
1705 StringRef getName() const {
1706 return (Constraint ? Constraint : MetaSubject)->getValueAsString("Name");
1709 bool isNegatedSubRule() const {
1710 assert(isSubRule() && "Not a sub-rule");
1711 return Constraint->getValueAsBit("Negated");
1714 std::string getSpelling() const {
1715 std::string Result = MetaSubject->getValueAsString("Name");
1718 if (isNegatedSubRule())
1719 Result += "unless(";
1720 Result += getName();
1721 if (isNegatedSubRule())
1728 std::string getEnumValueName() const {
1729 SmallString<128> Result;
1730 Result += "SubjectMatchRule_";
1731 Result += MetaSubject->getValueAsString("Name");
1734 if (isNegatedSubRule())
1736 Result += Constraint->getValueAsString("Name");
1738 if (isAbstractRule())
1739 Result += "_abstract";
1740 return Result.str();
1743 std::string getEnumValue() const { return "attr::" + getEnumValueName(); }
1745 static const char *EnumName;
1748 const char *AttributeSubjectMatchRule::EnumName = "attr::SubjectMatchRule";
1750 struct PragmaClangAttributeSupport {
1751 std::vector<AttributeSubjectMatchRule> Rules;
1753 class RuleOrAggregateRuleSet {
1754 std::vector<AttributeSubjectMatchRule> Rules;
1756 RuleOrAggregateRuleSet(ArrayRef<AttributeSubjectMatchRule> Rules,
1758 : Rules(Rules), IsRule(IsRule) {}
1761 bool isRule() const { return IsRule; }
1763 const AttributeSubjectMatchRule &getRule() const {
1764 assert(IsRule && "not a rule!");
1768 ArrayRef<AttributeSubjectMatchRule> getAggregateRuleSet() const {
1772 static RuleOrAggregateRuleSet
1773 getRule(const AttributeSubjectMatchRule &Rule) {
1774 return RuleOrAggregateRuleSet(Rule, /*IsRule=*/true);
1776 static RuleOrAggregateRuleSet
1777 getAggregateRuleSet(ArrayRef<AttributeSubjectMatchRule> Rules) {
1778 return RuleOrAggregateRuleSet(Rules, /*IsRule=*/false);
1781 llvm::DenseMap<const Record *, RuleOrAggregateRuleSet> SubjectsToRules;
1783 PragmaClangAttributeSupport(RecordKeeper &Records);
1785 bool isAttributedSupported(const Record &Attribute);
1787 void emitMatchRuleList(raw_ostream &OS);
1789 std::string generateStrictConformsTo(const Record &Attr, raw_ostream &OS);
1791 void generateParsingHelpers(raw_ostream &OS);
1794 } // end anonymous namespace
1796 static bool doesDeclDeriveFrom(const Record *D, const Record *Base) {
1797 const Record *CurrentBase = D->getValueAsDef("Base");
1800 if (CurrentBase == Base)
1802 return doesDeclDeriveFrom(CurrentBase, Base);
1805 PragmaClangAttributeSupport::PragmaClangAttributeSupport(
1806 RecordKeeper &Records) {
1807 std::vector<Record *> MetaSubjects =
1808 Records.getAllDerivedDefinitions("AttrSubjectMatcherRule");
1809 auto MapFromSubjectsToRules = [this](const Record *SubjectContainer,
1810 const Record *MetaSubject,
1811 const Record *Constraint) {
1812 Rules.emplace_back(MetaSubject, Constraint);
1813 std::vector<Record *> ApplicableSubjects =
1814 SubjectContainer->getValueAsListOfDefs("Subjects");
1815 for (const auto *Subject : ApplicableSubjects) {
1818 .try_emplace(Subject, RuleOrAggregateRuleSet::getRule(
1819 AttributeSubjectMatchRule(MetaSubject,
1823 PrintFatalError("Attribute subject match rules should not represent"
1824 "same attribute subjects.");
1828 for (const auto *MetaSubject : MetaSubjects) {
1829 MapFromSubjectsToRules(MetaSubject, MetaSubject, /*Constraints=*/nullptr);
1830 std::vector<Record *> Constraints =
1831 MetaSubject->getValueAsListOfDefs("Constraints");
1832 for (const auto *Constraint : Constraints)
1833 MapFromSubjectsToRules(Constraint, MetaSubject, Constraint);
1836 std::vector<Record *> Aggregates =
1837 Records.getAllDerivedDefinitions("AttrSubjectMatcherAggregateRule");
1838 std::vector<Record *> DeclNodes = Records.getAllDerivedDefinitions("DDecl");
1839 for (const auto *Aggregate : Aggregates) {
1840 Record *SubjectDecl = Aggregate->getValueAsDef("Subject");
1842 // Gather sub-classes of the aggregate subject that act as attribute
1844 std::vector<AttributeSubjectMatchRule> Rules;
1845 for (const auto *D : DeclNodes) {
1846 if (doesDeclDeriveFrom(D, SubjectDecl)) {
1847 auto It = SubjectsToRules.find(D);
1848 if (It == SubjectsToRules.end())
1850 if (!It->second.isRule() || It->second.getRule().isSubRule())
1851 continue; // Assume that the rule will be included as well.
1852 Rules.push_back(It->second.getRule());
1858 .try_emplace(SubjectDecl,
1859 RuleOrAggregateRuleSet::getAggregateRuleSet(Rules))
1862 PrintFatalError("Attribute subject match rules should not represent"
1863 "same attribute subjects.");
1868 static PragmaClangAttributeSupport &
1869 getPragmaAttributeSupport(RecordKeeper &Records) {
1870 static PragmaClangAttributeSupport Instance(Records);
1874 void PragmaClangAttributeSupport::emitMatchRuleList(raw_ostream &OS) {
1875 OS << "#ifndef ATTR_MATCH_SUB_RULE\n";
1876 OS << "#define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, "
1878 << "ATTR_MATCH_RULE(Value, Spelling, IsAbstract)\n";
1880 for (const auto &Rule : Rules) {
1881 OS << (Rule.isSubRule() ? "ATTR_MATCH_SUB_RULE" : "ATTR_MATCH_RULE") << '(';
1882 OS << Rule.getEnumValueName() << ", \"" << Rule.getSpelling() << "\", "
1883 << Rule.isAbstractRule();
1884 if (Rule.isSubRule())
1886 << AttributeSubjectMatchRule(Rule.MetaSubject, nullptr).getEnumValue()
1887 << ", " << Rule.isNegatedSubRule();
1890 OS << "#undef ATTR_MATCH_SUB_RULE\n";
1893 bool PragmaClangAttributeSupport::isAttributedSupported(
1894 const Record &Attribute) {
1895 // If the attribute explicitly specified whether to support #pragma clang
1896 // attribute, use that setting.
1898 bool SpecifiedResult =
1899 Attribute.getValueAsBitOrUnset("PragmaAttributeSupport", Unset);
1901 return SpecifiedResult;
1904 // An attribute requires delayed parsing (LateParsed is on)
1905 if (Attribute.getValueAsBit("LateParsed"))
1907 // An attribute has no GNU/CXX11 spelling
1908 if (!hasGNUorCXX11Spelling(Attribute))
1910 // An attribute subject list has a subject that isn't covered by one of the
1911 // subject match rules or has no subjects at all.
1912 if (Attribute.isValueUnset("Subjects"))
1914 const Record *SubjectObj = Attribute.getValueAsDef("Subjects");
1915 std::vector<Record *> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
1916 if (Subjects.empty())
1918 for (const auto *Subject : Subjects) {
1919 if (SubjectsToRules.find(Subject) == SubjectsToRules.end())
1925 static std::string GenerateTestExpression(ArrayRef<Record *> LangOpts) {
1928 for (auto *E : LangOpts) {
1932 const StringRef Code = E->getValueAsString("CustomCode");
1933 if (!Code.empty()) {
1938 Test += "LangOpts.";
1939 Test += E->getValueAsString("Name");
1950 PragmaClangAttributeSupport::generateStrictConformsTo(const Record &Attr,
1952 if (!isAttributedSupported(Attr))
1954 // Generate a function that constructs a set of matching rules that describe
1955 // to which declarations the attribute should apply to.
1956 std::string FnName = "matchRulesFor" + Attr.getName().str();
1957 OS << "static void " << FnName << "(llvm::SmallVectorImpl<std::pair<"
1958 << AttributeSubjectMatchRule::EnumName
1959 << ", bool>> &MatchRules, const LangOptions &LangOpts) {\n";
1960 if (Attr.isValueUnset("Subjects")) {
1964 const Record *SubjectObj = Attr.getValueAsDef("Subjects");
1965 std::vector<Record *> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
1966 for (const auto *Subject : Subjects) {
1967 auto It = SubjectsToRules.find(Subject);
1968 assert(It != SubjectsToRules.end() &&
1969 "This attribute is unsupported by #pragma clang attribute");
1970 for (const auto &Rule : It->getSecond().getAggregateRuleSet()) {
1971 // The rule might be language specific, so only subtract it from the given
1972 // rules if the specific language options are specified.
1973 std::vector<Record *> LangOpts = Rule.getLangOpts();
1974 OS << " MatchRules.push_back(std::make_pair(" << Rule.getEnumValue()
1975 << ", /*IsSupported=*/" << GenerateTestExpression(LangOpts)
1983 void PragmaClangAttributeSupport::generateParsingHelpers(raw_ostream &OS) {
1984 // Generate routines that check the names of sub-rules.
1985 OS << "Optional<attr::SubjectMatchRule> "
1986 "defaultIsAttributeSubjectMatchSubRuleFor(StringRef, bool) {\n";
1987 OS << " return None;\n";
1990 std::map<const Record *, std::vector<AttributeSubjectMatchRule>>
1992 for (const auto &Rule : Rules) {
1993 if (!Rule.isSubRule())
1995 SubMatchRules[Rule.MetaSubject].push_back(Rule);
1998 for (const auto &SubMatchRule : SubMatchRules) {
1999 OS << "Optional<attr::SubjectMatchRule> isAttributeSubjectMatchSubRuleFor_"
2000 << SubMatchRule.first->getValueAsString("Name")
2001 << "(StringRef Name, bool IsUnless) {\n";
2002 OS << " if (IsUnless)\n";
2004 "llvm::StringSwitch<Optional<attr::SubjectMatchRule>>(Name).\n";
2005 for (const auto &Rule : SubMatchRule.second) {
2006 if (Rule.isNegatedSubRule())
2007 OS << " Case(\"" << Rule.getName() << "\", " << Rule.getEnumValue()
2010 OS << " Default(None);\n";
2012 "llvm::StringSwitch<Optional<attr::SubjectMatchRule>>(Name).\n";
2013 for (const auto &Rule : SubMatchRule.second) {
2014 if (!Rule.isNegatedSubRule())
2015 OS << " Case(\"" << Rule.getName() << "\", " << Rule.getEnumValue()
2018 OS << " Default(None);\n";
2022 // Generate the function that checks for the top-level rules.
2023 OS << "std::pair<Optional<attr::SubjectMatchRule>, "
2024 "Optional<attr::SubjectMatchRule> (*)(StringRef, "
2025 "bool)> isAttributeSubjectMatchRule(StringRef Name) {\n";
2027 "llvm::StringSwitch<std::pair<Optional<attr::SubjectMatchRule>, "
2028 "Optional<attr::SubjectMatchRule> (*) (StringRef, "
2030 for (const auto &Rule : Rules) {
2031 if (Rule.isSubRule())
2033 std::string SubRuleFunction;
2034 if (SubMatchRules.count(Rule.MetaSubject))
2036 ("isAttributeSubjectMatchSubRuleFor_" + Rule.getName()).str();
2038 SubRuleFunction = "defaultIsAttributeSubjectMatchSubRuleFor";
2039 OS << " Case(\"" << Rule.getName() << "\", std::make_pair("
2040 << Rule.getEnumValue() << ", " << SubRuleFunction << ")).\n";
2042 OS << " Default(std::make_pair(None, "
2043 "defaultIsAttributeSubjectMatchSubRuleFor));\n";
2046 // Generate the function that checks for the submatch rules.
2047 OS << "const char *validAttributeSubjectMatchSubRules("
2048 << AttributeSubjectMatchRule::EnumName << " Rule) {\n";
2049 OS << " switch (Rule) {\n";
2050 for (const auto &SubMatchRule : SubMatchRules) {
2052 << AttributeSubjectMatchRule(SubMatchRule.first, nullptr).getEnumValue()
2054 OS << " return \"'";
2055 bool IsFirst = true;
2056 for (const auto &Rule : SubMatchRule.second) {
2060 if (Rule.isNegatedSubRule())
2062 OS << Rule.getName();
2063 if (Rule.isNegatedSubRule())
2069 OS << " default: return nullptr;\n";
2074 template <typename Fn>
2075 static void forEachUniqueSpelling(const Record &Attr, Fn &&F) {
2076 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
2077 SmallDenseSet<StringRef, 8> Seen;
2078 for (const FlattenedSpelling &S : Spellings) {
2079 if (Seen.insert(S.name()).second)
2084 /// Emits the first-argument-is-type property for attributes.
2085 static void emitClangAttrTypeArgList(RecordKeeper &Records, raw_ostream &OS) {
2086 OS << "#if defined(CLANG_ATTR_TYPE_ARG_LIST)\n";
2087 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2089 for (const auto *Attr : Attrs) {
2090 // Determine whether the first argument is a type.
2091 std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args");
2095 if (Args[0]->getSuperClasses().back().first->getName() != "TypeArgument")
2098 // All these spellings take a single type argument.
2099 forEachUniqueSpelling(*Attr, [&](const FlattenedSpelling &S) {
2100 OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
2103 OS << "#endif // CLANG_ATTR_TYPE_ARG_LIST\n\n";
2106 /// Emits the parse-arguments-in-unevaluated-context property for
2108 static void emitClangAttrArgContextList(RecordKeeper &Records, raw_ostream &OS) {
2109 OS << "#if defined(CLANG_ATTR_ARG_CONTEXT_LIST)\n";
2110 ParsedAttrMap Attrs = getParsedAttrList(Records);
2111 for (const auto &I : Attrs) {
2112 const Record &Attr = *I.second;
2114 if (!Attr.getValueAsBit("ParseArgumentsAsUnevaluated"))
2117 // All these spellings take are parsed unevaluated.
2118 forEachUniqueSpelling(Attr, [&](const FlattenedSpelling &S) {
2119 OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
2122 OS << "#endif // CLANG_ATTR_ARG_CONTEXT_LIST\n\n";
2125 static bool isIdentifierArgument(Record *Arg) {
2126 return !Arg->getSuperClasses().empty() &&
2127 llvm::StringSwitch<bool>(Arg->getSuperClasses().back().first->getName())
2128 .Case("IdentifierArgument", true)
2129 .Case("EnumArgument", true)
2130 .Case("VariadicEnumArgument", true)
2134 static bool isVariadicIdentifierArgument(Record *Arg) {
2135 return !Arg->getSuperClasses().empty() &&
2136 llvm::StringSwitch<bool>(
2137 Arg->getSuperClasses().back().first->getName())
2138 .Case("VariadicIdentifierArgument", true)
2139 .Case("VariadicParamOrParamIdxArgument", true)
2143 static void emitClangAttrVariadicIdentifierArgList(RecordKeeper &Records,
2145 OS << "#if defined(CLANG_ATTR_VARIADIC_IDENTIFIER_ARG_LIST)\n";
2146 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2147 for (const auto *A : Attrs) {
2148 // Determine whether the first argument is a variadic identifier.
2149 std::vector<Record *> Args = A->getValueAsListOfDefs("Args");
2150 if (Args.empty() || !isVariadicIdentifierArgument(Args[0]))
2153 // All these spellings take an identifier argument.
2154 forEachUniqueSpelling(*A, [&](const FlattenedSpelling &S) {
2155 OS << ".Case(\"" << S.name() << "\", "
2160 OS << "#endif // CLANG_ATTR_VARIADIC_IDENTIFIER_ARG_LIST\n\n";
2163 // Emits the first-argument-is-identifier property for attributes.
2164 static void emitClangAttrIdentifierArgList(RecordKeeper &Records, raw_ostream &OS) {
2165 OS << "#if defined(CLANG_ATTR_IDENTIFIER_ARG_LIST)\n";
2166 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
2168 for (const auto *Attr : Attrs) {
2169 // Determine whether the first argument is an identifier.
2170 std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args");
2171 if (Args.empty() || !isIdentifierArgument(Args[0]))
2174 // All these spellings take an identifier argument.
2175 forEachUniqueSpelling(*Attr, [&](const FlattenedSpelling &S) {
2176 OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
2179 OS << "#endif // CLANG_ATTR_IDENTIFIER_ARG_LIST\n\n";
2182 static bool keywordThisIsaIdentifierInArgument(const Record *Arg) {
2183 return !Arg->getSuperClasses().empty() &&
2184 llvm::StringSwitch<bool>(
2185 Arg->getSuperClasses().back().first->getName())
2186 .Case("VariadicParamOrParamIdxArgument", true)
2190 static void emitClangAttrThisIsaIdentifierArgList(RecordKeeper &Records,
2192 OS << "#if defined(CLANG_ATTR_THIS_ISA_IDENTIFIER_ARG_LIST)\n";
2193 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2194 for (const auto *A : Attrs) {
2195 // Determine whether the first argument is a variadic identifier.
2196 std::vector<Record *> Args = A->getValueAsListOfDefs("Args");
2197 if (Args.empty() || !keywordThisIsaIdentifierInArgument(Args[0]))
2200 // All these spellings take an identifier argument.
2201 forEachUniqueSpelling(*A, [&](const FlattenedSpelling &S) {
2202 OS << ".Case(\"" << S.name() << "\", "
2207 OS << "#endif // CLANG_ATTR_THIS_ISA_IDENTIFIER_ARG_LIST\n\n";
2212 // Emits the class definitions for attributes.
2213 void EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS) {
2214 emitSourceFileHeader("Attribute classes' definitions", OS);
2216 OS << "#ifndef LLVM_CLANG_ATTR_CLASSES_INC\n";
2217 OS << "#define LLVM_CLANG_ATTR_CLASSES_INC\n\n";
2219 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
2221 for (const auto *Attr : Attrs) {
2222 const Record &R = *Attr;
2224 // FIXME: Currently, documentation is generated as-needed due to the fact
2225 // that there is no way to allow a generated project "reach into" the docs
2226 // directory (for instance, it may be an out-of-tree build). However, we want
2227 // to ensure that every attribute has a Documentation field, and produce an
2228 // error if it has been neglected. Otherwise, the on-demand generation which
2229 // happens server-side will fail. This code is ensuring that functionality,
2230 // even though this Emitter doesn't technically need the documentation.
2231 // When attribute documentation can be generated as part of the build
2232 // itself, this code can be removed.
2233 (void)R.getValueAsListOfDefs("Documentation");
2235 if (!R.getValueAsBit("ASTNode"))
2238 ArrayRef<std::pair<Record *, SMRange>> Supers = R.getSuperClasses();
2239 assert(!Supers.empty() && "Forgot to specify a superclass for the attr");
2240 std::string SuperName;
2241 bool Inheritable = false;
2242 for (const auto &Super : llvm::reverse(Supers)) {
2243 const Record *R = Super.first;
2244 if (R->getName() != "TargetSpecificAttr" &&
2245 R->getName() != "DeclOrTypeAttr" && SuperName.empty())
2246 SuperName = R->getName();
2247 if (R->getName() == "InheritableAttr")
2251 OS << "class " << R.getName() << "Attr : public " << SuperName << " {\n";
2253 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
2254 std::vector<std::unique_ptr<Argument>> Args;
2255 Args.reserve(ArgRecords.size());
2257 bool HasOptArg = false;
2258 bool HasFakeArg = false;
2259 for (const auto *ArgRecord : ArgRecords) {
2260 Args.emplace_back(createArgument(*ArgRecord, R.getName()));
2261 Args.back()->writeDeclarations(OS);
2264 // For these purposes, fake takes priority over optional.
2265 if (Args.back()->isFake()) {
2267 } else if (Args.back()->isOptional()) {
2274 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
2276 // If there are zero or one spellings, all spelling-related functionality
2277 // can be elided. If all of the spellings share the same name, the spelling
2278 // functionality can also be elided.
2279 bool ElideSpelling = (Spellings.size() <= 1) ||
2280 SpellingNamesAreCommon(Spellings);
2282 // This maps spelling index values to semantic Spelling enumerants.
2283 SemanticSpellingMap SemanticToSyntacticMap;
2286 OS << CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
2288 // Emit CreateImplicit factory methods.
2289 auto emitCreateImplicit = [&](bool emitFake) {
2290 OS << " static " << R.getName() << "Attr *CreateImplicit(";
2291 OS << "ASTContext &Ctx";
2293 OS << ", Spelling S";
2294 for (auto const &ai : Args) {
2295 if (ai->isFake() && !emitFake) continue;
2297 ai->writeCtorParameters(OS);
2299 OS << ", SourceRange Loc = SourceRange()";
2301 OS << " auto *A = new (Ctx) " << R.getName();
2302 OS << "Attr(Loc, Ctx, ";
2303 for (auto const &ai : Args) {
2304 if (ai->isFake() && !emitFake) continue;
2305 ai->writeImplicitCtorArgs(OS);
2308 OS << (ElideSpelling ? "0" : "S") << ");\n";
2309 OS << " A->setImplicit(true);\n";
2310 OS << " return A;\n }\n\n";
2313 // Emit a CreateImplicit that takes all the arguments.
2314 emitCreateImplicit(true);
2316 // Emit a CreateImplicit that takes all the non-fake arguments.
2318 emitCreateImplicit(false);
2321 // Emit constructors.
2322 auto emitCtor = [&](bool emitOpt, bool emitFake) {
2323 auto shouldEmitArg = [=](const std::unique_ptr<Argument> &arg) {
2324 if (arg->isFake()) return emitFake;
2325 if (arg->isOptional()) return emitOpt;
2329 OS << " " << R.getName() << "Attr(SourceRange R, ASTContext &Ctx\n";
2330 for (auto const &ai : Args) {
2331 if (!shouldEmitArg(ai)) continue;
2333 ai->writeCtorParameters(OS);
2338 OS << "unsigned SI\n";
2341 OS << " : " << SuperName << "(attr::" << R.getName() << ", R, SI, "
2342 << ( R.getValueAsBit("LateParsed") ? "true" : "false" );
2345 << (R.getValueAsBit("InheritEvenIfAlreadyPresent") ? "true"
2350 for (auto const &ai : Args) {
2352 if (!shouldEmitArg(ai)) {
2353 ai->writeCtorDefaultInitializers(OS);
2355 ai->writeCtorInitializers(OS);
2362 for (auto const &ai : Args) {
2363 if (!shouldEmitArg(ai)) continue;
2364 ai->writeCtorBody(OS);
2369 // Emit a constructor that includes all the arguments.
2370 // This is necessary for cloning.
2371 emitCtor(true, true);
2373 // Emit a constructor that takes all the non-fake arguments.
2375 emitCtor(true, false);
2378 // Emit a constructor that takes all the non-fake, non-optional arguments.
2380 emitCtor(false, false);
2383 OS << " " << R.getName() << "Attr *clone(ASTContext &C) const;\n";
2384 OS << " void printPretty(raw_ostream &OS,\n"
2385 << " const PrintingPolicy &Policy) const;\n";
2386 OS << " const char *getSpelling() const;\n";
2388 if (!ElideSpelling) {
2389 assert(!SemanticToSyntacticMap.empty() && "Empty semantic mapping list");
2390 OS << " Spelling getSemanticSpelling() const {\n";
2391 WriteSemanticSpellingSwitch("SpellingListIndex", SemanticToSyntacticMap,
2396 writeAttrAccessorDefinition(R, OS);
2398 for (auto const &ai : Args) {
2399 ai->writeAccessors(OS);
2402 // Don't write conversion routines for fake arguments.
2403 if (ai->isFake()) continue;
2405 if (ai->isEnumArg())
2406 static_cast<const EnumArgument *>(ai.get())->writeConversion(OS);
2407 else if (ai->isVariadicEnumArg())
2408 static_cast<const VariadicEnumArgument *>(ai.get())
2409 ->writeConversion(OS);
2412 OS << R.getValueAsString("AdditionalMembers");
2415 OS << " static bool classof(const Attr *A) { return A->getKind() == "
2416 << "attr::" << R.getName() << "; }\n";
2421 OS << "#endif // LLVM_CLANG_ATTR_CLASSES_INC\n";
2424 // Emits the class method definitions for attributes.
2425 void EmitClangAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
2426 emitSourceFileHeader("Attribute classes' member function definitions", OS);
2428 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
2430 for (auto *Attr : Attrs) {
2433 if (!R.getValueAsBit("ASTNode"))
2436 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
2437 std::vector<std::unique_ptr<Argument>> Args;
2438 for (const auto *Arg : ArgRecords)
2439 Args.emplace_back(createArgument(*Arg, R.getName()));
2441 for (auto const &ai : Args)
2442 ai->writeAccessorDefinitions(OS);
2444 OS << R.getName() << "Attr *" << R.getName()
2445 << "Attr::clone(ASTContext &C) const {\n";
2446 OS << " auto *A = new (C) " << R.getName() << "Attr(getLocation(), C";
2447 for (auto const &ai : Args) {
2449 ai->writeCloneArgs(OS);
2451 OS << ", getSpellingListIndex());\n";
2452 OS << " A->Inherited = Inherited;\n";
2453 OS << " A->IsPackExpansion = IsPackExpansion;\n";
2454 OS << " A->Implicit = Implicit;\n";
2455 OS << " return A;\n}\n\n";
2457 writePrettyPrintFunction(R, Args, OS);
2458 writeGetSpellingFunction(R, OS);
2461 // Instead of relying on virtual dispatch we just create a huge dispatch
2462 // switch. This is both smaller and faster than virtual functions.
2463 auto EmitFunc = [&](const char *Method) {
2464 OS << " switch (getKind()) {\n";
2465 for (const auto *Attr : Attrs) {
2466 const Record &R = *Attr;
2467 if (!R.getValueAsBit("ASTNode"))
2470 OS << " case attr::" << R.getName() << ":\n";
2471 OS << " return cast<" << R.getName() << "Attr>(this)->" << Method
2475 OS << " llvm_unreachable(\"Unexpected attribute kind!\");\n";
2479 OS << "const char *Attr::getSpelling() const {\n";
2480 EmitFunc("getSpelling()");
2482 OS << "Attr *Attr::clone(ASTContext &C) const {\n";
2483 EmitFunc("clone(C)");
2485 OS << "void Attr::printPretty(raw_ostream &OS, "
2486 "const PrintingPolicy &Policy) const {\n";
2487 EmitFunc("printPretty(OS, Policy)");
2490 } // end namespace clang
2492 static void emitAttrList(raw_ostream &OS, StringRef Class,
2493 const std::vector<Record*> &AttrList) {
2494 for (auto Cur : AttrList) {
2495 OS << Class << "(" << Cur->getName() << ")\n";
2499 // Determines if an attribute has a Pragma spelling.
2500 static bool AttrHasPragmaSpelling(const Record *R) {
2501 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*R);
2502 return llvm::find_if(Spellings, [](const FlattenedSpelling &S) {
2503 return S.variety() == "Pragma";
2504 }) != Spellings.end();
2509 struct AttrClassDescriptor {
2510 const char * const MacroName;
2511 const char * const TableGenName;
2514 } // end anonymous namespace
2516 static const AttrClassDescriptor AttrClassDescriptors[] = {
2518 { "TYPE_ATTR", "TypeAttr" },
2519 { "STMT_ATTR", "StmtAttr" },
2520 { "INHERITABLE_ATTR", "InheritableAttr" },
2521 { "DECL_OR_TYPE_ATTR", "DeclOrTypeAttr" },
2522 { "INHERITABLE_PARAM_ATTR", "InheritableParamAttr" },
2523 { "PARAMETER_ABI_ATTR", "ParameterABIAttr" }
2526 static void emitDefaultDefine(raw_ostream &OS, StringRef name,
2527 const char *superName) {
2528 OS << "#ifndef " << name << "\n";
2529 OS << "#define " << name << "(NAME) ";
2530 if (superName) OS << superName << "(NAME)";
2531 OS << "\n#endif\n\n";
2536 /// A class of attributes.
2538 const AttrClassDescriptor &Descriptor;
2540 AttrClass *SuperClass = nullptr;
2541 std::vector<AttrClass*> SubClasses;
2542 std::vector<Record*> Attrs;
2544 AttrClass(const AttrClassDescriptor &Descriptor, Record *R)
2545 : Descriptor(Descriptor), TheRecord(R) {}
2547 void emitDefaultDefines(raw_ostream &OS) const {
2548 // Default the macro unless this is a root class (i.e. Attr).
2550 emitDefaultDefine(OS, Descriptor.MacroName,
2551 SuperClass->Descriptor.MacroName);
2555 void emitUndefs(raw_ostream &OS) const {
2556 OS << "#undef " << Descriptor.MacroName << "\n";
2559 void emitAttrList(raw_ostream &OS) const {
2560 for (auto SubClass : SubClasses) {
2561 SubClass->emitAttrList(OS);
2564 ::emitAttrList(OS, Descriptor.MacroName, Attrs);
2567 void classifyAttrOnRoot(Record *Attr) {
2568 bool result = classifyAttr(Attr);
2569 assert(result && "failed to classify on root"); (void) result;
2572 void emitAttrRange(raw_ostream &OS) const {
2573 OS << "ATTR_RANGE(" << Descriptor.TableGenName
2574 << ", " << getFirstAttr()->getName()
2575 << ", " << getLastAttr()->getName() << ")\n";
2579 bool classifyAttr(Record *Attr) {
2580 // Check all the subclasses.
2581 for (auto SubClass : SubClasses) {
2582 if (SubClass->classifyAttr(Attr))
2586 // It's not more specific than this class, but it might still belong here.
2587 if (Attr->isSubClassOf(TheRecord)) {
2588 Attrs.push_back(Attr);
2595 Record *getFirstAttr() const {
2596 if (!SubClasses.empty())
2597 return SubClasses.front()->getFirstAttr();
2598 return Attrs.front();
2601 Record *getLastAttr() const {
2603 return Attrs.back();
2604 return SubClasses.back()->getLastAttr();
2608 /// The entire hierarchy of attribute classes.
2609 class AttrClassHierarchy {
2610 std::vector<std::unique_ptr<AttrClass>> Classes;
2613 AttrClassHierarchy(RecordKeeper &Records) {
2614 // Find records for all the classes.
2615 for (auto &Descriptor : AttrClassDescriptors) {
2616 Record *ClassRecord = Records.getClass(Descriptor.TableGenName);
2617 AttrClass *Class = new AttrClass(Descriptor, ClassRecord);
2618 Classes.emplace_back(Class);
2621 // Link up the hierarchy.
2622 for (auto &Class : Classes) {
2623 if (AttrClass *SuperClass = findSuperClass(Class->TheRecord)) {
2624 Class->SuperClass = SuperClass;
2625 SuperClass->SubClasses.push_back(Class.get());
2630 for (auto i = Classes.begin(), e = Classes.end(); i != e; ++i) {
2631 assert((i == Classes.begin()) == ((*i)->SuperClass == nullptr) &&
2632 "only the first class should be a root class!");
2637 void emitDefaultDefines(raw_ostream &OS) const {
2638 for (auto &Class : Classes) {
2639 Class->emitDefaultDefines(OS);
2643 void emitUndefs(raw_ostream &OS) const {
2644 for (auto &Class : Classes) {
2645 Class->emitUndefs(OS);
2649 void emitAttrLists(raw_ostream &OS) const {
2650 // Just start from the root class.
2651 Classes[0]->emitAttrList(OS);
2654 void emitAttrRanges(raw_ostream &OS) const {
2655 for (auto &Class : Classes)
2656 Class->emitAttrRange(OS);
2659 void classifyAttr(Record *Attr) {
2660 // Add the attribute to the root class.
2661 Classes[0]->classifyAttrOnRoot(Attr);
2665 AttrClass *findClassByRecord(Record *R) const {
2666 for (auto &Class : Classes) {
2667 if (Class->TheRecord == R)
2673 AttrClass *findSuperClass(Record *R) const {
2674 // TableGen flattens the superclass list, so we just need to walk it
2676 auto SuperClasses = R->getSuperClasses();
2677 for (signed i = 0, e = SuperClasses.size(); i != e; ++i) {
2678 auto SuperClass = findClassByRecord(SuperClasses[e - i - 1].first);
2679 if (SuperClass) return SuperClass;
2685 } // end anonymous namespace
2689 // Emits the enumeration list for attributes.
2690 void EmitClangAttrList(RecordKeeper &Records, raw_ostream &OS) {
2691 emitSourceFileHeader("List of all attributes that Clang recognizes", OS);
2693 AttrClassHierarchy Hierarchy(Records);
2695 // Add defaulting macro definitions.
2696 Hierarchy.emitDefaultDefines(OS);
2697 emitDefaultDefine(OS, "PRAGMA_SPELLING_ATTR", nullptr);
2699 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2700 std::vector<Record *> PragmaAttrs;
2701 for (auto *Attr : Attrs) {
2702 if (!Attr->getValueAsBit("ASTNode"))
2705 // Add the attribute to the ad-hoc groups.
2706 if (AttrHasPragmaSpelling(Attr))
2707 PragmaAttrs.push_back(Attr);
2709 // Place it in the hierarchy.
2710 Hierarchy.classifyAttr(Attr);
2713 // Emit the main attribute list.
2714 Hierarchy.emitAttrLists(OS);
2716 // Emit the ad hoc groups.
2717 emitAttrList(OS, "PRAGMA_SPELLING_ATTR", PragmaAttrs);
2719 // Emit the attribute ranges.
2720 OS << "#ifdef ATTR_RANGE\n";
2721 Hierarchy.emitAttrRanges(OS);
2722 OS << "#undef ATTR_RANGE\n";
2725 Hierarchy.emitUndefs(OS);
2726 OS << "#undef PRAGMA_SPELLING_ATTR\n";
2729 // Emits the enumeration list for attributes.
2730 void EmitClangAttrSubjectMatchRuleList(RecordKeeper &Records, raw_ostream &OS) {
2731 emitSourceFileHeader(
2732 "List of all attribute subject matching rules that Clang recognizes", OS);
2733 PragmaClangAttributeSupport &PragmaAttributeSupport =
2734 getPragmaAttributeSupport(Records);
2735 emitDefaultDefine(OS, "ATTR_MATCH_RULE", nullptr);
2736 PragmaAttributeSupport.emitMatchRuleList(OS);
2737 OS << "#undef ATTR_MATCH_RULE\n";
2740 // Emits the code to read an attribute from a precompiled header.
2741 void EmitClangAttrPCHRead(RecordKeeper &Records, raw_ostream &OS) {
2742 emitSourceFileHeader("Attribute deserialization code", OS);
2744 Record *InhClass = Records.getClass("InheritableAttr");
2745 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"),
2747 std::vector<std::unique_ptr<Argument>> Args;
2749 OS << " switch (Kind) {\n";
2750 for (const auto *Attr : Attrs) {
2751 const Record &R = *Attr;
2752 if (!R.getValueAsBit("ASTNode"))
2755 OS << " case attr::" << R.getName() << ": {\n";
2756 if (R.isSubClassOf(InhClass))
2757 OS << " bool isInherited = Record.readInt();\n";
2758 OS << " bool isImplicit = Record.readInt();\n";
2759 OS << " unsigned Spelling = Record.readInt();\n";
2760 ArgRecords = R.getValueAsListOfDefs("Args");
2762 for (const auto *Arg : ArgRecords) {
2763 Args.emplace_back(createArgument(*Arg, R.getName()));
2764 Args.back()->writePCHReadDecls(OS);
2766 OS << " New = new (Context) " << R.getName() << "Attr(Range, Context";
2767 for (auto const &ri : Args) {
2769 ri->writePCHReadArgs(OS);
2771 OS << ", Spelling);\n";
2772 if (R.isSubClassOf(InhClass))
2773 OS << " cast<InheritableAttr>(New)->setInherited(isInherited);\n";
2774 OS << " New->setImplicit(isImplicit);\n";
2781 // Emits the code to write an attribute to a precompiled header.
2782 void EmitClangAttrPCHWrite(RecordKeeper &Records, raw_ostream &OS) {
2783 emitSourceFileHeader("Attribute serialization code", OS);
2785 Record *InhClass = Records.getClass("InheritableAttr");
2786 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
2788 OS << " switch (A->getKind()) {\n";
2789 for (const auto *Attr : Attrs) {
2790 const Record &R = *Attr;
2791 if (!R.getValueAsBit("ASTNode"))
2793 OS << " case attr::" << R.getName() << ": {\n";
2794 Args = R.getValueAsListOfDefs("Args");
2795 if (R.isSubClassOf(InhClass) || !Args.empty())
2796 OS << " const auto *SA = cast<" << R.getName()
2798 if (R.isSubClassOf(InhClass))
2799 OS << " Record.push_back(SA->isInherited());\n";
2800 OS << " Record.push_back(A->isImplicit());\n";
2801 OS << " Record.push_back(A->getSpellingListIndex());\n";
2803 for (const auto *Arg : Args)
2804 createArgument(*Arg, R.getName())->writePCHWrite(OS);
2811 // Helper function for GenerateTargetSpecificAttrChecks that alters the 'Test'
2812 // parameter with only a single check type, if applicable.
2813 static bool GenerateTargetSpecificAttrCheck(const Record *R, std::string &Test,
2814 std::string *FnName,
2816 StringRef CheckAgainst,
2818 if (!R->isValueUnset(ListName)) {
2820 std::vector<StringRef> Items = R->getValueAsListOfStrings(ListName);
2821 for (auto I = Items.begin(), E = Items.end(); I != E; ++I) {
2822 StringRef Part = *I;
2823 Test += CheckAgainst;
2838 // Generate a conditional expression to check if the current target satisfies
2839 // the conditions for a TargetSpecificAttr record, and append the code for
2840 // those checks to the Test string. If the FnName string pointer is non-null,
2841 // append a unique suffix to distinguish this set of target checks from other
2842 // TargetSpecificAttr records.
2843 static bool GenerateTargetSpecificAttrChecks(const Record *R,
2844 std::vector<StringRef> &Arches,
2846 std::string *FnName) {
2847 bool AnyTargetChecks = false;
2849 // It is assumed that there will be an llvm::Triple object
2850 // named "T" and a TargetInfo object named "Target" within
2851 // scope that can be used to determine whether the attribute exists in
2854 // If one or more architectures is specified, check those. Arches are handled
2855 // differently because GenerateTargetRequirements needs to combine the list
2857 if (!Arches.empty()) {
2858 AnyTargetChecks = true;
2860 for (auto I = Arches.begin(), E = Arches.end(); I != E; ++I) {
2861 StringRef Part = *I;
2862 Test += "T.getArch() == llvm::Triple::";
2872 // If the attribute is specific to particular OSes, check those.
2873 AnyTargetChecks |= GenerateTargetSpecificAttrCheck(
2874 R, Test, FnName, "OSes", "T.getOS()", "llvm::Triple::");
2876 // If one or more object formats is specified, check those.
2878 GenerateTargetSpecificAttrCheck(R, Test, FnName, "ObjectFormats",
2879 "T.getObjectFormat()", "llvm::Triple::");
2881 // If custom code is specified, emit it.
2882 StringRef Code = R->getValueAsString("CustomCode");
2883 if (!Code.empty()) {
2884 AnyTargetChecks = true;
2890 return AnyTargetChecks;
2893 static void GenerateHasAttrSpellingStringSwitch(
2894 const std::vector<Record *> &Attrs, raw_ostream &OS,
2895 const std::string &Variety = "", const std::string &Scope = "") {
2896 for (const auto *Attr : Attrs) {
2897 // C++11-style attributes have specific version information associated with
2898 // them. If the attribute has no scope, the version information must not
2899 // have the default value (1), as that's incorrect. Instead, the unscoped
2900 // attribute version information should be taken from the SD-6 standing
2901 // document, which can be found at:
2902 // https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations
2905 if (Variety == "CXX11") {
2906 std::vector<Record *> Spellings = Attr->getValueAsListOfDefs("Spellings");
2907 for (const auto &Spelling : Spellings) {
2908 if (Spelling->getValueAsString("Variety") == "CXX11") {
2909 Version = static_cast<int>(Spelling->getValueAsInt("Version"));
2910 if (Scope.empty() && Version == 1)
2911 PrintError(Spelling->getLoc(), "C++ standard attributes must "
2912 "have valid version information.");
2919 if (Attr->isSubClassOf("TargetSpecificAttr")) {
2920 const Record *R = Attr->getValueAsDef("Target");
2921 std::vector<StringRef> Arches = R->getValueAsListOfStrings("Arches");
2922 GenerateTargetSpecificAttrChecks(R, Arches, Test, nullptr);
2924 // If this is the C++11 variety, also add in the LangOpts test.
2925 if (Variety == "CXX11")
2926 Test += " && LangOpts.CPlusPlus11";
2927 else if (Variety == "C2x")
2928 Test += " && LangOpts.DoubleSquareBracketAttributes";
2929 } else if (Variety == "CXX11")
2930 // C++11 mode should be checked against LangOpts, which is presumed to be
2931 // present in the caller.
2932 Test = "LangOpts.CPlusPlus11";
2933 else if (Variety == "C2x")
2934 Test = "LangOpts.DoubleSquareBracketAttributes";
2936 std::string TestStr =
2937 !Test.empty() ? Test + " ? " + llvm::itostr(Version) + " : 0" : "1";
2938 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
2939 for (const auto &S : Spellings)
2940 if (Variety.empty() || (Variety == S.variety() &&
2941 (Scope.empty() || Scope == S.nameSpace())))
2942 OS << " .Case(\"" << S.name() << "\", " << TestStr << ")\n";
2944 OS << " .Default(0);\n";
2947 // Emits the list of spellings for attributes.
2948 void EmitClangAttrHasAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
2949 emitSourceFileHeader("Code to implement the __has_attribute logic", OS);
2951 // Separate all of the attributes out into four group: generic, C++11, GNU,
2952 // and declspecs. Then generate a big switch statement for each of them.
2953 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2954 std::vector<Record *> Declspec, Microsoft, GNU, Pragma;
2955 std::map<std::string, std::vector<Record *>> CXX, C2x;
2957 // Walk over the list of all attributes, and split them out based on the
2958 // spelling variety.
2959 for (auto *R : Attrs) {
2960 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*R);
2961 for (const auto &SI : Spellings) {
2962 const std::string &Variety = SI.variety();
2963 if (Variety == "GNU")
2965 else if (Variety == "Declspec")
2966 Declspec.push_back(R);
2967 else if (Variety == "Microsoft")
2968 Microsoft.push_back(R);
2969 else if (Variety == "CXX11")
2970 CXX[SI.nameSpace()].push_back(R);
2971 else if (Variety == "C2x")
2972 C2x[SI.nameSpace()].push_back(R);
2973 else if (Variety == "Pragma")
2974 Pragma.push_back(R);
2978 OS << "const llvm::Triple &T = Target.getTriple();\n";
2979 OS << "switch (Syntax) {\n";
2980 OS << "case AttrSyntax::GNU:\n";
2981 OS << " return llvm::StringSwitch<int>(Name)\n";
2982 GenerateHasAttrSpellingStringSwitch(GNU, OS, "GNU");
2983 OS << "case AttrSyntax::Declspec:\n";
2984 OS << " return llvm::StringSwitch<int>(Name)\n";
2985 GenerateHasAttrSpellingStringSwitch(Declspec, OS, "Declspec");
2986 OS << "case AttrSyntax::Microsoft:\n";
2987 OS << " return llvm::StringSwitch<int>(Name)\n";
2988 GenerateHasAttrSpellingStringSwitch(Microsoft, OS, "Microsoft");
2989 OS << "case AttrSyntax::Pragma:\n";
2990 OS << " return llvm::StringSwitch<int>(Name)\n";
2991 GenerateHasAttrSpellingStringSwitch(Pragma, OS, "Pragma");
2992 auto fn = [&OS](const char *Spelling, const char *Variety,
2993 const std::map<std::string, std::vector<Record *>> &List) {
2994 OS << "case AttrSyntax::" << Variety << ": {\n";
2995 // C++11-style attributes are further split out based on the Scope.
2996 for (auto I = List.cbegin(), E = List.cend(); I != E; ++I) {
2997 if (I != List.cbegin())
2999 if (I->first.empty())
3000 OS << "if (ScopeName == \"\") {\n";
3002 OS << "if (ScopeName == \"" << I->first << "\") {\n";
3003 OS << " return llvm::StringSwitch<int>(Name)\n";
3004 GenerateHasAttrSpellingStringSwitch(I->second, OS, Spelling, I->first);
3007 OS << "\n} break;\n";
3009 fn("CXX11", "CXX", CXX);
3010 fn("C2x", "C", C2x);
3014 void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS) {
3015 emitSourceFileHeader("Code to translate different attribute spellings "
3016 "into internal identifiers", OS);
3018 OS << " switch (AttrKind) {\n";
3020 ParsedAttrMap Attrs = getParsedAttrList(Records);
3021 for (const auto &I : Attrs) {
3022 const Record &R = *I.second;
3023 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
3024 OS << " case AT_" << I.first << ": {\n";
3025 for (unsigned I = 0; I < Spellings.size(); ++ I) {
3026 OS << " if (Name == \"" << Spellings[I].name() << "\" && "
3028 << StringSwitch<unsigned>(Spellings[I].variety())
3032 .Case("Declspec", 3)
3033 .Case("Microsoft", 4)
3037 << " && Scope == \"" << Spellings[I].nameSpace() << "\")\n"
3038 << " return " << I << ";\n";
3046 OS << " return 0;\n";
3049 // Emits code used by RecursiveASTVisitor to visit attributes
3050 void EmitClangAttrASTVisitor(RecordKeeper &Records, raw_ostream &OS) {
3051 emitSourceFileHeader("Used by RecursiveASTVisitor to visit attributes.", OS);
3053 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
3055 // Write method declarations for Traverse* methods.
3056 // We emit this here because we only generate methods for attributes that
3057 // are declared as ASTNodes.
3058 OS << "#ifdef ATTR_VISITOR_DECLS_ONLY\n\n";
3059 for (const auto *Attr : Attrs) {
3060 const Record &R = *Attr;
3061 if (!R.getValueAsBit("ASTNode"))
3063 OS << " bool Traverse"
3064 << R.getName() << "Attr(" << R.getName() << "Attr *A);\n";
3066 << R.getName() << "Attr(" << R.getName() << "Attr *A) {\n"
3067 << " return true; \n"
3070 OS << "\n#else // ATTR_VISITOR_DECLS_ONLY\n\n";
3072 // Write individual Traverse* methods for each attribute class.
3073 for (const auto *Attr : Attrs) {
3074 const Record &R = *Attr;
3075 if (!R.getValueAsBit("ASTNode"))
3078 OS << "template <typename Derived>\n"
3079 << "bool VISITORCLASS<Derived>::Traverse"
3080 << R.getName() << "Attr(" << R.getName() << "Attr *A) {\n"
3081 << " if (!getDerived().VisitAttr(A))\n"
3082 << " return false;\n"
3083 << " if (!getDerived().Visit" << R.getName() << "Attr(A))\n"
3084 << " return false;\n";
3086 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
3087 for (const auto *Arg : ArgRecords)
3088 createArgument(*Arg, R.getName())->writeASTVisitorTraversal(OS);
3090 OS << " return true;\n";
3094 // Write generic Traverse routine
3095 OS << "template <typename Derived>\n"
3096 << "bool VISITORCLASS<Derived>::TraverseAttr(Attr *A) {\n"
3098 << " return true;\n"
3100 << " switch (A->getKind()) {\n";
3102 for (const auto *Attr : Attrs) {
3103 const Record &R = *Attr;
3104 if (!R.getValueAsBit("ASTNode"))
3107 OS << " case attr::" << R.getName() << ":\n"
3108 << " return getDerived().Traverse" << R.getName() << "Attr("
3109 << "cast<" << R.getName() << "Attr>(A));\n";
3111 OS << " }\n"; // end switch
3112 OS << " llvm_unreachable(\"bad attribute kind\");\n";
3113 OS << "}\n"; // end function
3114 OS << "#endif // ATTR_VISITOR_DECLS_ONLY\n";
3117 void EmitClangAttrTemplateInstantiateHelper(const std::vector<Record *> &Attrs,
3119 bool AppliesToDecl) {
3121 OS << " switch (At->getKind()) {\n";
3122 for (const auto *Attr : Attrs) {
3123 const Record &R = *Attr;
3124 if (!R.getValueAsBit("ASTNode"))
3126 OS << " case attr::" << R.getName() << ": {\n";
3127 bool ShouldClone = R.getValueAsBit("Clone") &&
3129 R.getValueAsBit("MeaningfulToClassTemplateDefinition"));
3132 OS << " return nullptr;\n";
3137 OS << " const auto *A = cast<"
3138 << R.getName() << "Attr>(At);\n";
3139 bool TDependent = R.getValueAsBit("TemplateDependent");
3142 OS << " return A->clone(C);\n";
3147 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
3148 std::vector<std::unique_ptr<Argument>> Args;
3149 Args.reserve(ArgRecords.size());
3151 for (const auto *ArgRecord : ArgRecords)
3152 Args.emplace_back(createArgument(*ArgRecord, R.getName()));
3154 for (auto const &ai : Args)
3155 ai->writeTemplateInstantiation(OS);
3157 OS << " return new (C) " << R.getName() << "Attr(A->getLocation(), C";
3158 for (auto const &ai : Args) {
3160 ai->writeTemplateInstantiationArgs(OS);
3162 OS << ", A->getSpellingListIndex());\n }\n";
3164 OS << " } // end switch\n"
3165 << " llvm_unreachable(\"Unknown attribute!\");\n"
3166 << " return nullptr;\n";
3169 // Emits code to instantiate dependent attributes on templates.
3170 void EmitClangAttrTemplateInstantiate(RecordKeeper &Records, raw_ostream &OS) {
3171 emitSourceFileHeader("Template instantiation code for attributes", OS);
3173 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
3175 OS << "namespace clang {\n"
3176 << "namespace sema {\n\n"
3177 << "Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, "
3179 << " const MultiLevelTemplateArgumentList &TemplateArgs) {\n";
3180 EmitClangAttrTemplateInstantiateHelper(Attrs, OS, /*AppliesToDecl*/false);
3182 << "Attr *instantiateTemplateAttributeForDecl(const Attr *At,\n"
3183 << " ASTContext &C, Sema &S,\n"
3184 << " const MultiLevelTemplateArgumentList &TemplateArgs) {\n";
3185 EmitClangAttrTemplateInstantiateHelper(Attrs, OS, /*AppliesToDecl*/true);
3187 << "} // end namespace sema\n"
3188 << "} // end namespace clang\n";
3191 // Emits the list of parsed attributes.
3192 void EmitClangAttrParsedAttrList(RecordKeeper &Records, raw_ostream &OS) {
3193 emitSourceFileHeader("List of all attributes that Clang recognizes", OS);
3195 OS << "#ifndef PARSED_ATTR\n";
3196 OS << "#define PARSED_ATTR(NAME) NAME\n";
3199 ParsedAttrMap Names = getParsedAttrList(Records);
3200 for (const auto &I : Names) {
3201 OS << "PARSED_ATTR(" << I.first << ")\n";
3205 static bool isArgVariadic(const Record &R, StringRef AttrName) {
3206 return createArgument(R, AttrName)->isVariadic();
3209 static void emitArgInfo(const Record &R, raw_ostream &OS) {
3210 // This function will count the number of arguments specified for the
3211 // attribute and emit the number of required arguments followed by the
3212 // number of optional arguments.
3213 std::vector<Record *> Args = R.getValueAsListOfDefs("Args");
3214 unsigned ArgCount = 0, OptCount = 0;
3215 bool HasVariadic = false;
3216 for (const auto *Arg : Args) {
3217 // If the arg is fake, it's the user's job to supply it: general parsing
3218 // logic shouldn't need to know anything about it.
3219 if (Arg->getValueAsBit("Fake"))
3221 Arg->getValueAsBit("Optional") ? ++OptCount : ++ArgCount;
3222 if (!HasVariadic && isArgVariadic(*Arg, R.getName()))
3226 // If there is a variadic argument, we will set the optional argument count
3227 // to its largest value. Since it's currently a 4-bit number, we set it to 15.
3228 OS << ArgCount << ", " << (HasVariadic ? 15 : OptCount);
3231 static void GenerateDefaultAppertainsTo(raw_ostream &OS) {
3232 OS << "static bool defaultAppertainsTo(Sema &, const ParsedAttr &,";
3233 OS << "const Decl *) {\n";
3234 OS << " return true;\n";
3238 static std::string GetDiagnosticSpelling(const Record &R) {
3239 std::string Ret = R.getValueAsString("DiagSpelling");
3243 // If we couldn't find the DiagSpelling in this object, we can check to see
3244 // if the object is one that has a base, and if it is, loop up to the Base
3245 // member recursively.
3246 std::string Super = R.getSuperClasses().back().first->getName();
3247 if (Super == "DDecl" || Super == "DStmt")
3248 return GetDiagnosticSpelling(*R.getValueAsDef("Base"));
3253 static std::string CalculateDiagnostic(const Record &S) {
3254 // If the SubjectList object has a custom diagnostic associated with it,
3255 // return that directly.
3256 const StringRef CustomDiag = S.getValueAsString("CustomDiag");
3257 if (!CustomDiag.empty())
3258 return ("\"" + Twine(CustomDiag) + "\"").str();
3260 std::vector<std::string> DiagList;
3261 std::vector<Record *> Subjects = S.getValueAsListOfDefs("Subjects");
3262 for (const auto *Subject : Subjects) {
3263 const Record &R = *Subject;
3264 // Get the diagnostic text from the Decl or Stmt node given.
3265 std::string V = GetDiagnosticSpelling(R);
3267 PrintError(R.getLoc(),
3268 "Could not determine diagnostic spelling for the node: " +
3269 R.getName() + "; please add one to DeclNodes.td");
3271 // The node may contain a list of elements itself, so split the elements
3272 // by a comma, and trim any whitespace.
3273 SmallVector<StringRef, 2> Frags;
3274 llvm::SplitString(V, Frags, ",");
3275 for (auto Str : Frags) {
3276 DiagList.push_back(Str.trim());
3281 if (DiagList.empty()) {
3282 PrintFatalError(S.getLoc(),
3283 "Could not deduce diagnostic argument for Attr subjects");
3287 // FIXME: this is not particularly good for localization purposes and ideally
3288 // should be part of the diagnostics engine itself with some sort of list
3291 // A single member of the list can be returned directly.
3292 if (DiagList.size() == 1)
3293 return '"' + DiagList.front() + '"';
3295 if (DiagList.size() == 2)
3296 return '"' + DiagList[0] + " and " + DiagList[1] + '"';
3298 // If there are more than two in the list, we serialize the first N - 1
3299 // elements with a comma. This leaves the string in the state: foo, bar,
3300 // baz (but misses quux). We can then add ", and " for the last element
3302 std::string Diag = llvm::join(DiagList.begin(), DiagList.end() - 1, ", ");
3303 return '"' + Diag + ", and " + *(DiagList.end() - 1) + '"';
3306 static std::string GetSubjectWithSuffix(const Record *R) {
3307 const std::string &B = R->getName();
3308 if (B == "DeclBase")
3313 static std::string functionNameForCustomAppertainsTo(const Record &Subject) {
3314 return "is" + Subject.getName().str();
3317 static std::string GenerateCustomAppertainsTo(const Record &Subject,
3319 std::string FnName = functionNameForCustomAppertainsTo(Subject);
3321 // If this code has already been generated, simply return the previous
3323 static std::set<std::string> CustomSubjectSet;
3324 auto I = CustomSubjectSet.find(FnName);
3325 if (I != CustomSubjectSet.end())
3328 Record *Base = Subject.getValueAsDef("Base");
3330 // Not currently support custom subjects within custom subjects.
3331 if (Base->isSubClassOf("SubsetSubject")) {
3332 PrintFatalError(Subject.getLoc(),
3333 "SubsetSubjects within SubsetSubjects is not supported");
3337 OS << "static bool " << FnName << "(const Decl *D) {\n";
3338 OS << " if (const auto *S = dyn_cast<";
3339 OS << GetSubjectWithSuffix(Base);
3341 OS << " return " << Subject.getValueAsString("CheckCode") << ";\n";
3342 OS << " return false;\n";
3345 CustomSubjectSet.insert(FnName);
3349 static std::string GenerateAppertainsTo(const Record &Attr, raw_ostream &OS) {
3350 // If the attribute does not contain a Subjects definition, then use the
3351 // default appertainsTo logic.
3352 if (Attr.isValueUnset("Subjects"))
3353 return "defaultAppertainsTo";
3355 const Record *SubjectObj = Attr.getValueAsDef("Subjects");
3356 std::vector<Record*> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
3358 // If the list of subjects is empty, it is assumed that the attribute
3359 // appertains to everything.
3360 if (Subjects.empty())
3361 return "defaultAppertainsTo";
3363 bool Warn = SubjectObj->getValueAsDef("Diag")->getValueAsBit("Warn");
3365 // Otherwise, generate an appertainsTo check specific to this attribute which
3366 // checks all of the given subjects against the Decl passed in. Return the
3367 // name of that check to the caller.
3369 // If D is null, that means the attribute was not applied to a declaration
3370 // at all (for instance because it was applied to a type), or that the caller
3371 // has determined that the check should fail (perhaps prior to the creation
3372 // of the declaration).
3373 std::string FnName = "check" + Attr.getName().str() + "AppertainsTo";
3374 std::stringstream SS;
3375 SS << "static bool " << FnName << "(Sema &S, const ParsedAttr &Attr, ";
3376 SS << "const Decl *D) {\n";
3377 SS << " if (!D || (";
3378 for (auto I = Subjects.begin(), E = Subjects.end(); I != E; ++I) {
3379 // If the subject has custom code associated with it, generate a function
3380 // for it. The function cannot be inlined into this check (yet) because it
3381 // requires the subject to be of a specific type, and were that information
3382 // inlined here, it would not support an attribute with multiple custom
3384 if ((*I)->isSubClassOf("SubsetSubject")) {
3385 SS << "!" << GenerateCustomAppertainsTo(**I, OS) << "(D)";
3387 SS << "!isa<" << GetSubjectWithSuffix(*I) << ">(D)";
3394 SS << " S.Diag(Attr.getLoc(), diag::";
3395 SS << (Warn ? "warn_attribute_wrong_decl_type_str" :
3396 "err_attribute_wrong_decl_type_str");
3398 SS << " << Attr << ";
3399 SS << CalculateDiagnostic(*SubjectObj) << ";\n";
3400 SS << " return false;\n";
3402 SS << " return true;\n";
3410 emitAttributeMatchRules(PragmaClangAttributeSupport &PragmaAttributeSupport,
3412 OS << "static bool checkAttributeMatchRuleAppliesTo(const Decl *D, "
3413 << AttributeSubjectMatchRule::EnumName << " rule) {\n";
3414 OS << " switch (rule) {\n";
3415 for (const auto &Rule : PragmaAttributeSupport.Rules) {
3416 if (Rule.isAbstractRule()) {
3417 OS << " case " << Rule.getEnumValue() << ":\n";
3418 OS << " assert(false && \"Abstract matcher rule isn't allowed\");\n";
3419 OS << " return false;\n";
3422 std::vector<Record *> Subjects = Rule.getSubjects();
3423 assert(!Subjects.empty() && "Missing subjects");
3424 OS << " case " << Rule.getEnumValue() << ":\n";
3426 for (auto I = Subjects.begin(), E = Subjects.end(); I != E; ++I) {
3427 // If the subject has custom code associated with it, use the function
3428 // that was generated for GenerateAppertainsTo to check if the declaration
3430 if ((*I)->isSubClassOf("SubsetSubject"))
3431 OS << functionNameForCustomAppertainsTo(**I) << "(D)";
3433 OS << "isa<" << GetSubjectWithSuffix(*I) << ">(D)";
3441 OS << " llvm_unreachable(\"Invalid match rule\");\nreturn false;\n";
3445 static void GenerateDefaultLangOptRequirements(raw_ostream &OS) {
3446 OS << "static bool defaultDiagnoseLangOpts(Sema &, ";
3447 OS << "const ParsedAttr &) {\n";
3448 OS << " return true;\n";
3452 static std::string GenerateLangOptRequirements(const Record &R,
3454 // If the attribute has an empty or unset list of language requirements,
3455 // return the default handler.
3456 std::vector<Record *> LangOpts = R.getValueAsListOfDefs("LangOpts");
3457 if (LangOpts.empty())
3458 return "defaultDiagnoseLangOpts";
3460 // Generate a unique function name for the diagnostic test. The list of
3461 // options should usually be short (one or two options), and the
3462 // uniqueness isn't strictly necessary (it is just for codegen efficiency).
3463 std::string FnName = "check";
3464 for (auto I = LangOpts.begin(), E = LangOpts.end(); I != E; ++I)
3465 FnName += (*I)->getValueAsString("Name");
3466 FnName += "LangOpts";
3468 // If this code has already been generated, simply return the previous
3470 static std::set<std::string> CustomLangOptsSet;
3471 auto I = CustomLangOptsSet.find(FnName);
3472 if (I != CustomLangOptsSet.end())
3475 OS << "static bool " << FnName << "(Sema &S, const ParsedAttr &Attr) {\n";
3476 OS << " auto &LangOpts = S.LangOpts;\n";
3477 OS << " if (" << GenerateTestExpression(LangOpts) << ")\n";
3478 OS << " return true;\n\n";
3479 OS << " S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) ";
3480 OS << "<< Attr.getName();\n";
3481 OS << " return false;\n";
3484 CustomLangOptsSet.insert(FnName);
3488 static void GenerateDefaultTargetRequirements(raw_ostream &OS) {
3489 OS << "static bool defaultTargetRequirements(const TargetInfo &) {\n";
3490 OS << " return true;\n";
3494 static std::string GenerateTargetRequirements(const Record &Attr,
3495 const ParsedAttrMap &Dupes,
3497 // If the attribute is not a target specific attribute, return the default
3499 if (!Attr.isSubClassOf("TargetSpecificAttr"))
3500 return "defaultTargetRequirements";
3502 // Get the list of architectures to be tested for.
3503 const Record *R = Attr.getValueAsDef("Target");
3504 std::vector<StringRef> Arches = R->getValueAsListOfStrings("Arches");
3506 // If there are other attributes which share the same parsed attribute kind,
3507 // such as target-specific attributes with a shared spelling, collapse the
3508 // duplicate architectures. This is required because a shared target-specific
3509 // attribute has only one ParsedAttr::Kind enumeration value, but it
3510 // applies to multiple target architectures. In order for the attribute to be
3511 // considered valid, all of its architectures need to be included.
3512 if (!Attr.isValueUnset("ParseKind")) {
3513 const StringRef APK = Attr.getValueAsString("ParseKind");
3514 for (const auto &I : Dupes) {
3515 if (I.first == APK) {
3516 std::vector<StringRef> DA =
3517 I.second->getValueAsDef("Target")->getValueAsListOfStrings(
3519 Arches.insert(Arches.end(), DA.begin(), DA.end());
3524 std::string FnName = "isTarget";
3526 bool UsesT = GenerateTargetSpecificAttrChecks(R, Arches, Test, &FnName);
3528 // If this code has already been generated, simply return the previous
3530 static std::set<std::string> CustomTargetSet;
3531 auto I = CustomTargetSet.find(FnName);
3532 if (I != CustomTargetSet.end())
3535 OS << "static bool " << FnName << "(const TargetInfo &Target) {\n";
3537 OS << " const llvm::Triple &T = Target.getTriple(); (void)T;\n";
3538 OS << " return " << Test << ";\n";
3541 CustomTargetSet.insert(FnName);
3545 static void GenerateDefaultSpellingIndexToSemanticSpelling(raw_ostream &OS) {
3546 OS << "static unsigned defaultSpellingIndexToSemanticSpelling("
3547 << "const ParsedAttr &Attr) {\n";
3548 OS << " return UINT_MAX;\n";
3552 static std::string GenerateSpellingIndexToSemanticSpelling(const Record &Attr,
3554 // If the attribute does not have a semantic form, we can bail out early.
3555 if (!Attr.getValueAsBit("ASTNode"))
3556 return "defaultSpellingIndexToSemanticSpelling";
3558 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
3560 // If there are zero or one spellings, or all of the spellings share the same
3561 // name, we can also bail out early.
3562 if (Spellings.size() <= 1 || SpellingNamesAreCommon(Spellings))
3563 return "defaultSpellingIndexToSemanticSpelling";
3565 // Generate the enumeration we will use for the mapping.
3566 SemanticSpellingMap SemanticToSyntacticMap;
3567 std::string Enum = CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
3568 std::string Name = Attr.getName().str() + "AttrSpellingMap";
3570 OS << "static unsigned " << Name << "(const ParsedAttr &Attr) {\n";
3572 OS << " unsigned Idx = Attr.getAttributeSpellingListIndex();\n";
3573 WriteSemanticSpellingSwitch("Idx", SemanticToSyntacticMap, OS);
3579 static bool IsKnownToGCC(const Record &Attr) {
3580 // Look at the spellings for this subject; if there are any spellings which
3581 // claim to be known to GCC, the attribute is known to GCC.
3582 return llvm::any_of(
3583 GetFlattenedSpellings(Attr),
3584 [](const FlattenedSpelling &S) { return S.knownToGCC(); });
3587 /// Emits the parsed attribute helpers
3588 void EmitClangAttrParsedAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
3589 emitSourceFileHeader("Parsed attribute helpers", OS);
3591 PragmaClangAttributeSupport &PragmaAttributeSupport =
3592 getPragmaAttributeSupport(Records);
3594 // Get the list of parsed attributes, and accept the optional list of
3595 // duplicates due to the ParseKind.
3596 ParsedAttrMap Dupes;
3597 ParsedAttrMap Attrs = getParsedAttrList(Records, &Dupes);
3599 // Generate the default appertainsTo, target and language option diagnostic,
3600 // and spelling list index mapping methods.
3601 GenerateDefaultAppertainsTo(OS);
3602 GenerateDefaultLangOptRequirements(OS);
3603 GenerateDefaultTargetRequirements(OS);
3604 GenerateDefaultSpellingIndexToSemanticSpelling(OS);
3606 // Generate the appertainsTo diagnostic methods and write their names into
3607 // another mapping. At the same time, generate the AttrInfoMap object
3608 // contents. Due to the reliance on generated code, use separate streams so
3609 // that code will not be interleaved.
3611 raw_string_ostream SS {Buffer};
3612 for (auto I = Attrs.begin(), E = Attrs.end(); I != E; ++I) {
3613 // TODO: If the attribute's kind appears in the list of duplicates, that is
3614 // because it is a target-specific attribute that appears multiple times.
3615 // It would be beneficial to test whether the duplicates are "similar
3616 // enough" to each other to not cause problems. For instance, check that
3617 // the spellings are identical, and custom parsing rules match, etc.
3619 // We need to generate struct instances based off ParsedAttrInfo from
3622 emitArgInfo(*I->second, SS);
3623 SS << ", " << I->second->getValueAsBit("HasCustomParsing");
3624 SS << ", " << I->second->isSubClassOf("TargetSpecificAttr");
3626 << (I->second->isSubClassOf("TypeAttr") ||
3627 I->second->isSubClassOf("DeclOrTypeAttr"));
3628 SS << ", " << I->second->isSubClassOf("StmtAttr");
3629 SS << ", " << IsKnownToGCC(*I->second);
3630 SS << ", " << PragmaAttributeSupport.isAttributedSupported(*I->second);
3631 SS << ", " << GenerateAppertainsTo(*I->second, OS);
3632 SS << ", " << GenerateLangOptRequirements(*I->second, OS);
3633 SS << ", " << GenerateTargetRequirements(*I->second, Dupes, OS);
3634 SS << ", " << GenerateSpellingIndexToSemanticSpelling(*I->second, OS);
3636 << PragmaAttributeSupport.generateStrictConformsTo(*I->second, OS);
3642 SS << " // AT_" << I->first << "\n";
3645 OS << "static const ParsedAttrInfo AttrInfoMap[ParsedAttr::UnknownAttribute "
3650 // Generate the attribute match rules.
3651 emitAttributeMatchRules(PragmaAttributeSupport, OS);
3654 // Emits the kind list of parsed attributes
3655 void EmitClangAttrParsedAttrKinds(RecordKeeper &Records, raw_ostream &OS) {
3656 emitSourceFileHeader("Attribute name matcher", OS);
3658 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
3659 std::vector<StringMatcher::StringPair> GNU, Declspec, Microsoft, CXX11,
3660 Keywords, Pragma, C2x;
3661 std::set<std::string> Seen;
3662 for (const auto *A : Attrs) {
3663 const Record &Attr = *A;
3665 bool SemaHandler = Attr.getValueAsBit("SemaHandler");
3666 bool Ignored = Attr.getValueAsBit("Ignored");
3667 if (SemaHandler || Ignored) {
3668 // Attribute spellings can be shared between target-specific attributes,
3669 // and can be shared between syntaxes for the same attribute. For
3670 // instance, an attribute can be spelled GNU<"interrupt"> for an ARM-
3671 // specific attribute, or MSP430-specific attribute. Additionally, an
3672 // attribute can be spelled GNU<"dllexport"> and Declspec<"dllexport">
3673 // for the same semantic attribute. Ultimately, we need to map each of
3674 // these to a single ParsedAttr::Kind value, but the StringMatcher
3675 // class cannot handle duplicate match strings. So we generate a list of
3676 // string to match based on the syntax, and emit multiple string matchers
3677 // depending on the syntax used.
3678 std::string AttrName;
3679 if (Attr.isSubClassOf("TargetSpecificAttr") &&
3680 !Attr.isValueUnset("ParseKind")) {
3681 AttrName = Attr.getValueAsString("ParseKind");
3682 if (Seen.find(AttrName) != Seen.end())
3684 Seen.insert(AttrName);
3686 AttrName = NormalizeAttrName(StringRef(Attr.getName())).str();
3688 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
3689 for (const auto &S : Spellings) {
3690 const std::string &RawSpelling = S.name();
3691 std::vector<StringMatcher::StringPair> *Matches = nullptr;
3692 std::string Spelling;
3693 const std::string &Variety = S.variety();
3694 if (Variety == "CXX11") {
3696 Spelling += S.nameSpace();
3698 } else if (Variety == "C2x") {
3700 Spelling += S.nameSpace();
3702 } else if (Variety == "GNU")
3704 else if (Variety == "Declspec")
3705 Matches = &Declspec;
3706 else if (Variety == "Microsoft")
3707 Matches = &Microsoft;
3708 else if (Variety == "Keyword")
3709 Matches = &Keywords;
3710 else if (Variety == "Pragma")
3713 assert(Matches && "Unsupported spelling variety found");
3715 if (Variety == "GNU")
3716 Spelling += NormalizeGNUAttrSpelling(RawSpelling);
3718 Spelling += RawSpelling;
3721 Matches->push_back(StringMatcher::StringPair(
3722 Spelling, "return ParsedAttr::AT_" + AttrName + ";"));
3724 Matches->push_back(StringMatcher::StringPair(
3725 Spelling, "return ParsedAttr::IgnoredAttribute;"));
3730 OS << "static ParsedAttr::Kind getAttrKind(StringRef Name, ";
3731 OS << "ParsedAttr::Syntax Syntax) {\n";
3732 OS << " if (ParsedAttr::AS_GNU == Syntax) {\n";
3733 StringMatcher("Name", GNU, OS).Emit();
3734 OS << " } else if (ParsedAttr::AS_Declspec == Syntax) {\n";
3735 StringMatcher("Name", Declspec, OS).Emit();
3736 OS << " } else if (ParsedAttr::AS_Microsoft == Syntax) {\n";
3737 StringMatcher("Name", Microsoft, OS).Emit();
3738 OS << " } else if (ParsedAttr::AS_CXX11 == Syntax) {\n";
3739 StringMatcher("Name", CXX11, OS).Emit();
3740 OS << " } else if (ParsedAttr::AS_C2x == Syntax) {\n";
3741 StringMatcher("Name", C2x, OS).Emit();
3742 OS << " } else if (ParsedAttr::AS_Keyword == Syntax || ";
3743 OS << "ParsedAttr::AS_ContextSensitiveKeyword == Syntax) {\n";
3744 StringMatcher("Name", Keywords, OS).Emit();
3745 OS << " } else if (ParsedAttr::AS_Pragma == Syntax) {\n";
3746 StringMatcher("Name", Pragma, OS).Emit();
3748 OS << " return ParsedAttr::UnknownAttribute;\n"
3752 // Emits the code to dump an attribute.
3753 void EmitClangAttrTextNodeDump(RecordKeeper &Records, raw_ostream &OS) {
3754 emitSourceFileHeader("Attribute text node dumper", OS);
3756 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
3757 for (const auto *Attr : Attrs) {
3758 const Record &R = *Attr;
3759 if (!R.getValueAsBit("ASTNode"))
3762 // If the attribute has a semantically-meaningful name (which is determined
3763 // by whether there is a Spelling enumeration for it), then write out the
3764 // spelling used for the attribute.
3766 std::string FunctionContent;
3767 llvm::raw_string_ostream SS(FunctionContent);
3769 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
3770 if (Spellings.size() > 1 && !SpellingNamesAreCommon(Spellings))
3771 SS << " OS << \" \" << A->getSpelling();\n";
3773 Args = R.getValueAsListOfDefs("Args");
3774 for (const auto *Arg : Args)
3775 createArgument(*Arg, R.getName())->writeDump(SS);
3778 OS << " void Visit" << R.getName() << "Attr(const " << R.getName()
3781 OS << " const auto *SA = cast<" << R.getName()
3782 << "Attr>(A); (void)SA;\n";
3789 void EmitClangAttrNodeTraverse(RecordKeeper &Records, raw_ostream &OS) {
3790 emitSourceFileHeader("Attribute text node traverser", OS);
3792 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
3793 for (const auto *Attr : Attrs) {
3794 const Record &R = *Attr;
3795 if (!R.getValueAsBit("ASTNode"))
3798 std::string FunctionContent;
3799 llvm::raw_string_ostream SS(FunctionContent);
3801 Args = R.getValueAsListOfDefs("Args");
3802 for (const auto *Arg : Args)
3803 createArgument(*Arg, R.getName())->writeDumpChildren(SS);
3805 OS << " void Visit" << R.getName() << "Attr(const " << R.getName()
3808 OS << " const auto *SA = cast<" << R.getName()
3809 << "Attr>(A); (void)SA;\n";
3816 void EmitClangAttrParserStringSwitches(RecordKeeper &Records,
3818 emitSourceFileHeader("Parser-related llvm::StringSwitch cases", OS);
3819 emitClangAttrArgContextList(Records, OS);
3820 emitClangAttrIdentifierArgList(Records, OS);
3821 emitClangAttrVariadicIdentifierArgList(Records, OS);
3822 emitClangAttrThisIsaIdentifierArgList(Records, OS);
3823 emitClangAttrTypeArgList(Records, OS);
3824 emitClangAttrLateParsedList(Records, OS);
3827 void EmitClangAttrSubjectMatchRulesParserStringSwitches(RecordKeeper &Records,
3829 getPragmaAttributeSupport(Records).generateParsingHelpers(OS);
3832 enum class SpellingKind {
3841 static const size_t NumSpellingKinds = (size_t)SpellingKind::Pragma + 1;
3843 class SpellingList {
3844 std::vector<std::string> Spellings[NumSpellingKinds];
3847 ArrayRef<std::string> operator[](SpellingKind K) const {
3848 return Spellings[(size_t)K];
3851 void add(const Record &Attr, FlattenedSpelling Spelling) {
3852 SpellingKind Kind = StringSwitch<SpellingKind>(Spelling.variety())
3853 .Case("GNU", SpellingKind::GNU)
3854 .Case("CXX11", SpellingKind::CXX11)
3855 .Case("C2x", SpellingKind::C2x)
3856 .Case("Declspec", SpellingKind::Declspec)
3857 .Case("Microsoft", SpellingKind::Microsoft)
3858 .Case("Keyword", SpellingKind::Keyword)
3859 .Case("Pragma", SpellingKind::Pragma);
3861 if (!Spelling.nameSpace().empty()) {
3863 case SpellingKind::CXX11:
3864 case SpellingKind::C2x:
3865 Name = Spelling.nameSpace() + "::";
3867 case SpellingKind::Pragma:
3868 Name = Spelling.nameSpace() + " ";
3871 PrintFatalError(Attr.getLoc(), "Unexpected namespace in spelling");
3874 Name += Spelling.name();
3876 Spellings[(size_t)Kind].push_back(Name);
3880 class DocumentationData {
3882 const Record *Documentation;
3883 const Record *Attribute;
3884 std::string Heading;
3885 SpellingList SupportedSpellings;
3887 DocumentationData(const Record &Documentation, const Record &Attribute,
3888 std::pair<std::string, SpellingList> HeadingAndSpellings)
3889 : Documentation(&Documentation), Attribute(&Attribute),
3890 Heading(std::move(HeadingAndSpellings.first)),
3891 SupportedSpellings(std::move(HeadingAndSpellings.second)) {}
3894 static void WriteCategoryHeader(const Record *DocCategory,
3896 const StringRef Name = DocCategory->getValueAsString("Name");
3897 OS << Name << "\n" << std::string(Name.size(), '=') << "\n";
3899 // If there is content, print that as well.
3900 const StringRef ContentStr = DocCategory->getValueAsString("Content");
3901 // Trim leading and trailing newlines and spaces.
3902 OS << ContentStr.trim();
3907 static std::pair<std::string, SpellingList>
3908 GetAttributeHeadingAndSpellings(const Record &Documentation,
3909 const Record &Attribute) {
3910 // FIXME: there is no way to have a per-spelling category for the attribute
3911 // documentation. This may not be a limiting factor since the spellings
3912 // should generally be consistently applied across the category.
3914 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attribute);
3915 if (Spellings.empty())
3916 PrintFatalError(Attribute.getLoc(),
3917 "Attribute has no supported spellings; cannot be "
3920 // Determine the heading to be used for this attribute.
3921 std::string Heading = Documentation.getValueAsString("Heading");
3922 if (Heading.empty()) {
3923 // If there's only one spelling, we can simply use that.
3924 if (Spellings.size() == 1)
3925 Heading = Spellings.begin()->name();
3927 std::set<std::string> Uniques;
3928 for (auto I = Spellings.begin(), E = Spellings.end();
3929 I != E && Uniques.size() <= 1; ++I) {
3930 std::string Spelling = NormalizeNameForSpellingComparison(I->name());
3931 Uniques.insert(Spelling);
3933 // If the semantic map has only one spelling, that is sufficient for our
3935 if (Uniques.size() == 1)
3936 Heading = *Uniques.begin();
3940 // If the heading is still empty, it is an error.
3941 if (Heading.empty())
3942 PrintFatalError(Attribute.getLoc(),
3943 "This attribute requires a heading to be specified");
3945 SpellingList SupportedSpellings;
3946 for (const auto &I : Spellings)
3947 SupportedSpellings.add(Attribute, I);
3949 return std::make_pair(std::move(Heading), std::move(SupportedSpellings));
3952 static void WriteDocumentation(RecordKeeper &Records,
3953 const DocumentationData &Doc, raw_ostream &OS) {
3954 OS << Doc.Heading << "\n" << std::string(Doc.Heading.length(), '-') << "\n";
3956 // List what spelling syntaxes the attribute supports.
3957 OS << ".. csv-table:: Supported Syntaxes\n";
3958 OS << " :header: \"GNU\", \"C++11\", \"C2x\", \"``__declspec``\",";
3959 OS << " \"Keyword\", \"``#pragma``\", \"``#pragma clang attribute``\"\n\n";
3961 for (size_t Kind = 0; Kind != NumSpellingKinds; ++Kind) {
3962 SpellingKind K = (SpellingKind)Kind;
3963 // TODO: List Microsoft (IDL-style attribute) spellings once we fully
3965 if (K == SpellingKind::Microsoft)
3968 bool PrintedAny = false;
3969 for (StringRef Spelling : Doc.SupportedSpellings[K]) {
3972 OS << "``" << Spelling << "``";
3979 if (getPragmaAttributeSupport(Records).isAttributedSupported(
3984 // If the attribute is deprecated, print a message about it, and possibly
3985 // provide a replacement attribute.
3986 if (!Doc.Documentation->isValueUnset("Deprecated")) {
3987 OS << "This attribute has been deprecated, and may be removed in a future "
3988 << "version of Clang.";
3989 const Record &Deprecated = *Doc.Documentation->getValueAsDef("Deprecated");
3990 const StringRef Replacement = Deprecated.getValueAsString("Replacement");
3991 if (!Replacement.empty())
3992 OS << " This attribute has been superseded by ``" << Replacement
3997 const StringRef ContentStr = Doc.Documentation->getValueAsString("Content");
3998 // Trim leading and trailing newlines and spaces.
3999 OS << ContentStr.trim();
4004 void EmitClangAttrDocs(RecordKeeper &Records, raw_ostream &OS) {
4005 // Get the documentation introduction paragraph.
4006 const Record *Documentation = Records.getDef("GlobalDocumentation");
4007 if (!Documentation) {
4008 PrintFatalError("The Documentation top-level definition is missing, "
4009 "no documentation will be generated.");
4013 OS << Documentation->getValueAsString("Intro") << "\n";
4015 // Gather the Documentation lists from each of the attributes, based on the
4016 // category provided.
4017 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
4018 std::map<const Record *, std::vector<DocumentationData>> SplitDocs;
4019 for (const auto *A : Attrs) {
4020 const Record &Attr = *A;
4021 std::vector<Record *> Docs = Attr.getValueAsListOfDefs("Documentation");
4022 for (const auto *D : Docs) {
4023 const Record &Doc = *D;
4024 const Record *Category = Doc.getValueAsDef("Category");
4025 // If the category is "undocumented", then there cannot be any other
4026 // documentation categories (otherwise, the attribute would become
4028 const StringRef Cat = Category->getValueAsString("Name");
4029 bool Undocumented = Cat == "Undocumented";
4030 if (Undocumented && Docs.size() > 1)
4031 PrintFatalError(Doc.getLoc(),
4032 "Attribute is \"Undocumented\", but has multiple "
4033 "documentation categories");
4036 SplitDocs[Category].push_back(DocumentationData(
4037 Doc, Attr, GetAttributeHeadingAndSpellings(Doc, Attr)));
4041 // Having split the attributes out based on what documentation goes where,
4042 // we can begin to generate sections of documentation.
4043 for (auto &I : SplitDocs) {
4044 WriteCategoryHeader(I.first, OS);
4046 llvm::sort(I.second,
4047 [](const DocumentationData &D1, const DocumentationData &D2) {
4048 return D1.Heading < D2.Heading;
4051 // Walk over each of the attributes in the category and write out their
4053 for (const auto &Doc : I.second)
4054 WriteDocumentation(Records, Doc, OS);
4058 void EmitTestPragmaAttributeSupportedAttributes(RecordKeeper &Records,
4060 PragmaClangAttributeSupport Support = getPragmaAttributeSupport(Records);
4061 ParsedAttrMap Attrs = getParsedAttrList(Records);
4062 OS << "#pragma clang attribute supports the following attributes:\n";
4063 for (const auto &I : Attrs) {
4064 if (!Support.isAttributedSupported(*I.second))
4067 if (I.second->isValueUnset("Subjects")) {
4071 const Record *SubjectObj = I.second->getValueAsDef("Subjects");
4072 std::vector<Record *> Subjects =
4073 SubjectObj->getValueAsListOfDefs("Subjects");
4075 for (const auto &Subject : llvm::enumerate(Subjects)) {
4076 if (Subject.index())
4078 PragmaClangAttributeSupport::RuleOrAggregateRuleSet &RuleSet =
4079 Support.SubjectsToRules.find(Subject.value())->getSecond();
4080 if (RuleSet.isRule()) {
4081 OS << RuleSet.getRule().getEnumValueName();
4085 for (const auto &Rule : llvm::enumerate(RuleSet.getAggregateRuleSet())) {
4088 OS << Rule.value().getEnumValueName();
4094 OS << "End of supported attributes.\n";
4097 } // end namespace clang