1 //===- ClangAttrEmitter.cpp - Generate Clang attribute handling =-*- C++ -*--=//
2 //
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
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // These tablegen backends emit Clang attribute processing code
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "TableGenBackends.h"
14 #include "ASTTableGen.h"
15
16 #include "llvm/ADT/ArrayRef.h"
17 #include "llvm/ADT/DenseMap.h"
18 #include "llvm/ADT/DenseSet.h"
19 #include "llvm/ADT/MapVector.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/SmallString.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/ADT/StringRef.h"
24 #include "llvm/ADT/StringSet.h"
25 #include "llvm/ADT/StringSwitch.h"
26 #include "llvm/ADT/iterator_range.h"
27 #include "llvm/Support/ErrorHandling.h"
28 #include "llvm/Support/raw_ostream.h"
29 #include "llvm/TableGen/Error.h"
30 #include "llvm/TableGen/Record.h"
31 #include "llvm/TableGen/StringMatcher.h"
32 #include "llvm/TableGen/TableGenBackend.h"
33 #include <algorithm>
34 #include <cassert>
35 #include <cctype>
36 #include <cstddef>
37 #include <cstdint>
38 #include <map>
39 #include <memory>
40 #include <optional>
41 #include <set>
42 #include <sstream>
43 #include <string>
44 #include <utility>
45 #include <vector>
46
47 using namespace llvm;
48
49 namespace {
50
51 class FlattenedSpelling {
52 std::string V, N, NS;
53 bool K = false;
54 const Record &OriginalSpelling;
55
56 public:
FlattenedSpelling(const std::string & Variety,const std::string & Name,const std::string & Namespace,bool KnownToGCC,const Record & OriginalSpelling)57 FlattenedSpelling(const std::string &Variety, const std::string &Name,
58 const std::string &Namespace, bool KnownToGCC,
59 const Record &OriginalSpelling)
60 : V(Variety), N(Name), NS(Namespace), K(KnownToGCC),
61 OriginalSpelling(OriginalSpelling) {}
FlattenedSpelling(const Record & Spelling)62 explicit FlattenedSpelling(const Record &Spelling)
63 : V(std::string(Spelling.getValueAsString("Variety"))),
64 N(std::string(Spelling.getValueAsString("Name"))),
65 OriginalSpelling(Spelling) {
66 assert(V != "GCC" && V != "Clang" &&
67 "Given a GCC spelling, which means this hasn't been flattened!");
68 if (V == "CXX11" || V == "C23" || V == "Pragma")
69 NS = std::string(Spelling.getValueAsString("Namespace"));
70 }
71
variety() const72 const std::string &variety() const { return V; }
name() const73 const std::string &name() const { return N; }
nameSpace() const74 const std::string &nameSpace() const { return NS; }
knownToGCC() const75 bool knownToGCC() const { return K; }
getSpellingRecord() const76 const Record &getSpellingRecord() const { return OriginalSpelling; }
77 };
78
79 } // end anonymous namespace
80
81 static std::vector<FlattenedSpelling>
GetFlattenedSpellings(const Record & Attr)82 GetFlattenedSpellings(const Record &Attr) {
83 std::vector<Record *> Spellings = Attr.getValueAsListOfDefs("Spellings");
84 std::vector<FlattenedSpelling> Ret;
85
86 for (const auto &Spelling : Spellings) {
87 StringRef Variety = Spelling->getValueAsString("Variety");
88 StringRef Name = Spelling->getValueAsString("Name");
89 if (Variety == "GCC") {
90 Ret.emplace_back("GNU", std::string(Name), "", true, *Spelling);
91 Ret.emplace_back("CXX11", std::string(Name), "gnu", true, *Spelling);
92 if (Spelling->getValueAsBit("AllowInC"))
93 Ret.emplace_back("C23", std::string(Name), "gnu", true, *Spelling);
94 } else if (Variety == "Clang") {
95 Ret.emplace_back("GNU", std::string(Name), "", false, *Spelling);
96 Ret.emplace_back("CXX11", std::string(Name), "clang", false, *Spelling);
97 if (Spelling->getValueAsBit("AllowInC"))
98 Ret.emplace_back("C23", std::string(Name), "clang", false, *Spelling);
99 } else
100 Ret.push_back(FlattenedSpelling(*Spelling));
101 }
102
103 return Ret;
104 }
105
ReadPCHRecord(StringRef type)106 static std::string ReadPCHRecord(StringRef type) {
107 return StringSwitch<std::string>(type)
108 .EndsWith("Decl *", "Record.GetLocalDeclAs<" +
109 std::string(type.data(), 0, type.size() - 1) +
110 ">(Record.readInt())")
111 .Case("TypeSourceInfo *", "Record.readTypeSourceInfo()")
112 .Case("Expr *", "Record.readExpr()")
113 .Case("IdentifierInfo *", "Record.readIdentifier()")
114 .Case("StringRef", "Record.readString()")
115 .Case("ParamIdx", "ParamIdx::deserialize(Record.readInt())")
116 .Case("OMPTraitInfo *", "Record.readOMPTraitInfo()")
117 .Default("Record.readInt()");
118 }
119
120 // Get a type that is suitable for storing an object of the specified type.
getStorageType(StringRef type)121 static StringRef getStorageType(StringRef type) {
122 return StringSwitch<StringRef>(type)
123 .Case("StringRef", "std::string")
124 .Default(type);
125 }
126
127 // Assumes that the way to get the value is SA->getname()
WritePCHRecord(StringRef type,StringRef name)128 static std::string WritePCHRecord(StringRef type, StringRef name) {
129 return "Record." +
130 StringSwitch<std::string>(type)
131 .EndsWith("Decl *", "AddDeclRef(" + std::string(name) + ");\n")
132 .Case("TypeSourceInfo *",
133 "AddTypeSourceInfo(" + std::string(name) + ");\n")
134 .Case("Expr *", "AddStmt(" + std::string(name) + ");\n")
135 .Case("IdentifierInfo *",
136 "AddIdentifierRef(" + std::string(name) + ");\n")
137 .Case("StringRef", "AddString(" + std::string(name) + ");\n")
138 .Case("ParamIdx",
139 "push_back(" + std::string(name) + ".serialize());\n")
140 .Case("OMPTraitInfo *",
141 "writeOMPTraitInfo(" + std::string(name) + ");\n")
142 .Default("push_back(" + std::string(name) + ");\n");
143 }
144
145 // Normalize attribute name by removing leading and trailing
146 // underscores. For example, __foo, foo__, __foo__ would
147 // become foo.
NormalizeAttrName(StringRef AttrName)148 static StringRef NormalizeAttrName(StringRef AttrName) {
149 AttrName.consume_front("__");
150 AttrName.consume_back("__");
151 return AttrName;
152 }
153
154 // Normalize the name by removing any and all leading and trailing underscores.
155 // This is different from NormalizeAttrName in that it also handles names like
156 // _pascal and __pascal.
NormalizeNameForSpellingComparison(StringRef Name)157 static StringRef NormalizeNameForSpellingComparison(StringRef Name) {
158 return Name.trim("_");
159 }
160
161 // Normalize the spelling of a GNU attribute (i.e. "x" in "__attribute__((x))"),
162 // removing "__" if it appears at the beginning and end of the attribute's name.
NormalizeGNUAttrSpelling(StringRef AttrSpelling)163 static StringRef NormalizeGNUAttrSpelling(StringRef AttrSpelling) {
164 if (AttrSpelling.starts_with("__") && AttrSpelling.ends_with("__")) {
165 AttrSpelling = AttrSpelling.substr(2, AttrSpelling.size() - 4);
166 }
167
168 return AttrSpelling;
169 }
170
171 typedef std::vector<std::pair<std::string, const Record *>> ParsedAttrMap;
172
getParsedAttrList(const RecordKeeper & Records,ParsedAttrMap * Dupes=nullptr)173 static ParsedAttrMap getParsedAttrList(const RecordKeeper &Records,
174 ParsedAttrMap *Dupes = nullptr) {
175 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
176 std::set<std::string> Seen;
177 ParsedAttrMap R;
178 for (const auto *Attr : Attrs) {
179 if (Attr->getValueAsBit("SemaHandler")) {
180 std::string AN;
181 if (Attr->isSubClassOf("TargetSpecificAttr") &&
182 !Attr->isValueUnset("ParseKind")) {
183 AN = std::string(Attr->getValueAsString("ParseKind"));
184
185 // If this attribute has already been handled, it does not need to be
186 // handled again.
187 if (Seen.find(AN) != Seen.end()) {
188 if (Dupes)
189 Dupes->push_back(std::make_pair(AN, Attr));
190 continue;
191 }
192 Seen.insert(AN);
193 } else
194 AN = NormalizeAttrName(Attr->getName()).str();
195
196 R.push_back(std::make_pair(AN, Attr));
197 }
198 }
199 return R;
200 }
201
202 namespace {
203
204 class Argument {
205 std::string lowerName, upperName;
206 StringRef attrName;
207 bool isOpt;
208 bool Fake;
209
210 public:
Argument(StringRef Arg,StringRef Attr)211 Argument(StringRef Arg, StringRef Attr)
212 : lowerName(std::string(Arg)), upperName(lowerName), attrName(Attr),
213 isOpt(false), Fake(false) {
214 if (!lowerName.empty()) {
215 lowerName[0] = std::tolower(lowerName[0]);
216 upperName[0] = std::toupper(upperName[0]);
217 }
218 // Work around MinGW's macro definition of 'interface' to 'struct'. We
219 // have an attribute argument called 'Interface', so only the lower case
220 // name conflicts with the macro definition.
221 if (lowerName == "interface")
222 lowerName = "interface_";
223 }
Argument(const Record & Arg,StringRef Attr)224 Argument(const Record &Arg, StringRef Attr)
225 : Argument(Arg.getValueAsString("Name"), Attr) {}
226 virtual ~Argument() = default;
227
getLowerName() const228 StringRef getLowerName() const { return lowerName; }
getUpperName() const229 StringRef getUpperName() const { return upperName; }
getAttrName() const230 StringRef getAttrName() const { return attrName; }
231
isOptional() const232 bool isOptional() const { return isOpt; }
setOptional(bool set)233 void setOptional(bool set) { isOpt = set; }
234
isFake() const235 bool isFake() const { return Fake; }
setFake(bool fake)236 void setFake(bool fake) { Fake = fake; }
237
238 // These functions print the argument contents formatted in different ways.
239 virtual void writeAccessors(raw_ostream &OS) const = 0;
writeAccessorDefinitions(raw_ostream & OS) const240 virtual void writeAccessorDefinitions(raw_ostream &OS) const {}
writeASTVisitorTraversal(raw_ostream & OS) const241 virtual void writeASTVisitorTraversal(raw_ostream &OS) const {}
242 virtual void writeCloneArgs(raw_ostream &OS) const = 0;
243 virtual void writeTemplateInstantiationArgs(raw_ostream &OS) const = 0;
writeTemplateInstantiation(raw_ostream & OS) const244 virtual void writeTemplateInstantiation(raw_ostream &OS) const {}
writeCtorBody(raw_ostream & OS) const245 virtual void writeCtorBody(raw_ostream &OS) const {}
246 virtual void writeCtorInitializers(raw_ostream &OS) const = 0;
247 virtual void writeCtorDefaultInitializers(raw_ostream &OS) const = 0;
248 virtual void writeCtorParameters(raw_ostream &OS) const = 0;
249 virtual void writeDeclarations(raw_ostream &OS) const = 0;
250 virtual void writePCHReadArgs(raw_ostream &OS) const = 0;
251 virtual void writePCHReadDecls(raw_ostream &OS) const = 0;
252 virtual void writePCHWrite(raw_ostream &OS) const = 0;
getIsOmitted() const253 virtual std::string getIsOmitted() const { return "false"; }
254 virtual void writeValue(raw_ostream &OS) const = 0;
255 virtual void writeDump(raw_ostream &OS) const = 0;
writeDumpChildren(raw_ostream & OS) const256 virtual void writeDumpChildren(raw_ostream &OS) const {}
writeHasChildren(raw_ostream & OS) const257 virtual void writeHasChildren(raw_ostream &OS) const { OS << "false"; }
258
isEnumArg() const259 virtual bool isEnumArg() const { return false; }
isVariadicEnumArg() const260 virtual bool isVariadicEnumArg() const { return false; }
isVariadic() const261 virtual bool isVariadic() const { return false; }
262
writeImplicitCtorArgs(raw_ostream & OS) const263 virtual void writeImplicitCtorArgs(raw_ostream &OS) const {
264 OS << getUpperName();
265 }
266 };
267
268 class SimpleArgument : public Argument {
269 std::string type;
270
271 public:
SimpleArgument(const Record & Arg,StringRef Attr,std::string T)272 SimpleArgument(const Record &Arg, StringRef Attr, std::string T)
273 : Argument(Arg, Attr), type(std::move(T)) {}
274
getType() const275 std::string getType() const { return type; }
276
writeAccessors(raw_ostream & OS) const277 void writeAccessors(raw_ostream &OS) const override {
278 OS << " " << type << " get" << getUpperName() << "() const {\n";
279 OS << " return " << getLowerName() << ";\n";
280 OS << " }";
281 }
282
writeCloneArgs(raw_ostream & OS) const283 void writeCloneArgs(raw_ostream &OS) const override {
284 OS << getLowerName();
285 }
286
writeTemplateInstantiationArgs(raw_ostream & OS) const287 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
288 OS << "A->get" << getUpperName() << "()";
289 }
290
writeCtorInitializers(raw_ostream & OS) const291 void writeCtorInitializers(raw_ostream &OS) const override {
292 OS << getLowerName() << "(" << getUpperName() << ")";
293 }
294
writeCtorDefaultInitializers(raw_ostream & OS) const295 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
296 OS << getLowerName() << "()";
297 }
298
writeCtorParameters(raw_ostream & OS) const299 void writeCtorParameters(raw_ostream &OS) const override {
300 OS << type << " " << getUpperName();
301 }
302
writeDeclarations(raw_ostream & OS) const303 void writeDeclarations(raw_ostream &OS) const override {
304 OS << type << " " << getLowerName() << ";";
305 }
306
writePCHReadDecls(raw_ostream & OS) const307 void writePCHReadDecls(raw_ostream &OS) const override {
308 std::string read = ReadPCHRecord(type);
309 OS << " " << type << " " << getLowerName() << " = " << read << ";\n";
310 }
311
writePCHReadArgs(raw_ostream & OS) const312 void writePCHReadArgs(raw_ostream &OS) const override {
313 OS << getLowerName();
314 }
315
writePCHWrite(raw_ostream & OS) const316 void writePCHWrite(raw_ostream &OS) const override {
317 OS << " "
318 << WritePCHRecord(type,
319 "SA->get" + std::string(getUpperName()) + "()");
320 }
321
getIsOmitted() const322 std::string getIsOmitted() const override {
323 auto IsOneOf = [](StringRef subject, auto... list) {
324 return ((subject == list) || ...);
325 };
326
327 if (IsOneOf(type, "IdentifierInfo *", "Expr *"))
328 return "!get" + getUpperName().str() + "()";
329 if (IsOneOf(type, "TypeSourceInfo *"))
330 return "!get" + getUpperName().str() + "Loc()";
331 if (IsOneOf(type, "ParamIdx"))
332 return "!get" + getUpperName().str() + "().isValid()";
333
334 assert(IsOneOf(type, "unsigned", "int", "bool", "FunctionDecl *",
335 "VarDecl *"));
336 return "false";
337 }
338
writeValue(raw_ostream & OS) const339 void writeValue(raw_ostream &OS) const override {
340 if (type == "FunctionDecl *")
341 OS << "\" << get" << getUpperName()
342 << "()->getNameInfo().getAsString() << \"";
343 else if (type == "IdentifierInfo *")
344 // Some non-optional (comma required) identifier arguments can be the
345 // empty string but are then recorded as a nullptr.
346 OS << "\" << (get" << getUpperName() << "() ? get" << getUpperName()
347 << "()->getName() : \"\") << \"";
348 else if (type == "VarDecl *")
349 OS << "\" << get" << getUpperName() << "()->getName() << \"";
350 else if (type == "TypeSourceInfo *")
351 OS << "\" << get" << getUpperName() << "().getAsString() << \"";
352 else if (type == "ParamIdx")
353 OS << "\" << get" << getUpperName() << "().getSourceIndex() << \"";
354 else
355 OS << "\" << get" << getUpperName() << "() << \"";
356 }
357
writeDump(raw_ostream & OS) const358 void writeDump(raw_ostream &OS) const override {
359 if (StringRef(type).ends_with("Decl *")) {
360 OS << " OS << \" \";\n";
361 OS << " dumpBareDeclRef(SA->get" << getUpperName() << "());\n";
362 } else if (type == "IdentifierInfo *") {
363 // Some non-optional (comma required) identifier arguments can be the
364 // empty string but are then recorded as a nullptr.
365 OS << " if (SA->get" << getUpperName() << "())\n"
366 << " OS << \" \" << SA->get" << getUpperName()
367 << "()->getName();\n";
368 } else if (type == "TypeSourceInfo *") {
369 if (isOptional())
370 OS << " if (SA->get" << getUpperName() << "Loc())";
371 OS << " OS << \" \" << SA->get" << getUpperName()
372 << "().getAsString();\n";
373 } else if (type == "bool") {
374 OS << " if (SA->get" << getUpperName() << "()) OS << \" "
375 << getUpperName() << "\";\n";
376 } else if (type == "int" || type == "unsigned") {
377 OS << " OS << \" \" << SA->get" << getUpperName() << "();\n";
378 } else if (type == "ParamIdx") {
379 if (isOptional())
380 OS << " if (SA->get" << getUpperName() << "().isValid())\n ";
381 OS << " OS << \" \" << SA->get" << getUpperName()
382 << "().getSourceIndex();\n";
383 } else if (type == "OMPTraitInfo *") {
384 OS << " OS << \" \" << SA->get" << getUpperName() << "();\n";
385 } else {
386 llvm_unreachable("Unknown SimpleArgument type!");
387 }
388 }
389 };
390
391 class DefaultSimpleArgument : public SimpleArgument {
392 int64_t Default;
393
394 public:
DefaultSimpleArgument(const Record & Arg,StringRef Attr,std::string T,int64_t Default)395 DefaultSimpleArgument(const Record &Arg, StringRef Attr,
396 std::string T, int64_t Default)
397 : SimpleArgument(Arg, Attr, T), Default(Default) {}
398
writeAccessors(raw_ostream & OS) const399 void writeAccessors(raw_ostream &OS) const override {
400 SimpleArgument::writeAccessors(OS);
401
402 OS << "\n\n static const " << getType() << " Default" << getUpperName()
403 << " = ";
404 if (getType() == "bool")
405 OS << (Default != 0 ? "true" : "false");
406 else
407 OS << Default;
408 OS << ";";
409 }
410 };
411
412 class StringArgument : public Argument {
413 public:
StringArgument(const Record & Arg,StringRef Attr)414 StringArgument(const Record &Arg, StringRef Attr)
415 : Argument(Arg, Attr)
416 {}
417
writeAccessors(raw_ostream & OS) const418 void writeAccessors(raw_ostream &OS) const override {
419 OS << " llvm::StringRef get" << getUpperName() << "() const {\n";
420 OS << " return llvm::StringRef(" << getLowerName() << ", "
421 << getLowerName() << "Length);\n";
422 OS << " }\n";
423 OS << " unsigned get" << getUpperName() << "Length() const {\n";
424 OS << " return " << getLowerName() << "Length;\n";
425 OS << " }\n";
426 OS << " void set" << getUpperName()
427 << "(ASTContext &C, llvm::StringRef S) {\n";
428 OS << " " << getLowerName() << "Length = S.size();\n";
429 OS << " this->" << getLowerName() << " = new (C, 1) char ["
430 << getLowerName() << "Length];\n";
431 OS << " if (!S.empty())\n";
432 OS << " std::memcpy(this->" << getLowerName() << ", S.data(), "
433 << getLowerName() << "Length);\n";
434 OS << " }";
435 }
436
writeCloneArgs(raw_ostream & OS) const437 void writeCloneArgs(raw_ostream &OS) const override {
438 OS << "get" << getUpperName() << "()";
439 }
440
writeTemplateInstantiationArgs(raw_ostream & OS) const441 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
442 OS << "A->get" << getUpperName() << "()";
443 }
444
writeCtorBody(raw_ostream & OS) const445 void writeCtorBody(raw_ostream &OS) const override {
446 OS << " if (!" << getUpperName() << ".empty())\n";
447 OS << " std::memcpy(" << getLowerName() << ", " << getUpperName()
448 << ".data(), " << getLowerName() << "Length);\n";
449 }
450
writeCtorInitializers(raw_ostream & OS) const451 void writeCtorInitializers(raw_ostream &OS) const override {
452 OS << getLowerName() << "Length(" << getUpperName() << ".size()),"
453 << getLowerName() << "(new (Ctx, 1) char[" << getLowerName()
454 << "Length])";
455 }
456
writeCtorDefaultInitializers(raw_ostream & OS) const457 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
458 OS << getLowerName() << "Length(0)," << getLowerName() << "(nullptr)";
459 }
460
writeCtorParameters(raw_ostream & OS) const461 void writeCtorParameters(raw_ostream &OS) const override {
462 OS << "llvm::StringRef " << getUpperName();
463 }
464
writeDeclarations(raw_ostream & OS) const465 void writeDeclarations(raw_ostream &OS) const override {
466 OS << "unsigned " << getLowerName() << "Length;\n";
467 OS << "char *" << getLowerName() << ";";
468 }
469
writePCHReadDecls(raw_ostream & OS) const470 void writePCHReadDecls(raw_ostream &OS) const override {
471 OS << " std::string " << getLowerName()
472 << "= Record.readString();\n";
473 }
474
writePCHReadArgs(raw_ostream & OS) const475 void writePCHReadArgs(raw_ostream &OS) const override {
476 OS << getLowerName();
477 }
478
writePCHWrite(raw_ostream & OS) const479 void writePCHWrite(raw_ostream &OS) const override {
480 OS << " Record.AddString(SA->get" << getUpperName() << "());\n";
481 }
482
writeValue(raw_ostream & OS) const483 void writeValue(raw_ostream &OS) const override {
484 OS << "\\\"\" << get" << getUpperName() << "() << \"\\\"";
485 }
486
writeDump(raw_ostream & OS) const487 void writeDump(raw_ostream &OS) const override {
488 OS << " OS << \" \\\"\" << SA->get" << getUpperName()
489 << "() << \"\\\"\";\n";
490 }
491 };
492
493 class AlignedArgument : public Argument {
494 public:
AlignedArgument(const Record & Arg,StringRef Attr)495 AlignedArgument(const Record &Arg, StringRef Attr)
496 : Argument(Arg, Attr)
497 {}
498
writeAccessors(raw_ostream & OS) const499 void writeAccessors(raw_ostream &OS) const override {
500 OS << " bool is" << getUpperName() << "Dependent() const;\n";
501 OS << " bool is" << getUpperName() << "ErrorDependent() const;\n";
502
503 OS << " unsigned get" << getUpperName() << "(ASTContext &Ctx) const;\n";
504
505 OS << " bool is" << getUpperName() << "Expr() const {\n";
506 OS << " return is" << getLowerName() << "Expr;\n";
507 OS << " }\n";
508
509 OS << " Expr *get" << getUpperName() << "Expr() const {\n";
510 OS << " assert(is" << getLowerName() << "Expr);\n";
511 OS << " return " << getLowerName() << "Expr;\n";
512 OS << " }\n";
513
514 OS << " TypeSourceInfo *get" << getUpperName() << "Type() const {\n";
515 OS << " assert(!is" << getLowerName() << "Expr);\n";
516 OS << " return " << getLowerName() << "Type;\n";
517 OS << " }";
518
519 OS << " std::optional<unsigned> getCached" << getUpperName()
520 << "Value() const {\n";
521 OS << " return " << getLowerName() << "Cache;\n";
522 OS << " }";
523
524 OS << " void setCached" << getUpperName()
525 << "Value(unsigned AlignVal) {\n";
526 OS << " " << getLowerName() << "Cache = AlignVal;\n";
527 OS << " }";
528 }
529
writeAccessorDefinitions(raw_ostream & OS) const530 void writeAccessorDefinitions(raw_ostream &OS) const override {
531 OS << "bool " << getAttrName() << "Attr::is" << getUpperName()
532 << "Dependent() const {\n";
533 OS << " if (is" << getLowerName() << "Expr)\n";
534 OS << " return " << getLowerName() << "Expr && (" << getLowerName()
535 << "Expr->isValueDependent() || " << getLowerName()
536 << "Expr->isTypeDependent());\n";
537 OS << " else\n";
538 OS << " return " << getLowerName()
539 << "Type->getType()->isDependentType();\n";
540 OS << "}\n";
541
542 OS << "bool " << getAttrName() << "Attr::is" << getUpperName()
543 << "ErrorDependent() const {\n";
544 OS << " if (is" << getLowerName() << "Expr)\n";
545 OS << " return " << getLowerName() << "Expr && " << getLowerName()
546 << "Expr->containsErrors();\n";
547 OS << " return " << getLowerName()
548 << "Type->getType()->containsErrors();\n";
549 OS << "}\n";
550 }
551
writeASTVisitorTraversal(raw_ostream & OS) const552 void writeASTVisitorTraversal(raw_ostream &OS) const override {
553 StringRef Name = getUpperName();
554 OS << " if (A->is" << Name << "Expr()) {\n"
555 << " if (!getDerived().TraverseStmt(A->get" << Name << "Expr()))\n"
556 << " return false;\n"
557 << " } else if (auto *TSI = A->get" << Name << "Type()) {\n"
558 << " if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))\n"
559 << " return false;\n"
560 << " }\n";
561 }
562
writeCloneArgs(raw_ostream & OS) const563 void writeCloneArgs(raw_ostream &OS) const override {
564 OS << "is" << getLowerName() << "Expr, is" << getLowerName()
565 << "Expr ? static_cast<void*>(" << getLowerName()
566 << "Expr) : " << getLowerName()
567 << "Type";
568 }
569
writeTemplateInstantiationArgs(raw_ostream & OS) const570 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
571 // FIXME: move the definition in Sema::InstantiateAttrs to here.
572 // In the meantime, aligned attributes are cloned.
573 }
574
writeCtorBody(raw_ostream & OS) const575 void writeCtorBody(raw_ostream &OS) const override {
576 OS << " if (is" << getLowerName() << "Expr)\n";
577 OS << " " << getLowerName() << "Expr = reinterpret_cast<Expr *>("
578 << getUpperName() << ");\n";
579 OS << " else\n";
580 OS << " " << getLowerName()
581 << "Type = reinterpret_cast<TypeSourceInfo *>(" << getUpperName()
582 << ");\n";
583 }
584
writeCtorInitializers(raw_ostream & OS) const585 void writeCtorInitializers(raw_ostream &OS) const override {
586 OS << "is" << getLowerName() << "Expr(Is" << getUpperName() << "Expr)";
587 }
588
writeCtorDefaultInitializers(raw_ostream & OS) const589 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
590 OS << "is" << getLowerName() << "Expr(false)";
591 }
592
writeCtorParameters(raw_ostream & OS) const593 void writeCtorParameters(raw_ostream &OS) const override {
594 OS << "bool Is" << getUpperName() << "Expr, void *" << getUpperName();
595 }
596
writeImplicitCtorArgs(raw_ostream & OS) const597 void writeImplicitCtorArgs(raw_ostream &OS) const override {
598 OS << "Is" << getUpperName() << "Expr, " << getUpperName();
599 }
600
writeDeclarations(raw_ostream & OS) const601 void writeDeclarations(raw_ostream &OS) const override {
602 OS << "bool is" << getLowerName() << "Expr;\n";
603 OS << "union {\n";
604 OS << "Expr *" << getLowerName() << "Expr;\n";
605 OS << "TypeSourceInfo *" << getLowerName() << "Type;\n";
606 OS << "};\n";
607 OS << "std::optional<unsigned> " << getLowerName() << "Cache;\n";
608 }
609
writePCHReadArgs(raw_ostream & OS) const610 void writePCHReadArgs(raw_ostream &OS) const override {
611 OS << "is" << getLowerName() << "Expr, " << getLowerName() << "Ptr";
612 }
613
writePCHReadDecls(raw_ostream & OS) const614 void writePCHReadDecls(raw_ostream &OS) const override {
615 OS << " bool is" << getLowerName() << "Expr = Record.readInt();\n";
616 OS << " void *" << getLowerName() << "Ptr;\n";
617 OS << " if (is" << getLowerName() << "Expr)\n";
618 OS << " " << getLowerName() << "Ptr = Record.readExpr();\n";
619 OS << " else\n";
620 OS << " " << getLowerName()
621 << "Ptr = Record.readTypeSourceInfo();\n";
622 }
623
writePCHWrite(raw_ostream & OS) const624 void writePCHWrite(raw_ostream &OS) const override {
625 OS << " Record.push_back(SA->is" << getUpperName() << "Expr());\n";
626 OS << " if (SA->is" << getUpperName() << "Expr())\n";
627 OS << " Record.AddStmt(SA->get" << getUpperName() << "Expr());\n";
628 OS << " else\n";
629 OS << " Record.AddTypeSourceInfo(SA->get" << getUpperName()
630 << "Type());\n";
631 }
632
getIsOmitted() const633 std::string getIsOmitted() const override {
634 return "!((is" + getLowerName().str() + "Expr && " +
635 getLowerName().str() + "Expr) || (!is" + getLowerName().str() +
636 "Expr && " + getLowerName().str() + "Type))";
637 }
638
writeValue(raw_ostream & OS) const639 void writeValue(raw_ostream &OS) const override {
640 OS << "\";\n";
641 OS << " if (is" << getLowerName() << "Expr && " << getLowerName()
642 << "Expr)";
643 OS << " " << getLowerName()
644 << "Expr->printPretty(OS, nullptr, Policy);\n";
645 OS << " if (!is" << getLowerName() << "Expr && " << getLowerName()
646 << "Type)";
647 OS << " " << getLowerName()
648 << "Type->getType().print(OS, Policy);\n";
649 OS << " OS << \"";
650 }
651
writeDump(raw_ostream & OS) const652 void writeDump(raw_ostream &OS) const override {
653 OS << " if (!SA->is" << getUpperName() << "Expr())\n";
654 OS << " dumpType(SA->get" << getUpperName()
655 << "Type()->getType());\n";
656 }
657
writeDumpChildren(raw_ostream & OS) const658 void writeDumpChildren(raw_ostream &OS) const override {
659 OS << " if (SA->is" << getUpperName() << "Expr())\n";
660 OS << " Visit(SA->get" << getUpperName() << "Expr());\n";
661 }
662
writeHasChildren(raw_ostream & OS) const663 void writeHasChildren(raw_ostream &OS) const override {
664 OS << "SA->is" << getUpperName() << "Expr()";
665 }
666 };
667
668 class VariadicArgument : public Argument {
669 std::string Type, ArgName, ArgSizeName, RangeName;
670
671 protected:
672 // Assumed to receive a parameter: raw_ostream OS.
writeValueImpl(raw_ostream & OS) const673 virtual void writeValueImpl(raw_ostream &OS) const {
674 OS << " OS << Val;\n";
675 }
676 // Assumed to receive a parameter: raw_ostream OS.
writeDumpImpl(raw_ostream & OS) const677 virtual void writeDumpImpl(raw_ostream &OS) const {
678 OS << " OS << \" \" << Val;\n";
679 }
680
681 public:
VariadicArgument(const Record & Arg,StringRef Attr,std::string T)682 VariadicArgument(const Record &Arg, StringRef Attr, std::string T)
683 : Argument(Arg, Attr), Type(std::move(T)),
684 ArgName(getLowerName().str() + "_"), ArgSizeName(ArgName + "Size"),
685 RangeName(std::string(getLowerName())) {}
686
VariadicArgument(StringRef Arg,StringRef Attr,std::string T)687 VariadicArgument(StringRef Arg, StringRef Attr, std::string T)
688 : Argument(Arg, Attr), Type(std::move(T)),
689 ArgName(getLowerName().str() + "_"), ArgSizeName(ArgName + "Size"),
690 RangeName(std::string(getLowerName())) {}
691
getType() const692 const std::string &getType() const { return Type; }
getArgName() const693 const std::string &getArgName() const { return ArgName; }
getArgSizeName() const694 const std::string &getArgSizeName() const { return ArgSizeName; }
isVariadic() const695 bool isVariadic() const override { return true; }
696
writeAccessors(raw_ostream & OS) const697 void writeAccessors(raw_ostream &OS) const override {
698 std::string IteratorType = getLowerName().str() + "_iterator";
699 std::string BeginFn = getLowerName().str() + "_begin()";
700 std::string EndFn = getLowerName().str() + "_end()";
701
702 OS << " typedef " << Type << "* " << IteratorType << ";\n";
703 OS << " " << IteratorType << " " << BeginFn << " const {"
704 << " return " << ArgName << "; }\n";
705 OS << " " << IteratorType << " " << EndFn << " const {"
706 << " return " << ArgName << " + " << ArgSizeName << "; }\n";
707 OS << " unsigned " << getLowerName() << "_size() const {"
708 << " return " << ArgSizeName << "; }\n";
709 OS << " llvm::iterator_range<" << IteratorType << "> " << RangeName
710 << "() const { return llvm::make_range(" << BeginFn << ", " << EndFn
711 << "); }\n";
712 }
713
writeSetter(raw_ostream & OS) const714 void writeSetter(raw_ostream &OS) const {
715 OS << " void set" << getUpperName() << "(ASTContext &Ctx, ";
716 writeCtorParameters(OS);
717 OS << ") {\n";
718 OS << " " << ArgSizeName << " = " << getUpperName() << "Size;\n";
719 OS << " " << ArgName << " = new (Ctx, 16) " << getType() << "["
720 << ArgSizeName << "];\n";
721 OS << " ";
722 writeCtorBody(OS);
723 OS << " }\n";
724 }
725
writeCloneArgs(raw_ostream & OS) const726 void writeCloneArgs(raw_ostream &OS) const override {
727 OS << ArgName << ", " << ArgSizeName;
728 }
729
writeTemplateInstantiationArgs(raw_ostream & OS) const730 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
731 // This isn't elegant, but we have to go through public methods...
732 OS << "A->" << getLowerName() << "_begin(), "
733 << "A->" << getLowerName() << "_size()";
734 }
735
writeASTVisitorTraversal(raw_ostream & OS) const736 void writeASTVisitorTraversal(raw_ostream &OS) const override {
737 // FIXME: Traverse the elements.
738 }
739
writeCtorBody(raw_ostream & OS) const740 void writeCtorBody(raw_ostream &OS) const override {
741 OS << " std::copy(" << getUpperName() << ", " << getUpperName() << " + "
742 << ArgSizeName << ", " << ArgName << ");\n";
743 }
744
writeCtorInitializers(raw_ostream & OS) const745 void writeCtorInitializers(raw_ostream &OS) const override {
746 OS << ArgSizeName << "(" << getUpperName() << "Size), "
747 << ArgName << "(new (Ctx, 16) " << getType() << "["
748 << ArgSizeName << "])";
749 }
750
writeCtorDefaultInitializers(raw_ostream & OS) const751 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
752 OS << ArgSizeName << "(0), " << ArgName << "(nullptr)";
753 }
754
writeCtorParameters(raw_ostream & OS) const755 void writeCtorParameters(raw_ostream &OS) const override {
756 OS << getType() << " *" << getUpperName() << ", unsigned "
757 << getUpperName() << "Size";
758 }
759
writeImplicitCtorArgs(raw_ostream & OS) const760 void writeImplicitCtorArgs(raw_ostream &OS) const override {
761 OS << getUpperName() << ", " << getUpperName() << "Size";
762 }
763
writeDeclarations(raw_ostream & OS) const764 void writeDeclarations(raw_ostream &OS) const override {
765 OS << " unsigned " << ArgSizeName << ";\n";
766 OS << " " << getType() << " *" << ArgName << ";";
767 }
768
writePCHReadDecls(raw_ostream & OS) const769 void writePCHReadDecls(raw_ostream &OS) const override {
770 OS << " unsigned " << getLowerName() << "Size = Record.readInt();\n";
771 OS << " SmallVector<" << getType() << ", 4> "
772 << getLowerName() << ";\n";
773 OS << " " << getLowerName() << ".reserve(" << getLowerName()
774 << "Size);\n";
775
776 // If we can't store the values in the current type (if it's something
777 // like StringRef), store them in a different type and convert the
778 // container afterwards.
779 std::string StorageType = std::string(getStorageType(getType()));
780 std::string StorageName = std::string(getLowerName());
781 if (StorageType != getType()) {
782 StorageName += "Storage";
783 OS << " SmallVector<" << StorageType << ", 4> "
784 << StorageName << ";\n";
785 OS << " " << StorageName << ".reserve(" << getLowerName()
786 << "Size);\n";
787 }
788
789 OS << " for (unsigned i = 0; i != " << getLowerName() << "Size; ++i)\n";
790 std::string read = ReadPCHRecord(Type);
791 OS << " " << StorageName << ".push_back(" << read << ");\n";
792
793 if (StorageType != getType()) {
794 OS << " for (unsigned i = 0; i != " << getLowerName() << "Size; ++i)\n";
795 OS << " " << getLowerName() << ".push_back("
796 << StorageName << "[i]);\n";
797 }
798 }
799
writePCHReadArgs(raw_ostream & OS) const800 void writePCHReadArgs(raw_ostream &OS) const override {
801 OS << getLowerName() << ".data(), " << getLowerName() << "Size";
802 }
803
writePCHWrite(raw_ostream & OS) const804 void writePCHWrite(raw_ostream &OS) const override {
805 OS << " Record.push_back(SA->" << getLowerName() << "_size());\n";
806 OS << " for (auto &Val : SA->" << RangeName << "())\n";
807 OS << " " << WritePCHRecord(Type, "Val");
808 }
809
writeValue(raw_ostream & OS) const810 void writeValue(raw_ostream &OS) const override {
811 OS << "\";\n";
812 OS << " for (const auto &Val : " << RangeName << "()) {\n"
813 << " DelimitAttributeArgument(OS, IsFirstArgument);\n";
814 writeValueImpl(OS);
815 OS << " }\n";
816 OS << " OS << \"";
817 }
818
writeDump(raw_ostream & OS) const819 void writeDump(raw_ostream &OS) const override {
820 OS << " for (const auto &Val : SA->" << RangeName << "())\n";
821 writeDumpImpl(OS);
822 }
823 };
824
825 class VariadicOMPInteropInfoArgument : public VariadicArgument {
826 public:
VariadicOMPInteropInfoArgument(const Record & Arg,StringRef Attr)827 VariadicOMPInteropInfoArgument(const Record &Arg, StringRef Attr)
828 : VariadicArgument(Arg, Attr, "OMPInteropInfo") {}
829
writeDump(raw_ostream & OS) const830 void writeDump(raw_ostream &OS) const override {
831 OS << " for (" << getAttrName() << "Attr::" << getLowerName()
832 << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
833 << getLowerName() << "_end(); I != E; ++I) {\n";
834 OS << " if (I->IsTarget && I->IsTargetSync)\n";
835 OS << " OS << \" Target_TargetSync\";\n";
836 OS << " else if (I->IsTarget)\n";
837 OS << " OS << \" Target\";\n";
838 OS << " else\n";
839 OS << " OS << \" TargetSync\";\n";
840 OS << " }\n";
841 }
842
writePCHReadDecls(raw_ostream & OS) const843 void writePCHReadDecls(raw_ostream &OS) const override {
844 OS << " unsigned " << getLowerName() << "Size = Record.readInt();\n";
845 OS << " SmallVector<OMPInteropInfo, 4> " << getLowerName() << ";\n";
846 OS << " " << getLowerName() << ".reserve(" << getLowerName()
847 << "Size);\n";
848 OS << " for (unsigned I = 0, E = " << getLowerName() << "Size; ";
849 OS << "I != E; ++I) {\n";
850 OS << " bool IsTarget = Record.readBool();\n";
851 OS << " bool IsTargetSync = Record.readBool();\n";
852 OS << " " << getLowerName()
853 << ".emplace_back(IsTarget, IsTargetSync);\n";
854 OS << " }\n";
855 }
856
writePCHWrite(raw_ostream & OS) const857 void writePCHWrite(raw_ostream &OS) const override {
858 OS << " Record.push_back(SA->" << getLowerName() << "_size());\n";
859 OS << " for (" << getAttrName() << "Attr::" << getLowerName()
860 << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
861 << getLowerName() << "_end(); I != E; ++I) {\n";
862 OS << " Record.writeBool(I->IsTarget);\n";
863 OS << " Record.writeBool(I->IsTargetSync);\n";
864 OS << " }\n";
865 }
866 };
867
868 class VariadicParamIdxArgument : public VariadicArgument {
869 public:
VariadicParamIdxArgument(const Record & Arg,StringRef Attr)870 VariadicParamIdxArgument(const Record &Arg, StringRef Attr)
871 : VariadicArgument(Arg, Attr, "ParamIdx") {}
872
873 public:
writeValueImpl(raw_ostream & OS) const874 void writeValueImpl(raw_ostream &OS) const override {
875 OS << " OS << Val.getSourceIndex();\n";
876 }
877
writeDumpImpl(raw_ostream & OS) const878 void writeDumpImpl(raw_ostream &OS) const override {
879 OS << " OS << \" \" << Val.getSourceIndex();\n";
880 }
881 };
882
883 struct VariadicParamOrParamIdxArgument : public VariadicArgument {
VariadicParamOrParamIdxArgument__anond1516bc70211::VariadicParamOrParamIdxArgument884 VariadicParamOrParamIdxArgument(const Record &Arg, StringRef Attr)
885 : VariadicArgument(Arg, Attr, "int") {}
886 };
887
888 // Unique the enums, but maintain the original declaration ordering.
889 std::vector<StringRef>
uniqueEnumsInOrder(const std::vector<StringRef> & enums)890 uniqueEnumsInOrder(const std::vector<StringRef> &enums) {
891 std::vector<StringRef> uniques;
892 SmallDenseSet<StringRef, 8> unique_set;
893 for (const auto &i : enums) {
894 if (unique_set.insert(i).second)
895 uniques.push_back(i);
896 }
897 return uniques;
898 }
899
900 class EnumArgument : public Argument {
901 std::string fullType;
902 StringRef shortType;
903 std::vector<StringRef> values, enums, uniques;
904 bool isExternal;
905
906 public:
EnumArgument(const Record & Arg,StringRef Attr)907 EnumArgument(const Record &Arg, StringRef Attr)
908 : Argument(Arg, Attr), values(Arg.getValueAsListOfStrings("Values")),
909 enums(Arg.getValueAsListOfStrings("Enums")),
910 uniques(uniqueEnumsInOrder(enums)),
911 isExternal(Arg.getValueAsBit("IsExternalType")) {
912 StringRef Type = Arg.getValueAsString("Type");
913 shortType = isExternal ? Type.rsplit("::").second : Type;
914 // If shortType didn't contain :: at all rsplit will give us an empty
915 // string.
916 if (shortType.empty())
917 shortType = Type;
918 fullType = isExternal ? Type : (getAttrName() + "Attr::" + Type).str();
919
920 // FIXME: Emit a proper error
921 assert(!uniques.empty());
922 }
923
isEnumArg() const924 bool isEnumArg() const override { return true; }
925
writeAccessors(raw_ostream & OS) const926 void writeAccessors(raw_ostream &OS) const override {
927 OS << " " << fullType << " get" << getUpperName() << "() const {\n";
928 OS << " return " << getLowerName() << ";\n";
929 OS << " }";
930 }
931
writeCloneArgs(raw_ostream & OS) const932 void writeCloneArgs(raw_ostream &OS) const override {
933 OS << getLowerName();
934 }
935
writeTemplateInstantiationArgs(raw_ostream & OS) const936 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
937 OS << "A->get" << getUpperName() << "()";
938 }
writeCtorInitializers(raw_ostream & OS) const939 void writeCtorInitializers(raw_ostream &OS) const override {
940 OS << getLowerName() << "(" << getUpperName() << ")";
941 }
writeCtorDefaultInitializers(raw_ostream & OS) const942 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
943 OS << getLowerName() << "(" << fullType << "(0))";
944 }
writeCtorParameters(raw_ostream & OS) const945 void writeCtorParameters(raw_ostream &OS) const override {
946 OS << fullType << " " << getUpperName();
947 }
writeDeclarations(raw_ostream & OS) const948 void writeDeclarations(raw_ostream &OS) const override {
949 if (!isExternal) {
950 auto i = uniques.cbegin(), e = uniques.cend();
951 // The last one needs to not have a comma.
952 --e;
953
954 OS << "public:\n";
955 OS << " enum " << shortType << " {\n";
956 for (; i != e; ++i)
957 OS << " " << *i << ",\n";
958 OS << " " << *e << "\n";
959 OS << " };\n";
960 }
961
962 OS << "private:\n";
963 OS << " " << fullType << " " << getLowerName() << ";";
964 }
965
writePCHReadDecls(raw_ostream & OS) const966 void writePCHReadDecls(raw_ostream &OS) const override {
967 OS << " " << fullType << " " << getLowerName() << "(static_cast<"
968 << fullType << ">(Record.readInt()));\n";
969 }
970
writePCHReadArgs(raw_ostream & OS) const971 void writePCHReadArgs(raw_ostream &OS) const override {
972 OS << getLowerName();
973 }
974
writePCHWrite(raw_ostream & OS) const975 void writePCHWrite(raw_ostream &OS) const override {
976 OS << "Record.push_back(static_cast<uint64_t>(SA->get" << getUpperName()
977 << "()));\n";
978 }
979
writeValue(raw_ostream & OS) const980 void writeValue(raw_ostream &OS) const override {
981 // FIXME: this isn't 100% correct -- some enum arguments require printing
982 // as a string literal, while others require printing as an identifier.
983 // Tablegen currently does not distinguish between the two forms.
984 OS << "\\\"\" << " << getAttrName() << "Attr::Convert" << shortType
985 << "ToStr(get" << getUpperName() << "()) << \"\\\"";
986 }
987
writeDump(raw_ostream & OS) const988 void writeDump(raw_ostream &OS) const override {
989 OS << " switch(SA->get" << getUpperName() << "()) {\n";
990 for (const auto &I : uniques) {
991 OS << " case " << fullType << "::" << I << ":\n";
992 OS << " OS << \" " << I << "\";\n";
993 OS << " break;\n";
994 }
995 if (isExternal) {
996 OS << " default:\n";
997 OS << " llvm_unreachable(\"Invalid attribute value\");\n";
998 }
999 OS << " }\n";
1000 }
1001
writeConversion(raw_ostream & OS,bool Header) const1002 void writeConversion(raw_ostream &OS, bool Header) const {
1003 if (Header) {
1004 OS << " static bool ConvertStrTo" << shortType << "(StringRef Val, "
1005 << fullType << " &Out);\n";
1006 OS << " static const char *Convert" << shortType << "ToStr("
1007 << fullType << " Val);\n";
1008 return;
1009 }
1010
1011 OS << "bool " << getAttrName() << "Attr::ConvertStrTo" << shortType
1012 << "(StringRef Val, " << fullType << " &Out) {\n";
1013 OS << " std::optional<" << fullType << "> "
1014 << "R = llvm::StringSwitch<std::optional<" << fullType << ">>(Val)\n";
1015 for (size_t I = 0; I < enums.size(); ++I) {
1016 OS << " .Case(\"" << values[I] << "\", ";
1017 OS << fullType << "::" << enums[I] << ")\n";
1018 }
1019 OS << " .Default(std::optional<" << fullType << ">());\n";
1020 OS << " if (R) {\n";
1021 OS << " Out = *R;\n return true;\n }\n";
1022 OS << " return false;\n";
1023 OS << "}\n\n";
1024
1025 // Mapping from enumeration values back to enumeration strings isn't
1026 // trivial because some enumeration values have multiple named
1027 // enumerators, such as type_visibility(internal) and
1028 // type_visibility(hidden) both mapping to TypeVisibilityAttr::Hidden.
1029 OS << "const char *" << getAttrName() << "Attr::Convert" << shortType
1030 << "ToStr(" << fullType << " Val) {\n"
1031 << " switch(Val) {\n";
1032 SmallDenseSet<StringRef, 8> Uniques;
1033 for (size_t I = 0; I < enums.size(); ++I) {
1034 if (Uniques.insert(enums[I]).second)
1035 OS << " case " << fullType << "::" << enums[I] << ": return \""
1036 << values[I] << "\";\n";
1037 }
1038 if (isExternal) {
1039 OS << " default: llvm_unreachable(\"Invalid attribute value\");\n";
1040 }
1041 OS << " }\n"
1042 << " llvm_unreachable(\"No enumerator with that value\");\n"
1043 << "}\n";
1044 }
1045 };
1046
1047 class VariadicEnumArgument: public VariadicArgument {
1048 std::string fullType;
1049 StringRef shortType;
1050 std::vector<StringRef> values, enums, uniques;
1051 bool isExternal;
1052
1053 protected:
writeValueImpl(raw_ostream & OS) const1054 void writeValueImpl(raw_ostream &OS) const override {
1055 // FIXME: this isn't 100% correct -- some enum arguments require printing
1056 // as a string literal, while others require printing as an identifier.
1057 // Tablegen currently does not distinguish between the two forms.
1058 OS << " OS << \"\\\"\" << " << getAttrName() << "Attr::Convert"
1059 << shortType << "ToStr(Val)"
1060 << "<< \"\\\"\";\n";
1061 }
1062
1063 public:
VariadicEnumArgument(const Record & Arg,StringRef Attr)1064 VariadicEnumArgument(const Record &Arg, StringRef Attr)
1065 : VariadicArgument(Arg, Attr,
1066 std::string(Arg.getValueAsString("Type"))),
1067 values(Arg.getValueAsListOfStrings("Values")),
1068 enums(Arg.getValueAsListOfStrings("Enums")),
1069 uniques(uniqueEnumsInOrder(enums)),
1070 isExternal(Arg.getValueAsBit("IsExternalType")) {
1071 StringRef Type = Arg.getValueAsString("Type");
1072 shortType = isExternal ? Type.rsplit("::").second : Type;
1073 // If shortType didn't contain :: at all rsplit will give us an empty
1074 // string.
1075 if (shortType.empty())
1076 shortType = Type;
1077 fullType = isExternal ? Type : (getAttrName() + "Attr::" + Type).str();
1078
1079 // FIXME: Emit a proper error
1080 assert(!uniques.empty());
1081 }
1082
isVariadicEnumArg() const1083 bool isVariadicEnumArg() const override { return true; }
1084
writeDeclarations(raw_ostream & OS) const1085 void writeDeclarations(raw_ostream &OS) const override {
1086 if (!isExternal) {
1087 auto i = uniques.cbegin(), e = uniques.cend();
1088 // The last one needs to not have a comma.
1089 --e;
1090
1091 OS << "public:\n";
1092 OS << " enum " << shortType << " {\n";
1093 for (; i != e; ++i)
1094 OS << " " << *i << ",\n";
1095 OS << " " << *e << "\n";
1096 OS << " };\n";
1097 }
1098 OS << "private:\n";
1099
1100 VariadicArgument::writeDeclarations(OS);
1101 }
1102
writeDump(raw_ostream & OS) const1103 void writeDump(raw_ostream &OS) const override {
1104 OS << " for (" << getAttrName() << "Attr::" << getLowerName()
1105 << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
1106 << getLowerName() << "_end(); I != E; ++I) {\n";
1107 OS << " switch(*I) {\n";
1108 for (const auto &UI : uniques) {
1109 OS << " case " << fullType << "::" << UI << ":\n";
1110 OS << " OS << \" " << UI << "\";\n";
1111 OS << " break;\n";
1112 }
1113 OS << " }\n";
1114 OS << " }\n";
1115 }
1116
writePCHReadDecls(raw_ostream & OS) const1117 void writePCHReadDecls(raw_ostream &OS) const override {
1118 OS << " unsigned " << getLowerName() << "Size = Record.readInt();\n";
1119 OS << " SmallVector<" << fullType << ", 4> " << getLowerName()
1120 << ";\n";
1121 OS << " " << getLowerName() << ".reserve(" << getLowerName()
1122 << "Size);\n";
1123 OS << " for (unsigned i = " << getLowerName() << "Size; i; --i)\n";
1124 OS << " " << getLowerName() << ".push_back("
1125 << "static_cast<" << fullType << ">(Record.readInt()));\n";
1126 }
1127
writePCHWrite(raw_ostream & OS) const1128 void writePCHWrite(raw_ostream &OS) const override {
1129 OS << " Record.push_back(SA->" << getLowerName() << "_size());\n";
1130 OS << " for (" << getAttrName() << "Attr::" << getLowerName()
1131 << "_iterator i = SA->" << getLowerName() << "_begin(), e = SA->"
1132 << getLowerName() << "_end(); i != e; ++i)\n";
1133 OS << " " << WritePCHRecord(fullType, "(*i)");
1134 }
1135
writeConversion(raw_ostream & OS,bool Header) const1136 void writeConversion(raw_ostream &OS, bool Header) const {
1137 if (Header) {
1138 OS << " static bool ConvertStrTo" << shortType << "(StringRef Val, "
1139 << fullType << " &Out);\n";
1140 OS << " static const char *Convert" << shortType << "ToStr("
1141 << fullType << " Val);\n";
1142 return;
1143 }
1144
1145 OS << "bool " << getAttrName() << "Attr::ConvertStrTo" << shortType
1146 << "(StringRef Val, ";
1147 OS << fullType << " &Out) {\n";
1148 OS << " std::optional<" << fullType
1149 << "> R = llvm::StringSwitch<std::optional<";
1150 OS << fullType << ">>(Val)\n";
1151 for (size_t I = 0; I < enums.size(); ++I) {
1152 OS << " .Case(\"" << values[I] << "\", ";
1153 OS << fullType << "::" << enums[I] << ")\n";
1154 }
1155 OS << " .Default(std::optional<" << fullType << ">());\n";
1156 OS << " if (R) {\n";
1157 OS << " Out = *R;\n return true;\n }\n";
1158 OS << " return false;\n";
1159 OS << "}\n\n";
1160
1161 OS << "const char *" << getAttrName() << "Attr::Convert" << shortType
1162 << "ToStr(" << fullType << " Val) {\n"
1163 << " switch(Val) {\n";
1164 SmallDenseSet<StringRef, 8> Uniques;
1165 for (size_t I = 0; I < enums.size(); ++I) {
1166 if (Uniques.insert(enums[I]).second)
1167 OS << " case " << fullType << "::" << enums[I] << ": return \""
1168 << values[I] << "\";\n";
1169 }
1170 OS << " }\n"
1171 << " llvm_unreachable(\"No enumerator with that value\");\n"
1172 << "}\n";
1173 }
1174 };
1175
1176 class VersionArgument : public Argument {
1177 public:
VersionArgument(const Record & Arg,StringRef Attr)1178 VersionArgument(const Record &Arg, StringRef Attr)
1179 : Argument(Arg, Attr)
1180 {}
1181
writeAccessors(raw_ostream & OS) const1182 void writeAccessors(raw_ostream &OS) const override {
1183 OS << " VersionTuple get" << getUpperName() << "() const {\n";
1184 OS << " return " << getLowerName() << ";\n";
1185 OS << " }\n";
1186 OS << " void set" << getUpperName()
1187 << "(ASTContext &C, VersionTuple V) {\n";
1188 OS << " " << getLowerName() << " = V;\n";
1189 OS << " }";
1190 }
1191
writeCloneArgs(raw_ostream & OS) const1192 void writeCloneArgs(raw_ostream &OS) const override {
1193 OS << "get" << getUpperName() << "()";
1194 }
1195
writeTemplateInstantiationArgs(raw_ostream & OS) const1196 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
1197 OS << "A->get" << getUpperName() << "()";
1198 }
1199
writeCtorInitializers(raw_ostream & OS) const1200 void writeCtorInitializers(raw_ostream &OS) const override {
1201 OS << getLowerName() << "(" << getUpperName() << ")";
1202 }
1203
writeCtorDefaultInitializers(raw_ostream & OS) const1204 void writeCtorDefaultInitializers(raw_ostream &OS) const override {
1205 OS << getLowerName() << "()";
1206 }
1207
writeCtorParameters(raw_ostream & OS) const1208 void writeCtorParameters(raw_ostream &OS) const override {
1209 OS << "VersionTuple " << getUpperName();
1210 }
1211
writeDeclarations(raw_ostream & OS) const1212 void writeDeclarations(raw_ostream &OS) const override {
1213 OS << "VersionTuple " << getLowerName() << ";\n";
1214 }
1215
writePCHReadDecls(raw_ostream & OS) const1216 void writePCHReadDecls(raw_ostream &OS) const override {
1217 OS << " VersionTuple " << getLowerName()
1218 << "= Record.readVersionTuple();\n";
1219 }
1220
writePCHReadArgs(raw_ostream & OS) const1221 void writePCHReadArgs(raw_ostream &OS) const override {
1222 OS << getLowerName();
1223 }
1224
writePCHWrite(raw_ostream & OS) const1225 void writePCHWrite(raw_ostream &OS) const override {
1226 OS << " Record.AddVersionTuple(SA->get" << getUpperName() << "());\n";
1227 }
1228
writeValue(raw_ostream & OS) const1229 void writeValue(raw_ostream &OS) const override {
1230 OS << getLowerName() << "=\" << get" << getUpperName() << "() << \"";
1231 }
1232
writeDump(raw_ostream & OS) const1233 void writeDump(raw_ostream &OS) const override {
1234 OS << " OS << \" \" << SA->get" << getUpperName() << "();\n";
1235 }
1236 };
1237
1238 class ExprArgument : public SimpleArgument {
1239 public:
ExprArgument(const Record & Arg,StringRef Attr)1240 ExprArgument(const Record &Arg, StringRef Attr)
1241 : SimpleArgument(Arg, Attr, "Expr *")
1242 {}
1243
writeASTVisitorTraversal(raw_ostream & OS) const1244 void writeASTVisitorTraversal(raw_ostream &OS) const override {
1245 OS << " if (!"
1246 << "getDerived().TraverseStmt(A->get" << getUpperName() << "()))\n";
1247 OS << " return false;\n";
1248 }
1249
writeTemplateInstantiationArgs(raw_ostream & OS) const1250 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
1251 OS << "tempInst" << getUpperName();
1252 }
1253
writeTemplateInstantiation(raw_ostream & OS) const1254 void writeTemplateInstantiation(raw_ostream &OS) const override {
1255 OS << " " << getType() << " tempInst" << getUpperName() << ";\n";
1256 OS << " {\n";
1257 OS << " EnterExpressionEvaluationContext "
1258 << "Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);\n";
1259 OS << " ExprResult " << "Result = S.SubstExpr("
1260 << "A->get" << getUpperName() << "(), TemplateArgs);\n";
1261 OS << " if (Result.isInvalid())\n";
1262 OS << " return nullptr;\n";
1263 OS << " tempInst" << getUpperName() << " = Result.get();\n";
1264 OS << " }\n";
1265 }
1266
writeValue(raw_ostream & OS) const1267 void writeValue(raw_ostream &OS) const override {
1268 OS << "\";\n";
1269 OS << " get" << getUpperName()
1270 << "()->printPretty(OS, nullptr, Policy);\n";
1271 OS << " OS << \"";
1272 }
1273
writeDump(raw_ostream & OS) const1274 void writeDump(raw_ostream &OS) const override {}
1275
writeDumpChildren(raw_ostream & OS) const1276 void writeDumpChildren(raw_ostream &OS) const override {
1277 OS << " Visit(SA->get" << getUpperName() << "());\n";
1278 }
1279
writeHasChildren(raw_ostream & OS) const1280 void writeHasChildren(raw_ostream &OS) const override { OS << "true"; }
1281 };
1282
1283 class VariadicExprArgument : public VariadicArgument {
1284 public:
VariadicExprArgument(const Record & Arg,StringRef Attr)1285 VariadicExprArgument(const Record &Arg, StringRef Attr)
1286 : VariadicArgument(Arg, Attr, "Expr *")
1287 {}
1288
VariadicExprArgument(StringRef ArgName,StringRef Attr)1289 VariadicExprArgument(StringRef ArgName, StringRef Attr)
1290 : VariadicArgument(ArgName, Attr, "Expr *") {}
1291
writeASTVisitorTraversal(raw_ostream & OS) const1292 void writeASTVisitorTraversal(raw_ostream &OS) const override {
1293 OS << " {\n";
1294 OS << " " << getType() << " *I = A->" << getLowerName()
1295 << "_begin();\n";
1296 OS << " " << getType() << " *E = A->" << getLowerName()
1297 << "_end();\n";
1298 OS << " for (; I != E; ++I) {\n";
1299 OS << " if (!getDerived().TraverseStmt(*I))\n";
1300 OS << " return false;\n";
1301 OS << " }\n";
1302 OS << " }\n";
1303 }
1304
writeTemplateInstantiationArgs(raw_ostream & OS) const1305 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
1306 OS << "tempInst" << getUpperName() << ", "
1307 << "A->" << getLowerName() << "_size()";
1308 }
1309
writeTemplateInstantiation(raw_ostream & OS) const1310 void writeTemplateInstantiation(raw_ostream &OS) const override {
1311 OS << " auto *tempInst" << getUpperName()
1312 << " = new (C, 16) " << getType()
1313 << "[A->" << getLowerName() << "_size()];\n";
1314 OS << " {\n";
1315 OS << " EnterExpressionEvaluationContext "
1316 << "Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);\n";
1317 OS << " " << getType() << " *TI = tempInst" << getUpperName()
1318 << ";\n";
1319 OS << " " << getType() << " *I = A->" << getLowerName()
1320 << "_begin();\n";
1321 OS << " " << getType() << " *E = A->" << getLowerName()
1322 << "_end();\n";
1323 OS << " for (; I != E; ++I, ++TI) {\n";
1324 OS << " ExprResult Result = S.SubstExpr(*I, TemplateArgs);\n";
1325 OS << " if (Result.isInvalid())\n";
1326 OS << " return nullptr;\n";
1327 OS << " *TI = Result.get();\n";
1328 OS << " }\n";
1329 OS << " }\n";
1330 }
1331
writeDump(raw_ostream & OS) const1332 void writeDump(raw_ostream &OS) const override {}
1333
writeDumpChildren(raw_ostream & OS) const1334 void writeDumpChildren(raw_ostream &OS) const override {
1335 OS << " for (" << getAttrName() << "Attr::" << getLowerName()
1336 << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
1337 << getLowerName() << "_end(); I != E; ++I)\n";
1338 OS << " Visit(*I);\n";
1339 }
1340
writeHasChildren(raw_ostream & OS) const1341 void writeHasChildren(raw_ostream &OS) const override {
1342 OS << "SA->" << getLowerName() << "_begin() != "
1343 << "SA->" << getLowerName() << "_end()";
1344 }
1345 };
1346
1347 class VariadicIdentifierArgument : public VariadicArgument {
1348 public:
VariadicIdentifierArgument(const Record & Arg,StringRef Attr)1349 VariadicIdentifierArgument(const Record &Arg, StringRef Attr)
1350 : VariadicArgument(Arg, Attr, "IdentifierInfo *")
1351 {}
1352 };
1353
1354 class VariadicStringArgument : public VariadicArgument {
1355 public:
VariadicStringArgument(const Record & Arg,StringRef Attr)1356 VariadicStringArgument(const Record &Arg, StringRef Attr)
1357 : VariadicArgument(Arg, Attr, "StringRef")
1358 {}
1359
writeCtorBody(raw_ostream & OS) const1360 void writeCtorBody(raw_ostream &OS) const override {
1361 OS << " for (size_t I = 0, E = " << getArgSizeName() << "; I != E;\n"
1362 " ++I) {\n"
1363 " StringRef Ref = " << getUpperName() << "[I];\n"
1364 " if (!Ref.empty()) {\n"
1365 " char *Mem = new (Ctx, 1) char[Ref.size()];\n"
1366 " std::memcpy(Mem, Ref.data(), Ref.size());\n"
1367 " " << getArgName() << "[I] = StringRef(Mem, Ref.size());\n"
1368 " }\n"
1369 " }\n";
1370 }
1371
writeValueImpl(raw_ostream & OS) const1372 void writeValueImpl(raw_ostream &OS) const override {
1373 OS << " OS << \"\\\"\" << Val << \"\\\"\";\n";
1374 }
1375 };
1376
1377 class TypeArgument : public SimpleArgument {
1378 public:
TypeArgument(const Record & Arg,StringRef Attr)1379 TypeArgument(const Record &Arg, StringRef Attr)
1380 : SimpleArgument(Arg, Attr, "TypeSourceInfo *")
1381 {}
1382
writeAccessors(raw_ostream & OS) const1383 void writeAccessors(raw_ostream &OS) const override {
1384 OS << " QualType get" << getUpperName() << "() const {\n";
1385 OS << " return " << getLowerName() << "->getType();\n";
1386 OS << " }";
1387 OS << " " << getType() << " get" << getUpperName() << "Loc() const {\n";
1388 OS << " return " << getLowerName() << ";\n";
1389 OS << " }";
1390 }
1391
writeASTVisitorTraversal(raw_ostream & OS) const1392 void writeASTVisitorTraversal(raw_ostream &OS) const override {
1393 OS << " if (auto *TSI = A->get" << getUpperName() << "Loc())\n";
1394 OS << " if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))\n";
1395 OS << " return false;\n";
1396 }
1397
writeTemplateInstantiation(raw_ostream & OS) const1398 void writeTemplateInstantiation(raw_ostream &OS) const override {
1399 OS << " " << getType() << " tempInst" << getUpperName() << " =\n";
1400 OS << " S.SubstType(A->get" << getUpperName() << "Loc(), "
1401 << "TemplateArgs, A->getLoc(), A->getAttrName());\n";
1402 OS << " if (!tempInst" << getUpperName() << ")\n";
1403 OS << " return nullptr;\n";
1404 }
1405
writeTemplateInstantiationArgs(raw_ostream & OS) const1406 void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
1407 OS << "tempInst" << getUpperName();
1408 }
1409
writePCHWrite(raw_ostream & OS) const1410 void writePCHWrite(raw_ostream &OS) const override {
1411 OS << " "
1412 << WritePCHRecord(getType(),
1413 "SA->get" + std::string(getUpperName()) + "Loc()");
1414 }
1415 };
1416
1417 class WrappedAttr : public SimpleArgument {
1418 public:
WrappedAttr(const Record & Arg,StringRef Attr)1419 WrappedAttr(const Record &Arg, StringRef Attr)
1420 : SimpleArgument(Arg, Attr, "Attr *") {}
1421
writePCHReadDecls(raw_ostream & OS) const1422 void writePCHReadDecls(raw_ostream &OS) const override {
1423 OS << " Attr *" << getLowerName() << " = Record.readAttr();";
1424 }
1425
writePCHWrite(raw_ostream & OS) const1426 void writePCHWrite(raw_ostream &OS) const override {
1427 OS << " AddAttr(SA->get" << getUpperName() << "());";
1428 }
1429
writeDump(raw_ostream & OS) const1430 void writeDump(raw_ostream &OS) const override {}
1431
writeDumpChildren(raw_ostream & OS) const1432 void writeDumpChildren(raw_ostream &OS) const override {
1433 OS << " Visit(SA->get" << getUpperName() << "());\n";
1434 }
1435
writeHasChildren(raw_ostream & OS) const1436 void writeHasChildren(raw_ostream &OS) const override { OS << "true"; }
1437 };
1438
1439 } // end anonymous namespace
1440
1441 static std::unique_ptr<Argument>
createArgument(const Record & Arg,StringRef Attr,const Record * Search=nullptr)1442 createArgument(const Record &Arg, StringRef Attr,
1443 const Record *Search = nullptr) {
1444 if (!Search)
1445 Search = &Arg;
1446
1447 std::unique_ptr<Argument> Ptr;
1448 llvm::StringRef ArgName = Search->getName();
1449
1450 if (ArgName == "AlignedArgument")
1451 Ptr = std::make_unique<AlignedArgument>(Arg, Attr);
1452 else if (ArgName == "EnumArgument")
1453 Ptr = std::make_unique<EnumArgument>(Arg, Attr);
1454 else if (ArgName == "ExprArgument")
1455 Ptr = std::make_unique<ExprArgument>(Arg, Attr);
1456 else if (ArgName == "DeclArgument")
1457 Ptr = std::make_unique<SimpleArgument>(
1458 Arg, Attr, (Arg.getValueAsDef("Kind")->getName() + "Decl *").str());
1459 else if (ArgName == "IdentifierArgument")
1460 Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "IdentifierInfo *");
1461 else if (ArgName == "DefaultBoolArgument")
1462 Ptr = std::make_unique<DefaultSimpleArgument>(
1463 Arg, Attr, "bool", Arg.getValueAsBit("Default"));
1464 else if (ArgName == "BoolArgument")
1465 Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "bool");
1466 else if (ArgName == "DefaultIntArgument")
1467 Ptr = std::make_unique<DefaultSimpleArgument>(
1468 Arg, Attr, "int", Arg.getValueAsInt("Default"));
1469 else if (ArgName == "IntArgument")
1470 Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "int");
1471 else if (ArgName == "StringArgument")
1472 Ptr = std::make_unique<StringArgument>(Arg, Attr);
1473 else if (ArgName == "TypeArgument")
1474 Ptr = std::make_unique<TypeArgument>(Arg, Attr);
1475 else if (ArgName == "UnsignedArgument")
1476 Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "unsigned");
1477 else if (ArgName == "VariadicUnsignedArgument")
1478 Ptr = std::make_unique<VariadicArgument>(Arg, Attr, "unsigned");
1479 else if (ArgName == "VariadicStringArgument")
1480 Ptr = std::make_unique<VariadicStringArgument>(Arg, Attr);
1481 else if (ArgName == "VariadicEnumArgument")
1482 Ptr = std::make_unique<VariadicEnumArgument>(Arg, Attr);
1483 else if (ArgName == "VariadicExprArgument")
1484 Ptr = std::make_unique<VariadicExprArgument>(Arg, Attr);
1485 else if (ArgName == "VariadicParamIdxArgument")
1486 Ptr = std::make_unique<VariadicParamIdxArgument>(Arg, Attr);
1487 else if (ArgName == "VariadicParamOrParamIdxArgument")
1488 Ptr = std::make_unique<VariadicParamOrParamIdxArgument>(Arg, Attr);
1489 else if (ArgName == "ParamIdxArgument")
1490 Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "ParamIdx");
1491 else if (ArgName == "VariadicIdentifierArgument")
1492 Ptr = std::make_unique<VariadicIdentifierArgument>(Arg, Attr);
1493 else if (ArgName == "VersionArgument")
1494 Ptr = std::make_unique<VersionArgument>(Arg, Attr);
1495 else if (ArgName == "WrappedAttr")
1496 Ptr = std::make_unique<WrappedAttr>(Arg, Attr);
1497 else if (ArgName == "OMPTraitInfoArgument")
1498 Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "OMPTraitInfo *");
1499 else if (ArgName == "VariadicOMPInteropInfoArgument")
1500 Ptr = std::make_unique<VariadicOMPInteropInfoArgument>(Arg, Attr);
1501
1502 if (!Ptr) {
1503 // Search in reverse order so that the most-derived type is handled first.
1504 ArrayRef<std::pair<Record*, SMRange>> Bases = Search->getSuperClasses();
1505 for (const auto &Base : llvm::reverse(Bases)) {
1506 if ((Ptr = createArgument(Arg, Attr, Base.first)))
1507 break;
1508 }
1509 }
1510
1511 if (Ptr && Arg.getValueAsBit("Optional"))
1512 Ptr->setOptional(true);
1513
1514 if (Ptr && Arg.getValueAsBit("Fake"))
1515 Ptr->setFake(true);
1516
1517 return Ptr;
1518 }
1519
writeAvailabilityValue(raw_ostream & OS)1520 static void writeAvailabilityValue(raw_ostream &OS) {
1521 OS << "\" << getPlatform()->getName();\n"
1522 << " if (getStrict()) OS << \", strict\";\n"
1523 << " if (!getIntroduced().empty()) OS << \", introduced=\" << getIntroduced();\n"
1524 << " if (!getDeprecated().empty()) OS << \", deprecated=\" << getDeprecated();\n"
1525 << " if (!getObsoleted().empty()) OS << \", obsoleted=\" << getObsoleted();\n"
1526 << " if (getUnavailable()) OS << \", unavailable\";\n"
1527 << " OS << \"";
1528 }
1529
writeDeprecatedAttrValue(raw_ostream & OS,std::string & Variety)1530 static void writeDeprecatedAttrValue(raw_ostream &OS, std::string &Variety) {
1531 OS << "\\\"\" << getMessage() << \"\\\"\";\n";
1532 // Only GNU deprecated has an optional fixit argument at the second position.
1533 if (Variety == "GNU")
1534 OS << " if (!getReplacement().empty()) OS << \", \\\"\""
1535 " << getReplacement() << \"\\\"\";\n";
1536 OS << " OS << \"";
1537 }
1538
writeGetSpellingFunction(const Record & R,raw_ostream & OS)1539 static void writeGetSpellingFunction(const Record &R, raw_ostream &OS) {
1540 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
1541
1542 OS << "const char *" << R.getName() << "Attr::getSpelling() const {\n";
1543 if (Spellings.empty()) {
1544 OS << " return \"(No spelling)\";\n}\n\n";
1545 return;
1546 }
1547
1548 OS << " switch (getAttributeSpellingListIndex()) {\n"
1549 " default:\n"
1550 " llvm_unreachable(\"Unknown attribute spelling!\");\n"
1551 " return \"(No spelling)\";\n";
1552
1553 for (unsigned I = 0; I < Spellings.size(); ++I)
1554 OS << " case " << I << ":\n"
1555 " return \"" << Spellings[I].name() << "\";\n";
1556 // End of the switch statement.
1557 OS << " }\n";
1558 // End of the getSpelling function.
1559 OS << "}\n\n";
1560 }
1561
1562 static void
writePrettyPrintFunction(const Record & R,const std::vector<std::unique_ptr<Argument>> & Args,raw_ostream & OS)1563 writePrettyPrintFunction(const Record &R,
1564 const std::vector<std::unique_ptr<Argument>> &Args,
1565 raw_ostream &OS) {
1566 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
1567
1568 OS << "void " << R.getName() << "Attr::printPretty("
1569 << "raw_ostream &OS, const PrintingPolicy &Policy) const {\n";
1570
1571 if (Spellings.empty()) {
1572 OS << "}\n\n";
1573 return;
1574 }
1575
1576 OS << " bool IsFirstArgument = true; (void)IsFirstArgument;\n"
1577 << " unsigned TrailingOmittedArgs = 0; (void)TrailingOmittedArgs;\n"
1578 << " switch (getAttributeSpellingListIndex()) {\n"
1579 << " default:\n"
1580 << " llvm_unreachable(\"Unknown attribute spelling!\");\n"
1581 << " break;\n";
1582
1583 for (unsigned I = 0; I < Spellings.size(); ++ I) {
1584 llvm::SmallString<16> Prefix;
1585 llvm::SmallString<8> Suffix;
1586 // The actual spelling of the name and namespace (if applicable)
1587 // of an attribute without considering prefix and suffix.
1588 llvm::SmallString<64> Spelling;
1589 std::string Name = Spellings[I].name();
1590 std::string Variety = Spellings[I].variety();
1591
1592 if (Variety == "GNU") {
1593 Prefix = " __attribute__((";
1594 Suffix = "))";
1595 } else if (Variety == "CXX11" || Variety == "C23") {
1596 Prefix = " [[";
1597 Suffix = "]]";
1598 std::string Namespace = Spellings[I].nameSpace();
1599 if (!Namespace.empty()) {
1600 Spelling += Namespace;
1601 Spelling += "::";
1602 }
1603 } else if (Variety == "Declspec") {
1604 Prefix = " __declspec(";
1605 Suffix = ")";
1606 } else if (Variety == "Microsoft") {
1607 Prefix = "[";
1608 Suffix = "]";
1609 } else if (Variety == "Keyword") {
1610 Prefix = " ";
1611 Suffix = "";
1612 } else if (Variety == "Pragma") {
1613 Prefix = "#pragma ";
1614 Suffix = "\n";
1615 std::string Namespace = Spellings[I].nameSpace();
1616 if (!Namespace.empty()) {
1617 Spelling += Namespace;
1618 Spelling += " ";
1619 }
1620 } else if (Variety == "HLSLSemantic") {
1621 Prefix = ":";
1622 Suffix = "";
1623 } else {
1624 llvm_unreachable("Unknown attribute syntax variety!");
1625 }
1626
1627 Spelling += Name;
1628
1629 OS << " case " << I << " : {\n"
1630 << " OS << \"" << Prefix << Spelling << "\";\n";
1631
1632 if (Variety == "Pragma") {
1633 OS << " printPrettyPragma(OS, Policy);\n";
1634 OS << " OS << \"\\n\";";
1635 OS << " break;\n";
1636 OS << " }\n";
1637 continue;
1638 }
1639
1640 if (Spelling == "availability") {
1641 OS << " OS << \"(";
1642 writeAvailabilityValue(OS);
1643 OS << ")\";\n";
1644 } else if (Spelling == "deprecated" || Spelling == "gnu::deprecated") {
1645 OS << " OS << \"(";
1646 writeDeprecatedAttrValue(OS, Variety);
1647 OS << ")\";\n";
1648 } else {
1649 // To avoid printing parentheses around an empty argument list or
1650 // printing spurious commas at the end of an argument list, we need to
1651 // determine where the last provided non-fake argument is.
1652 bool FoundNonOptArg = false;
1653 for (const auto &arg : llvm::reverse(Args)) {
1654 if (arg->isFake())
1655 continue;
1656 if (FoundNonOptArg)
1657 continue;
1658 // FIXME: arg->getIsOmitted() == "false" means we haven't implemented
1659 // any way to detect whether the argument was omitted.
1660 if (!arg->isOptional() || arg->getIsOmitted() == "false") {
1661 FoundNonOptArg = true;
1662 continue;
1663 }
1664 OS << " if (" << arg->getIsOmitted() << ")\n"
1665 << " ++TrailingOmittedArgs;\n";
1666 }
1667 unsigned ArgIndex = 0;
1668 for (const auto &arg : Args) {
1669 if (arg->isFake())
1670 continue;
1671 std::string IsOmitted = arg->getIsOmitted();
1672 if (arg->isOptional() && IsOmitted != "false")
1673 OS << " if (!(" << IsOmitted << ")) {\n";
1674 // Variadic arguments print their own leading comma.
1675 if (!arg->isVariadic())
1676 OS << " DelimitAttributeArgument(OS, IsFirstArgument);\n";
1677 OS << " OS << \"";
1678 arg->writeValue(OS);
1679 OS << "\";\n";
1680 if (arg->isOptional() && IsOmitted != "false")
1681 OS << " }\n";
1682 ++ArgIndex;
1683 }
1684 if (ArgIndex != 0)
1685 OS << " if (!IsFirstArgument)\n"
1686 << " OS << \")\";\n";
1687 }
1688 OS << " OS << \"" << Suffix << "\";\n"
1689 << " break;\n"
1690 << " }\n";
1691 }
1692
1693 // End of the switch statement.
1694 OS << "}\n";
1695 // End of the print function.
1696 OS << "}\n\n";
1697 }
1698
1699 /// Return the index of a spelling in a spelling list.
1700 static unsigned
getSpellingListIndex(const std::vector<FlattenedSpelling> & SpellingList,const FlattenedSpelling & Spelling)1701 getSpellingListIndex(const std::vector<FlattenedSpelling> &SpellingList,
1702 const FlattenedSpelling &Spelling) {
1703 assert(!SpellingList.empty() && "Spelling list is empty!");
1704
1705 for (unsigned Index = 0; Index < SpellingList.size(); ++Index) {
1706 const FlattenedSpelling &S = SpellingList[Index];
1707 if (S.variety() != Spelling.variety())
1708 continue;
1709 if (S.nameSpace() != Spelling.nameSpace())
1710 continue;
1711 if (S.name() != Spelling.name())
1712 continue;
1713
1714 return Index;
1715 }
1716
1717 llvm_unreachable("Unknown spelling!");
1718 }
1719
writeAttrAccessorDefinition(const Record & R,raw_ostream & OS)1720 static void writeAttrAccessorDefinition(const Record &R, raw_ostream &OS) {
1721 std::vector<Record*> Accessors = R.getValueAsListOfDefs("Accessors");
1722 if (Accessors.empty())
1723 return;
1724
1725 const std::vector<FlattenedSpelling> SpellingList = GetFlattenedSpellings(R);
1726 assert(!SpellingList.empty() &&
1727 "Attribute with empty spelling list can't have accessors!");
1728 for (const auto *Accessor : Accessors) {
1729 const StringRef Name = Accessor->getValueAsString("Name");
1730 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Accessor);
1731
1732 OS << " bool " << Name
1733 << "() const { return getAttributeSpellingListIndex() == ";
1734 for (unsigned Index = 0; Index < Spellings.size(); ++Index) {
1735 OS << getSpellingListIndex(SpellingList, Spellings[Index]);
1736 if (Index != Spellings.size() - 1)
1737 OS << " ||\n getAttributeSpellingListIndex() == ";
1738 else
1739 OS << "; }\n";
1740 }
1741 }
1742 }
1743
1744 static bool
SpellingNamesAreCommon(const std::vector<FlattenedSpelling> & Spellings)1745 SpellingNamesAreCommon(const std::vector<FlattenedSpelling>& Spellings) {
1746 assert(!Spellings.empty() && "An empty list of spellings was provided");
1747 std::string FirstName =
1748 std::string(NormalizeNameForSpellingComparison(Spellings.front().name()));
1749 for (const auto &Spelling : llvm::drop_begin(Spellings)) {
1750 std::string Name =
1751 std::string(NormalizeNameForSpellingComparison(Spelling.name()));
1752 if (Name != FirstName)
1753 return false;
1754 }
1755 return true;
1756 }
1757
1758 typedef std::map<unsigned, std::string> SemanticSpellingMap;
1759 static std::string
CreateSemanticSpellings(const std::vector<FlattenedSpelling> & Spellings,SemanticSpellingMap & Map)1760 CreateSemanticSpellings(const std::vector<FlattenedSpelling> &Spellings,
1761 SemanticSpellingMap &Map) {
1762 // The enumerants are automatically generated based on the variety,
1763 // namespace (if present) and name for each attribute spelling. However,
1764 // care is taken to avoid trampling on the reserved namespace due to
1765 // underscores.
1766 std::string Ret(" enum Spelling {\n");
1767 std::set<std::string> Uniques;
1768 unsigned Idx = 0;
1769
1770 // If we have a need to have this many spellings we likely need to add an
1771 // extra bit to the SpellingIndex in AttributeCommonInfo, then increase the
1772 // value of SpellingNotCalculated there and here.
1773 assert(Spellings.size() < 15 &&
1774 "Too many spellings, would step on SpellingNotCalculated in "
1775 "AttributeCommonInfo");
1776 for (auto I = Spellings.begin(), E = Spellings.end(); I != E; ++I, ++Idx) {
1777 const FlattenedSpelling &S = *I;
1778 const std::string &Variety = S.variety();
1779 const std::string &Spelling = S.name();
1780 const std::string &Namespace = S.nameSpace();
1781 std::string EnumName;
1782
1783 EnumName += (Variety + "_");
1784 if (!Namespace.empty())
1785 EnumName += (NormalizeNameForSpellingComparison(Namespace).str() +
1786 "_");
1787 EnumName += NormalizeNameForSpellingComparison(Spelling);
1788
1789 // Even if the name is not unique, this spelling index corresponds to a
1790 // particular enumerant name that we've calculated.
1791 Map[Idx] = EnumName;
1792
1793 // Since we have been stripping underscores to avoid trampling on the
1794 // reserved namespace, we may have inadvertently created duplicate
1795 // enumerant names. These duplicates are not considered part of the
1796 // semantic spelling, and can be elided.
1797 if (Uniques.find(EnumName) != Uniques.end())
1798 continue;
1799
1800 Uniques.insert(EnumName);
1801 if (I != Spellings.begin())
1802 Ret += ",\n";
1803 // Duplicate spellings are not considered part of the semantic spelling
1804 // enumeration, but the spelling index and semantic spelling values are
1805 // meant to be equivalent, so we must specify a concrete value for each
1806 // enumerator.
1807 Ret += " " + EnumName + " = " + llvm::utostr(Idx);
1808 }
1809 Ret += ",\n SpellingNotCalculated = 15\n";
1810 Ret += "\n };\n\n";
1811 return Ret;
1812 }
1813
WriteSemanticSpellingSwitch(const std::string & VarName,const SemanticSpellingMap & Map,raw_ostream & OS)1814 void WriteSemanticSpellingSwitch(const std::string &VarName,
1815 const SemanticSpellingMap &Map,
1816 raw_ostream &OS) {
1817 OS << " switch (" << VarName << ") {\n default: "
1818 << "llvm_unreachable(\"Unknown spelling list index\");\n";
1819 for (const auto &I : Map)
1820 OS << " case " << I.first << ": return " << I.second << ";\n";
1821 OS << " }\n";
1822 }
1823
1824 // Emits the LateParsed property for attributes.
emitClangAttrLateParsedList(RecordKeeper & Records,raw_ostream & OS)1825 static void emitClangAttrLateParsedList(RecordKeeper &Records, raw_ostream &OS) {
1826 OS << "#if defined(CLANG_ATTR_LATE_PARSED_LIST)\n";
1827 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1828
1829 for (const auto *Attr : Attrs) {
1830 bool LateParsed = Attr->getValueAsBit("LateParsed");
1831
1832 if (LateParsed) {
1833 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
1834
1835 // FIXME: Handle non-GNU attributes
1836 for (const auto &I : Spellings) {
1837 if (I.variety() != "GNU")
1838 continue;
1839 OS << ".Case(\"" << I.name() << "\", " << LateParsed << ")\n";
1840 }
1841 }
1842 }
1843 OS << "#endif // CLANG_ATTR_LATE_PARSED_LIST\n\n";
1844 }
1845
hasGNUorCXX11Spelling(const Record & Attribute)1846 static bool hasGNUorCXX11Spelling(const Record &Attribute) {
1847 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attribute);
1848 for (const auto &I : Spellings) {
1849 if (I.variety() == "GNU" || I.variety() == "CXX11")
1850 return true;
1851 }
1852 return false;
1853 }
1854
1855 namespace {
1856
1857 struct AttributeSubjectMatchRule {
1858 const Record *MetaSubject;
1859 const Record *Constraint;
1860
AttributeSubjectMatchRule__anond1516bc70411::AttributeSubjectMatchRule1861 AttributeSubjectMatchRule(const Record *MetaSubject, const Record *Constraint)
1862 : MetaSubject(MetaSubject), Constraint(Constraint) {
1863 assert(MetaSubject && "Missing subject");
1864 }
1865
isSubRule__anond1516bc70411::AttributeSubjectMatchRule1866 bool isSubRule() const { return Constraint != nullptr; }
1867
getSubjects__anond1516bc70411::AttributeSubjectMatchRule1868 std::vector<Record *> getSubjects() const {
1869 return (Constraint ? Constraint : MetaSubject)
1870 ->getValueAsListOfDefs("Subjects");
1871 }
1872
getLangOpts__anond1516bc70411::AttributeSubjectMatchRule1873 std::vector<Record *> getLangOpts() const {
1874 if (Constraint) {
1875 // Lookup the options in the sub-rule first, in case the sub-rule
1876 // overrides the rules options.
1877 std::vector<Record *> Opts = Constraint->getValueAsListOfDefs("LangOpts");
1878 if (!Opts.empty())
1879 return Opts;
1880 }
1881 return MetaSubject->getValueAsListOfDefs("LangOpts");
1882 }
1883
1884 // Abstract rules are used only for sub-rules
isAbstractRule__anond1516bc70411::AttributeSubjectMatchRule1885 bool isAbstractRule() const { return getSubjects().empty(); }
1886
getName__anond1516bc70411::AttributeSubjectMatchRule1887 StringRef getName() const {
1888 return (Constraint ? Constraint : MetaSubject)->getValueAsString("Name");
1889 }
1890
isNegatedSubRule__anond1516bc70411::AttributeSubjectMatchRule1891 bool isNegatedSubRule() const {
1892 assert(isSubRule() && "Not a sub-rule");
1893 return Constraint->getValueAsBit("Negated");
1894 }
1895
getSpelling__anond1516bc70411::AttributeSubjectMatchRule1896 std::string getSpelling() const {
1897 std::string Result = std::string(MetaSubject->getValueAsString("Name"));
1898 if (isSubRule()) {
1899 Result += '(';
1900 if (isNegatedSubRule())
1901 Result += "unless(";
1902 Result += getName();
1903 if (isNegatedSubRule())
1904 Result += ')';
1905 Result += ')';
1906 }
1907 return Result;
1908 }
1909
getEnumValueName__anond1516bc70411::AttributeSubjectMatchRule1910 std::string getEnumValueName() const {
1911 SmallString<128> Result;
1912 Result += "SubjectMatchRule_";
1913 Result += MetaSubject->getValueAsString("Name");
1914 if (isSubRule()) {
1915 Result += "_";
1916 if (isNegatedSubRule())
1917 Result += "not_";
1918 Result += Constraint->getValueAsString("Name");
1919 }
1920 if (isAbstractRule())
1921 Result += "_abstract";
1922 return std::string(Result);
1923 }
1924
getEnumValue__anond1516bc70411::AttributeSubjectMatchRule1925 std::string getEnumValue() const { return "attr::" + getEnumValueName(); }
1926
1927 static const char *EnumName;
1928 };
1929
1930 const char *AttributeSubjectMatchRule::EnumName = "attr::SubjectMatchRule";
1931
1932 struct PragmaClangAttributeSupport {
1933 std::vector<AttributeSubjectMatchRule> Rules;
1934
1935 class RuleOrAggregateRuleSet {
1936 std::vector<AttributeSubjectMatchRule> Rules;
1937 bool IsRule;
RuleOrAggregateRuleSet(ArrayRef<AttributeSubjectMatchRule> Rules,bool IsRule)1938 RuleOrAggregateRuleSet(ArrayRef<AttributeSubjectMatchRule> Rules,
1939 bool IsRule)
1940 : Rules(Rules), IsRule(IsRule) {}
1941
1942 public:
isRule() const1943 bool isRule() const { return IsRule; }
1944
getRule() const1945 const AttributeSubjectMatchRule &getRule() const {
1946 assert(IsRule && "not a rule!");
1947 return Rules[0];
1948 }
1949
getAggregateRuleSet() const1950 ArrayRef<AttributeSubjectMatchRule> getAggregateRuleSet() const {
1951 return Rules;
1952 }
1953
1954 static RuleOrAggregateRuleSet
getRule(const AttributeSubjectMatchRule & Rule)1955 getRule(const AttributeSubjectMatchRule &Rule) {
1956 return RuleOrAggregateRuleSet(Rule, /*IsRule=*/true);
1957 }
1958 static RuleOrAggregateRuleSet
getAggregateRuleSet(ArrayRef<AttributeSubjectMatchRule> Rules)1959 getAggregateRuleSet(ArrayRef<AttributeSubjectMatchRule> Rules) {
1960 return RuleOrAggregateRuleSet(Rules, /*IsRule=*/false);
1961 }
1962 };
1963 llvm::DenseMap<const Record *, RuleOrAggregateRuleSet> SubjectsToRules;
1964
1965 PragmaClangAttributeSupport(RecordKeeper &Records);
1966
1967 bool isAttributedSupported(const Record &Attribute);
1968
1969 void emitMatchRuleList(raw_ostream &OS);
1970
1971 void generateStrictConformsTo(const Record &Attr, raw_ostream &OS);
1972
1973 void generateParsingHelpers(raw_ostream &OS);
1974 };
1975
1976 } // end anonymous namespace
1977
isSupportedPragmaClangAttributeSubject(const Record & Subject)1978 static bool isSupportedPragmaClangAttributeSubject(const Record &Subject) {
1979 // FIXME: #pragma clang attribute does not currently support statement
1980 // attributes, so test whether the subject is one that appertains to a
1981 // declaration node. However, it may be reasonable for support for statement
1982 // attributes to be added.
1983 if (Subject.isSubClassOf("DeclNode") || Subject.isSubClassOf("DeclBase") ||
1984 Subject.getName() == "DeclBase")
1985 return true;
1986
1987 if (Subject.isSubClassOf("SubsetSubject"))
1988 return isSupportedPragmaClangAttributeSubject(
1989 *Subject.getValueAsDef("Base"));
1990
1991 return false;
1992 }
1993
doesDeclDeriveFrom(const Record * D,const Record * Base)1994 static bool doesDeclDeriveFrom(const Record *D, const Record *Base) {
1995 const Record *CurrentBase = D->getValueAsOptionalDef(BaseFieldName);
1996 if (!CurrentBase)
1997 return false;
1998 if (CurrentBase == Base)
1999 return true;
2000 return doesDeclDeriveFrom(CurrentBase, Base);
2001 }
2002
PragmaClangAttributeSupport(RecordKeeper & Records)2003 PragmaClangAttributeSupport::PragmaClangAttributeSupport(
2004 RecordKeeper &Records) {
2005 std::vector<Record *> MetaSubjects =
2006 Records.getAllDerivedDefinitions("AttrSubjectMatcherRule");
2007 auto MapFromSubjectsToRules = [this](const Record *SubjectContainer,
2008 const Record *MetaSubject,
2009 const Record *Constraint) {
2010 Rules.emplace_back(MetaSubject, Constraint);
2011 std::vector<Record *> ApplicableSubjects =
2012 SubjectContainer->getValueAsListOfDefs("Subjects");
2013 for (const auto *Subject : ApplicableSubjects) {
2014 bool Inserted =
2015 SubjectsToRules
2016 .try_emplace(Subject, RuleOrAggregateRuleSet::getRule(
2017 AttributeSubjectMatchRule(MetaSubject,
2018 Constraint)))
2019 .second;
2020 if (!Inserted) {
2021 PrintFatalError("Attribute subject match rules should not represent"
2022 "same attribute subjects.");
2023 }
2024 }
2025 };
2026 for (const auto *MetaSubject : MetaSubjects) {
2027 MapFromSubjectsToRules(MetaSubject, MetaSubject, /*Constraints=*/nullptr);
2028 std::vector<Record *> Constraints =
2029 MetaSubject->getValueAsListOfDefs("Constraints");
2030 for (const auto *Constraint : Constraints)
2031 MapFromSubjectsToRules(Constraint, MetaSubject, Constraint);
2032 }
2033
2034 std::vector<Record *> Aggregates =
2035 Records.getAllDerivedDefinitions("AttrSubjectMatcherAggregateRule");
2036 std::vector<Record *> DeclNodes =
2037 Records.getAllDerivedDefinitions(DeclNodeClassName);
2038 for (const auto *Aggregate : Aggregates) {
2039 Record *SubjectDecl = Aggregate->getValueAsDef("Subject");
2040
2041 // Gather sub-classes of the aggregate subject that act as attribute
2042 // subject rules.
2043 std::vector<AttributeSubjectMatchRule> Rules;
2044 for (const auto *D : DeclNodes) {
2045 if (doesDeclDeriveFrom(D, SubjectDecl)) {
2046 auto It = SubjectsToRules.find(D);
2047 if (It == SubjectsToRules.end())
2048 continue;
2049 if (!It->second.isRule() || It->second.getRule().isSubRule())
2050 continue; // Assume that the rule will be included as well.
2051 Rules.push_back(It->second.getRule());
2052 }
2053 }
2054
2055 bool Inserted =
2056 SubjectsToRules
2057 .try_emplace(SubjectDecl,
2058 RuleOrAggregateRuleSet::getAggregateRuleSet(Rules))
2059 .second;
2060 if (!Inserted) {
2061 PrintFatalError("Attribute subject match rules should not represent"
2062 "same attribute subjects.");
2063 }
2064 }
2065 }
2066
2067 static PragmaClangAttributeSupport &
getPragmaAttributeSupport(RecordKeeper & Records)2068 getPragmaAttributeSupport(RecordKeeper &Records) {
2069 static PragmaClangAttributeSupport Instance(Records);
2070 return Instance;
2071 }
2072
emitMatchRuleList(raw_ostream & OS)2073 void PragmaClangAttributeSupport::emitMatchRuleList(raw_ostream &OS) {
2074 OS << "#ifndef ATTR_MATCH_SUB_RULE\n";
2075 OS << "#define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, "
2076 "IsNegated) "
2077 << "ATTR_MATCH_RULE(Value, Spelling, IsAbstract)\n";
2078 OS << "#endif\n";
2079 for (const auto &Rule : Rules) {
2080 OS << (Rule.isSubRule() ? "ATTR_MATCH_SUB_RULE" : "ATTR_MATCH_RULE") << '(';
2081 OS << Rule.getEnumValueName() << ", \"" << Rule.getSpelling() << "\", "
2082 << Rule.isAbstractRule();
2083 if (Rule.isSubRule())
2084 OS << ", "
2085 << AttributeSubjectMatchRule(Rule.MetaSubject, nullptr).getEnumValue()
2086 << ", " << Rule.isNegatedSubRule();
2087 OS << ")\n";
2088 }
2089 OS << "#undef ATTR_MATCH_SUB_RULE\n";
2090 }
2091
isAttributedSupported(const Record & Attribute)2092 bool PragmaClangAttributeSupport::isAttributedSupported(
2093 const Record &Attribute) {
2094 // If the attribute explicitly specified whether to support #pragma clang
2095 // attribute, use that setting.
2096 bool Unset;
2097 bool SpecifiedResult =
2098 Attribute.getValueAsBitOrUnset("PragmaAttributeSupport", Unset);
2099 if (!Unset)
2100 return SpecifiedResult;
2101
2102 // Opt-out rules:
2103 // An attribute requires delayed parsing (LateParsed is on)
2104 if (Attribute.getValueAsBit("LateParsed"))
2105 return false;
2106 // An attribute has no GNU/CXX11 spelling
2107 if (!hasGNUorCXX11Spelling(Attribute))
2108 return false;
2109 // An attribute subject list has a subject that isn't covered by one of the
2110 // subject match rules or has no subjects at all.
2111 if (Attribute.isValueUnset("Subjects"))
2112 return false;
2113 const Record *SubjectObj = Attribute.getValueAsDef("Subjects");
2114 std::vector<Record *> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
2115 bool HasAtLeastOneValidSubject = false;
2116 for (const auto *Subject : Subjects) {
2117 if (!isSupportedPragmaClangAttributeSubject(*Subject))
2118 continue;
2119 if (!SubjectsToRules.contains(Subject))
2120 return false;
2121 HasAtLeastOneValidSubject = true;
2122 }
2123 return HasAtLeastOneValidSubject;
2124 }
2125
GenerateTestExpression(ArrayRef<Record * > LangOpts)2126 static std::string GenerateTestExpression(ArrayRef<Record *> LangOpts) {
2127 std::string Test;
2128
2129 for (auto *E : LangOpts) {
2130 if (!Test.empty())
2131 Test += " || ";
2132
2133 const StringRef Code = E->getValueAsString("CustomCode");
2134 if (!Code.empty()) {
2135 Test += "(";
2136 Test += Code;
2137 Test += ")";
2138 if (!E->getValueAsString("Name").empty()) {
2139 PrintWarning(
2140 E->getLoc(),
2141 "non-empty 'Name' field ignored because 'CustomCode' was supplied");
2142 }
2143 } else {
2144 Test += "LangOpts.";
2145 Test += E->getValueAsString("Name");
2146 }
2147 }
2148
2149 if (Test.empty())
2150 return "true";
2151
2152 return Test;
2153 }
2154
2155 void
generateStrictConformsTo(const Record & Attr,raw_ostream & OS)2156 PragmaClangAttributeSupport::generateStrictConformsTo(const Record &Attr,
2157 raw_ostream &OS) {
2158 if (!isAttributedSupported(Attr) || Attr.isValueUnset("Subjects"))
2159 return;
2160 // Generate a function that constructs a set of matching rules that describe
2161 // to which declarations the attribute should apply to.
2162 OS << "void getPragmaAttributeMatchRules("
2163 << "llvm::SmallVectorImpl<std::pair<"
2164 << AttributeSubjectMatchRule::EnumName
2165 << ", bool>> &MatchRules, const LangOptions &LangOpts) const override {\n";
2166 const Record *SubjectObj = Attr.getValueAsDef("Subjects");
2167 std::vector<Record *> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
2168 for (const auto *Subject : Subjects) {
2169 if (!isSupportedPragmaClangAttributeSubject(*Subject))
2170 continue;
2171 auto It = SubjectsToRules.find(Subject);
2172 assert(It != SubjectsToRules.end() &&
2173 "This attribute is unsupported by #pragma clang attribute");
2174 for (const auto &Rule : It->getSecond().getAggregateRuleSet()) {
2175 // The rule might be language specific, so only subtract it from the given
2176 // rules if the specific language options are specified.
2177 std::vector<Record *> LangOpts = Rule.getLangOpts();
2178 OS << " MatchRules.push_back(std::make_pair(" << Rule.getEnumValue()
2179 << ", /*IsSupported=*/" << GenerateTestExpression(LangOpts)
2180 << "));\n";
2181 }
2182 }
2183 OS << "}\n\n";
2184 }
2185
generateParsingHelpers(raw_ostream & OS)2186 void PragmaClangAttributeSupport::generateParsingHelpers(raw_ostream &OS) {
2187 // Generate routines that check the names of sub-rules.
2188 OS << "std::optional<attr::SubjectMatchRule> "
2189 "defaultIsAttributeSubjectMatchSubRuleFor(StringRef, bool) {\n";
2190 OS << " return std::nullopt;\n";
2191 OS << "}\n\n";
2192
2193 llvm::MapVector<const Record *, std::vector<AttributeSubjectMatchRule>>
2194 SubMatchRules;
2195 for (const auto &Rule : Rules) {
2196 if (!Rule.isSubRule())
2197 continue;
2198 SubMatchRules[Rule.MetaSubject].push_back(Rule);
2199 }
2200
2201 for (const auto &SubMatchRule : SubMatchRules) {
2202 OS << "std::optional<attr::SubjectMatchRule> "
2203 "isAttributeSubjectMatchSubRuleFor_"
2204 << SubMatchRule.first->getValueAsString("Name")
2205 << "(StringRef Name, bool IsUnless) {\n";
2206 OS << " if (IsUnless)\n";
2207 OS << " return "
2208 "llvm::StringSwitch<std::optional<attr::SubjectMatchRule>>(Name).\n";
2209 for (const auto &Rule : SubMatchRule.second) {
2210 if (Rule.isNegatedSubRule())
2211 OS << " Case(\"" << Rule.getName() << "\", " << Rule.getEnumValue()
2212 << ").\n";
2213 }
2214 OS << " Default(std::nullopt);\n";
2215 OS << " return "
2216 "llvm::StringSwitch<std::optional<attr::SubjectMatchRule>>(Name).\n";
2217 for (const auto &Rule : SubMatchRule.second) {
2218 if (!Rule.isNegatedSubRule())
2219 OS << " Case(\"" << Rule.getName() << "\", " << Rule.getEnumValue()
2220 << ").\n";
2221 }
2222 OS << " Default(std::nullopt);\n";
2223 OS << "}\n\n";
2224 }
2225
2226 // Generate the function that checks for the top-level rules.
2227 OS << "std::pair<std::optional<attr::SubjectMatchRule>, "
2228 "std::optional<attr::SubjectMatchRule> (*)(StringRef, "
2229 "bool)> isAttributeSubjectMatchRule(StringRef Name) {\n";
2230 OS << " return "
2231 "llvm::StringSwitch<std::pair<std::optional<attr::SubjectMatchRule>, "
2232 "std::optional<attr::SubjectMatchRule> (*) (StringRef, "
2233 "bool)>>(Name).\n";
2234 for (const auto &Rule : Rules) {
2235 if (Rule.isSubRule())
2236 continue;
2237 std::string SubRuleFunction;
2238 if (SubMatchRules.count(Rule.MetaSubject))
2239 SubRuleFunction =
2240 ("isAttributeSubjectMatchSubRuleFor_" + Rule.getName()).str();
2241 else
2242 SubRuleFunction = "defaultIsAttributeSubjectMatchSubRuleFor";
2243 OS << " Case(\"" << Rule.getName() << "\", std::make_pair("
2244 << Rule.getEnumValue() << ", " << SubRuleFunction << ")).\n";
2245 }
2246 OS << " Default(std::make_pair(std::nullopt, "
2247 "defaultIsAttributeSubjectMatchSubRuleFor));\n";
2248 OS << "}\n\n";
2249
2250 // Generate the function that checks for the submatch rules.
2251 OS << "const char *validAttributeSubjectMatchSubRules("
2252 << AttributeSubjectMatchRule::EnumName << " Rule) {\n";
2253 OS << " switch (Rule) {\n";
2254 for (const auto &SubMatchRule : SubMatchRules) {
2255 OS << " case "
2256 << AttributeSubjectMatchRule(SubMatchRule.first, nullptr).getEnumValue()
2257 << ":\n";
2258 OS << " return \"'";
2259 bool IsFirst = true;
2260 for (const auto &Rule : SubMatchRule.second) {
2261 if (!IsFirst)
2262 OS << ", '";
2263 IsFirst = false;
2264 if (Rule.isNegatedSubRule())
2265 OS << "unless(";
2266 OS << Rule.getName();
2267 if (Rule.isNegatedSubRule())
2268 OS << ')';
2269 OS << "'";
2270 }
2271 OS << "\";\n";
2272 }
2273 OS << " default: return nullptr;\n";
2274 OS << " }\n";
2275 OS << "}\n\n";
2276 }
2277
2278 template <typename Fn>
forEachUniqueSpelling(const Record & Attr,Fn && F)2279 static void forEachUniqueSpelling(const Record &Attr, Fn &&F) {
2280 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
2281 SmallDenseSet<StringRef, 8> Seen;
2282 for (const FlattenedSpelling &S : Spellings) {
2283 if (Seen.insert(S.name()).second)
2284 F(S);
2285 }
2286 }
2287
isTypeArgument(const Record * Arg)2288 static bool isTypeArgument(const Record *Arg) {
2289 return !Arg->getSuperClasses().empty() &&
2290 Arg->getSuperClasses().back().first->getName() == "TypeArgument";
2291 }
2292
2293 /// Emits the first-argument-is-type property for attributes.
emitClangAttrTypeArgList(RecordKeeper & Records,raw_ostream & OS)2294 static void emitClangAttrTypeArgList(RecordKeeper &Records, raw_ostream &OS) {
2295 OS << "#if defined(CLANG_ATTR_TYPE_ARG_LIST)\n";
2296 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2297
2298 for (const auto *Attr : Attrs) {
2299 // Determine whether the first argument is a type.
2300 std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args");
2301 if (Args.empty())
2302 continue;
2303
2304 if (!isTypeArgument(Args[0]))
2305 continue;
2306
2307 // All these spellings take a single type argument.
2308 forEachUniqueSpelling(*Attr, [&](const FlattenedSpelling &S) {
2309 OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
2310 });
2311 }
2312 OS << "#endif // CLANG_ATTR_TYPE_ARG_LIST\n\n";
2313 }
2314
2315 /// Emits the parse-arguments-in-unevaluated-context property for
2316 /// attributes.
emitClangAttrArgContextList(RecordKeeper & Records,raw_ostream & OS)2317 static void emitClangAttrArgContextList(RecordKeeper &Records, raw_ostream &OS) {
2318 OS << "#if defined(CLANG_ATTR_ARG_CONTEXT_LIST)\n";
2319 ParsedAttrMap Attrs = getParsedAttrList(Records);
2320 for (const auto &I : Attrs) {
2321 const Record &Attr = *I.second;
2322
2323 if (!Attr.getValueAsBit("ParseArgumentsAsUnevaluated"))
2324 continue;
2325
2326 // All these spellings take are parsed unevaluated.
2327 forEachUniqueSpelling(Attr, [&](const FlattenedSpelling &S) {
2328 OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
2329 });
2330 }
2331 OS << "#endif // CLANG_ATTR_ARG_CONTEXT_LIST\n\n";
2332 }
2333
isIdentifierArgument(const Record * Arg)2334 static bool isIdentifierArgument(const Record *Arg) {
2335 return !Arg->getSuperClasses().empty() &&
2336 llvm::StringSwitch<bool>(Arg->getSuperClasses().back().first->getName())
2337 .Case("IdentifierArgument", true)
2338 .Case("EnumArgument", true)
2339 .Case("VariadicEnumArgument", true)
2340 .Default(false);
2341 }
2342
isVariadicIdentifierArgument(const Record * Arg)2343 static bool isVariadicIdentifierArgument(const Record *Arg) {
2344 return !Arg->getSuperClasses().empty() &&
2345 llvm::StringSwitch<bool>(
2346 Arg->getSuperClasses().back().first->getName())
2347 .Case("VariadicIdentifierArgument", true)
2348 .Case("VariadicParamOrParamIdxArgument", true)
2349 .Default(false);
2350 }
2351
isVariadicExprArgument(const Record * Arg)2352 static bool isVariadicExprArgument(const Record *Arg) {
2353 return !Arg->getSuperClasses().empty() &&
2354 llvm::StringSwitch<bool>(
2355 Arg->getSuperClasses().back().first->getName())
2356 .Case("VariadicExprArgument", true)
2357 .Default(false);
2358 }
2359
isStringLiteralArgument(const Record * Arg)2360 static bool isStringLiteralArgument(const Record *Arg) {
2361 return !Arg->getSuperClasses().empty() &&
2362 llvm::StringSwitch<bool>(
2363 Arg->getSuperClasses().back().first->getName())
2364 .Case("StringArgument", true)
2365 .Default(false);
2366 }
2367
isVariadicStringLiteralArgument(const Record * Arg)2368 static bool isVariadicStringLiteralArgument(const Record *Arg) {
2369 return !Arg->getSuperClasses().empty() &&
2370 llvm::StringSwitch<bool>(
2371 Arg->getSuperClasses().back().first->getName())
2372 .Case("VariadicStringArgument", true)
2373 .Default(false);
2374 }
2375
emitClangAttrVariadicIdentifierArgList(RecordKeeper & Records,raw_ostream & OS)2376 static void emitClangAttrVariadicIdentifierArgList(RecordKeeper &Records,
2377 raw_ostream &OS) {
2378 OS << "#if defined(CLANG_ATTR_VARIADIC_IDENTIFIER_ARG_LIST)\n";
2379 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2380 for (const auto *A : Attrs) {
2381 // Determine whether the first argument is a variadic identifier.
2382 std::vector<Record *> Args = A->getValueAsListOfDefs("Args");
2383 if (Args.empty() || !isVariadicIdentifierArgument(Args[0]))
2384 continue;
2385
2386 // All these spellings take an identifier argument.
2387 forEachUniqueSpelling(*A, [&](const FlattenedSpelling &S) {
2388 OS << ".Case(\"" << S.name() << "\", "
2389 << "true"
2390 << ")\n";
2391 });
2392 }
2393 OS << "#endif // CLANG_ATTR_VARIADIC_IDENTIFIER_ARG_LIST\n\n";
2394 }
2395
2396 // Emits the list of arguments that should be parsed as unevaluated string
2397 // literals for each attribute.
emitClangAttrUnevaluatedStringLiteralList(RecordKeeper & Records,raw_ostream & OS)2398 static void emitClangAttrUnevaluatedStringLiteralList(RecordKeeper &Records,
2399 raw_ostream &OS) {
2400 OS << "#if defined(CLANG_ATTR_STRING_LITERAL_ARG_LIST)\n";
2401 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2402 for (const auto *Attr : Attrs) {
2403 std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args");
2404 uint32_t Bits = 0;
2405 assert(Args.size() <= 32 && "unsupported number of arguments in attribute");
2406 for (uint32_t N = 0; N < Args.size(); ++N) {
2407 Bits |= (isStringLiteralArgument(Args[N]) << N);
2408 // If we have a variadic string argument, set all the remaining bits to 1
2409 if (isVariadicStringLiteralArgument(Args[N])) {
2410 Bits |= maskTrailingZeros<decltype(Bits)>(N);
2411 break;
2412 }
2413 }
2414 if (!Bits)
2415 continue;
2416 // All these spellings have at least one string literal has argument.
2417 forEachUniqueSpelling(*Attr, [&](const FlattenedSpelling &S) {
2418 OS << ".Case(\"" << S.name() << "\", " << Bits << ")\n";
2419 });
2420 }
2421 OS << "#endif // CLANG_ATTR_STRING_LITERAL_ARG_LIST\n\n";
2422 }
2423
2424 // Emits the first-argument-is-identifier property for attributes.
emitClangAttrIdentifierArgList(RecordKeeper & Records,raw_ostream & OS)2425 static void emitClangAttrIdentifierArgList(RecordKeeper &Records, raw_ostream &OS) {
2426 OS << "#if defined(CLANG_ATTR_IDENTIFIER_ARG_LIST)\n";
2427 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
2428
2429 for (const auto *Attr : Attrs) {
2430 // Determine whether the first argument is an identifier.
2431 std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args");
2432 if (Args.empty() || !isIdentifierArgument(Args[0]))
2433 continue;
2434
2435 // All these spellings take an identifier argument.
2436 forEachUniqueSpelling(*Attr, [&](const FlattenedSpelling &S) {
2437 OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
2438 });
2439 }
2440 OS << "#endif // CLANG_ATTR_IDENTIFIER_ARG_LIST\n\n";
2441 }
2442
keywordThisIsaIdentifierInArgument(const Record * Arg)2443 static bool keywordThisIsaIdentifierInArgument(const Record *Arg) {
2444 return !Arg->getSuperClasses().empty() &&
2445 llvm::StringSwitch<bool>(
2446 Arg->getSuperClasses().back().first->getName())
2447 .Case("VariadicParamOrParamIdxArgument", true)
2448 .Default(false);
2449 }
2450
emitClangAttrThisIsaIdentifierArgList(RecordKeeper & Records,raw_ostream & OS)2451 static void emitClangAttrThisIsaIdentifierArgList(RecordKeeper &Records,
2452 raw_ostream &OS) {
2453 OS << "#if defined(CLANG_ATTR_THIS_ISA_IDENTIFIER_ARG_LIST)\n";
2454 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
2455 for (const auto *A : Attrs) {
2456 // Determine whether the first argument is a variadic identifier.
2457 std::vector<Record *> Args = A->getValueAsListOfDefs("Args");
2458 if (Args.empty() || !keywordThisIsaIdentifierInArgument(Args[0]))
2459 continue;
2460
2461 // All these spellings take an identifier argument.
2462 forEachUniqueSpelling(*A, [&](const FlattenedSpelling &S) {
2463 OS << ".Case(\"" << S.name() << "\", "
2464 << "true"
2465 << ")\n";
2466 });
2467 }
2468 OS << "#endif // CLANG_ATTR_THIS_ISA_IDENTIFIER_ARG_LIST\n\n";
2469 }
2470
emitClangAttrAcceptsExprPack(RecordKeeper & Records,raw_ostream & OS)2471 static void emitClangAttrAcceptsExprPack(RecordKeeper &Records,
2472 raw_ostream &OS) {
2473 OS << "#if defined(CLANG_ATTR_ACCEPTS_EXPR_PACK)\n";
2474 ParsedAttrMap Attrs = getParsedAttrList(Records);
2475 for (const auto &I : Attrs) {
2476 const Record &Attr = *I.second;
2477
2478 if (!Attr.getValueAsBit("AcceptsExprPack"))
2479 continue;
2480
2481 forEachUniqueSpelling(Attr, [&](const FlattenedSpelling &S) {
2482 OS << ".Case(\"" << S.name() << "\", true)\n";
2483 });
2484 }
2485 OS << "#endif // CLANG_ATTR_ACCEPTS_EXPR_PACK\n\n";
2486 }
2487
isRegularKeywordAttribute(const FlattenedSpelling & S)2488 static bool isRegularKeywordAttribute(const FlattenedSpelling &S) {
2489 return (S.variety() == "Keyword" &&
2490 !S.getSpellingRecord().getValueAsBit("HasOwnParseRules"));
2491 }
2492
emitFormInitializer(raw_ostream & OS,const FlattenedSpelling & Spelling,StringRef SpellingIndex)2493 static void emitFormInitializer(raw_ostream &OS,
2494 const FlattenedSpelling &Spelling,
2495 StringRef SpellingIndex) {
2496 bool IsAlignas =
2497 (Spelling.variety() == "Keyword" && Spelling.name() == "alignas");
2498 OS << "{AttributeCommonInfo::AS_" << Spelling.variety() << ", "
2499 << SpellingIndex << ", " << (IsAlignas ? "true" : "false")
2500 << " /*IsAlignas*/, "
2501 << (isRegularKeywordAttribute(Spelling) ? "true" : "false")
2502 << " /*IsRegularKeywordAttribute*/}";
2503 }
2504
emitAttributes(RecordKeeper & Records,raw_ostream & OS,bool Header)2505 static void emitAttributes(RecordKeeper &Records, raw_ostream &OS,
2506 bool Header) {
2507 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
2508 ParsedAttrMap AttrMap = getParsedAttrList(Records);
2509
2510 // Helper to print the starting character of an attribute argument. If there
2511 // hasn't been an argument yet, it prints an opening parenthese; otherwise it
2512 // prints a comma.
2513 OS << "static inline void DelimitAttributeArgument("
2514 << "raw_ostream& OS, bool& IsFirst) {\n"
2515 << " if (IsFirst) {\n"
2516 << " IsFirst = false;\n"
2517 << " OS << \"(\";\n"
2518 << " } else\n"
2519 << " OS << \", \";\n"
2520 << "}\n";
2521
2522 for (const auto *Attr : Attrs) {
2523 const Record &R = *Attr;
2524
2525 // FIXME: Currently, documentation is generated as-needed due to the fact
2526 // that there is no way to allow a generated project "reach into" the docs
2527 // directory (for instance, it may be an out-of-tree build). However, we want
2528 // to ensure that every attribute has a Documentation field, and produce an
2529 // error if it has been neglected. Otherwise, the on-demand generation which
2530 // happens server-side will fail. This code is ensuring that functionality,
2531 // even though this Emitter doesn't technically need the documentation.
2532 // When attribute documentation can be generated as part of the build
2533 // itself, this code can be removed.
2534 (void)R.getValueAsListOfDefs("Documentation");
2535
2536 if (!R.getValueAsBit("ASTNode"))
2537 continue;
2538
2539 ArrayRef<std::pair<Record *, SMRange>> Supers = R.getSuperClasses();
2540 assert(!Supers.empty() && "Forgot to specify a superclass for the attr");
2541 std::string SuperName;
2542 bool Inheritable = false;
2543 for (const auto &Super : llvm::reverse(Supers)) {
2544 const Record *R = Super.first;
2545 if (R->getName() != "TargetSpecificAttr" &&
2546 R->getName() != "DeclOrTypeAttr" && SuperName.empty())
2547 SuperName = std::string(R->getName());
2548 if (R->getName() == "InheritableAttr")
2549 Inheritable = true;
2550 }
2551
2552 if (Header)
2553 OS << "class " << R.getName() << "Attr : public " << SuperName << " {\n";
2554 else
2555 OS << "\n// " << R.getName() << "Attr implementation\n\n";
2556
2557 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
2558 std::vector<std::unique_ptr<Argument>> Args;
2559 Args.reserve(ArgRecords.size());
2560
2561 bool AttrAcceptsExprPack = Attr->getValueAsBit("AcceptsExprPack");
2562 if (AttrAcceptsExprPack) {
2563 for (size_t I = 0; I < ArgRecords.size(); ++I) {
2564 const Record *ArgR = ArgRecords[I];
2565 if (isIdentifierArgument(ArgR) || isVariadicIdentifierArgument(ArgR) ||
2566 isTypeArgument(ArgR))
2567 PrintFatalError(Attr->getLoc(),
2568 "Attributes accepting packs cannot also "
2569 "have identifier or type arguments.");
2570 // When trying to determine if value-dependent expressions can populate
2571 // the attribute without prior instantiation, the decision is made based
2572 // on the assumption that only the last argument is ever variadic.
2573 if (I < (ArgRecords.size() - 1) && isVariadicExprArgument(ArgR))
2574 PrintFatalError(Attr->getLoc(),
2575 "Attributes accepting packs can only have the last "
2576 "argument be variadic.");
2577 }
2578 }
2579
2580 bool HasOptArg = false;
2581 bool HasFakeArg = false;
2582 for (const auto *ArgRecord : ArgRecords) {
2583 Args.emplace_back(createArgument(*ArgRecord, R.getName()));
2584 if (Header) {
2585 Args.back()->writeDeclarations(OS);
2586 OS << "\n\n";
2587 }
2588
2589 // For these purposes, fake takes priority over optional.
2590 if (Args.back()->isFake()) {
2591 HasFakeArg = true;
2592 } else if (Args.back()->isOptional()) {
2593 HasOptArg = true;
2594 }
2595 }
2596
2597 std::unique_ptr<VariadicExprArgument> DelayedArgs = nullptr;
2598 if (AttrAcceptsExprPack) {
2599 DelayedArgs =
2600 std::make_unique<VariadicExprArgument>("DelayedArgs", R.getName());
2601 if (Header) {
2602 DelayedArgs->writeDeclarations(OS);
2603 OS << "\n\n";
2604 }
2605 }
2606
2607 if (Header)
2608 OS << "public:\n";
2609
2610 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
2611
2612 // If there are zero or one spellings, all spelling-related functionality
2613 // can be elided. If all of the spellings share the same name, the spelling
2614 // functionality can also be elided.
2615 bool ElideSpelling = (Spellings.size() <= 1) ||
2616 SpellingNamesAreCommon(Spellings);
2617
2618 // This maps spelling index values to semantic Spelling enumerants.
2619 SemanticSpellingMap SemanticToSyntacticMap;
2620
2621 std::string SpellingEnum;
2622 if (Spellings.size() > 1)
2623 SpellingEnum = CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
2624 if (Header)
2625 OS << SpellingEnum;
2626
2627 const auto &ParsedAttrSpellingItr = llvm::find_if(
2628 AttrMap, [R](const std::pair<std::string, const Record *> &P) {
2629 return &R == P.second;
2630 });
2631
2632 // Emit CreateImplicit factory methods.
2633 auto emitCreate = [&](bool Implicit, bool DelayedArgsOnly, bool emitFake) {
2634 if (Header)
2635 OS << " static ";
2636 OS << R.getName() << "Attr *";
2637 if (!Header)
2638 OS << R.getName() << "Attr::";
2639 OS << "Create";
2640 if (Implicit)
2641 OS << "Implicit";
2642 if (DelayedArgsOnly)
2643 OS << "WithDelayedArgs";
2644 OS << "(";
2645 OS << "ASTContext &Ctx";
2646 if (!DelayedArgsOnly) {
2647 for (auto const &ai : Args) {
2648 if (ai->isFake() && !emitFake)
2649 continue;
2650 OS << ", ";
2651 ai->writeCtorParameters(OS);
2652 }
2653 } else {
2654 OS << ", ";
2655 DelayedArgs->writeCtorParameters(OS);
2656 }
2657 OS << ", const AttributeCommonInfo &CommonInfo";
2658 OS << ")";
2659 if (Header) {
2660 OS << ";\n";
2661 return;
2662 }
2663
2664 OS << " {\n";
2665 OS << " auto *A = new (Ctx) " << R.getName();
2666 OS << "Attr(Ctx, CommonInfo";
2667
2668 if (!DelayedArgsOnly) {
2669 for (auto const &ai : Args) {
2670 if (ai->isFake() && !emitFake)
2671 continue;
2672 OS << ", ";
2673 ai->writeImplicitCtorArgs(OS);
2674 }
2675 }
2676 OS << ");\n";
2677 if (Implicit) {
2678 OS << " A->setImplicit(true);\n";
2679 }
2680 if (Implicit || ElideSpelling) {
2681 OS << " if (!A->isAttributeSpellingListCalculated() && "
2682 "!A->getAttrName())\n";
2683 OS << " A->setAttributeSpellingListIndex(0);\n";
2684 }
2685 if (DelayedArgsOnly) {
2686 OS << " A->setDelayedArgs(Ctx, ";
2687 DelayedArgs->writeImplicitCtorArgs(OS);
2688 OS << ");\n";
2689 }
2690 OS << " return A;\n}\n\n";
2691 };
2692
2693 auto emitCreateNoCI = [&](bool Implicit, bool DelayedArgsOnly,
2694 bool emitFake) {
2695 if (Header)
2696 OS << " static ";
2697 OS << R.getName() << "Attr *";
2698 if (!Header)
2699 OS << R.getName() << "Attr::";
2700 OS << "Create";
2701 if (Implicit)
2702 OS << "Implicit";
2703 if (DelayedArgsOnly)
2704 OS << "WithDelayedArgs";
2705 OS << "(";
2706 OS << "ASTContext &Ctx";
2707 if (!DelayedArgsOnly) {
2708 for (auto const &ai : Args) {
2709 if (ai->isFake() && !emitFake)
2710 continue;
2711 OS << ", ";
2712 ai->writeCtorParameters(OS);
2713 }
2714 } else {
2715 OS << ", ";
2716 DelayedArgs->writeCtorParameters(OS);
2717 }
2718 OS << ", SourceRange Range";
2719 if (Header)
2720 OS << " = {}";
2721 if (Spellings.size() > 1) {
2722 OS << ", Spelling S";
2723 if (Header)
2724 OS << " = " << SemanticToSyntacticMap[0];
2725 }
2726 OS << ")";
2727 if (Header) {
2728 OS << ";\n";
2729 return;
2730 }
2731
2732 OS << " {\n";
2733 OS << " AttributeCommonInfo I(Range, ";
2734
2735 if (ParsedAttrSpellingItr != std::end(AttrMap))
2736 OS << "AT_" << ParsedAttrSpellingItr->first;
2737 else
2738 OS << "NoSemaHandlerAttribute";
2739
2740 if (Spellings.size() == 0) {
2741 OS << ", AttributeCommonInfo::Form::Implicit()";
2742 } else if (Spellings.size() == 1) {
2743 OS << ", ";
2744 emitFormInitializer(OS, Spellings[0], "0");
2745 } else {
2746 OS << ", [&]() {\n";
2747 OS << " switch (S) {\n";
2748 std::set<std::string> Uniques;
2749 unsigned Idx = 0;
2750 for (auto I = Spellings.begin(), E = Spellings.end(); I != E;
2751 ++I, ++Idx) {
2752 const FlattenedSpelling &S = *I;
2753 const auto &Name = SemanticToSyntacticMap[Idx];
2754 if (Uniques.insert(Name).second) {
2755 OS << " case " << Name << ":\n";
2756 OS << " return AttributeCommonInfo::Form";
2757 emitFormInitializer(OS, S, Name);
2758 OS << ";\n";
2759 }
2760 }
2761 OS << " default:\n";
2762 OS << " llvm_unreachable(\"Unknown attribute spelling!\");\n"
2763 << " return AttributeCommonInfo::Form";
2764 emitFormInitializer(OS, Spellings[0], "0");
2765 OS << ";\n"
2766 << " }\n"
2767 << " }()";
2768 }
2769
2770 OS << ");\n";
2771 OS << " return Create";
2772 if (Implicit)
2773 OS << "Implicit";
2774 if (DelayedArgsOnly)
2775 OS << "WithDelayedArgs";
2776 OS << "(Ctx";
2777 if (!DelayedArgsOnly) {
2778 for (auto const &ai : Args) {
2779 if (ai->isFake() && !emitFake)
2780 continue;
2781 OS << ", ";
2782 ai->writeImplicitCtorArgs(OS);
2783 }
2784 } else {
2785 OS << ", ";
2786 DelayedArgs->writeImplicitCtorArgs(OS);
2787 }
2788 OS << ", I);\n";
2789 OS << "}\n\n";
2790 };
2791
2792 auto emitCreates = [&](bool DelayedArgsOnly, bool emitFake) {
2793 emitCreate(true, DelayedArgsOnly, emitFake);
2794 emitCreate(false, DelayedArgsOnly, emitFake);
2795 emitCreateNoCI(true, DelayedArgsOnly, emitFake);
2796 emitCreateNoCI(false, DelayedArgsOnly, emitFake);
2797 };
2798
2799 if (Header)
2800 OS << " // Factory methods\n";
2801
2802 // Emit a CreateImplicit that takes all the arguments.
2803 emitCreates(false, true);
2804
2805 // Emit a CreateImplicit that takes all the non-fake arguments.
2806 if (HasFakeArg)
2807 emitCreates(false, false);
2808
2809 // Emit a CreateWithDelayedArgs that takes only the dependent argument
2810 // expressions.
2811 if (DelayedArgs)
2812 emitCreates(true, false);
2813
2814 // Emit constructors.
2815 auto emitCtor = [&](bool emitOpt, bool emitFake, bool emitNoArgs) {
2816 auto shouldEmitArg = [=](const std::unique_ptr<Argument> &arg) {
2817 if (emitNoArgs)
2818 return false;
2819 if (arg->isFake())
2820 return emitFake;
2821 if (arg->isOptional())
2822 return emitOpt;
2823 return true;
2824 };
2825 if (Header)
2826 OS << " ";
2827 else
2828 OS << R.getName() << "Attr::";
2829 OS << R.getName()
2830 << "Attr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo";
2831 OS << '\n';
2832 for (auto const &ai : Args) {
2833 if (!shouldEmitArg(ai))
2834 continue;
2835 OS << " , ";
2836 ai->writeCtorParameters(OS);
2837 OS << "\n";
2838 }
2839
2840 OS << " )";
2841 if (Header) {
2842 OS << ";\n";
2843 return;
2844 }
2845 OS << "\n : " << SuperName << "(Ctx, CommonInfo, ";
2846 OS << "attr::" << R.getName() << ", "
2847 << (R.getValueAsBit("LateParsed") ? "true" : "false");
2848 if (Inheritable) {
2849 OS << ", "
2850 << (R.getValueAsBit("InheritEvenIfAlreadyPresent") ? "true"
2851 : "false");
2852 }
2853 OS << ")\n";
2854
2855 for (auto const &ai : Args) {
2856 OS << " , ";
2857 if (!shouldEmitArg(ai)) {
2858 ai->writeCtorDefaultInitializers(OS);
2859 } else {
2860 ai->writeCtorInitializers(OS);
2861 }
2862 OS << "\n";
2863 }
2864 if (DelayedArgs) {
2865 OS << " , ";
2866 DelayedArgs->writeCtorDefaultInitializers(OS);
2867 OS << "\n";
2868 }
2869
2870 OS << " {\n";
2871
2872 for (auto const &ai : Args) {
2873 if (!shouldEmitArg(ai))
2874 continue;
2875 ai->writeCtorBody(OS);
2876 }
2877 OS << "}\n\n";
2878 };
2879
2880 if (Header)
2881 OS << "\n // Constructors\n";
2882
2883 // Emit a constructor that includes all the arguments.
2884 // This is necessary for cloning.
2885 emitCtor(true, true, false);
2886
2887 // Emit a constructor that takes all the non-fake arguments.
2888 if (HasFakeArg)
2889 emitCtor(true, false, false);
2890
2891 // Emit a constructor that takes all the non-fake, non-optional arguments.
2892 if (HasOptArg)
2893 emitCtor(false, false, false);
2894
2895 // Emit constructors that takes no arguments if none already exists.
2896 // This is used for delaying arguments.
2897 bool HasRequiredArgs =
2898 llvm::count_if(Args, [=](const std::unique_ptr<Argument> &arg) {
2899 return !arg->isFake() && !arg->isOptional();
2900 });
2901 if (DelayedArgs && HasRequiredArgs)
2902 emitCtor(false, false, true);
2903
2904 if (Header) {
2905 OS << '\n';
2906 OS << " " << R.getName() << "Attr *clone(ASTContext &C) const;\n";
2907 OS << " void printPretty(raw_ostream &OS,\n"
2908 << " const PrintingPolicy &Policy) const;\n";
2909 OS << " const char *getSpelling() const;\n";
2910 }
2911
2912 if (!ElideSpelling) {
2913 assert(!SemanticToSyntacticMap.empty() && "Empty semantic mapping list");
2914 if (Header)
2915 OS << " Spelling getSemanticSpelling() const;\n";
2916 else {
2917 OS << R.getName() << "Attr::Spelling " << R.getName()
2918 << "Attr::getSemanticSpelling() const {\n";
2919 WriteSemanticSpellingSwitch("getAttributeSpellingListIndex()",
2920 SemanticToSyntacticMap, OS);
2921 OS << "}\n";
2922 }
2923 }
2924
2925 if (Header)
2926 writeAttrAccessorDefinition(R, OS);
2927
2928 for (auto const &ai : Args) {
2929 if (Header) {
2930 ai->writeAccessors(OS);
2931 } else {
2932 ai->writeAccessorDefinitions(OS);
2933 }
2934 OS << "\n\n";
2935
2936 // Don't write conversion routines for fake arguments.
2937 if (ai->isFake()) continue;
2938
2939 if (ai->isEnumArg())
2940 static_cast<const EnumArgument *>(ai.get())->writeConversion(OS,
2941 Header);
2942 else if (ai->isVariadicEnumArg())
2943 static_cast<const VariadicEnumArgument *>(ai.get())->writeConversion(
2944 OS, Header);
2945 }
2946
2947 if (Header) {
2948 if (DelayedArgs) {
2949 DelayedArgs->writeAccessors(OS);
2950 DelayedArgs->writeSetter(OS);
2951 }
2952
2953 OS << R.getValueAsString("AdditionalMembers");
2954 OS << "\n\n";
2955
2956 OS << " static bool classof(const Attr *A) { return A->getKind() == "
2957 << "attr::" << R.getName() << "; }\n";
2958
2959 OS << "};\n\n";
2960 } else {
2961 if (DelayedArgs)
2962 DelayedArgs->writeAccessorDefinitions(OS);
2963
2964 OS << R.getName() << "Attr *" << R.getName()
2965 << "Attr::clone(ASTContext &C) const {\n";
2966 OS << " auto *A = new (C) " << R.getName() << "Attr(C, *this";
2967 for (auto const &ai : Args) {
2968 OS << ", ";
2969 ai->writeCloneArgs(OS);
2970 }
2971 OS << ");\n";
2972 OS << " A->Inherited = Inherited;\n";
2973 OS << " A->IsPackExpansion = IsPackExpansion;\n";
2974 OS << " A->setImplicit(Implicit);\n";
2975 if (DelayedArgs) {
2976 OS << " A->setDelayedArgs(C, ";
2977 DelayedArgs->writeCloneArgs(OS);
2978 OS << ");\n";
2979 }
2980 OS << " return A;\n}\n\n";
2981
2982 writePrettyPrintFunction(R, Args, OS);
2983 writeGetSpellingFunction(R, OS);
2984 }
2985 }
2986 }
2987 // Emits the class definitions for attributes.
EmitClangAttrClass(RecordKeeper & Records,raw_ostream & OS)2988 void clang::EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS) {
2989 emitSourceFileHeader("Attribute classes' definitions", OS, Records);
2990
2991 OS << "#ifndef LLVM_CLANG_ATTR_CLASSES_INC\n";
2992 OS << "#define LLVM_CLANG_ATTR_CLASSES_INC\n\n";
2993
2994 emitAttributes(Records, OS, true);
2995
2996 OS << "#endif // LLVM_CLANG_ATTR_CLASSES_INC\n";
2997 }
2998
2999 // Emits the class method definitions for attributes.
EmitClangAttrImpl(RecordKeeper & Records,raw_ostream & OS)3000 void clang::EmitClangAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
3001 emitSourceFileHeader("Attribute classes' member function definitions", OS,
3002 Records);
3003
3004 emitAttributes(Records, OS, false);
3005
3006 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
3007
3008 // Instead of relying on virtual dispatch we just create a huge dispatch
3009 // switch. This is both smaller and faster than virtual functions.
3010 auto EmitFunc = [&](const char *Method) {
3011 OS << " switch (getKind()) {\n";
3012 for (const auto *Attr : Attrs) {
3013 const Record &R = *Attr;
3014 if (!R.getValueAsBit("ASTNode"))
3015 continue;
3016
3017 OS << " case attr::" << R.getName() << ":\n";
3018 OS << " return cast<" << R.getName() << "Attr>(this)->" << Method
3019 << ";\n";
3020 }
3021 OS << " }\n";
3022 OS << " llvm_unreachable(\"Unexpected attribute kind!\");\n";
3023 OS << "}\n\n";
3024 };
3025
3026 OS << "const char *Attr::getSpelling() const {\n";
3027 EmitFunc("getSpelling()");
3028
3029 OS << "Attr *Attr::clone(ASTContext &C) const {\n";
3030 EmitFunc("clone(C)");
3031
3032 OS << "void Attr::printPretty(raw_ostream &OS, "
3033 "const PrintingPolicy &Policy) const {\n";
3034 EmitFunc("printPretty(OS, Policy)");
3035 }
3036
emitAttrList(raw_ostream & OS,StringRef Class,const std::vector<Record * > & AttrList)3037 static void emitAttrList(raw_ostream &OS, StringRef Class,
3038 const std::vector<Record*> &AttrList) {
3039 for (auto Cur : AttrList) {
3040 OS << Class << "(" << Cur->getName() << ")\n";
3041 }
3042 }
3043
3044 // Determines if an attribute has a Pragma spelling.
AttrHasPragmaSpelling(const Record * R)3045 static bool AttrHasPragmaSpelling(const Record *R) {
3046 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*R);
3047 return llvm::any_of(Spellings, [](const FlattenedSpelling &S) {
3048 return S.variety() == "Pragma";
3049 });
3050 }
3051
3052 namespace {
3053
3054 struct AttrClassDescriptor {
3055 const char * const MacroName;
3056 const char * const TableGenName;
3057 };
3058
3059 } // end anonymous namespace
3060
3061 static const AttrClassDescriptor AttrClassDescriptors[] = {
3062 { "ATTR", "Attr" },
3063 { "TYPE_ATTR", "TypeAttr" },
3064 { "STMT_ATTR", "StmtAttr" },
3065 { "DECL_OR_STMT_ATTR", "DeclOrStmtAttr" },
3066 { "INHERITABLE_ATTR", "InheritableAttr" },
3067 { "DECL_OR_TYPE_ATTR", "DeclOrTypeAttr" },
3068 { "INHERITABLE_PARAM_ATTR", "InheritableParamAttr" },
3069 { "PARAMETER_ABI_ATTR", "ParameterABIAttr" },
3070 { "HLSL_ANNOTATION_ATTR", "HLSLAnnotationAttr"}
3071 };
3072
emitDefaultDefine(raw_ostream & OS,StringRef name,const char * superName)3073 static void emitDefaultDefine(raw_ostream &OS, StringRef name,
3074 const char *superName) {
3075 OS << "#ifndef " << name << "\n";
3076 OS << "#define " << name << "(NAME) ";
3077 if (superName) OS << superName << "(NAME)";
3078 OS << "\n#endif\n\n";
3079 }
3080
3081 namespace {
3082
3083 /// A class of attributes.
3084 struct AttrClass {
3085 const AttrClassDescriptor &Descriptor;
3086 Record *TheRecord;
3087 AttrClass *SuperClass = nullptr;
3088 std::vector<AttrClass*> SubClasses;
3089 std::vector<Record*> Attrs;
3090
AttrClass__anond1516bc71711::AttrClass3091 AttrClass(const AttrClassDescriptor &Descriptor, Record *R)
3092 : Descriptor(Descriptor), TheRecord(R) {}
3093
emitDefaultDefines__anond1516bc71711::AttrClass3094 void emitDefaultDefines(raw_ostream &OS) const {
3095 // Default the macro unless this is a root class (i.e. Attr).
3096 if (SuperClass) {
3097 emitDefaultDefine(OS, Descriptor.MacroName,
3098 SuperClass->Descriptor.MacroName);
3099 }
3100 }
3101
emitUndefs__anond1516bc71711::AttrClass3102 void emitUndefs(raw_ostream &OS) const {
3103 OS << "#undef " << Descriptor.MacroName << "\n";
3104 }
3105
emitAttrList__anond1516bc71711::AttrClass3106 void emitAttrList(raw_ostream &OS) const {
3107 for (auto SubClass : SubClasses) {
3108 SubClass->emitAttrList(OS);
3109 }
3110
3111 ::emitAttrList(OS, Descriptor.MacroName, Attrs);
3112 }
3113
classifyAttrOnRoot__anond1516bc71711::AttrClass3114 void classifyAttrOnRoot(Record *Attr) {
3115 bool result = classifyAttr(Attr);
3116 assert(result && "failed to classify on root"); (void) result;
3117 }
3118
emitAttrRange__anond1516bc71711::AttrClass3119 void emitAttrRange(raw_ostream &OS) const {
3120 OS << "ATTR_RANGE(" << Descriptor.TableGenName
3121 << ", " << getFirstAttr()->getName()
3122 << ", " << getLastAttr()->getName() << ")\n";
3123 }
3124
3125 private:
classifyAttr__anond1516bc71711::AttrClass3126 bool classifyAttr(Record *Attr) {
3127 // Check all the subclasses.
3128 for (auto SubClass : SubClasses) {
3129 if (SubClass->classifyAttr(Attr))
3130 return true;
3131 }
3132
3133 // It's not more specific than this class, but it might still belong here.
3134 if (Attr->isSubClassOf(TheRecord)) {
3135 Attrs.push_back(Attr);
3136 return true;
3137 }
3138
3139 return false;
3140 }
3141
getFirstAttr__anond1516bc71711::AttrClass3142 Record *getFirstAttr() const {
3143 if (!SubClasses.empty())
3144 return SubClasses.front()->getFirstAttr();
3145 return Attrs.front();
3146 }
3147
getLastAttr__anond1516bc71711::AttrClass3148 Record *getLastAttr() const {
3149 if (!Attrs.empty())
3150 return Attrs.back();
3151 return SubClasses.back()->getLastAttr();
3152 }
3153 };
3154
3155 /// The entire hierarchy of attribute classes.
3156 class AttrClassHierarchy {
3157 std::vector<std::unique_ptr<AttrClass>> Classes;
3158
3159 public:
AttrClassHierarchy(RecordKeeper & Records)3160 AttrClassHierarchy(RecordKeeper &Records) {
3161 // Find records for all the classes.
3162 for (auto &Descriptor : AttrClassDescriptors) {
3163 Record *ClassRecord = Records.getClass(Descriptor.TableGenName);
3164 AttrClass *Class = new AttrClass(Descriptor, ClassRecord);
3165 Classes.emplace_back(Class);
3166 }
3167
3168 // Link up the hierarchy.
3169 for (auto &Class : Classes) {
3170 if (AttrClass *SuperClass = findSuperClass(Class->TheRecord)) {
3171 Class->SuperClass = SuperClass;
3172 SuperClass->SubClasses.push_back(Class.get());
3173 }
3174 }
3175
3176 #ifndef NDEBUG
3177 for (auto i = Classes.begin(), e = Classes.end(); i != e; ++i) {
3178 assert((i == Classes.begin()) == ((*i)->SuperClass == nullptr) &&
3179 "only the first class should be a root class!");
3180 }
3181 #endif
3182 }
3183
emitDefaultDefines(raw_ostream & OS) const3184 void emitDefaultDefines(raw_ostream &OS) const {
3185 for (auto &Class : Classes) {
3186 Class->emitDefaultDefines(OS);
3187 }
3188 }
3189
emitUndefs(raw_ostream & OS) const3190 void emitUndefs(raw_ostream &OS) const {
3191 for (auto &Class : Classes) {
3192 Class->emitUndefs(OS);
3193 }
3194 }
3195
emitAttrLists(raw_ostream & OS) const3196 void emitAttrLists(raw_ostream &OS) const {
3197 // Just start from the root class.
3198 Classes[0]->emitAttrList(OS);
3199 }
3200
emitAttrRanges(raw_ostream & OS) const3201 void emitAttrRanges(raw_ostream &OS) const {
3202 for (auto &Class : Classes)
3203 Class->emitAttrRange(OS);
3204 }
3205
classifyAttr(Record * Attr)3206 void classifyAttr(Record *Attr) {
3207 // Add the attribute to the root class.
3208 Classes[0]->classifyAttrOnRoot(Attr);
3209 }
3210
3211 private:
findClassByRecord(Record * R) const3212 AttrClass *findClassByRecord(Record *R) const {
3213 for (auto &Class : Classes) {
3214 if (Class->TheRecord == R)
3215 return Class.get();
3216 }
3217 return nullptr;
3218 }
3219
findSuperClass(Record * R) const3220 AttrClass *findSuperClass(Record *R) const {
3221 // TableGen flattens the superclass list, so we just need to walk it
3222 // in reverse.
3223 auto SuperClasses = R->getSuperClasses();
3224 for (signed i = 0, e = SuperClasses.size(); i != e; ++i) {
3225 auto SuperClass = findClassByRecord(SuperClasses[e - i - 1].first);
3226 if (SuperClass) return SuperClass;
3227 }
3228 return nullptr;
3229 }
3230 };
3231
3232 } // end anonymous namespace
3233
3234 namespace clang {
3235
3236 // Emits the enumeration list for attributes.
EmitClangAttrList(RecordKeeper & Records,raw_ostream & OS)3237 void EmitClangAttrList(RecordKeeper &Records, raw_ostream &OS) {
3238 emitSourceFileHeader("List of all attributes that Clang recognizes", OS,
3239 Records);
3240
3241 AttrClassHierarchy Hierarchy(Records);
3242
3243 // Add defaulting macro definitions.
3244 Hierarchy.emitDefaultDefines(OS);
3245 emitDefaultDefine(OS, "PRAGMA_SPELLING_ATTR", nullptr);
3246
3247 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
3248 std::vector<Record *> PragmaAttrs;
3249 for (auto *Attr : Attrs) {
3250 if (!Attr->getValueAsBit("ASTNode"))
3251 continue;
3252
3253 // Add the attribute to the ad-hoc groups.
3254 if (AttrHasPragmaSpelling(Attr))
3255 PragmaAttrs.push_back(Attr);
3256
3257 // Place it in the hierarchy.
3258 Hierarchy.classifyAttr(Attr);
3259 }
3260
3261 // Emit the main attribute list.
3262 Hierarchy.emitAttrLists(OS);
3263
3264 // Emit the ad hoc groups.
3265 emitAttrList(OS, "PRAGMA_SPELLING_ATTR", PragmaAttrs);
3266
3267 // Emit the attribute ranges.
3268 OS << "#ifdef ATTR_RANGE\n";
3269 Hierarchy.emitAttrRanges(OS);
3270 OS << "#undef ATTR_RANGE\n";
3271 OS << "#endif\n";
3272
3273 Hierarchy.emitUndefs(OS);
3274 OS << "#undef PRAGMA_SPELLING_ATTR\n";
3275 }
3276
3277 // Emits the enumeration list for attributes.
EmitClangAttrPrintList(const std::string & FieldName,RecordKeeper & Records,raw_ostream & OS)3278 void EmitClangAttrPrintList(const std::string &FieldName, RecordKeeper &Records,
3279 raw_ostream &OS) {
3280 emitSourceFileHeader(
3281 "List of attributes that can be print on the left side of a decl", OS,
3282 Records);
3283
3284 AttrClassHierarchy Hierarchy(Records);
3285
3286 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
3287 std::vector<Record *> PragmaAttrs;
3288 bool first = false;
3289
3290 for (auto *Attr : Attrs) {
3291 if (!Attr->getValueAsBit("ASTNode"))
3292 continue;
3293
3294 if (!Attr->getValueAsBit(FieldName))
3295 continue;
3296
3297 if (!first) {
3298 first = true;
3299 OS << "#define CLANG_ATTR_LIST_" << FieldName;
3300 }
3301
3302 OS << " \\\n case attr::" << Attr->getName() << ":";
3303 }
3304
3305 OS << '\n';
3306 }
3307
3308 // Emits the enumeration list for attributes.
EmitClangAttrSubjectMatchRuleList(RecordKeeper & Records,raw_ostream & OS)3309 void EmitClangAttrSubjectMatchRuleList(RecordKeeper &Records, raw_ostream &OS) {
3310 emitSourceFileHeader(
3311 "List of all attribute subject matching rules that Clang recognizes", OS,
3312 Records);
3313 PragmaClangAttributeSupport &PragmaAttributeSupport =
3314 getPragmaAttributeSupport(Records);
3315 emitDefaultDefine(OS, "ATTR_MATCH_RULE", nullptr);
3316 PragmaAttributeSupport.emitMatchRuleList(OS);
3317 OS << "#undef ATTR_MATCH_RULE\n";
3318 }
3319
3320 // Emits the code to read an attribute from a precompiled header.
EmitClangAttrPCHRead(RecordKeeper & Records,raw_ostream & OS)3321 void EmitClangAttrPCHRead(RecordKeeper &Records, raw_ostream &OS) {
3322 emitSourceFileHeader("Attribute deserialization code", OS, Records);
3323
3324 Record *InhClass = Records.getClass("InheritableAttr");
3325 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"),
3326 ArgRecords;
3327 std::vector<std::unique_ptr<Argument>> Args;
3328 std::unique_ptr<VariadicExprArgument> DelayedArgs;
3329
3330 OS << " switch (Kind) {\n";
3331 for (const auto *Attr : Attrs) {
3332 const Record &R = *Attr;
3333 if (!R.getValueAsBit("ASTNode"))
3334 continue;
3335
3336 OS << " case attr::" << R.getName() << ": {\n";
3337 if (R.isSubClassOf(InhClass))
3338 OS << " bool isInherited = Record.readInt();\n";
3339 OS << " bool isImplicit = Record.readInt();\n";
3340 OS << " bool isPackExpansion = Record.readInt();\n";
3341 DelayedArgs = nullptr;
3342 if (Attr->getValueAsBit("AcceptsExprPack")) {
3343 DelayedArgs =
3344 std::make_unique<VariadicExprArgument>("DelayedArgs", R.getName());
3345 DelayedArgs->writePCHReadDecls(OS);
3346 }
3347 ArgRecords = R.getValueAsListOfDefs("Args");
3348 Args.clear();
3349 for (const auto *Arg : ArgRecords) {
3350 Args.emplace_back(createArgument(*Arg, R.getName()));
3351 Args.back()->writePCHReadDecls(OS);
3352 }
3353 OS << " New = new (Context) " << R.getName() << "Attr(Context, Info";
3354 for (auto const &ri : Args) {
3355 OS << ", ";
3356 ri->writePCHReadArgs(OS);
3357 }
3358 OS << ");\n";
3359 if (R.isSubClassOf(InhClass))
3360 OS << " cast<InheritableAttr>(New)->setInherited(isInherited);\n";
3361 OS << " New->setImplicit(isImplicit);\n";
3362 OS << " New->setPackExpansion(isPackExpansion);\n";
3363 if (DelayedArgs) {
3364 OS << " cast<" << R.getName()
3365 << "Attr>(New)->setDelayedArgs(Context, ";
3366 DelayedArgs->writePCHReadArgs(OS);
3367 OS << ");\n";
3368 }
3369 OS << " break;\n";
3370 OS << " }\n";
3371 }
3372 OS << " }\n";
3373 }
3374
3375 // Emits the code to write an attribute to a precompiled header.
EmitClangAttrPCHWrite(RecordKeeper & Records,raw_ostream & OS)3376 void EmitClangAttrPCHWrite(RecordKeeper &Records, raw_ostream &OS) {
3377 emitSourceFileHeader("Attribute serialization code", OS, Records);
3378
3379 Record *InhClass = Records.getClass("InheritableAttr");
3380 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
3381
3382 OS << " switch (A->getKind()) {\n";
3383 for (const auto *Attr : Attrs) {
3384 const Record &R = *Attr;
3385 if (!R.getValueAsBit("ASTNode"))
3386 continue;
3387 OS << " case attr::" << R.getName() << ": {\n";
3388 Args = R.getValueAsListOfDefs("Args");
3389 if (R.isSubClassOf(InhClass) || !Args.empty())
3390 OS << " const auto *SA = cast<" << R.getName()
3391 << "Attr>(A);\n";
3392 if (R.isSubClassOf(InhClass))
3393 OS << " Record.push_back(SA->isInherited());\n";
3394 OS << " Record.push_back(A->isImplicit());\n";
3395 OS << " Record.push_back(A->isPackExpansion());\n";
3396 if (Attr->getValueAsBit("AcceptsExprPack"))
3397 VariadicExprArgument("DelayedArgs", R.getName()).writePCHWrite(OS);
3398
3399 for (const auto *Arg : Args)
3400 createArgument(*Arg, R.getName())->writePCHWrite(OS);
3401 OS << " break;\n";
3402 OS << " }\n";
3403 }
3404 OS << " }\n";
3405 }
3406
3407 // Helper function for GenerateTargetSpecificAttrChecks that alters the 'Test'
3408 // parameter with only a single check type, if applicable.
GenerateTargetSpecificAttrCheck(const Record * R,std::string & Test,std::string * FnName,StringRef ListName,StringRef CheckAgainst,StringRef Scope)3409 static bool GenerateTargetSpecificAttrCheck(const Record *R, std::string &Test,
3410 std::string *FnName,
3411 StringRef ListName,
3412 StringRef CheckAgainst,
3413 StringRef Scope) {
3414 if (!R->isValueUnset(ListName)) {
3415 Test += " && (";
3416 std::vector<StringRef> Items = R->getValueAsListOfStrings(ListName);
3417 for (auto I = Items.begin(), E = Items.end(); I != E; ++I) {
3418 StringRef Part = *I;
3419 Test += CheckAgainst;
3420 Test += " == ";
3421 Test += Scope;
3422 Test += Part;
3423 if (I + 1 != E)
3424 Test += " || ";
3425 if (FnName)
3426 *FnName += Part;
3427 }
3428 Test += ")";
3429 return true;
3430 }
3431 return false;
3432 }
3433
3434 // Generate a conditional expression to check if the current target satisfies
3435 // the conditions for a TargetSpecificAttr record, and append the code for
3436 // those checks to the Test string. If the FnName string pointer is non-null,
3437 // append a unique suffix to distinguish this set of target checks from other
3438 // TargetSpecificAttr records.
GenerateTargetSpecificAttrChecks(const Record * R,std::vector<StringRef> & Arches,std::string & Test,std::string * FnName)3439 static bool GenerateTargetSpecificAttrChecks(const Record *R,
3440 std::vector<StringRef> &Arches,
3441 std::string &Test,
3442 std::string *FnName) {
3443 bool AnyTargetChecks = false;
3444
3445 // It is assumed that there will be an llvm::Triple object
3446 // named "T" and a TargetInfo object named "Target" within
3447 // scope that can be used to determine whether the attribute exists in
3448 // a given target.
3449 Test += "true";
3450 // If one or more architectures is specified, check those. Arches are handled
3451 // differently because GenerateTargetRequirements needs to combine the list
3452 // with ParseKind.
3453 if (!Arches.empty()) {
3454 AnyTargetChecks = true;
3455 Test += " && (";
3456 for (auto I = Arches.begin(), E = Arches.end(); I != E; ++I) {
3457 StringRef Part = *I;
3458 Test += "T.getArch() == llvm::Triple::";
3459 Test += Part;
3460 if (I + 1 != E)
3461 Test += " || ";
3462 if (FnName)
3463 *FnName += Part;
3464 }
3465 Test += ")";
3466 }
3467
3468 // If the attribute is specific to particular OSes, check those.
3469 AnyTargetChecks |= GenerateTargetSpecificAttrCheck(
3470 R, Test, FnName, "OSes", "T.getOS()", "llvm::Triple::");
3471
3472 // If one or more object formats is specified, check those.
3473 AnyTargetChecks |=
3474 GenerateTargetSpecificAttrCheck(R, Test, FnName, "ObjectFormats",
3475 "T.getObjectFormat()", "llvm::Triple::");
3476
3477 // If custom code is specified, emit it.
3478 StringRef Code = R->getValueAsString("CustomCode");
3479 if (!Code.empty()) {
3480 AnyTargetChecks = true;
3481 Test += " && (";
3482 Test += Code;
3483 Test += ")";
3484 }
3485
3486 return AnyTargetChecks;
3487 }
3488
GenerateHasAttrSpellingStringSwitch(const std::vector<std::pair<const Record *,FlattenedSpelling>> & Attrs,raw_ostream & OS,const std::string & Variety,const std::string & Scope="")3489 static void GenerateHasAttrSpellingStringSwitch(
3490 const std::vector<std::pair<const Record *, FlattenedSpelling>> &Attrs,
3491 raw_ostream &OS, const std::string &Variety,
3492 const std::string &Scope = "") {
3493 for (const auto &[Attr, Spelling] : Attrs) {
3494 // C++11-style attributes have specific version information associated with
3495 // them. If the attribute has no scope, the version information must not
3496 // have the default value (1), as that's incorrect. Instead, the unscoped
3497 // attribute version information should be taken from the SD-6 standing
3498 // document, which can be found at:
3499 // https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations
3500 //
3501 // C23-style attributes have the same kind of version information
3502 // associated with them. The unscoped attribute version information should
3503 // be taken from the specification of the attribute in the C Standard.
3504 //
3505 // Clang-specific attributes have the same kind of version information
3506 // associated with them. This version is typically the default value (1).
3507 // These version values are clang-specific and should typically be
3508 // incremented once the attribute changes its syntax and/or semantics in a
3509 // a way that is impactful to the end user.
3510 int Version = 1;
3511
3512 assert(Spelling.variety() == Variety);
3513 std::string Name = "";
3514 if (Spelling.nameSpace().empty() || Scope == Spelling.nameSpace()) {
3515 Name = Spelling.name();
3516 Version = static_cast<int>(
3517 Spelling.getSpellingRecord().getValueAsInt("Version"));
3518 // Verify that explicitly specified CXX11 and C23 spellings (i.e.
3519 // not inferred from Clang/GCC spellings) have a version that's
3520 // different from the default (1).
3521 bool RequiresValidVersion =
3522 (Variety == "CXX11" || Variety == "C23") &&
3523 Spelling.getSpellingRecord().getValueAsString("Variety") == Variety;
3524 if (RequiresValidVersion && Scope.empty() && Version == 1)
3525 PrintError(Spelling.getSpellingRecord().getLoc(),
3526 "Standard attributes must have "
3527 "valid version information.");
3528 }
3529
3530 std::string Test;
3531 if (Attr->isSubClassOf("TargetSpecificAttr")) {
3532 const Record *R = Attr->getValueAsDef("Target");
3533 std::vector<StringRef> Arches = R->getValueAsListOfStrings("Arches");
3534 GenerateTargetSpecificAttrChecks(R, Arches, Test, nullptr);
3535
3536 // If this is the C++11 variety, also add in the LangOpts test.
3537 if (Variety == "CXX11")
3538 Test += " && LangOpts.CPlusPlus11";
3539 } else if (!Attr->getValueAsListOfDefs("TargetSpecificSpellings").empty()) {
3540 // Add target checks if this spelling is target-specific.
3541 const std::vector<Record *> TargetSpellings =
3542 Attr->getValueAsListOfDefs("TargetSpecificSpellings");
3543 for (const auto &TargetSpelling : TargetSpellings) {
3544 // Find spelling that matches current scope and name.
3545 for (const auto &Spelling : GetFlattenedSpellings(*TargetSpelling)) {
3546 if (Scope == Spelling.nameSpace() && Name == Spelling.name()) {
3547 const Record *Target = TargetSpelling->getValueAsDef("Target");
3548 std::vector<StringRef> Arches =
3549 Target->getValueAsListOfStrings("Arches");
3550 GenerateTargetSpecificAttrChecks(Target, Arches, Test,
3551 /*FnName=*/nullptr);
3552 break;
3553 }
3554 }
3555 }
3556
3557 if (Variety == "CXX11")
3558 Test += " && LangOpts.CPlusPlus11";
3559 } else if (Variety == "CXX11")
3560 // C++11 mode should be checked against LangOpts, which is presumed to be
3561 // present in the caller.
3562 Test = "LangOpts.CPlusPlus11";
3563
3564 std::string TestStr = !Test.empty()
3565 ? Test + " ? " + llvm::itostr(Version) + " : 0"
3566 : llvm::itostr(Version);
3567 if (Scope.empty() || Scope == Spelling.nameSpace())
3568 OS << " .Case(\"" << Spelling.name() << "\", " << TestStr << ")\n";
3569 }
3570 OS << " .Default(0);\n";
3571 }
3572
3573 // Emits list of regular keyword attributes with info about their arguments.
EmitClangRegularKeywordAttributeInfo(RecordKeeper & Records,raw_ostream & OS)3574 void EmitClangRegularKeywordAttributeInfo(RecordKeeper &Records,
3575 raw_ostream &OS) {
3576 emitSourceFileHeader(
3577 "A list of regular keyword attributes generated from the attribute"
3578 " definitions",
3579 OS);
3580 // Assume for now that the same token is not used in multiple regular
3581 // keyword attributes.
3582 for (auto *R : Records.getAllDerivedDefinitions("Attr"))
3583 for (const auto &S : GetFlattenedSpellings(*R)) {
3584 if (!isRegularKeywordAttribute(S))
3585 continue;
3586 std::vector<Record *> Args = R->getValueAsListOfDefs("Args");
3587 bool HasArgs = llvm::any_of(
3588 Args, [](const Record *Arg) { return !Arg->getValueAsBit("Fake"); });
3589
3590 OS << "KEYWORD_ATTRIBUTE("
3591 << S.getSpellingRecord().getValueAsString("Name") << ", "
3592 << (HasArgs ? "true" : "false") << ", )\n";
3593 }
3594 OS << "#undef KEYWORD_ATTRIBUTE\n";
3595 }
3596
3597 // Emits the list of spellings for attributes.
EmitClangAttrHasAttrImpl(RecordKeeper & Records,raw_ostream & OS)3598 void EmitClangAttrHasAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
3599 emitSourceFileHeader("Code to implement the __has_attribute logic", OS,
3600 Records);
3601
3602 // Separate all of the attributes out into four group: generic, C++11, GNU,
3603 // and declspecs. Then generate a big switch statement for each of them.
3604 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
3605 std::vector<std::pair<const Record *, FlattenedSpelling>> Declspec, Microsoft,
3606 GNU, Pragma, HLSLSemantic;
3607 std::map<std::string,
3608 std::vector<std::pair<const Record *, FlattenedSpelling>>>
3609 CXX, C23;
3610
3611 // Walk over the list of all attributes, and split them out based on the
3612 // spelling variety.
3613 for (auto *R : Attrs) {
3614 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*R);
3615 for (const auto &SI : Spellings) {
3616 const std::string &Variety = SI.variety();
3617 if (Variety == "GNU")
3618 GNU.emplace_back(R, SI);
3619 else if (Variety == "Declspec")
3620 Declspec.emplace_back(R, SI);
3621 else if (Variety == "Microsoft")
3622 Microsoft.emplace_back(R, SI);
3623 else if (Variety == "CXX11")
3624 CXX[SI.nameSpace()].emplace_back(R, SI);
3625 else if (Variety == "C23")
3626 C23[SI.nameSpace()].emplace_back(R, SI);
3627 else if (Variety == "Pragma")
3628 Pragma.emplace_back(R, SI);
3629 else if (Variety == "HLSLSemantic")
3630 HLSLSemantic.emplace_back(R, SI);
3631 }
3632 }
3633
3634 OS << "const llvm::Triple &T = Target.getTriple();\n";
3635 OS << "switch (Syntax) {\n";
3636 OS << "case AttributeCommonInfo::Syntax::AS_GNU:\n";
3637 OS << " return llvm::StringSwitch<int>(Name)\n";
3638 GenerateHasAttrSpellingStringSwitch(GNU, OS, "GNU");
3639 OS << "case AttributeCommonInfo::Syntax::AS_Declspec:\n";
3640 OS << " return llvm::StringSwitch<int>(Name)\n";
3641 GenerateHasAttrSpellingStringSwitch(Declspec, OS, "Declspec");
3642 OS << "case AttributeCommonInfo::Syntax::AS_Microsoft:\n";
3643 OS << " return llvm::StringSwitch<int>(Name)\n";
3644 GenerateHasAttrSpellingStringSwitch(Microsoft, OS, "Microsoft");
3645 OS << "case AttributeCommonInfo::Syntax::AS_Pragma:\n";
3646 OS << " return llvm::StringSwitch<int>(Name)\n";
3647 GenerateHasAttrSpellingStringSwitch(Pragma, OS, "Pragma");
3648 OS << "case AttributeCommonInfo::Syntax::AS_HLSLSemantic:\n";
3649 OS << " return llvm::StringSwitch<int>(Name)\n";
3650 GenerateHasAttrSpellingStringSwitch(HLSLSemantic, OS, "HLSLSemantic");
3651 auto fn = [&OS](const char *Spelling,
3652 const std::map<
3653 std::string,
3654 std::vector<std::pair<const Record *, FlattenedSpelling>>>
3655 &List) {
3656 OS << "case AttributeCommonInfo::Syntax::AS_" << Spelling << ": {\n";
3657 // C++11-style attributes are further split out based on the Scope.
3658 for (auto I = List.cbegin(), E = List.cend(); I != E; ++I) {
3659 if (I != List.cbegin())
3660 OS << " else ";
3661 if (I->first.empty())
3662 OS << "if (ScopeName == \"\") {\n";
3663 else
3664 OS << "if (ScopeName == \"" << I->first << "\") {\n";
3665 OS << " return llvm::StringSwitch<int>(Name)\n";
3666 GenerateHasAttrSpellingStringSwitch(I->second, OS, Spelling, I->first);
3667 OS << "}";
3668 }
3669 OS << "\n} break;\n";
3670 };
3671 fn("CXX11", CXX);
3672 fn("C23", C23);
3673 OS << "case AttributeCommonInfo::Syntax::AS_Keyword:\n";
3674 OS << "case AttributeCommonInfo::Syntax::AS_ContextSensitiveKeyword:\n";
3675 OS << " llvm_unreachable(\"hasAttribute not supported for keyword\");\n";
3676 OS << " return 0;\n";
3677 OS << "case AttributeCommonInfo::Syntax::AS_Implicit:\n";
3678 OS << " llvm_unreachable (\"hasAttribute not supported for "
3679 "AS_Implicit\");\n";
3680 OS << " return 0;\n";
3681
3682 OS << "}\n";
3683 }
3684
EmitClangAttrSpellingListIndex(RecordKeeper & Records,raw_ostream & OS)3685 void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS) {
3686 emitSourceFileHeader("Code to translate different attribute spellings into "
3687 "internal identifiers",
3688 OS, Records);
3689
3690 OS << " switch (getParsedKind()) {\n";
3691 OS << " case IgnoredAttribute:\n";
3692 OS << " case UnknownAttribute:\n";
3693 OS << " case NoSemaHandlerAttribute:\n";
3694 OS << " llvm_unreachable(\"Ignored/unknown shouldn't get here\");\n";
3695
3696 ParsedAttrMap Attrs = getParsedAttrList(Records);
3697 for (const auto &I : Attrs) {
3698 const Record &R = *I.second;
3699 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
3700 OS << " case AT_" << I.first << ": {\n";
3701 for (unsigned I = 0; I < Spellings.size(); ++ I) {
3702 OS << " if (Name == \"" << Spellings[I].name() << "\" && "
3703 << "getSyntax() == AttributeCommonInfo::AS_" << Spellings[I].variety()
3704 << " && Scope == \"" << Spellings[I].nameSpace() << "\")\n"
3705 << " return " << I << ";\n";
3706 }
3707
3708 OS << " break;\n";
3709 OS << " }\n";
3710 }
3711
3712 OS << " }\n";
3713 OS << " return 0;\n";
3714 }
3715
3716 // Emits code used by RecursiveASTVisitor to visit attributes
EmitClangAttrASTVisitor(RecordKeeper & Records,raw_ostream & OS)3717 void EmitClangAttrASTVisitor(RecordKeeper &Records, raw_ostream &OS) {
3718 emitSourceFileHeader("Used by RecursiveASTVisitor to visit attributes.", OS,
3719 Records);
3720
3721 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
3722
3723 // Write method declarations for Traverse* methods.
3724 // We emit this here because we only generate methods for attributes that
3725 // are declared as ASTNodes.
3726 OS << "#ifdef ATTR_VISITOR_DECLS_ONLY\n\n";
3727 for (const auto *Attr : Attrs) {
3728 const Record &R = *Attr;
3729 if (!R.getValueAsBit("ASTNode"))
3730 continue;
3731 OS << " bool Traverse"
3732 << R.getName() << "Attr(" << R.getName() << "Attr *A);\n";
3733 OS << " bool Visit"
3734 << R.getName() << "Attr(" << R.getName() << "Attr *A) {\n"
3735 << " return true; \n"
3736 << " }\n";
3737 }
3738 OS << "\n#else // ATTR_VISITOR_DECLS_ONLY\n\n";
3739
3740 // Write individual Traverse* methods for each attribute class.
3741 for (const auto *Attr : Attrs) {
3742 const Record &R = *Attr;
3743 if (!R.getValueAsBit("ASTNode"))
3744 continue;
3745
3746 OS << "template <typename Derived>\n"
3747 << "bool VISITORCLASS<Derived>::Traverse"
3748 << R.getName() << "Attr(" << R.getName() << "Attr *A) {\n"
3749 << " if (!getDerived().VisitAttr(A))\n"
3750 << " return false;\n"
3751 << " if (!getDerived().Visit" << R.getName() << "Attr(A))\n"
3752 << " return false;\n";
3753
3754 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
3755 for (const auto *Arg : ArgRecords)
3756 createArgument(*Arg, R.getName())->writeASTVisitorTraversal(OS);
3757
3758 if (Attr->getValueAsBit("AcceptsExprPack"))
3759 VariadicExprArgument("DelayedArgs", R.getName())
3760 .writeASTVisitorTraversal(OS);
3761
3762 OS << " return true;\n";
3763 OS << "}\n\n";
3764 }
3765
3766 // Write generic Traverse routine
3767 OS << "template <typename Derived>\n"
3768 << "bool VISITORCLASS<Derived>::TraverseAttr(Attr *A) {\n"
3769 << " if (!A)\n"
3770 << " return true;\n"
3771 << "\n"
3772 << " switch (A->getKind()) {\n";
3773
3774 for (const auto *Attr : Attrs) {
3775 const Record &R = *Attr;
3776 if (!R.getValueAsBit("ASTNode"))
3777 continue;
3778
3779 OS << " case attr::" << R.getName() << ":\n"
3780 << " return getDerived().Traverse" << R.getName() << "Attr("
3781 << "cast<" << R.getName() << "Attr>(A));\n";
3782 }
3783 OS << " }\n"; // end switch
3784 OS << " llvm_unreachable(\"bad attribute kind\");\n";
3785 OS << "}\n"; // end function
3786 OS << "#endif // ATTR_VISITOR_DECLS_ONLY\n";
3787 }
3788
EmitClangAttrTemplateInstantiateHelper(const std::vector<Record * > & Attrs,raw_ostream & OS,bool AppliesToDecl)3789 void EmitClangAttrTemplateInstantiateHelper(const std::vector<Record *> &Attrs,
3790 raw_ostream &OS,
3791 bool AppliesToDecl) {
3792
3793 OS << " switch (At->getKind()) {\n";
3794 for (const auto *Attr : Attrs) {
3795 const Record &R = *Attr;
3796 if (!R.getValueAsBit("ASTNode"))
3797 continue;
3798 OS << " case attr::" << R.getName() << ": {\n";
3799 bool ShouldClone = R.getValueAsBit("Clone") &&
3800 (!AppliesToDecl ||
3801 R.getValueAsBit("MeaningfulToClassTemplateDefinition"));
3802
3803 if (!ShouldClone) {
3804 OS << " return nullptr;\n";
3805 OS << " }\n";
3806 continue;
3807 }
3808
3809 OS << " const auto *A = cast<"
3810 << R.getName() << "Attr>(At);\n";
3811 bool TDependent = R.getValueAsBit("TemplateDependent");
3812
3813 if (!TDependent) {
3814 OS << " return A->clone(C);\n";
3815 OS << " }\n";
3816 continue;
3817 }
3818
3819 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
3820 std::vector<std::unique_ptr<Argument>> Args;
3821 Args.reserve(ArgRecords.size());
3822
3823 for (const auto *ArgRecord : ArgRecords)
3824 Args.emplace_back(createArgument(*ArgRecord, R.getName()));
3825
3826 for (auto const &ai : Args)
3827 ai->writeTemplateInstantiation(OS);
3828
3829 OS << " return new (C) " << R.getName() << "Attr(C, *A";
3830 for (auto const &ai : Args) {
3831 OS << ", ";
3832 ai->writeTemplateInstantiationArgs(OS);
3833 }
3834 OS << ");\n"
3835 << " }\n";
3836 }
3837 OS << " } // end switch\n"
3838 << " llvm_unreachable(\"Unknown attribute!\");\n"
3839 << " return nullptr;\n";
3840 }
3841
3842 // Emits code to instantiate dependent attributes on templates.
EmitClangAttrTemplateInstantiate(RecordKeeper & Records,raw_ostream & OS)3843 void EmitClangAttrTemplateInstantiate(RecordKeeper &Records, raw_ostream &OS) {
3844 emitSourceFileHeader("Template instantiation code for attributes", OS,
3845 Records);
3846
3847 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
3848
3849 OS << "namespace clang {\n"
3850 << "namespace sema {\n\n"
3851 << "Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, "
3852 << "Sema &S,\n"
3853 << " const MultiLevelTemplateArgumentList &TemplateArgs) {\n";
3854 EmitClangAttrTemplateInstantiateHelper(Attrs, OS, /*AppliesToDecl*/false);
3855 OS << "}\n\n"
3856 << "Attr *instantiateTemplateAttributeForDecl(const Attr *At,\n"
3857 << " ASTContext &C, Sema &S,\n"
3858 << " const MultiLevelTemplateArgumentList &TemplateArgs) {\n";
3859 EmitClangAttrTemplateInstantiateHelper(Attrs, OS, /*AppliesToDecl*/true);
3860 OS << "}\n\n"
3861 << "} // end namespace sema\n"
3862 << "} // end namespace clang\n";
3863 }
3864
3865 // Emits the list of parsed attributes.
EmitClangAttrParsedAttrList(RecordKeeper & Records,raw_ostream & OS)3866 void EmitClangAttrParsedAttrList(RecordKeeper &Records, raw_ostream &OS) {
3867 emitSourceFileHeader("List of all attributes that Clang recognizes", OS,
3868 Records);
3869
3870 OS << "#ifndef PARSED_ATTR\n";
3871 OS << "#define PARSED_ATTR(NAME) NAME\n";
3872 OS << "#endif\n\n";
3873
3874 ParsedAttrMap Names = getParsedAttrList(Records);
3875 for (const auto &I : Names) {
3876 OS << "PARSED_ATTR(" << I.first << ")\n";
3877 }
3878 }
3879
isArgVariadic(const Record & R,StringRef AttrName)3880 static bool isArgVariadic(const Record &R, StringRef AttrName) {
3881 return createArgument(R, AttrName)->isVariadic();
3882 }
3883
emitArgInfo(const Record & R,raw_ostream & OS)3884 static void emitArgInfo(const Record &R, raw_ostream &OS) {
3885 // This function will count the number of arguments specified for the
3886 // attribute and emit the number of required arguments followed by the
3887 // number of optional arguments.
3888 std::vector<Record *> Args = R.getValueAsListOfDefs("Args");
3889 unsigned ArgCount = 0, OptCount = 0, ArgMemberCount = 0;
3890 bool HasVariadic = false;
3891 for (const auto *Arg : Args) {
3892 // If the arg is fake, it's the user's job to supply it: general parsing
3893 // logic shouldn't need to know anything about it.
3894 if (Arg->getValueAsBit("Fake"))
3895 continue;
3896 Arg->getValueAsBit("Optional") ? ++OptCount : ++ArgCount;
3897 ++ArgMemberCount;
3898 if (!HasVariadic && isArgVariadic(*Arg, R.getName()))
3899 HasVariadic = true;
3900 }
3901
3902 // If there is a variadic argument, we will set the optional argument count
3903 // to its largest value. Since it's currently a 4-bit number, we set it to 15.
3904 OS << " /*NumArgs=*/" << ArgCount << ",\n";
3905 OS << " /*OptArgs=*/" << (HasVariadic ? 15 : OptCount) << ",\n";
3906 OS << " /*NumArgMembers=*/" << ArgMemberCount << ",\n";
3907 }
3908
GetDiagnosticSpelling(const Record & R)3909 static std::string GetDiagnosticSpelling(const Record &R) {
3910 std::string Ret = std::string(R.getValueAsString("DiagSpelling"));
3911 if (!Ret.empty())
3912 return Ret;
3913
3914 // If we couldn't find the DiagSpelling in this object, we can check to see
3915 // if the object is one that has a base, and if it is, loop up to the Base
3916 // member recursively.
3917 if (auto Base = R.getValueAsOptionalDef(BaseFieldName))
3918 return GetDiagnosticSpelling(*Base);
3919
3920 return "";
3921 }
3922
CalculateDiagnostic(const Record & S)3923 static std::string CalculateDiagnostic(const Record &S) {
3924 // If the SubjectList object has a custom diagnostic associated with it,
3925 // return that directly.
3926 const StringRef CustomDiag = S.getValueAsString("CustomDiag");
3927 if (!CustomDiag.empty())
3928 return ("\"" + Twine(CustomDiag) + "\"").str();
3929
3930 std::vector<std::string> DiagList;
3931 std::vector<Record *> Subjects = S.getValueAsListOfDefs("Subjects");
3932 for (const auto *Subject : Subjects) {
3933 const Record &R = *Subject;
3934 // Get the diagnostic text from the Decl or Stmt node given.
3935 std::string V = GetDiagnosticSpelling(R);
3936 if (V.empty()) {
3937 PrintError(R.getLoc(),
3938 "Could not determine diagnostic spelling for the node: " +
3939 R.getName() + "; please add one to DeclNodes.td");
3940 } else {
3941 // The node may contain a list of elements itself, so split the elements
3942 // by a comma, and trim any whitespace.
3943 SmallVector<StringRef, 2> Frags;
3944 llvm::SplitString(V, Frags, ",");
3945 for (auto Str : Frags) {
3946 DiagList.push_back(std::string(Str.trim()));
3947 }
3948 }
3949 }
3950
3951 if (DiagList.empty()) {
3952 PrintFatalError(S.getLoc(),
3953 "Could not deduce diagnostic argument for Attr subjects");
3954 return "";
3955 }
3956
3957 // FIXME: this is not particularly good for localization purposes and ideally
3958 // should be part of the diagnostics engine itself with some sort of list
3959 // specifier.
3960
3961 // A single member of the list can be returned directly.
3962 if (DiagList.size() == 1)
3963 return '"' + DiagList.front() + '"';
3964
3965 if (DiagList.size() == 2)
3966 return '"' + DiagList[0] + " and " + DiagList[1] + '"';
3967
3968 // If there are more than two in the list, we serialize the first N - 1
3969 // elements with a comma. This leaves the string in the state: foo, bar,
3970 // baz (but misses quux). We can then add ", and " for the last element
3971 // manually.
3972 std::string Diag = llvm::join(DiagList.begin(), DiagList.end() - 1, ", ");
3973 return '"' + Diag + ", and " + *(DiagList.end() - 1) + '"';
3974 }
3975
GetSubjectWithSuffix(const Record * R)3976 static std::string GetSubjectWithSuffix(const Record *R) {
3977 const std::string &B = std::string(R->getName());
3978 if (B == "DeclBase")
3979 return "Decl";
3980 return B + "Decl";
3981 }
3982
functionNameForCustomAppertainsTo(const Record & Subject)3983 static std::string functionNameForCustomAppertainsTo(const Record &Subject) {
3984 return "is" + Subject.getName().str();
3985 }
3986
GenerateCustomAppertainsTo(const Record & Subject,raw_ostream & OS)3987 static void GenerateCustomAppertainsTo(const Record &Subject, raw_ostream &OS) {
3988 std::string FnName = functionNameForCustomAppertainsTo(Subject);
3989
3990 // If this code has already been generated, we don't need to do anything.
3991 static std::set<std::string> CustomSubjectSet;
3992 auto I = CustomSubjectSet.find(FnName);
3993 if (I != CustomSubjectSet.end())
3994 return;
3995
3996 // This only works with non-root Decls.
3997 Record *Base = Subject.getValueAsDef(BaseFieldName);
3998
3999 // Not currently support custom subjects within custom subjects.
4000 if (Base->isSubClassOf("SubsetSubject")) {
4001 PrintFatalError(Subject.getLoc(),
4002 "SubsetSubjects within SubsetSubjects is not supported");
4003 return;
4004 }
4005
4006 OS << "static bool " << FnName << "(const Decl *D) {\n";
4007 OS << " if (const auto *S = dyn_cast<";
4008 OS << GetSubjectWithSuffix(Base);
4009 OS << ">(D))\n";
4010 OS << " return " << Subject.getValueAsString("CheckCode") << ";\n";
4011 OS << " return false;\n";
4012 OS << "}\n\n";
4013
4014 CustomSubjectSet.insert(FnName);
4015 }
4016
GenerateAppertainsTo(const Record & Attr,raw_ostream & OS)4017 static void GenerateAppertainsTo(const Record &Attr, raw_ostream &OS) {
4018 // If the attribute does not contain a Subjects definition, then use the
4019 // default appertainsTo logic.
4020 if (Attr.isValueUnset("Subjects"))
4021 return;
4022
4023 const Record *SubjectObj = Attr.getValueAsDef("Subjects");
4024 std::vector<Record *> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
4025
4026 // If the list of subjects is empty, it is assumed that the attribute
4027 // appertains to everything.
4028 if (Subjects.empty())
4029 return;
4030
4031 bool Warn = SubjectObj->getValueAsDef("Diag")->getValueAsBit("Warn");
4032
4033 // Split the subjects into declaration subjects and statement subjects.
4034 // FIXME: subset subjects are added to the declaration list until there are
4035 // enough statement attributes with custom subject needs to warrant
4036 // the implementation effort.
4037 std::vector<Record *> DeclSubjects, StmtSubjects;
4038 llvm::copy_if(
4039 Subjects, std::back_inserter(DeclSubjects), [](const Record *R) {
4040 return R->isSubClassOf("SubsetSubject") || !R->isSubClassOf("StmtNode");
4041 });
4042 llvm::copy_if(Subjects, std::back_inserter(StmtSubjects),
4043 [](const Record *R) { return R->isSubClassOf("StmtNode"); });
4044
4045 // We should have sorted all of the subjects into two lists.
4046 // FIXME: this assertion will be wrong if we ever add type attribute subjects.
4047 assert(DeclSubjects.size() + StmtSubjects.size() == Subjects.size());
4048
4049 if (DeclSubjects.empty()) {
4050 // If there are no decl subjects but there are stmt subjects, diagnose
4051 // trying to apply a statement attribute to a declaration.
4052 if (!StmtSubjects.empty()) {
4053 OS << "bool diagAppertainsToDecl(Sema &S, const ParsedAttr &AL, ";
4054 OS << "const Decl *D) const override {\n";
4055 OS << " S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_decl)\n";
4056 OS << " << AL << AL.isRegularKeywordAttribute() << "
4057 "D->getLocation();\n";
4058 OS << " return false;\n";
4059 OS << "}\n\n";
4060 }
4061 } else {
4062 // Otherwise, generate an appertainsTo check specific to this attribute
4063 // which checks all of the given subjects against the Decl passed in.
4064 OS << "bool diagAppertainsToDecl(Sema &S, ";
4065 OS << "const ParsedAttr &Attr, const Decl *D) const override {\n";
4066 OS << " if (";
4067 for (auto I = DeclSubjects.begin(), E = DeclSubjects.end(); I != E; ++I) {
4068 // If the subject has custom code associated with it, use the generated
4069 // function for it. The function cannot be inlined into this check (yet)
4070 // because it requires the subject to be of a specific type, and were that
4071 // information inlined here, it would not support an attribute with
4072 // multiple custom subjects.
4073 if ((*I)->isSubClassOf("SubsetSubject"))
4074 OS << "!" << functionNameForCustomAppertainsTo(**I) << "(D)";
4075 else
4076 OS << "!isa<" << GetSubjectWithSuffix(*I) << ">(D)";
4077
4078 if (I + 1 != E)
4079 OS << " && ";
4080 }
4081 OS << ") {\n";
4082 OS << " S.Diag(Attr.getLoc(), diag::";
4083 OS << (Warn ? "warn_attribute_wrong_decl_type_str"
4084 : "err_attribute_wrong_decl_type_str");
4085 OS << ")\n";
4086 OS << " << Attr << Attr.isRegularKeywordAttribute() << ";
4087 OS << CalculateDiagnostic(*SubjectObj) << ";\n";
4088 OS << " return false;\n";
4089 OS << " }\n";
4090 OS << " return true;\n";
4091 OS << "}\n\n";
4092 }
4093
4094 if (StmtSubjects.empty()) {
4095 // If there are no stmt subjects but there are decl subjects, diagnose
4096 // trying to apply a declaration attribute to a statement.
4097 if (!DeclSubjects.empty()) {
4098 OS << "bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, ";
4099 OS << "const Stmt *St) const override {\n";
4100 OS << " S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)\n";
4101 OS << " << AL << AL.isRegularKeywordAttribute() << "
4102 "St->getBeginLoc();\n";
4103 OS << " return false;\n";
4104 OS << "}\n\n";
4105 }
4106 } else {
4107 // Now, do the same for statements.
4108 OS << "bool diagAppertainsToStmt(Sema &S, ";
4109 OS << "const ParsedAttr &Attr, const Stmt *St) const override {\n";
4110 OS << " if (";
4111 for (auto I = StmtSubjects.begin(), E = StmtSubjects.end(); I != E; ++I) {
4112 OS << "!isa<" << (*I)->getName() << ">(St)";
4113 if (I + 1 != E)
4114 OS << " && ";
4115 }
4116 OS << ") {\n";
4117 OS << " S.Diag(Attr.getLoc(), diag::";
4118 OS << (Warn ? "warn_attribute_wrong_decl_type_str"
4119 : "err_attribute_wrong_decl_type_str");
4120 OS << ")\n";
4121 OS << " << Attr << Attr.isRegularKeywordAttribute() << ";
4122 OS << CalculateDiagnostic(*SubjectObj) << ";\n";
4123 OS << " return false;\n";
4124 OS << " }\n";
4125 OS << " return true;\n";
4126 OS << "}\n\n";
4127 }
4128 }
4129
4130 // Generates the mutual exclusion checks. The checks for parsed attributes are
4131 // written into OS and the checks for merging declaration attributes are
4132 // written into MergeOS.
GenerateMutualExclusionsChecks(const Record & Attr,const RecordKeeper & Records,raw_ostream & OS,raw_ostream & MergeDeclOS,raw_ostream & MergeStmtOS)4133 static void GenerateMutualExclusionsChecks(const Record &Attr,
4134 const RecordKeeper &Records,
4135 raw_ostream &OS,
4136 raw_ostream &MergeDeclOS,
4137 raw_ostream &MergeStmtOS) {
4138 // Find all of the definitions that inherit from MutualExclusions and include
4139 // the given attribute in the list of exclusions to generate the
4140 // diagMutualExclusion() check.
4141 std::vector<Record *> ExclusionsList =
4142 Records.getAllDerivedDefinitions("MutualExclusions");
4143
4144 // We don't do any of this magic for type attributes yet.
4145 if (Attr.isSubClassOf("TypeAttr"))
4146 return;
4147
4148 // This means the attribute is either a statement attribute, a decl
4149 // attribute, or both; find out which.
4150 bool CurAttrIsStmtAttr =
4151 Attr.isSubClassOf("StmtAttr") || Attr.isSubClassOf("DeclOrStmtAttr");
4152 bool CurAttrIsDeclAttr =
4153 !CurAttrIsStmtAttr || Attr.isSubClassOf("DeclOrStmtAttr");
4154
4155 std::vector<std::string> DeclAttrs, StmtAttrs;
4156
4157 for (const Record *Exclusion : ExclusionsList) {
4158 std::vector<Record *> MutuallyExclusiveAttrs =
4159 Exclusion->getValueAsListOfDefs("Exclusions");
4160 auto IsCurAttr = [Attr](const Record *R) {
4161 return R->getName() == Attr.getName();
4162 };
4163 if (llvm::any_of(MutuallyExclusiveAttrs, IsCurAttr)) {
4164 // This list of exclusions includes the attribute we're looking for, so
4165 // add the exclusive attributes to the proper list for checking.
4166 for (const Record *AttrToExclude : MutuallyExclusiveAttrs) {
4167 if (IsCurAttr(AttrToExclude))
4168 continue;
4169
4170 if (CurAttrIsStmtAttr)
4171 StmtAttrs.push_back((AttrToExclude->getName() + "Attr").str());
4172 if (CurAttrIsDeclAttr)
4173 DeclAttrs.push_back((AttrToExclude->getName() + "Attr").str());
4174 }
4175 }
4176 }
4177
4178 // If there are any decl or stmt attributes, silence -Woverloaded-virtual
4179 // warnings for them both.
4180 if (!DeclAttrs.empty() || !StmtAttrs.empty())
4181 OS << " using ParsedAttrInfo::diagMutualExclusion;\n\n";
4182
4183 // If we discovered any decl or stmt attributes to test for, generate the
4184 // predicates for them now.
4185 if (!DeclAttrs.empty()) {
4186 // Generate the ParsedAttrInfo subclass logic for declarations.
4187 OS << " bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, "
4188 << "const Decl *D) const override {\n";
4189 for (const std::string &A : DeclAttrs) {
4190 OS << " if (const auto *A = D->getAttr<" << A << ">()) {\n";
4191 OS << " S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)"
4192 << " << AL << A << (AL.isRegularKeywordAttribute() ||"
4193 << " A->isRegularKeywordAttribute());\n";
4194 OS << " S.Diag(A->getLocation(), diag::note_conflicting_attribute);";
4195 OS << " \nreturn false;\n";
4196 OS << " }\n";
4197 }
4198 OS << " return true;\n";
4199 OS << " }\n\n";
4200
4201 // Also generate the declaration attribute merging logic if the current
4202 // attribute is one that can be inheritted on a declaration. It is assumed
4203 // this code will be executed in the context of a function with parameters:
4204 // Sema &S, Decl *D, Attr *A and that returns a bool (false on diagnostic,
4205 // true on success).
4206 if (Attr.isSubClassOf("InheritableAttr")) {
4207 MergeDeclOS << " if (const auto *Second = dyn_cast<"
4208 << (Attr.getName() + "Attr").str() << ">(A)) {\n";
4209 for (const std::string &A : DeclAttrs) {
4210 MergeDeclOS << " if (const auto *First = D->getAttr<" << A
4211 << ">()) {\n";
4212 MergeDeclOS << " S.Diag(First->getLocation(), "
4213 << "diag::err_attributes_are_not_compatible) << First << "
4214 << "Second << (First->isRegularKeywordAttribute() || "
4215 << "Second->isRegularKeywordAttribute());\n";
4216 MergeDeclOS << " S.Diag(Second->getLocation(), "
4217 << "diag::note_conflicting_attribute);\n";
4218 MergeDeclOS << " return false;\n";
4219 MergeDeclOS << " }\n";
4220 }
4221 MergeDeclOS << " return true;\n";
4222 MergeDeclOS << " }\n";
4223 }
4224 }
4225
4226 // Statement attributes are a bit different from declarations. With
4227 // declarations, each attribute is added to the declaration as it is
4228 // processed, and so you can look on the Decl * itself to see if there is a
4229 // conflicting attribute. Statement attributes are processed as a group
4230 // because AttributedStmt needs to tail-allocate all of the attribute nodes
4231 // at once. This means we cannot check whether the statement already contains
4232 // an attribute to check for the conflict. Instead, we need to check whether
4233 // the given list of semantic attributes contain any conflicts. It is assumed
4234 // this code will be executed in the context of a function with parameters:
4235 // Sema &S, const SmallVectorImpl<const Attr *> &C. The code will be within a
4236 // loop which loops over the container C with a loop variable named A to
4237 // represent the current attribute to check for conflicts.
4238 //
4239 // FIXME: it would be nice not to walk over the list of potential attributes
4240 // to apply to the statement more than once, but statements typically don't
4241 // have long lists of attributes on them, so re-walking the list should not
4242 // be an expensive operation.
4243 if (!StmtAttrs.empty()) {
4244 MergeStmtOS << " if (const auto *Second = dyn_cast<"
4245 << (Attr.getName() + "Attr").str() << ">(A)) {\n";
4246 MergeStmtOS << " auto Iter = llvm::find_if(C, [](const Attr *Check) "
4247 << "{ return isa<";
4248 interleave(
4249 StmtAttrs, [&](const std::string &Name) { MergeStmtOS << Name; },
4250 [&] { MergeStmtOS << ", "; });
4251 MergeStmtOS << ">(Check); });\n";
4252 MergeStmtOS << " if (Iter != C.end()) {\n";
4253 MergeStmtOS << " S.Diag((*Iter)->getLocation(), "
4254 << "diag::err_attributes_are_not_compatible) << *Iter << "
4255 << "Second << ((*Iter)->isRegularKeywordAttribute() || "
4256 << "Second->isRegularKeywordAttribute());\n";
4257 MergeStmtOS << " S.Diag(Second->getLocation(), "
4258 << "diag::note_conflicting_attribute);\n";
4259 MergeStmtOS << " return false;\n";
4260 MergeStmtOS << " }\n";
4261 MergeStmtOS << " }\n";
4262 }
4263 }
4264
4265 static void
emitAttributeMatchRules(PragmaClangAttributeSupport & PragmaAttributeSupport,raw_ostream & OS)4266 emitAttributeMatchRules(PragmaClangAttributeSupport &PragmaAttributeSupport,
4267 raw_ostream &OS) {
4268 OS << "static bool checkAttributeMatchRuleAppliesTo(const Decl *D, "
4269 << AttributeSubjectMatchRule::EnumName << " rule) {\n";
4270 OS << " switch (rule) {\n";
4271 for (const auto &Rule : PragmaAttributeSupport.Rules) {
4272 if (Rule.isAbstractRule()) {
4273 OS << " case " << Rule.getEnumValue() << ":\n";
4274 OS << " assert(false && \"Abstract matcher rule isn't allowed\");\n";
4275 OS << " return false;\n";
4276 continue;
4277 }
4278 std::vector<Record *> Subjects = Rule.getSubjects();
4279 assert(!Subjects.empty() && "Missing subjects");
4280 OS << " case " << Rule.getEnumValue() << ":\n";
4281 OS << " return ";
4282 for (auto I = Subjects.begin(), E = Subjects.end(); I != E; ++I) {
4283 // If the subject has custom code associated with it, use the function
4284 // that was generated for GenerateAppertainsTo to check if the declaration
4285 // is valid.
4286 if ((*I)->isSubClassOf("SubsetSubject"))
4287 OS << functionNameForCustomAppertainsTo(**I) << "(D)";
4288 else
4289 OS << "isa<" << GetSubjectWithSuffix(*I) << ">(D)";
4290
4291 if (I + 1 != E)
4292 OS << " || ";
4293 }
4294 OS << ";\n";
4295 }
4296 OS << " }\n";
4297 OS << " llvm_unreachable(\"Invalid match rule\");\nreturn false;\n";
4298 OS << "}\n\n";
4299 }
4300
GenerateLangOptRequirements(const Record & R,raw_ostream & OS)4301 static void GenerateLangOptRequirements(const Record &R,
4302 raw_ostream &OS) {
4303 // If the attribute has an empty or unset list of language requirements,
4304 // use the default handler.
4305 std::vector<Record *> LangOpts = R.getValueAsListOfDefs("LangOpts");
4306 if (LangOpts.empty())
4307 return;
4308
4309 OS << "bool acceptsLangOpts(const LangOptions &LangOpts) const override {\n";
4310 OS << " return " << GenerateTestExpression(LangOpts) << ";\n";
4311 OS << "}\n\n";
4312 }
4313
GenerateTargetRequirements(const Record & Attr,const ParsedAttrMap & Dupes,raw_ostream & OS)4314 static void GenerateTargetRequirements(const Record &Attr,
4315 const ParsedAttrMap &Dupes,
4316 raw_ostream &OS) {
4317 // If the attribute is not a target specific attribute, use the default
4318 // target handler.
4319 if (!Attr.isSubClassOf("TargetSpecificAttr"))
4320 return;
4321
4322 // Get the list of architectures to be tested for.
4323 const Record *R = Attr.getValueAsDef("Target");
4324 std::vector<StringRef> Arches = R->getValueAsListOfStrings("Arches");
4325
4326 // If there are other attributes which share the same parsed attribute kind,
4327 // such as target-specific attributes with a shared spelling, collapse the
4328 // duplicate architectures. This is required because a shared target-specific
4329 // attribute has only one ParsedAttr::Kind enumeration value, but it
4330 // applies to multiple target architectures. In order for the attribute to be
4331 // considered valid, all of its architectures need to be included.
4332 if (!Attr.isValueUnset("ParseKind")) {
4333 const StringRef APK = Attr.getValueAsString("ParseKind");
4334 for (const auto &I : Dupes) {
4335 if (I.first == APK) {
4336 std::vector<StringRef> DA =
4337 I.second->getValueAsDef("Target")->getValueAsListOfStrings(
4338 "Arches");
4339 Arches.insert(Arches.end(), DA.begin(), DA.end());
4340 }
4341 }
4342 }
4343
4344 std::string FnName = "isTarget";
4345 std::string Test;
4346 bool UsesT = GenerateTargetSpecificAttrChecks(R, Arches, Test, &FnName);
4347
4348 OS << "bool existsInTarget(const TargetInfo &Target) const override {\n";
4349 if (UsesT)
4350 OS << " const llvm::Triple &T = Target.getTriple(); (void)T;\n";
4351 OS << " return " << Test << ";\n";
4352 OS << "}\n\n";
4353 }
4354
4355 static void
GenerateSpellingTargetRequirements(const Record & Attr,const std::vector<Record * > & TargetSpellings,raw_ostream & OS)4356 GenerateSpellingTargetRequirements(const Record &Attr,
4357 const std::vector<Record *> &TargetSpellings,
4358 raw_ostream &OS) {
4359 // If there are no target specific spellings, use the default target handler.
4360 if (TargetSpellings.empty())
4361 return;
4362
4363 std::string Test;
4364 bool UsesT = false;
4365 const std::vector<FlattenedSpelling> SpellingList =
4366 GetFlattenedSpellings(Attr);
4367 for (unsigned TargetIndex = 0; TargetIndex < TargetSpellings.size();
4368 ++TargetIndex) {
4369 const auto &TargetSpelling = TargetSpellings[TargetIndex];
4370 std::vector<FlattenedSpelling> Spellings =
4371 GetFlattenedSpellings(*TargetSpelling);
4372
4373 Test += "((SpellingListIndex == ";
4374 for (unsigned Index = 0; Index < Spellings.size(); ++Index) {
4375 Test +=
4376 llvm::itostr(getSpellingListIndex(SpellingList, Spellings[Index]));
4377 if (Index != Spellings.size() - 1)
4378 Test += " ||\n SpellingListIndex == ";
4379 else
4380 Test += ") && ";
4381 }
4382
4383 const Record *Target = TargetSpelling->getValueAsDef("Target");
4384 std::vector<StringRef> Arches = Target->getValueAsListOfStrings("Arches");
4385 std::string FnName = "isTargetSpelling";
4386 UsesT |= GenerateTargetSpecificAttrChecks(Target, Arches, Test, &FnName);
4387 Test += ")";
4388 if (TargetIndex != TargetSpellings.size() - 1)
4389 Test += " || ";
4390 }
4391
4392 OS << "bool spellingExistsInTarget(const TargetInfo &Target,\n";
4393 OS << " const unsigned SpellingListIndex) const "
4394 "override {\n";
4395 if (UsesT)
4396 OS << " const llvm::Triple &T = Target.getTriple(); (void)T;\n";
4397 OS << " return " << Test << ";\n", OS << "}\n\n";
4398 }
4399
GenerateSpellingIndexToSemanticSpelling(const Record & Attr,raw_ostream & OS)4400 static void GenerateSpellingIndexToSemanticSpelling(const Record &Attr,
4401 raw_ostream &OS) {
4402 // If the attribute does not have a semantic form, we can bail out early.
4403 if (!Attr.getValueAsBit("ASTNode"))
4404 return;
4405
4406 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
4407
4408 // If there are zero or one spellings, or all of the spellings share the same
4409 // name, we can also bail out early.
4410 if (Spellings.size() <= 1 || SpellingNamesAreCommon(Spellings))
4411 return;
4412
4413 // Generate the enumeration we will use for the mapping.
4414 SemanticSpellingMap SemanticToSyntacticMap;
4415 std::string Enum = CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
4416 std::string Name = Attr.getName().str() + "AttrSpellingMap";
4417
4418 OS << "unsigned spellingIndexToSemanticSpelling(";
4419 OS << "const ParsedAttr &Attr) const override {\n";
4420 OS << Enum;
4421 OS << " unsigned Idx = Attr.getAttributeSpellingListIndex();\n";
4422 WriteSemanticSpellingSwitch("Idx", SemanticToSyntacticMap, OS);
4423 OS << "}\n\n";
4424 }
4425
GenerateHandleDeclAttribute(const Record & Attr,raw_ostream & OS)4426 static void GenerateHandleDeclAttribute(const Record &Attr, raw_ostream &OS) {
4427 // Only generate if Attr can be handled simply.
4428 if (!Attr.getValueAsBit("SimpleHandler"))
4429 return;
4430
4431 // Generate a function which just converts from ParsedAttr to the Attr type.
4432 OS << "AttrHandling handleDeclAttribute(Sema &S, Decl *D,";
4433 OS << "const ParsedAttr &Attr) const override {\n";
4434 OS << " D->addAttr(::new (S.Context) " << Attr.getName();
4435 OS << "Attr(S.Context, Attr));\n";
4436 OS << " return AttributeApplied;\n";
4437 OS << "}\n\n";
4438 }
4439
isParamExpr(const Record * Arg)4440 static bool isParamExpr(const Record *Arg) {
4441 return !Arg->getSuperClasses().empty() &&
4442 llvm::StringSwitch<bool>(
4443 Arg->getSuperClasses().back().first->getName())
4444 .Case("ExprArgument", true)
4445 .Case("VariadicExprArgument", true)
4446 .Default(false);
4447 }
4448
GenerateIsParamExpr(const Record & Attr,raw_ostream & OS)4449 void GenerateIsParamExpr(const Record &Attr, raw_ostream &OS) {
4450 OS << "bool isParamExpr(size_t N) const override {\n";
4451 OS << " return ";
4452 auto Args = Attr.getValueAsListOfDefs("Args");
4453 for (size_t I = 0; I < Args.size(); ++I)
4454 if (isParamExpr(Args[I]))
4455 OS << "(N == " << I << ") || ";
4456 OS << "false;\n";
4457 OS << "}\n\n";
4458 }
4459
GenerateHandleAttrWithDelayedArgs(RecordKeeper & Records,raw_ostream & OS)4460 void GenerateHandleAttrWithDelayedArgs(RecordKeeper &Records, raw_ostream &OS) {
4461 OS << "static void handleAttrWithDelayedArgs(Sema &S, Decl *D, ";
4462 OS << "const ParsedAttr &Attr) {\n";
4463 OS << " SmallVector<Expr *, 4> ArgExprs;\n";
4464 OS << " ArgExprs.reserve(Attr.getNumArgs());\n";
4465 OS << " for (unsigned I = 0; I < Attr.getNumArgs(); ++I) {\n";
4466 OS << " assert(!Attr.isArgIdent(I));\n";
4467 OS << " ArgExprs.push_back(Attr.getArgAsExpr(I));\n";
4468 OS << " }\n";
4469 OS << " clang::Attr *CreatedAttr = nullptr;\n";
4470 OS << " switch (Attr.getKind()) {\n";
4471 OS << " default:\n";
4472 OS << " llvm_unreachable(\"Attribute cannot hold delayed arguments.\");\n";
4473 ParsedAttrMap Attrs = getParsedAttrList(Records);
4474 for (const auto &I : Attrs) {
4475 const Record &R = *I.second;
4476 if (!R.getValueAsBit("AcceptsExprPack"))
4477 continue;
4478 OS << " case ParsedAttr::AT_" << I.first << ": {\n";
4479 OS << " CreatedAttr = " << R.getName() << "Attr::CreateWithDelayedArgs";
4480 OS << "(S.Context, ArgExprs.data(), ArgExprs.size(), Attr);\n";
4481 OS << " break;\n";
4482 OS << " }\n";
4483 }
4484 OS << " }\n";
4485 OS << " D->addAttr(CreatedAttr);\n";
4486 OS << "}\n\n";
4487 }
4488
IsKnownToGCC(const Record & Attr)4489 static bool IsKnownToGCC(const Record &Attr) {
4490 // Look at the spellings for this subject; if there are any spellings which
4491 // claim to be known to GCC, the attribute is known to GCC.
4492 return llvm::any_of(
4493 GetFlattenedSpellings(Attr),
4494 [](const FlattenedSpelling &S) { return S.knownToGCC(); });
4495 }
4496
4497 /// Emits the parsed attribute helpers
EmitClangAttrParsedAttrImpl(RecordKeeper & Records,raw_ostream & OS)4498 void EmitClangAttrParsedAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
4499 emitSourceFileHeader("Parsed attribute helpers", OS, Records);
4500
4501 OS << "#if !defined(WANT_DECL_MERGE_LOGIC) && "
4502 << "!defined(WANT_STMT_MERGE_LOGIC)\n";
4503 PragmaClangAttributeSupport &PragmaAttributeSupport =
4504 getPragmaAttributeSupport(Records);
4505
4506 // Get the list of parsed attributes, and accept the optional list of
4507 // duplicates due to the ParseKind.
4508 ParsedAttrMap Dupes;
4509 ParsedAttrMap Attrs = getParsedAttrList(Records, &Dupes);
4510
4511 // Generate all of the custom appertainsTo functions that the attributes
4512 // will be using.
4513 for (const auto &I : Attrs) {
4514 const Record &Attr = *I.second;
4515 if (Attr.isValueUnset("Subjects"))
4516 continue;
4517 const Record *SubjectObj = Attr.getValueAsDef("Subjects");
4518 for (auto Subject : SubjectObj->getValueAsListOfDefs("Subjects"))
4519 if (Subject->isSubClassOf("SubsetSubject"))
4520 GenerateCustomAppertainsTo(*Subject, OS);
4521 }
4522
4523 // This stream is used to collect all of the declaration attribute merging
4524 // logic for performing mutual exclusion checks. This gets emitted at the
4525 // end of the file in a helper function of its own.
4526 std::string DeclMergeChecks, StmtMergeChecks;
4527 raw_string_ostream MergeDeclOS(DeclMergeChecks), MergeStmtOS(StmtMergeChecks);
4528
4529 // Generate a ParsedAttrInfo struct for each of the attributes.
4530 for (auto I = Attrs.begin(), E = Attrs.end(); I != E; ++I) {
4531 // TODO: If the attribute's kind appears in the list of duplicates, that is
4532 // because it is a target-specific attribute that appears multiple times.
4533 // It would be beneficial to test whether the duplicates are "similar
4534 // enough" to each other to not cause problems. For instance, check that
4535 // the spellings are identical, and custom parsing rules match, etc.
4536
4537 // We need to generate struct instances based off ParsedAttrInfo from
4538 // ParsedAttr.cpp.
4539 const std::string &AttrName = I->first;
4540 const Record &Attr = *I->second;
4541 auto Spellings = GetFlattenedSpellings(Attr);
4542 if (!Spellings.empty()) {
4543 OS << "static constexpr ParsedAttrInfo::Spelling " << I->first
4544 << "Spellings[] = {\n";
4545 for (const auto &S : Spellings) {
4546 const std::string &RawSpelling = S.name();
4547 std::string Spelling;
4548 if (!S.nameSpace().empty())
4549 Spelling += S.nameSpace() + "::";
4550 if (S.variety() == "GNU")
4551 Spelling += NormalizeGNUAttrSpelling(RawSpelling);
4552 else
4553 Spelling += RawSpelling;
4554 OS << " {AttributeCommonInfo::AS_" << S.variety();
4555 OS << ", \"" << Spelling << "\"},\n";
4556 }
4557 OS << "};\n";
4558 }
4559
4560 std::vector<std::string> ArgNames;
4561 for (const auto &Arg : Attr.getValueAsListOfDefs("Args")) {
4562 bool UnusedUnset;
4563 if (Arg->getValueAsBitOrUnset("Fake", UnusedUnset))
4564 continue;
4565 ArgNames.push_back(Arg->getValueAsString("Name").str());
4566 for (const auto &Class : Arg->getSuperClasses()) {
4567 if (Class.first->getName().starts_with("Variadic")) {
4568 ArgNames.back().append("...");
4569 break;
4570 }
4571 }
4572 }
4573 if (!ArgNames.empty()) {
4574 OS << "static constexpr const char *" << I->first << "ArgNames[] = {\n";
4575 for (const auto &N : ArgNames)
4576 OS << '"' << N << "\",";
4577 OS << "};\n";
4578 }
4579
4580 OS << "struct ParsedAttrInfo" << I->first
4581 << " final : public ParsedAttrInfo {\n";
4582 OS << " constexpr ParsedAttrInfo" << I->first << "() : ParsedAttrInfo(\n";
4583 OS << " /*AttrKind=*/ParsedAttr::AT_" << AttrName << ",\n";
4584 emitArgInfo(Attr, OS);
4585 OS << " /*HasCustomParsing=*/";
4586 OS << Attr.getValueAsBit("HasCustomParsing") << ",\n";
4587 OS << " /*AcceptsExprPack=*/";
4588 OS << Attr.getValueAsBit("AcceptsExprPack") << ",\n";
4589 OS << " /*IsTargetSpecific=*/";
4590 OS << Attr.isSubClassOf("TargetSpecificAttr") << ",\n";
4591 OS << " /*IsType=*/";
4592 OS << (Attr.isSubClassOf("TypeAttr") || Attr.isSubClassOf("DeclOrTypeAttr"))
4593 << ",\n";
4594 OS << " /*IsStmt=*/";
4595 OS << (Attr.isSubClassOf("StmtAttr") || Attr.isSubClassOf("DeclOrStmtAttr"))
4596 << ",\n";
4597 OS << " /*IsKnownToGCC=*/";
4598 OS << IsKnownToGCC(Attr) << ",\n";
4599 OS << " /*IsSupportedByPragmaAttribute=*/";
4600 OS << PragmaAttributeSupport.isAttributedSupported(*I->second) << ",\n";
4601 if (!Spellings.empty())
4602 OS << " /*Spellings=*/" << I->first << "Spellings,\n";
4603 else
4604 OS << " /*Spellings=*/{},\n";
4605 if (!ArgNames.empty())
4606 OS << " /*ArgNames=*/" << I->first << "ArgNames";
4607 else
4608 OS << " /*ArgNames=*/{}";
4609 OS << ") {}\n";
4610 GenerateAppertainsTo(Attr, OS);
4611 GenerateMutualExclusionsChecks(Attr, Records, OS, MergeDeclOS, MergeStmtOS);
4612 GenerateLangOptRequirements(Attr, OS);
4613 GenerateTargetRequirements(Attr, Dupes, OS);
4614 GenerateSpellingTargetRequirements(
4615 Attr, Attr.getValueAsListOfDefs("TargetSpecificSpellings"), OS);
4616 GenerateSpellingIndexToSemanticSpelling(Attr, OS);
4617 PragmaAttributeSupport.generateStrictConformsTo(*I->second, OS);
4618 GenerateHandleDeclAttribute(Attr, OS);
4619 GenerateIsParamExpr(Attr, OS);
4620 OS << "static const ParsedAttrInfo" << I->first << " Instance;\n";
4621 OS << "};\n";
4622 OS << "const ParsedAttrInfo" << I->first << " ParsedAttrInfo" << I->first
4623 << "::Instance;\n";
4624 }
4625
4626 OS << "static const ParsedAttrInfo *AttrInfoMap[] = {\n";
4627 for (auto I = Attrs.begin(), E = Attrs.end(); I != E; ++I) {
4628 OS << "&ParsedAttrInfo" << I->first << "::Instance,\n";
4629 }
4630 OS << "};\n\n";
4631
4632 // Generate function for handling attributes with delayed arguments
4633 GenerateHandleAttrWithDelayedArgs(Records, OS);
4634
4635 // Generate the attribute match rules.
4636 emitAttributeMatchRules(PragmaAttributeSupport, OS);
4637
4638 OS << "#elif defined(WANT_DECL_MERGE_LOGIC)\n\n";
4639
4640 // Write out the declaration merging check logic.
4641 OS << "static bool DiagnoseMutualExclusions(Sema &S, const NamedDecl *D, "
4642 << "const Attr *A) {\n";
4643 OS << MergeDeclOS.str();
4644 OS << " return true;\n";
4645 OS << "}\n\n";
4646
4647 OS << "#elif defined(WANT_STMT_MERGE_LOGIC)\n\n";
4648
4649 // Write out the statement merging check logic.
4650 OS << "static bool DiagnoseMutualExclusions(Sema &S, "
4651 << "const SmallVectorImpl<const Attr *> &C) {\n";
4652 OS << " for (const Attr *A : C) {\n";
4653 OS << MergeStmtOS.str();
4654 OS << " }\n";
4655 OS << " return true;\n";
4656 OS << "}\n\n";
4657
4658 OS << "#endif\n";
4659 }
4660
4661 // Emits the kind list of parsed attributes
EmitClangAttrParsedAttrKinds(RecordKeeper & Records,raw_ostream & OS)4662 void EmitClangAttrParsedAttrKinds(RecordKeeper &Records, raw_ostream &OS) {
4663 emitSourceFileHeader("Attribute name matcher", OS, Records);
4664
4665 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
4666 std::vector<StringMatcher::StringPair> GNU, Declspec, Microsoft, CXX11,
4667 Keywords, Pragma, C23, HLSLSemantic;
4668 std::set<std::string> Seen;
4669 for (const auto *A : Attrs) {
4670 const Record &Attr = *A;
4671
4672 bool SemaHandler = Attr.getValueAsBit("SemaHandler");
4673 bool Ignored = Attr.getValueAsBit("Ignored");
4674 if (SemaHandler || Ignored) {
4675 // Attribute spellings can be shared between target-specific attributes,
4676 // and can be shared between syntaxes for the same attribute. For
4677 // instance, an attribute can be spelled GNU<"interrupt"> for an ARM-
4678 // specific attribute, or MSP430-specific attribute. Additionally, an
4679 // attribute can be spelled GNU<"dllexport"> and Declspec<"dllexport">
4680 // for the same semantic attribute. Ultimately, we need to map each of
4681 // these to a single AttributeCommonInfo::Kind value, but the
4682 // StringMatcher class cannot handle duplicate match strings. So we
4683 // generate a list of string to match based on the syntax, and emit
4684 // multiple string matchers depending on the syntax used.
4685 std::string AttrName;
4686 if (Attr.isSubClassOf("TargetSpecificAttr") &&
4687 !Attr.isValueUnset("ParseKind")) {
4688 AttrName = std::string(Attr.getValueAsString("ParseKind"));
4689 if (!Seen.insert(AttrName).second)
4690 continue;
4691 } else
4692 AttrName = NormalizeAttrName(StringRef(Attr.getName())).str();
4693
4694 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
4695 for (const auto &S : Spellings) {
4696 const std::string &RawSpelling = S.name();
4697 std::vector<StringMatcher::StringPair> *Matches = nullptr;
4698 std::string Spelling;
4699 const std::string &Variety = S.variety();
4700 if (Variety == "CXX11") {
4701 Matches = &CXX11;
4702 if (!S.nameSpace().empty())
4703 Spelling += S.nameSpace() + "::";
4704 } else if (Variety == "C23") {
4705 Matches = &C23;
4706 if (!S.nameSpace().empty())
4707 Spelling += S.nameSpace() + "::";
4708 } else if (Variety == "GNU")
4709 Matches = &GNU;
4710 else if (Variety == "Declspec")
4711 Matches = &Declspec;
4712 else if (Variety == "Microsoft")
4713 Matches = &Microsoft;
4714 else if (Variety == "Keyword")
4715 Matches = &Keywords;
4716 else if (Variety == "Pragma")
4717 Matches = &Pragma;
4718 else if (Variety == "HLSLSemantic")
4719 Matches = &HLSLSemantic;
4720
4721 assert(Matches && "Unsupported spelling variety found");
4722
4723 if (Variety == "GNU")
4724 Spelling += NormalizeGNUAttrSpelling(RawSpelling);
4725 else
4726 Spelling += RawSpelling;
4727
4728 if (SemaHandler)
4729 Matches->push_back(StringMatcher::StringPair(
4730 Spelling, "return AttributeCommonInfo::AT_" + AttrName + ";"));
4731 else
4732 Matches->push_back(StringMatcher::StringPair(
4733 Spelling, "return AttributeCommonInfo::IgnoredAttribute;"));
4734 }
4735 }
4736 }
4737
4738 OS << "static AttributeCommonInfo::Kind getAttrKind(StringRef Name, ";
4739 OS << "AttributeCommonInfo::Syntax Syntax) {\n";
4740 OS << " if (AttributeCommonInfo::AS_GNU == Syntax) {\n";
4741 StringMatcher("Name", GNU, OS).Emit();
4742 OS << " } else if (AttributeCommonInfo::AS_Declspec == Syntax) {\n";
4743 StringMatcher("Name", Declspec, OS).Emit();
4744 OS << " } else if (AttributeCommonInfo::AS_Microsoft == Syntax) {\n";
4745 StringMatcher("Name", Microsoft, OS).Emit();
4746 OS << " } else if (AttributeCommonInfo::AS_CXX11 == Syntax) {\n";
4747 StringMatcher("Name", CXX11, OS).Emit();
4748 OS << " } else if (AttributeCommonInfo::AS_C23 == Syntax) {\n";
4749 StringMatcher("Name", C23, OS).Emit();
4750 OS << " } else if (AttributeCommonInfo::AS_Keyword == Syntax || ";
4751 OS << "AttributeCommonInfo::AS_ContextSensitiveKeyword == Syntax) {\n";
4752 StringMatcher("Name", Keywords, OS).Emit();
4753 OS << " } else if (AttributeCommonInfo::AS_Pragma == Syntax) {\n";
4754 StringMatcher("Name", Pragma, OS).Emit();
4755 OS << " } else if (AttributeCommonInfo::AS_HLSLSemantic == Syntax) {\n";
4756 StringMatcher("Name", HLSLSemantic, OS).Emit();
4757 OS << " }\n";
4758 OS << " return AttributeCommonInfo::UnknownAttribute;\n"
4759 << "}\n";
4760 }
4761
4762 // Emits the code to dump an attribute.
EmitClangAttrTextNodeDump(RecordKeeper & Records,raw_ostream & OS)4763 void EmitClangAttrTextNodeDump(RecordKeeper &Records, raw_ostream &OS) {
4764 emitSourceFileHeader("Attribute text node dumper", OS, Records);
4765
4766 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
4767 for (const auto *Attr : Attrs) {
4768 const Record &R = *Attr;
4769 if (!R.getValueAsBit("ASTNode"))
4770 continue;
4771
4772 // If the attribute has a semantically-meaningful name (which is determined
4773 // by whether there is a Spelling enumeration for it), then write out the
4774 // spelling used for the attribute.
4775
4776 std::string FunctionContent;
4777 llvm::raw_string_ostream SS(FunctionContent);
4778
4779 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
4780 if (Spellings.size() > 1 && !SpellingNamesAreCommon(Spellings))
4781 SS << " OS << \" \" << A->getSpelling();\n";
4782
4783 Args = R.getValueAsListOfDefs("Args");
4784 for (const auto *Arg : Args)
4785 createArgument(*Arg, R.getName())->writeDump(SS);
4786
4787 if (Attr->getValueAsBit("AcceptsExprPack"))
4788 VariadicExprArgument("DelayedArgs", R.getName()).writeDump(OS);
4789
4790 if (SS.tell()) {
4791 OS << " void Visit" << R.getName() << "Attr(const " << R.getName()
4792 << "Attr *A) {\n";
4793 if (!Args.empty())
4794 OS << " const auto *SA = cast<" << R.getName()
4795 << "Attr>(A); (void)SA;\n";
4796 OS << SS.str();
4797 OS << " }\n";
4798 }
4799 }
4800 }
4801
EmitClangAttrNodeTraverse(RecordKeeper & Records,raw_ostream & OS)4802 void EmitClangAttrNodeTraverse(RecordKeeper &Records, raw_ostream &OS) {
4803 emitSourceFileHeader("Attribute text node traverser", OS, Records);
4804
4805 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
4806 for (const auto *Attr : Attrs) {
4807 const Record &R = *Attr;
4808 if (!R.getValueAsBit("ASTNode"))
4809 continue;
4810
4811 std::string FunctionContent;
4812 llvm::raw_string_ostream SS(FunctionContent);
4813
4814 Args = R.getValueAsListOfDefs("Args");
4815 for (const auto *Arg : Args)
4816 createArgument(*Arg, R.getName())->writeDumpChildren(SS);
4817 if (Attr->getValueAsBit("AcceptsExprPack"))
4818 VariadicExprArgument("DelayedArgs", R.getName()).writeDumpChildren(SS);
4819 if (SS.tell()) {
4820 OS << " void Visit" << R.getName() << "Attr(const " << R.getName()
4821 << "Attr *A) {\n";
4822 if (!Args.empty())
4823 OS << " const auto *SA = cast<" << R.getName()
4824 << "Attr>(A); (void)SA;\n";
4825 OS << SS.str();
4826 OS << " }\n";
4827 }
4828 }
4829 }
4830
EmitClangAttrParserStringSwitches(RecordKeeper & Records,raw_ostream & OS)4831 void EmitClangAttrParserStringSwitches(RecordKeeper &Records, raw_ostream &OS) {
4832 emitSourceFileHeader("Parser-related llvm::StringSwitch cases", OS, Records);
4833 emitClangAttrArgContextList(Records, OS);
4834 emitClangAttrIdentifierArgList(Records, OS);
4835 emitClangAttrUnevaluatedStringLiteralList(Records, OS);
4836 emitClangAttrVariadicIdentifierArgList(Records, OS);
4837 emitClangAttrThisIsaIdentifierArgList(Records, OS);
4838 emitClangAttrAcceptsExprPack(Records, OS);
4839 emitClangAttrTypeArgList(Records, OS);
4840 emitClangAttrLateParsedList(Records, OS);
4841 }
4842
EmitClangAttrSubjectMatchRulesParserStringSwitches(RecordKeeper & Records,raw_ostream & OS)4843 void EmitClangAttrSubjectMatchRulesParserStringSwitches(RecordKeeper &Records,
4844 raw_ostream &OS) {
4845 getPragmaAttributeSupport(Records).generateParsingHelpers(OS);
4846 }
4847
EmitClangAttrDocTable(RecordKeeper & Records,raw_ostream & OS)4848 void EmitClangAttrDocTable(RecordKeeper &Records, raw_ostream &OS) {
4849 emitSourceFileHeader("Clang attribute documentation", OS, Records);
4850
4851 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
4852 for (const auto *A : Attrs) {
4853 if (!A->getValueAsBit("ASTNode"))
4854 continue;
4855 std::vector<Record *> Docs = A->getValueAsListOfDefs("Documentation");
4856 assert(!Docs.empty());
4857 // Only look at the first documentation if there are several.
4858 // (Currently there's only one such attr, revisit if this becomes common).
4859 StringRef Text =
4860 Docs.front()->getValueAsOptionalString("Content").value_or("");
4861 OS << "\nstatic const char AttrDoc_" << A->getName() << "[] = "
4862 << "R\"reST(" << Text.trim() << ")reST\";\n";
4863 }
4864 }
4865
4866 enum class SpellingKind : size_t {
4867 GNU,
4868 CXX11,
4869 C23,
4870 Declspec,
4871 Microsoft,
4872 Keyword,
4873 Pragma,
4874 HLSLSemantic,
4875 NumSpellingKinds
4876 };
4877 static const size_t NumSpellingKinds = (size_t)SpellingKind::NumSpellingKinds;
4878
4879 class SpellingList {
4880 std::vector<std::string> Spellings[NumSpellingKinds];
4881
4882 public:
operator [](SpellingKind K) const4883 ArrayRef<std::string> operator[](SpellingKind K) const {
4884 return Spellings[(size_t)K];
4885 }
4886
add(const Record & Attr,FlattenedSpelling Spelling)4887 void add(const Record &Attr, FlattenedSpelling Spelling) {
4888 SpellingKind Kind = StringSwitch<SpellingKind>(Spelling.variety())
4889 .Case("GNU", SpellingKind::GNU)
4890 .Case("CXX11", SpellingKind::CXX11)
4891 .Case("C23", SpellingKind::C23)
4892 .Case("Declspec", SpellingKind::Declspec)
4893 .Case("Microsoft", SpellingKind::Microsoft)
4894 .Case("Keyword", SpellingKind::Keyword)
4895 .Case("Pragma", SpellingKind::Pragma)
4896 .Case("HLSLSemantic", SpellingKind::HLSLSemantic);
4897 std::string Name;
4898 if (!Spelling.nameSpace().empty()) {
4899 switch (Kind) {
4900 case SpellingKind::CXX11:
4901 case SpellingKind::C23:
4902 Name = Spelling.nameSpace() + "::";
4903 break;
4904 case SpellingKind::Pragma:
4905 Name = Spelling.nameSpace() + " ";
4906 break;
4907 default:
4908 PrintFatalError(Attr.getLoc(), "Unexpected namespace in spelling");
4909 }
4910 }
4911 Name += Spelling.name();
4912
4913 Spellings[(size_t)Kind].push_back(Name);
4914 }
4915 };
4916
4917 class DocumentationData {
4918 public:
4919 const Record *Documentation;
4920 const Record *Attribute;
4921 std::string Heading;
4922 SpellingList SupportedSpellings;
4923
DocumentationData(const Record & Documentation,const Record & Attribute,std::pair<std::string,SpellingList> HeadingAndSpellings)4924 DocumentationData(const Record &Documentation, const Record &Attribute,
4925 std::pair<std::string, SpellingList> HeadingAndSpellings)
4926 : Documentation(&Documentation), Attribute(&Attribute),
4927 Heading(std::move(HeadingAndSpellings.first)),
4928 SupportedSpellings(std::move(HeadingAndSpellings.second)) {}
4929 };
4930
WriteCategoryHeader(const Record * DocCategory,raw_ostream & OS)4931 static void WriteCategoryHeader(const Record *DocCategory,
4932 raw_ostream &OS) {
4933 const StringRef Name = DocCategory->getValueAsString("Name");
4934 OS << Name << "\n" << std::string(Name.size(), '=') << "\n";
4935
4936 // If there is content, print that as well.
4937 const StringRef ContentStr = DocCategory->getValueAsString("Content");
4938 // Trim leading and trailing newlines and spaces.
4939 OS << ContentStr.trim();
4940
4941 OS << "\n\n";
4942 }
4943
4944 static std::pair<std::string, SpellingList>
GetAttributeHeadingAndSpellings(const Record & Documentation,const Record & Attribute,StringRef Cat)4945 GetAttributeHeadingAndSpellings(const Record &Documentation,
4946 const Record &Attribute,
4947 StringRef Cat) {
4948 // FIXME: there is no way to have a per-spelling category for the attribute
4949 // documentation. This may not be a limiting factor since the spellings
4950 // should generally be consistently applied across the category.
4951
4952 std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attribute);
4953 if (Spellings.empty())
4954 PrintFatalError(Attribute.getLoc(),
4955 "Attribute has no supported spellings; cannot be "
4956 "documented");
4957
4958 // Determine the heading to be used for this attribute.
4959 std::string Heading = std::string(Documentation.getValueAsString("Heading"));
4960 if (Heading.empty()) {
4961 // If there's only one spelling, we can simply use that.
4962 if (Spellings.size() == 1)
4963 Heading = Spellings.begin()->name();
4964 else {
4965 std::set<std::string> Uniques;
4966 for (auto I = Spellings.begin(), E = Spellings.end();
4967 I != E; ++I) {
4968 std::string Spelling =
4969 std::string(NormalizeNameForSpellingComparison(I->name()));
4970 Uniques.insert(Spelling);
4971 }
4972 // If the semantic map has only one spelling, that is sufficient for our
4973 // needs.
4974 if (Uniques.size() == 1)
4975 Heading = *Uniques.begin();
4976 // If it's in the undocumented category, just construct a header by
4977 // concatenating all the spellings. Might not be great, but better than
4978 // nothing.
4979 else if (Cat == "Undocumented")
4980 Heading = llvm::join(Uniques.begin(), Uniques.end(), ", ");
4981 }
4982 }
4983
4984 // If the heading is still empty, it is an error.
4985 if (Heading.empty())
4986 PrintFatalError(Attribute.getLoc(),
4987 "This attribute requires a heading to be specified");
4988
4989 SpellingList SupportedSpellings;
4990 for (const auto &I : Spellings)
4991 SupportedSpellings.add(Attribute, I);
4992
4993 return std::make_pair(std::move(Heading), std::move(SupportedSpellings));
4994 }
4995
WriteDocumentation(RecordKeeper & Records,const DocumentationData & Doc,raw_ostream & OS)4996 static void WriteDocumentation(RecordKeeper &Records,
4997 const DocumentationData &Doc, raw_ostream &OS) {
4998 OS << Doc.Heading << "\n" << std::string(Doc.Heading.length(), '-') << "\n";
4999
5000 // List what spelling syntaxes the attribute supports.
5001 // Note: "#pragma clang attribute" is handled outside the spelling kinds loop
5002 // so it must be last.
5003 OS << ".. csv-table:: Supported Syntaxes\n";
5004 OS << " :header: \"GNU\", \"C++11\", \"C23\", \"``__declspec``\",";
5005 OS << " \"Keyword\", \"``#pragma``\", \"HLSL Semantic\", \"``#pragma clang ";
5006 OS << "attribute``\"\n\n \"";
5007 for (size_t Kind = 0; Kind != NumSpellingKinds; ++Kind) {
5008 SpellingKind K = (SpellingKind)Kind;
5009 // TODO: List Microsoft (IDL-style attribute) spellings once we fully
5010 // support them.
5011 if (K == SpellingKind::Microsoft)
5012 continue;
5013
5014 bool PrintedAny = false;
5015 for (StringRef Spelling : Doc.SupportedSpellings[K]) {
5016 if (PrintedAny)
5017 OS << " |br| ";
5018 OS << "``" << Spelling << "``";
5019 PrintedAny = true;
5020 }
5021
5022 OS << "\",\"";
5023 }
5024
5025 if (getPragmaAttributeSupport(Records).isAttributedSupported(
5026 *Doc.Attribute))
5027 OS << "Yes";
5028 OS << "\"\n\n";
5029
5030 // If the attribute is deprecated, print a message about it, and possibly
5031 // provide a replacement attribute.
5032 if (!Doc.Documentation->isValueUnset("Deprecated")) {
5033 OS << "This attribute has been deprecated, and may be removed in a future "
5034 << "version of Clang.";
5035 const Record &Deprecated = *Doc.Documentation->getValueAsDef("Deprecated");
5036 const StringRef Replacement = Deprecated.getValueAsString("Replacement");
5037 if (!Replacement.empty())
5038 OS << " This attribute has been superseded by ``" << Replacement
5039 << "``.";
5040 OS << "\n\n";
5041 }
5042
5043 const StringRef ContentStr = Doc.Documentation->getValueAsString("Content");
5044 // Trim leading and trailing newlines and spaces.
5045 OS << ContentStr.trim();
5046
5047 OS << "\n\n\n";
5048 }
5049
EmitClangAttrDocs(RecordKeeper & Records,raw_ostream & OS)5050 void EmitClangAttrDocs(RecordKeeper &Records, raw_ostream &OS) {
5051 // Get the documentation introduction paragraph.
5052 const Record *Documentation = Records.getDef("GlobalDocumentation");
5053 if (!Documentation) {
5054 PrintFatalError("The Documentation top-level definition is missing, "
5055 "no documentation will be generated.");
5056 return;
5057 }
5058
5059 OS << Documentation->getValueAsString("Intro") << "\n";
5060
5061 // Gather the Documentation lists from each of the attributes, based on the
5062 // category provided.
5063 std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
5064 struct CategoryLess {
5065 bool operator()(const Record *L, const Record *R) const {
5066 return L->getValueAsString("Name") < R->getValueAsString("Name");
5067 }
5068 };
5069 std::map<const Record *, std::vector<DocumentationData>, CategoryLess>
5070 SplitDocs;
5071 for (const auto *A : Attrs) {
5072 const Record &Attr = *A;
5073 std::vector<Record *> Docs = Attr.getValueAsListOfDefs("Documentation");
5074 for (const auto *D : Docs) {
5075 const Record &Doc = *D;
5076 const Record *Category = Doc.getValueAsDef("Category");
5077 // If the category is "InternalOnly", then there cannot be any other
5078 // documentation categories (otherwise, the attribute would be
5079 // emitted into the docs).
5080 const StringRef Cat = Category->getValueAsString("Name");
5081 bool InternalOnly = Cat == "InternalOnly";
5082 if (InternalOnly && Docs.size() > 1)
5083 PrintFatalError(Doc.getLoc(),
5084 "Attribute is \"InternalOnly\", but has multiple "
5085 "documentation categories");
5086
5087 if (!InternalOnly)
5088 SplitDocs[Category].push_back(DocumentationData(
5089 Doc, Attr, GetAttributeHeadingAndSpellings(Doc, Attr, Cat)));
5090 }
5091 }
5092
5093 // Having split the attributes out based on what documentation goes where,
5094 // we can begin to generate sections of documentation.
5095 for (auto &I : SplitDocs) {
5096 WriteCategoryHeader(I.first, OS);
5097
5098 llvm::sort(I.second,
5099 [](const DocumentationData &D1, const DocumentationData &D2) {
5100 return D1.Heading < D2.Heading;
5101 });
5102
5103 // Walk over each of the attributes in the category and write out their
5104 // documentation.
5105 for (const auto &Doc : I.second)
5106 WriteDocumentation(Records, Doc, OS);
5107 }
5108 }
5109
EmitTestPragmaAttributeSupportedAttributes(RecordKeeper & Records,raw_ostream & OS)5110 void EmitTestPragmaAttributeSupportedAttributes(RecordKeeper &Records,
5111 raw_ostream &OS) {
5112 PragmaClangAttributeSupport Support = getPragmaAttributeSupport(Records);
5113 ParsedAttrMap Attrs = getParsedAttrList(Records);
5114 OS << "#pragma clang attribute supports the following attributes:\n";
5115 for (const auto &I : Attrs) {
5116 if (!Support.isAttributedSupported(*I.second))
5117 continue;
5118 OS << I.first;
5119 if (I.second->isValueUnset("Subjects")) {
5120 OS << " ()\n";
5121 continue;
5122 }
5123 const Record *SubjectObj = I.second->getValueAsDef("Subjects");
5124 std::vector<Record *> Subjects =
5125 SubjectObj->getValueAsListOfDefs("Subjects");
5126 OS << " (";
5127 bool PrintComma = false;
5128 for (const auto &Subject : llvm::enumerate(Subjects)) {
5129 if (!isSupportedPragmaClangAttributeSubject(*Subject.value()))
5130 continue;
5131 if (PrintComma)
5132 OS << ", ";
5133 PrintComma = true;
5134 PragmaClangAttributeSupport::RuleOrAggregateRuleSet &RuleSet =
5135 Support.SubjectsToRules.find(Subject.value())->getSecond();
5136 if (RuleSet.isRule()) {
5137 OS << RuleSet.getRule().getEnumValueName();
5138 continue;
5139 }
5140 OS << "(";
5141 for (const auto &Rule : llvm::enumerate(RuleSet.getAggregateRuleSet())) {
5142 if (Rule.index())
5143 OS << ", ";
5144 OS << Rule.value().getEnumValueName();
5145 }
5146 OS << ")";
5147 }
5148 OS << ")\n";
5149 }
5150 OS << "End of supported attributes.\n";
5151 }
5152
5153 } // end namespace clang
5154