1 //===- ClangAttrEmitter.cpp - Generate Clang attribute handling =-*- C++ -*--=//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // These tablegen backends emit Clang attribute processing code
12 //===----------------------------------------------------------------------===//
14 #include "llvm/ADT/SmallString.h"
15 #include "llvm/ADT/StringSwitch.h"
16 #include "llvm/TableGen/Record.h"
17 #include "llvm/TableGen/StringMatcher.h"
18 #include "llvm/TableGen/TableGenBackend.h"
24 static const std::vector<StringRef>
25 getValueAsListOfStrings(Record &R, StringRef FieldName) {
26 ListInit *List = R.getValueAsListInit(FieldName);
27 assert (List && "Got a null ListInit");
29 std::vector<StringRef> Strings;
30 Strings.reserve(List->getSize());
32 for (ListInit::const_iterator i = List->begin(), e = List->end();
35 assert(*i && "Got a null element in a ListInit");
36 if (StringInit *S = dyn_cast<StringInit>(*i))
37 Strings.push_back(S->getValue());
39 assert(false && "Got a non-string, non-code element in a ListInit");
45 static std::string ReadPCHRecord(StringRef type) {
46 return StringSwitch<std::string>(type)
47 .EndsWith("Decl *", "GetLocalDeclAs<"
48 + std::string(type, 0, type.size()-1) + ">(F, Record[Idx++])")
49 .Case("QualType", "getLocalType(F, Record[Idx++])")
50 .Case("Expr *", "ReadExpr(F)")
51 .Case("IdentifierInfo *", "GetIdentifierInfo(F, Record, Idx)")
52 .Case("SourceLocation", "ReadSourceLocation(F, Record, Idx)")
53 .Default("Record[Idx++]");
56 // Assumes that the way to get the value is SA->getname()
57 static std::string WritePCHRecord(StringRef type, StringRef name) {
58 return StringSwitch<std::string>(type)
59 .EndsWith("Decl *", "AddDeclRef(" + std::string(name) +
61 .Case("QualType", "AddTypeRef(" + std::string(name) + ", Record);\n")
62 .Case("Expr *", "AddStmt(" + std::string(name) + ");\n")
63 .Case("IdentifierInfo *",
64 "AddIdentifierRef(" + std::string(name) + ", Record);\n")
65 .Case("SourceLocation",
66 "AddSourceLocation(" + std::string(name) + ", Record);\n")
67 .Default("Record.push_back(" + std::string(name) + ");\n");
70 // Normalize attribute name by removing leading and trailing
71 // underscores. For example, __foo, foo__, __foo__ would
73 static StringRef NormalizeAttrName(StringRef AttrName) {
74 if (AttrName.startswith("__"))
75 AttrName = AttrName.substr(2, AttrName.size());
77 if (AttrName.endswith("__"))
78 AttrName = AttrName.substr(0, AttrName.size() - 2);
83 // Normalize attribute spelling only if the spelling has both leading
84 // and trailing underscores. For example, __ms_struct__ will be
85 // normalized to "ms_struct"; __cdecl will remain intact.
86 static StringRef NormalizeAttrSpelling(StringRef AttrSpelling) {
87 if (AttrSpelling.startswith("__") && AttrSpelling.endswith("__")) {
88 AttrSpelling = AttrSpelling.substr(2, AttrSpelling.size() - 4);
96 std::string lowerName, upperName;
100 Argument(Record &Arg, StringRef Attr)
101 : lowerName(Arg.getValueAsString("Name")), upperName(lowerName),
103 if (!lowerName.empty()) {
104 lowerName[0] = std::tolower(lowerName[0]);
105 upperName[0] = std::toupper(upperName[0]);
108 virtual ~Argument() {}
110 StringRef getLowerName() const { return lowerName; }
111 StringRef getUpperName() const { return upperName; }
112 StringRef getAttrName() const { return attrName; }
114 // These functions print the argument contents formatted in different ways.
115 virtual void writeAccessors(raw_ostream &OS) const = 0;
116 virtual void writeAccessorDefinitions(raw_ostream &OS) const {}
117 virtual void writeCloneArgs(raw_ostream &OS) const = 0;
118 virtual void writeTemplateInstantiationArgs(raw_ostream &OS) const = 0;
119 virtual void writeTemplateInstantiation(raw_ostream &OS) const {}
120 virtual void writeCtorBody(raw_ostream &OS) const {}
121 virtual void writeCtorInitializers(raw_ostream &OS) const = 0;
122 virtual void writeCtorParameters(raw_ostream &OS) const = 0;
123 virtual void writeDeclarations(raw_ostream &OS) const = 0;
124 virtual void writePCHReadArgs(raw_ostream &OS) const = 0;
125 virtual void writePCHReadDecls(raw_ostream &OS) const = 0;
126 virtual void writePCHWrite(raw_ostream &OS) const = 0;
127 virtual void writeValue(raw_ostream &OS) const = 0;
128 virtual void writeDump(raw_ostream &OS) const = 0;
129 virtual void writeDumpChildren(raw_ostream &OS) const {}
130 virtual void writeHasChildren(raw_ostream &OS) const { OS << "false"; }
133 class SimpleArgument : public Argument {
137 SimpleArgument(Record &Arg, StringRef Attr, std::string T)
138 : Argument(Arg, Attr), type(T)
141 std::string getType() const { return type; }
143 void writeAccessors(raw_ostream &OS) const {
144 OS << " " << type << " get" << getUpperName() << "() const {\n";
145 OS << " return " << getLowerName() << ";\n";
148 void writeCloneArgs(raw_ostream &OS) const {
149 OS << getLowerName();
151 void writeTemplateInstantiationArgs(raw_ostream &OS) const {
152 OS << "A->get" << getUpperName() << "()";
154 void writeCtorInitializers(raw_ostream &OS) const {
155 OS << getLowerName() << "(" << getUpperName() << ")";
157 void writeCtorParameters(raw_ostream &OS) const {
158 OS << type << " " << getUpperName();
160 void writeDeclarations(raw_ostream &OS) const {
161 OS << type << " " << getLowerName() << ";";
163 void writePCHReadDecls(raw_ostream &OS) const {
164 std::string read = ReadPCHRecord(type);
165 OS << " " << type << " " << getLowerName() << " = " << read << ";\n";
167 void writePCHReadArgs(raw_ostream &OS) const {
168 OS << getLowerName();
170 void writePCHWrite(raw_ostream &OS) const {
171 OS << " " << WritePCHRecord(type, "SA->get" +
172 std::string(getUpperName()) + "()");
174 void writeValue(raw_ostream &OS) const {
175 if (type == "FunctionDecl *") {
176 OS << "\" << get" << getUpperName() << "()->getNameInfo().getAsString() << \"";
177 } else if (type == "IdentifierInfo *") {
178 OS << "\" << get" << getUpperName() << "()->getName() << \"";
179 } else if (type == "QualType") {
180 OS << "\" << get" << getUpperName() << "().getAsString() << \"";
181 } else if (type == "SourceLocation") {
182 OS << "\" << get" << getUpperName() << "().getRawEncoding() << \"";
184 OS << "\" << get" << getUpperName() << "() << \"";
187 void writeDump(raw_ostream &OS) const {
188 if (type == "FunctionDecl *") {
189 OS << " OS << \" \";\n";
190 OS << " dumpBareDeclRef(SA->get" << getUpperName() << "());\n";
191 } else if (type == "IdentifierInfo *") {
192 OS << " OS << \" \" << SA->get" << getUpperName()
193 << "()->getName();\n";
194 } else if (type == "QualType") {
195 OS << " OS << \" \" << SA->get" << getUpperName()
196 << "().getAsString();\n";
197 } else if (type == "SourceLocation") {
198 OS << " OS << \" \";\n";
199 OS << " SA->get" << getUpperName() << "().print(OS, *SM);\n";
200 } else if (type == "bool") {
201 OS << " if (SA->get" << getUpperName() << "()) OS << \" "
202 << getUpperName() << "\";\n";
203 } else if (type == "int" || type == "unsigned") {
204 OS << " OS << \" \" << SA->get" << getUpperName() << "();\n";
206 llvm_unreachable("Unknown SimpleArgument type!");
211 class StringArgument : public Argument {
213 StringArgument(Record &Arg, StringRef Attr)
214 : Argument(Arg, Attr)
217 void writeAccessors(raw_ostream &OS) const {
218 OS << " llvm::StringRef get" << getUpperName() << "() const {\n";
219 OS << " return llvm::StringRef(" << getLowerName() << ", "
220 << getLowerName() << "Length);\n";
222 OS << " unsigned get" << getUpperName() << "Length() const {\n";
223 OS << " return " << getLowerName() << "Length;\n";
225 OS << " void set" << getUpperName()
226 << "(ASTContext &C, llvm::StringRef S) {\n";
227 OS << " " << getLowerName() << "Length = S.size();\n";
228 OS << " this->" << getLowerName() << " = new (C, 1) char ["
229 << getLowerName() << "Length];\n";
230 OS << " std::memcpy(this->" << getLowerName() << ", S.data(), "
231 << getLowerName() << "Length);\n";
234 void writeCloneArgs(raw_ostream &OS) const {
235 OS << "get" << getUpperName() << "()";
237 void writeTemplateInstantiationArgs(raw_ostream &OS) const {
238 OS << "A->get" << getUpperName() << "()";
240 void writeCtorBody(raw_ostream &OS) const {
241 OS << " std::memcpy(" << getLowerName() << ", " << getUpperName()
242 << ".data(), " << getLowerName() << "Length);";
244 void writeCtorInitializers(raw_ostream &OS) const {
245 OS << getLowerName() << "Length(" << getUpperName() << ".size()),"
246 << getLowerName() << "(new (Ctx, 1) char[" << getLowerName()
249 void writeCtorParameters(raw_ostream &OS) const {
250 OS << "llvm::StringRef " << getUpperName();
252 void writeDeclarations(raw_ostream &OS) const {
253 OS << "unsigned " << getLowerName() << "Length;\n";
254 OS << "char *" << getLowerName() << ";";
256 void writePCHReadDecls(raw_ostream &OS) const {
257 OS << " std::string " << getLowerName()
258 << "= ReadString(Record, Idx);\n";
260 void writePCHReadArgs(raw_ostream &OS) const {
261 OS << getLowerName();
263 void writePCHWrite(raw_ostream &OS) const {
264 OS << " AddString(SA->get" << getUpperName() << "(), Record);\n";
266 void writeValue(raw_ostream &OS) const {
267 OS << "\\\"\" << get" << getUpperName() << "() << \"\\\"";
269 void writeDump(raw_ostream &OS) const {
270 OS << " OS << \" \\\"\" << SA->get" << getUpperName()
271 << "() << \"\\\"\";\n";
275 class AlignedArgument : public Argument {
277 AlignedArgument(Record &Arg, StringRef Attr)
278 : Argument(Arg, Attr)
281 void writeAccessors(raw_ostream &OS) const {
282 OS << " bool is" << getUpperName() << "Dependent() const;\n";
284 OS << " unsigned get" << getUpperName() << "(ASTContext &Ctx) const;\n";
286 OS << " bool is" << getUpperName() << "Expr() const {\n";
287 OS << " return is" << getLowerName() << "Expr;\n";
290 OS << " Expr *get" << getUpperName() << "Expr() const {\n";
291 OS << " assert(is" << getLowerName() << "Expr);\n";
292 OS << " return " << getLowerName() << "Expr;\n";
295 OS << " TypeSourceInfo *get" << getUpperName() << "Type() const {\n";
296 OS << " assert(!is" << getLowerName() << "Expr);\n";
297 OS << " return " << getLowerName() << "Type;\n";
300 void writeAccessorDefinitions(raw_ostream &OS) const {
301 OS << "bool " << getAttrName() << "Attr::is" << getUpperName()
302 << "Dependent() const {\n";
303 OS << " if (is" << getLowerName() << "Expr)\n";
304 OS << " return " << getLowerName() << "Expr && (" << getLowerName()
305 << "Expr->isValueDependent() || " << getLowerName()
306 << "Expr->isTypeDependent());\n";
308 OS << " return " << getLowerName()
309 << "Type->getType()->isDependentType();\n";
312 // FIXME: Do not do the calculation here
313 // FIXME: Handle types correctly
314 // A null pointer means maximum alignment
315 // FIXME: Load the platform-specific maximum alignment, rather than
317 OS << "unsigned " << getAttrName() << "Attr::get" << getUpperName()
318 << "(ASTContext &Ctx) const {\n";
319 OS << " assert(!is" << getUpperName() << "Dependent());\n";
320 OS << " if (is" << getLowerName() << "Expr)\n";
321 OS << " return (" << getLowerName() << "Expr ? " << getLowerName()
322 << "Expr->EvaluateKnownConstInt(Ctx).getZExtValue() : 16)"
323 << "* Ctx.getCharWidth();\n";
325 OS << " return 0; // FIXME\n";
328 void writeCloneArgs(raw_ostream &OS) const {
329 OS << "is" << getLowerName() << "Expr, is" << getLowerName()
330 << "Expr ? static_cast<void*>(" << getLowerName()
331 << "Expr) : " << getLowerName()
334 void writeTemplateInstantiationArgs(raw_ostream &OS) const {
335 // FIXME: move the definition in Sema::InstantiateAttrs to here.
336 // In the meantime, aligned attributes are cloned.
338 void writeCtorBody(raw_ostream &OS) const {
339 OS << " if (is" << getLowerName() << "Expr)\n";
340 OS << " " << getLowerName() << "Expr = reinterpret_cast<Expr *>("
341 << getUpperName() << ");\n";
343 OS << " " << getLowerName()
344 << "Type = reinterpret_cast<TypeSourceInfo *>(" << getUpperName()
347 void writeCtorInitializers(raw_ostream &OS) const {
348 OS << "is" << getLowerName() << "Expr(Is" << getUpperName() << "Expr)";
350 void writeCtorParameters(raw_ostream &OS) const {
351 OS << "bool Is" << getUpperName() << "Expr, void *" << getUpperName();
353 void writeDeclarations(raw_ostream &OS) const {
354 OS << "bool is" << getLowerName() << "Expr;\n";
356 OS << "Expr *" << getLowerName() << "Expr;\n";
357 OS << "TypeSourceInfo *" << getLowerName() << "Type;\n";
360 void writePCHReadArgs(raw_ostream &OS) const {
361 OS << "is" << getLowerName() << "Expr, " << getLowerName() << "Ptr";
363 void writePCHReadDecls(raw_ostream &OS) const {
364 OS << " bool is" << getLowerName() << "Expr = Record[Idx++];\n";
365 OS << " void *" << getLowerName() << "Ptr;\n";
366 OS << " if (is" << getLowerName() << "Expr)\n";
367 OS << " " << getLowerName() << "Ptr = ReadExpr(F);\n";
369 OS << " " << getLowerName()
370 << "Ptr = GetTypeSourceInfo(F, Record, Idx);\n";
372 void writePCHWrite(raw_ostream &OS) const {
373 OS << " Record.push_back(SA->is" << getUpperName() << "Expr());\n";
374 OS << " if (SA->is" << getUpperName() << "Expr())\n";
375 OS << " AddStmt(SA->get" << getUpperName() << "Expr());\n";
377 OS << " AddTypeSourceInfo(SA->get" << getUpperName()
378 << "Type(), Record);\n";
380 void writeValue(raw_ostream &OS) const {
382 << " " << getLowerName() << "Expr->printPretty(OS, 0, Policy);\n"
385 void writeDump(raw_ostream &OS) const {
387 void writeDumpChildren(raw_ostream &OS) const {
388 OS << " if (SA->is" << getUpperName() << "Expr()) {\n";
389 OS << " lastChild();\n";
390 OS << " dumpStmt(SA->get" << getUpperName() << "Expr());\n";
392 OS << " dumpType(SA->get" << getUpperName()
393 << "Type()->getType());\n";
395 void writeHasChildren(raw_ostream &OS) const {
396 OS << "SA->is" << getUpperName() << "Expr()";
400 class VariadicArgument : public Argument {
404 VariadicArgument(Record &Arg, StringRef Attr, std::string T)
405 : Argument(Arg, Attr), type(T)
408 std::string getType() const { return type; }
410 void writeAccessors(raw_ostream &OS) const {
411 OS << " typedef " << type << "* " << getLowerName() << "_iterator;\n";
412 OS << " " << getLowerName() << "_iterator " << getLowerName()
413 << "_begin() const {\n";
414 OS << " return " << getLowerName() << ";\n";
416 OS << " " << getLowerName() << "_iterator " << getLowerName()
417 << "_end() const {\n";
418 OS << " return " << getLowerName() << " + " << getLowerName()
421 OS << " unsigned " << getLowerName() << "_size() const {\n"
422 << " return " << getLowerName() << "Size;\n";
425 void writeCloneArgs(raw_ostream &OS) const {
426 OS << getLowerName() << ", " << getLowerName() << "Size";
428 void writeTemplateInstantiationArgs(raw_ostream &OS) const {
429 // This isn't elegant, but we have to go through public methods...
430 OS << "A->" << getLowerName() << "_begin(), "
431 << "A->" << getLowerName() << "_size()";
433 void writeCtorBody(raw_ostream &OS) const {
434 // FIXME: memcpy is not safe on non-trivial types.
435 OS << " std::memcpy(" << getLowerName() << ", " << getUpperName()
436 << ", " << getLowerName() << "Size * sizeof(" << getType() << "));\n";
438 void writeCtorInitializers(raw_ostream &OS) const {
439 OS << getLowerName() << "Size(" << getUpperName() << "Size), "
440 << getLowerName() << "(new (Ctx, 16) " << getType() << "["
441 << getLowerName() << "Size])";
443 void writeCtorParameters(raw_ostream &OS) const {
444 OS << getType() << " *" << getUpperName() << ", unsigned "
445 << getUpperName() << "Size";
447 void writeDeclarations(raw_ostream &OS) const {
448 OS << " unsigned " << getLowerName() << "Size;\n";
449 OS << " " << getType() << " *" << getLowerName() << ";";
451 void writePCHReadDecls(raw_ostream &OS) const {
452 OS << " unsigned " << getLowerName() << "Size = Record[Idx++];\n";
453 OS << " SmallVector<" << type << ", 4> " << getLowerName()
455 OS << " " << getLowerName() << ".reserve(" << getLowerName()
457 OS << " for (unsigned i = " << getLowerName() << "Size; i; --i)\n";
459 std::string read = ReadPCHRecord(type);
460 OS << " " << getLowerName() << ".push_back(" << read << ");\n";
462 void writePCHReadArgs(raw_ostream &OS) const {
463 OS << getLowerName() << ".data(), " << getLowerName() << "Size";
465 void writePCHWrite(raw_ostream &OS) const{
466 OS << " Record.push_back(SA->" << getLowerName() << "_size());\n";
467 OS << " for (" << getAttrName() << "Attr::" << getLowerName()
468 << "_iterator i = SA->" << getLowerName() << "_begin(), e = SA->"
469 << getLowerName() << "_end(); i != e; ++i)\n";
470 OS << " " << WritePCHRecord(type, "(*i)");
472 void writeValue(raw_ostream &OS) const {
474 OS << " bool isFirst = true;\n"
475 << " for (" << getAttrName() << "Attr::" << getLowerName()
476 << "_iterator i = " << getLowerName() << "_begin(), e = "
477 << getLowerName() << "_end(); i != e; ++i) {\n"
478 << " if (isFirst) isFirst = false;\n"
479 << " else OS << \", \";\n"
484 void writeDump(raw_ostream &OS) const {
485 OS << " for (" << getAttrName() << "Attr::" << getLowerName()
486 << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
487 << getLowerName() << "_end(); I != E; ++I)\n";
488 OS << " OS << \" \" << *I;\n";
492 class EnumArgument : public Argument {
494 std::vector<StringRef> values, enums, uniques;
496 EnumArgument(Record &Arg, StringRef Attr)
497 : Argument(Arg, Attr), type(Arg.getValueAsString("Type")),
498 values(getValueAsListOfStrings(Arg, "Values")),
499 enums(getValueAsListOfStrings(Arg, "Enums")),
502 // Calculate the various enum values
503 std::sort(uniques.begin(), uniques.end());
504 uniques.erase(std::unique(uniques.begin(), uniques.end()), uniques.end());
505 // FIXME: Emit a proper error
506 assert(!uniques.empty());
509 void writeAccessors(raw_ostream &OS) const {
510 OS << " " << type << " get" << getUpperName() << "() const {\n";
511 OS << " return " << getLowerName() << ";\n";
514 void writeCloneArgs(raw_ostream &OS) const {
515 OS << getLowerName();
517 void writeTemplateInstantiationArgs(raw_ostream &OS) const {
518 OS << "A->get" << getUpperName() << "()";
520 void writeCtorInitializers(raw_ostream &OS) const {
521 OS << getLowerName() << "(" << getUpperName() << ")";
523 void writeCtorParameters(raw_ostream &OS) const {
524 OS << type << " " << getUpperName();
526 void writeDeclarations(raw_ostream &OS) const {
527 std::vector<StringRef>::const_iterator i = uniques.begin(),
529 // The last one needs to not have a comma.
533 OS << " enum " << type << " {\n";
535 OS << " " << *i << ",\n";
536 OS << " " << *e << "\n";
539 OS << " " << type << " " << getLowerName() << ";";
541 void writePCHReadDecls(raw_ostream &OS) const {
542 OS << " " << getAttrName() << "Attr::" << type << " " << getLowerName()
543 << "(static_cast<" << getAttrName() << "Attr::" << type
544 << ">(Record[Idx++]));\n";
546 void writePCHReadArgs(raw_ostream &OS) const {
547 OS << getLowerName();
549 void writePCHWrite(raw_ostream &OS) const {
550 OS << "Record.push_back(SA->get" << getUpperName() << "());\n";
552 void writeValue(raw_ostream &OS) const {
553 OS << "\" << get" << getUpperName() << "() << \"";
555 void writeDump(raw_ostream &OS) const {
556 OS << " switch(SA->get" << getUpperName() << "()) {\n";
557 for (std::vector<StringRef>::const_iterator I = uniques.begin(),
558 E = uniques.end(); I != E; ++I) {
559 OS << " case " << getAttrName() << "Attr::" << *I << ":\n";
560 OS << " OS << \" " << *I << "\";\n";
567 class VersionArgument : public Argument {
569 VersionArgument(Record &Arg, StringRef Attr)
570 : Argument(Arg, Attr)
573 void writeAccessors(raw_ostream &OS) const {
574 OS << " VersionTuple get" << getUpperName() << "() const {\n";
575 OS << " return " << getLowerName() << ";\n";
577 OS << " void set" << getUpperName()
578 << "(ASTContext &C, VersionTuple V) {\n";
579 OS << " " << getLowerName() << " = V;\n";
582 void writeCloneArgs(raw_ostream &OS) const {
583 OS << "get" << getUpperName() << "()";
585 void writeTemplateInstantiationArgs(raw_ostream &OS) const {
586 OS << "A->get" << getUpperName() << "()";
588 void writeCtorBody(raw_ostream &OS) const {
590 void writeCtorInitializers(raw_ostream &OS) const {
591 OS << getLowerName() << "(" << getUpperName() << ")";
593 void writeCtorParameters(raw_ostream &OS) const {
594 OS << "VersionTuple " << getUpperName();
596 void writeDeclarations(raw_ostream &OS) const {
597 OS << "VersionTuple " << getLowerName() << ";\n";
599 void writePCHReadDecls(raw_ostream &OS) const {
600 OS << " VersionTuple " << getLowerName()
601 << "= ReadVersionTuple(Record, Idx);\n";
603 void writePCHReadArgs(raw_ostream &OS) const {
604 OS << getLowerName();
606 void writePCHWrite(raw_ostream &OS) const {
607 OS << " AddVersionTuple(SA->get" << getUpperName() << "(), Record);\n";
609 void writeValue(raw_ostream &OS) const {
610 OS << getLowerName() << "=\" << get" << getUpperName() << "() << \"";
612 void writeDump(raw_ostream &OS) const {
613 OS << " OS << \" \" << SA->get" << getUpperName() << "();\n";
617 class ExprArgument : public SimpleArgument {
619 ExprArgument(Record &Arg, StringRef Attr)
620 : SimpleArgument(Arg, Attr, "Expr *")
623 void writeTemplateInstantiationArgs(raw_ostream &OS) const {
624 OS << "tempInst" << getUpperName();
627 void writeTemplateInstantiation(raw_ostream &OS) const {
628 OS << " " << getType() << " tempInst" << getUpperName() << ";\n";
630 OS << " EnterExpressionEvaluationContext "
631 << "Unevaluated(S, Sema::Unevaluated);\n";
632 OS << " ExprResult " << "Result = S.SubstExpr("
633 << "A->get" << getUpperName() << "(), TemplateArgs);\n";
634 OS << " tempInst" << getUpperName() << " = "
635 << "Result.takeAs<Expr>();\n";
639 void writeDump(raw_ostream &OS) const {
642 void writeDumpChildren(raw_ostream &OS) const {
643 OS << " lastChild();\n";
644 OS << " dumpStmt(SA->get" << getUpperName() << "());\n";
646 void writeHasChildren(raw_ostream &OS) const { OS << "true"; }
649 class VariadicExprArgument : public VariadicArgument {
651 VariadicExprArgument(Record &Arg, StringRef Attr)
652 : VariadicArgument(Arg, Attr, "Expr *")
655 void writeTemplateInstantiationArgs(raw_ostream &OS) const {
656 OS << "tempInst" << getUpperName() << ", "
657 << "A->" << getLowerName() << "_size()";
660 void writeTemplateInstantiation(raw_ostream &OS) const {
661 OS << " " << getType() << " *tempInst" << getUpperName()
662 << " = new (C, 16) " << getType()
663 << "[A->" << getLowerName() << "_size()];\n";
665 OS << " EnterExpressionEvaluationContext "
666 << "Unevaluated(S, Sema::Unevaluated);\n";
667 OS << " " << getType() << " *TI = tempInst" << getUpperName()
669 OS << " " << getType() << " *I = A->" << getLowerName()
671 OS << " " << getType() << " *E = A->" << getLowerName()
673 OS << " for (; I != E; ++I, ++TI) {\n";
674 OS << " ExprResult Result = S.SubstExpr(*I, TemplateArgs);\n";
675 OS << " *TI = Result.takeAs<Expr>();\n";
680 void writeDump(raw_ostream &OS) const {
683 void writeDumpChildren(raw_ostream &OS) const {
684 OS << " for (" << getAttrName() << "Attr::" << getLowerName()
685 << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
686 << getLowerName() << "_end(); I != E; ++I) {\n";
687 OS << " if (I + 1 == E)\n";
688 OS << " lastChild();\n";
689 OS << " dumpStmt(*I);\n";
693 void writeHasChildren(raw_ostream &OS) const {
694 OS << "SA->" << getLowerName() << "_begin() != "
695 << "SA->" << getLowerName() << "_end()";
700 static Argument *createArgument(Record &Arg, StringRef Attr,
701 Record *Search = 0) {
706 llvm::StringRef ArgName = Search->getName();
708 if (ArgName == "AlignedArgument") Ptr = new AlignedArgument(Arg, Attr);
709 else if (ArgName == "EnumArgument") Ptr = new EnumArgument(Arg, Attr);
710 else if (ArgName == "ExprArgument") Ptr = new ExprArgument(Arg, Attr);
711 else if (ArgName == "FunctionArgument")
712 Ptr = new SimpleArgument(Arg, Attr, "FunctionDecl *");
713 else if (ArgName == "IdentifierArgument")
714 Ptr = new SimpleArgument(Arg, Attr, "IdentifierInfo *");
715 else if (ArgName == "BoolArgument") Ptr = new SimpleArgument(Arg, Attr,
717 else if (ArgName == "IntArgument") Ptr = new SimpleArgument(Arg, Attr, "int");
718 else if (ArgName == "StringArgument") Ptr = new StringArgument(Arg, Attr);
719 else if (ArgName == "TypeArgument")
720 Ptr = new SimpleArgument(Arg, Attr, "QualType");
721 else if (ArgName == "UnsignedArgument")
722 Ptr = new SimpleArgument(Arg, Attr, "unsigned");
723 else if (ArgName == "SourceLocArgument")
724 Ptr = new SimpleArgument(Arg, Attr, "SourceLocation");
725 else if (ArgName == "VariadicUnsignedArgument")
726 Ptr = new VariadicArgument(Arg, Attr, "unsigned");
727 else if (ArgName == "VariadicExprArgument")
728 Ptr = new VariadicExprArgument(Arg, Attr);
729 else if (ArgName == "VersionArgument")
730 Ptr = new VersionArgument(Arg, Attr);
733 std::vector<Record*> Bases = Search->getSuperClasses();
734 for (std::vector<Record*>::iterator i = Bases.begin(), e = Bases.end();
736 Ptr = createArgument(Arg, Attr, *i);
744 static void writeAvailabilityValue(raw_ostream &OS) {
745 OS << "\" << getPlatform()->getName();\n"
746 << " if (!getIntroduced().empty()) OS << \", introduced=\" << getIntroduced();\n"
747 << " if (!getDeprecated().empty()) OS << \", deprecated=\" << getDeprecated();\n"
748 << " if (!getObsoleted().empty()) OS << \", obsoleted=\" << getObsoleted();\n"
749 << " if (getUnavailable()) OS << \", unavailable\";\n"
753 static void writePrettyPrintFunction(Record &R, std::vector<Argument*> &Args,
755 std::vector<Record*> Spellings = R.getValueAsListOfDefs("Spellings");
757 OS << "void " << R.getName() << "Attr::printPretty("
758 << "raw_ostream &OS, const PrintingPolicy &Policy) const {\n";
760 if (Spellings.size() == 0) {
766 " switch (SpellingListIndex) {\n"
768 " llvm_unreachable(\"Unknown attribute spelling!\");\n"
771 for (unsigned I = 0; I < Spellings.size(); ++ I) {
772 llvm::SmallString<16> Prefix;
773 llvm::SmallString<8> Suffix;
774 // The actual spelling of the name and namespace (if applicable)
775 // of an attribute without considering prefix and suffix.
776 llvm::SmallString<64> Spelling;
777 std::string Name = Spellings[I]->getValueAsString("Name");
778 std::string Variety = Spellings[I]->getValueAsString("Variety");
780 if (Variety == "GNU") {
781 Prefix = " __attribute__((";
783 } else if (Variety == "CXX11") {
786 std::string Namespace = Spellings[I]->getValueAsString("Namespace");
787 if (Namespace != "") {
788 Spelling += Namespace;
791 } else if (Variety == "Declspec") {
792 Prefix = " __declspec(";
794 } else if (Variety == "Keyword") {
798 llvm_unreachable("Unknown attribute syntax variety!");
804 " case " << I << " : {\n"
805 " OS << \"" + Prefix.str() + Spelling.str();
807 if (Args.size()) OS << "(";
808 if (Spelling == "availability") {
809 writeAvailabilityValue(OS);
811 for (std::vector<Argument*>::const_iterator I = Args.begin(),
812 E = Args.end(); I != E; ++ I) {
813 if (I != Args.begin()) OS << ", ";
814 (*I)->writeValue(OS);
818 if (Args.size()) OS << ")";
819 OS << Suffix.str() + "\";\n";
826 // End of the switch statement.
828 // End of the print function.
832 /// \brief Return the index of a spelling in a spelling list.
833 static unsigned getSpellingListIndex(const std::vector<Record*> &SpellingList,
834 const Record &Spelling) {
835 assert(SpellingList.size() && "Spelling list is empty!");
837 for (unsigned Index = 0; Index < SpellingList.size(); ++Index) {
838 Record *S = SpellingList[Index];
839 if (S->getValueAsString("Variety") != Spelling.getValueAsString("Variety"))
841 if (S->getValueAsString("Variety") == "CXX11" &&
842 S->getValueAsString("Namespace") !=
843 Spelling.getValueAsString("Namespace"))
845 if (S->getValueAsString("Name") != Spelling.getValueAsString("Name"))
851 llvm_unreachable("Unknown spelling!");
854 static void writeAttrAccessorDefinition(Record &R, raw_ostream &OS) {
855 std::vector<Record*> Accessors = R.getValueAsListOfDefs("Accessors");
856 for (std::vector<Record*>::const_iterator I = Accessors.begin(),
857 E = Accessors.end(); I != E; ++I) {
858 Record *Accessor = *I;
859 std::string Name = Accessor->getValueAsString("Name");
860 std::vector<Record*> Spellings = Accessor->getValueAsListOfDefs(
862 std::vector<Record*> SpellingList = R.getValueAsListOfDefs("Spellings");
863 assert(SpellingList.size() &&
864 "Attribute with empty spelling list can't have accessors!");
866 OS << " bool " << Name << "() const { return SpellingListIndex == ";
867 for (unsigned Index = 0; Index < Spellings.size(); ++Index) {
868 OS << getSpellingListIndex(SpellingList, *Spellings[Index]);
869 if (Index != Spellings.size() -1)
870 OS << " ||\n SpellingListIndex == ";
879 // Emits the class definitions for attributes.
880 void EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS) {
881 emitSourceFileHeader("Attribute classes' definitions", OS);
883 OS << "#ifndef LLVM_CLANG_ATTR_CLASSES_INC\n";
884 OS << "#define LLVM_CLANG_ATTR_CLASSES_INC\n\n";
886 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
888 for (std::vector<Record*>::iterator i = Attrs.begin(), e = Attrs.end();
892 if (!R.getValueAsBit("ASTNode"))
895 const std::string &SuperName = R.getSuperClasses().back()->getName();
897 OS << "class " << R.getName() << "Attr : public " << SuperName << " {\n";
899 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
900 std::vector<Argument*> Args;
901 std::vector<Argument*>::iterator ai, ae;
902 Args.reserve(ArgRecords.size());
904 for (std::vector<Record*>::iterator ri = ArgRecords.begin(),
905 re = ArgRecords.end();
907 Record &ArgRecord = **ri;
908 Argument *Arg = createArgument(ArgRecord, R.getName());
912 Arg->writeDeclarations(OS);
918 OS << "\n public:\n";
919 OS << " " << R.getName() << "Attr(SourceRange R, ASTContext &Ctx\n";
921 for (ai = Args.begin(); ai != ae; ++ai) {
923 (*ai)->writeCtorParameters(OS);
928 OS << "unsigned SI = 0\n";
931 OS << " : " << SuperName << "(attr::" << R.getName() << ", R, SI)\n";
933 for (ai = Args.begin(); ai != ae; ++ai) {
935 (*ai)->writeCtorInitializers(OS);
941 for (ai = Args.begin(); ai != ae; ++ai) {
942 (*ai)->writeCtorBody(OS);
947 OS << " virtual " << R.getName() << "Attr *clone (ASTContext &C) const;\n";
948 OS << " virtual void printPretty(raw_ostream &OS,\n"
949 << " const PrintingPolicy &Policy) const;\n";
951 writeAttrAccessorDefinition(R, OS);
953 for (ai = Args.begin(); ai != ae; ++ai) {
954 (*ai)->writeAccessors(OS);
958 OS << R.getValueAsString("AdditionalMembers");
961 OS << " static bool classof(const Attr *A) { return A->getKind() == "
962 << "attr::" << R.getName() << "; }\n";
964 bool LateParsed = R.getValueAsBit("LateParsed");
965 OS << " virtual bool isLateParsed() const { return "
966 << LateParsed << "; }\n";
974 // Emits the all-arguments-are-expressions property for attributes.
975 void EmitClangAttrExprArgsList(RecordKeeper &Records, raw_ostream &OS) {
976 emitSourceFileHeader("llvm::StringSwitch code to match attributes with "
977 "expression arguments", OS);
979 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
981 for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end();
985 // Determine whether the first argument is something that is always
987 std::vector<Record *> Args = Attr.getValueAsListOfDefs("Args");
988 if (Args.empty() || Args[0]->getSuperClasses().empty())
991 // Check whether this is one of the argument kinds that implies an
993 // FIXME: Aligned is weird.
994 if (!llvm::StringSwitch<bool>(Args[0]->getSuperClasses().back()->getName())
995 .Case("AlignedArgument", true)
996 .Case("BoolArgument", true)
997 .Case("DefaultIntArgument", true)
998 .Case("IntArgument", true)
999 .Case("ExprArgument", true)
1000 .Case("UnsignedArgument", true)
1001 .Case("VariadicUnsignedArgument", true)
1002 .Case("VariadicExprArgument", true)
1006 std::vector<Record*> Spellings = Attr.getValueAsListOfDefs("Spellings");
1008 for (std::vector<Record*>::const_iterator I = Spellings.begin(),
1009 E = Spellings.end(); I != E; ++I) {
1010 OS << ".Case(\"" << (*I)->getValueAsString("Name") << "\", "
1016 // Emits the class method definitions for attributes.
1017 void EmitClangAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
1018 emitSourceFileHeader("Attribute classes' member function definitions", OS);
1020 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1021 std::vector<Record*>::iterator i = Attrs.begin(), e = Attrs.end(), ri, re;
1022 std::vector<Argument*>::iterator ai, ae;
1024 for (; i != e; ++i) {
1027 if (!R.getValueAsBit("ASTNode"))
1030 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
1031 std::vector<Argument*> Args;
1032 for (ri = ArgRecords.begin(), re = ArgRecords.end(); ri != re; ++ri)
1033 Args.push_back(createArgument(**ri, R.getName()));
1035 for (ai = Args.begin(), ae = Args.end(); ai != ae; ++ai)
1036 (*ai)->writeAccessorDefinitions(OS);
1038 OS << R.getName() << "Attr *" << R.getName()
1039 << "Attr::clone(ASTContext &C) const {\n";
1040 OS << " return new (C) " << R.getName() << "Attr(getLocation(), C";
1041 for (ai = Args.begin(); ai != ae; ++ai) {
1043 (*ai)->writeCloneArgs(OS);
1045 OS << ", getSpellingListIndex());\n}\n\n";
1047 writePrettyPrintFunction(R, Args, OS);
1051 } // end namespace clang
1053 static void EmitAttrList(raw_ostream &OS, StringRef Class,
1054 const std::vector<Record*> &AttrList) {
1055 std::vector<Record*>::const_iterator i = AttrList.begin(), e = AttrList.end();
1058 // Move the end iterator back to emit the last attribute.
1059 for(--e; i != e; ++i) {
1060 if (!(*i)->getValueAsBit("ASTNode"))
1063 OS << Class << "(" << (*i)->getName() << ")\n";
1066 OS << "LAST_" << Class << "(" << (*i)->getName() << ")\n\n";
1072 // Emits the enumeration list for attributes.
1073 void EmitClangAttrList(RecordKeeper &Records, raw_ostream &OS) {
1074 emitSourceFileHeader("List of all attributes that Clang recognizes", OS);
1076 OS << "#ifndef LAST_ATTR\n";
1077 OS << "#define LAST_ATTR(NAME) ATTR(NAME)\n";
1080 OS << "#ifndef INHERITABLE_ATTR\n";
1081 OS << "#define INHERITABLE_ATTR(NAME) ATTR(NAME)\n";
1084 OS << "#ifndef LAST_INHERITABLE_ATTR\n";
1085 OS << "#define LAST_INHERITABLE_ATTR(NAME) INHERITABLE_ATTR(NAME)\n";
1088 OS << "#ifndef INHERITABLE_PARAM_ATTR\n";
1089 OS << "#define INHERITABLE_PARAM_ATTR(NAME) ATTR(NAME)\n";
1092 OS << "#ifndef LAST_INHERITABLE_PARAM_ATTR\n";
1093 OS << "#define LAST_INHERITABLE_PARAM_ATTR(NAME)"
1094 " INHERITABLE_PARAM_ATTR(NAME)\n";
1097 OS << "#ifndef MS_INHERITABLE_ATTR\n";
1098 OS << "#define MS_INHERITABLE_ATTR(NAME) INHERITABLE_ATTR(NAME)\n";
1101 OS << "#ifndef LAST_MS_INHERITABLE_ATTR\n";
1102 OS << "#define LAST_MS_INHERITABLE_ATTR(NAME)"
1103 " MS_INHERITABLE_ATTR(NAME)\n";
1106 Record *InhClass = Records.getClass("InheritableAttr");
1107 Record *InhParamClass = Records.getClass("InheritableParamAttr");
1108 Record *MSInheritanceClass = Records.getClass("MSInheritanceAttr");
1109 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"),
1110 NonInhAttrs, InhAttrs, InhParamAttrs, MSInhAttrs;
1111 for (std::vector<Record*>::iterator i = Attrs.begin(), e = Attrs.end();
1113 if (!(*i)->getValueAsBit("ASTNode"))
1116 if ((*i)->isSubClassOf(InhParamClass))
1117 InhParamAttrs.push_back(*i);
1118 else if ((*i)->isSubClassOf(MSInheritanceClass))
1119 MSInhAttrs.push_back(*i);
1120 else if ((*i)->isSubClassOf(InhClass))
1121 InhAttrs.push_back(*i);
1123 NonInhAttrs.push_back(*i);
1126 EmitAttrList(OS, "INHERITABLE_PARAM_ATTR", InhParamAttrs);
1127 EmitAttrList(OS, "MS_INHERITABLE_ATTR", MSInhAttrs);
1128 EmitAttrList(OS, "INHERITABLE_ATTR", InhAttrs);
1129 EmitAttrList(OS, "ATTR", NonInhAttrs);
1131 OS << "#undef LAST_ATTR\n";
1132 OS << "#undef INHERITABLE_ATTR\n";
1133 OS << "#undef MS_INHERITABLE_ATTR\n";
1134 OS << "#undef LAST_INHERITABLE_ATTR\n";
1135 OS << "#undef LAST_INHERITABLE_PARAM_ATTR\n";
1136 OS << "#undef LAST_MS_INHERITABLE_ATTR\n";
1137 OS << "#undef ATTR\n";
1140 // Emits the code to read an attribute from a precompiled header.
1141 void EmitClangAttrPCHRead(RecordKeeper &Records, raw_ostream &OS) {
1142 emitSourceFileHeader("Attribute deserialization code", OS);
1144 Record *InhClass = Records.getClass("InheritableAttr");
1145 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"),
1147 std::vector<Record*>::iterator i = Attrs.begin(), e = Attrs.end(), ai, ae;
1148 std::vector<Argument*> Args;
1149 std::vector<Argument*>::iterator ri, re;
1151 OS << " switch (Kind) {\n";
1152 OS << " default:\n";
1153 OS << " assert(0 && \"Unknown attribute!\");\n";
1155 for (; i != e; ++i) {
1157 if (!R.getValueAsBit("ASTNode"))
1160 OS << " case attr::" << R.getName() << ": {\n";
1161 if (R.isSubClassOf(InhClass))
1162 OS << " bool isInherited = Record[Idx++];\n";
1163 ArgRecords = R.getValueAsListOfDefs("Args");
1165 for (ai = ArgRecords.begin(), ae = ArgRecords.end(); ai != ae; ++ai) {
1166 Argument *A = createArgument(**ai, R.getName());
1168 A->writePCHReadDecls(OS);
1170 OS << " New = new (Context) " << R.getName() << "Attr(Range, Context";
1171 for (ri = Args.begin(), re = Args.end(); ri != re; ++ri) {
1173 (*ri)->writePCHReadArgs(OS);
1176 if (R.isSubClassOf(InhClass))
1177 OS << " cast<InheritableAttr>(New)->setInherited(isInherited);\n";
1184 // Emits the code to write an attribute to a precompiled header.
1185 void EmitClangAttrPCHWrite(RecordKeeper &Records, raw_ostream &OS) {
1186 emitSourceFileHeader("Attribute serialization code", OS);
1188 Record *InhClass = Records.getClass("InheritableAttr");
1189 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
1190 std::vector<Record*>::iterator i = Attrs.begin(), e = Attrs.end(), ai, ae;
1192 OS << " switch (A->getKind()) {\n";
1193 OS << " default:\n";
1194 OS << " llvm_unreachable(\"Unknown attribute kind!\");\n";
1196 for (; i != e; ++i) {
1198 if (!R.getValueAsBit("ASTNode"))
1200 OS << " case attr::" << R.getName() << ": {\n";
1201 Args = R.getValueAsListOfDefs("Args");
1202 if (R.isSubClassOf(InhClass) || !Args.empty())
1203 OS << " const " << R.getName() << "Attr *SA = cast<" << R.getName()
1205 if (R.isSubClassOf(InhClass))
1206 OS << " Record.push_back(SA->isInherited());\n";
1207 for (ai = Args.begin(), ae = Args.end(); ai != ae; ++ai)
1208 createArgument(**ai, R.getName())->writePCHWrite(OS);
1215 // Emits the list of spellings for attributes.
1216 void EmitClangAttrSpellingList(RecordKeeper &Records, raw_ostream &OS) {
1217 emitSourceFileHeader("llvm::StringSwitch code to match all known attributes",
1220 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1222 for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end(); I != E; ++I) {
1225 std::vector<Record*> Spellings = Attr.getValueAsListOfDefs("Spellings");
1227 for (std::vector<Record*>::const_iterator I = Spellings.begin(), E = Spellings.end(); I != E; ++I) {
1228 OS << ".Case(\"" << (*I)->getValueAsString("Name") << "\", true)\n";
1234 void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS) {
1235 emitSourceFileHeader("Code to translate different attribute spellings "
1236 "into internal identifiers", OS);
1239 " unsigned Index = 0;\n"
1240 " switch (AttrKind) {\n"
1242 " llvm_unreachable(\"Unknown attribute kind!\");\n"
1245 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1246 for (std::vector<Record*>::const_iterator I = Attrs.begin(), E = Attrs.end();
1249 // We only care about attributes that participate in Sema checking, so
1250 // skip those attributes that are not able to make their way to Sema.
1251 if (!R.getValueAsBit("SemaHandler"))
1254 std::vector<Record*> Spellings = R.getValueAsListOfDefs("Spellings");
1255 // Each distinct spelling yields an attribute kind.
1256 if (R.getValueAsBit("DistinctSpellings")) {
1257 for (unsigned I = 0; I < Spellings.size(); ++ I) {
1259 " case AT_" << Spellings[I]->getValueAsString("Name") << ": \n"
1260 " Index = " << I << ";\n"
1264 OS << " case AT_" << R.getName() << " : {\n";
1265 for (unsigned I = 0; I < Spellings.size(); ++ I) {
1266 SmallString<16> Namespace;
1267 if (Spellings[I]->getValueAsString("Variety") == "CXX11")
1268 Namespace = Spellings[I]->getValueAsString("Namespace");
1272 OS << " if (Name == \""
1273 << Spellings[I]->getValueAsString("Name") << "\" && "
1275 << StringSwitch<unsigned>(Spellings[I]->getValueAsString("Variety"))
1278 .Case("Declspec", 2)
1281 << " && Scope == \"" << Namespace << "\")\n"
1282 << " return " << I << ";\n";
1291 OS << " return Index;\n";
1294 // Emits the LateParsed property for attributes.
1295 void EmitClangAttrLateParsedList(RecordKeeper &Records, raw_ostream &OS) {
1296 emitSourceFileHeader("llvm::StringSwitch code to match late parsed "
1299 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1301 for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end();
1305 bool LateParsed = Attr.getValueAsBit("LateParsed");
1308 std::vector<Record*> Spellings =
1309 Attr.getValueAsListOfDefs("Spellings");
1311 // FIXME: Handle non-GNU attributes
1312 for (std::vector<Record*>::const_iterator I = Spellings.begin(),
1313 E = Spellings.end(); I != E; ++I) {
1314 if ((*I)->getValueAsString("Variety") != "GNU")
1316 OS << ".Case(\"" << (*I)->getValueAsString("Name") << "\", "
1317 << LateParsed << ")\n";
1323 // Emits code to instantiate dependent attributes on templates.
1324 void EmitClangAttrTemplateInstantiate(RecordKeeper &Records, raw_ostream &OS) {
1325 emitSourceFileHeader("Template instantiation code for attributes", OS);
1327 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1329 OS << "namespace clang {\n"
1330 << "namespace sema {\n\n"
1331 << "Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, "
1333 << " const MultiLevelTemplateArgumentList &TemplateArgs) {\n"
1334 << " switch (At->getKind()) {\n"
1338 for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end();
1341 if (!R.getValueAsBit("ASTNode"))
1344 OS << " case attr::" << R.getName() << ": {\n";
1345 bool ShouldClone = R.getValueAsBit("Clone");
1348 OS << " return NULL;\n";
1353 OS << " const " << R.getName() << "Attr *A = cast<"
1354 << R.getName() << "Attr>(At);\n";
1355 bool TDependent = R.getValueAsBit("TemplateDependent");
1358 OS << " return A->clone(C);\n";
1363 std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
1364 std::vector<Argument*> Args;
1365 std::vector<Argument*>::iterator ai, ae;
1366 Args.reserve(ArgRecords.size());
1368 for (std::vector<Record*>::iterator ri = ArgRecords.begin(),
1369 re = ArgRecords.end();
1371 Record &ArgRecord = **ri;
1372 Argument *Arg = createArgument(ArgRecord, R.getName());
1374 Args.push_back(Arg);
1378 for (ai = Args.begin(); ai != ae; ++ai) {
1379 (*ai)->writeTemplateInstantiation(OS);
1381 OS << " return new (C) " << R.getName() << "Attr(A->getLocation(), C";
1382 for (ai = Args.begin(); ai != ae; ++ai) {
1384 (*ai)->writeTemplateInstantiationArgs(OS);
1388 OS << " } // end switch\n"
1389 << " llvm_unreachable(\"Unknown attribute!\");\n"
1392 << "} // end namespace sema\n"
1393 << "} // end namespace clang\n";
1396 // Emits the list of parsed attributes.
1397 void EmitClangAttrParsedAttrList(RecordKeeper &Records, raw_ostream &OS) {
1398 emitSourceFileHeader("List of all attributes that Clang recognizes", OS);
1400 OS << "#ifndef PARSED_ATTR\n";
1401 OS << "#define PARSED_ATTR(NAME) NAME\n";
1404 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1406 for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end();
1410 bool SemaHandler = Attr.getValueAsBit("SemaHandler");
1411 bool DistinctSpellings = Attr.getValueAsBit("DistinctSpellings");
1414 if (DistinctSpellings) {
1415 std::vector<Record*> Spellings = Attr.getValueAsListOfDefs("Spellings");
1417 for (std::vector<Record*>::const_iterator I = Spellings.begin(),
1418 E = Spellings.end(); I != E; ++I) {
1419 std::string AttrName = (*I)->getValueAsString("Name");
1421 StringRef Spelling = NormalizeAttrName(AttrName);
1423 OS << "PARSED_ATTR(" << Spelling << ")\n";
1426 StringRef AttrName = Attr.getName();
1427 AttrName = NormalizeAttrName(AttrName);
1428 OS << "PARSED_ATTR(" << AttrName << ")\n";
1434 // Emits the kind list of parsed attributes
1435 void EmitClangAttrParsedAttrKinds(RecordKeeper &Records, raw_ostream &OS) {
1436 emitSourceFileHeader("Attribute name matcher", OS);
1438 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
1440 std::vector<StringMatcher::StringPair> Matches;
1441 for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end();
1445 bool SemaHandler = Attr.getValueAsBit("SemaHandler");
1446 bool Ignored = Attr.getValueAsBit("Ignored");
1447 bool DistinctSpellings = Attr.getValueAsBit("DistinctSpellings");
1448 if (SemaHandler || Ignored) {
1449 std::vector<Record*> Spellings = Attr.getValueAsListOfDefs("Spellings");
1451 for (std::vector<Record*>::const_iterator I = Spellings.begin(),
1452 E = Spellings.end(); I != E; ++I) {
1453 std::string RawSpelling = (*I)->getValueAsString("Name");
1454 StringRef AttrName = NormalizeAttrName(DistinctSpellings
1455 ? StringRef(RawSpelling)
1456 : StringRef(Attr.getName()));
1458 SmallString<64> Spelling;
1459 if ((*I)->getValueAsString("Variety") == "CXX11") {
1460 Spelling += (*I)->getValueAsString("Namespace");
1463 Spelling += NormalizeAttrSpelling(RawSpelling);
1467 StringMatcher::StringPair(
1468 StringRef(Spelling),
1469 "return AttributeList::AT_" + AttrName.str() + ";"));
1472 StringMatcher::StringPair(
1473 StringRef(Spelling),
1474 "return AttributeList::IgnoredAttribute;"));
1479 OS << "static AttributeList::Kind getAttrKind(StringRef Name) {\n";
1480 StringMatcher("Name", Matches, OS).Emit();
1481 OS << "return AttributeList::UnknownAttribute;\n"
1485 // Emits the code to dump an attribute.
1486 void EmitClangAttrDump(RecordKeeper &Records, raw_ostream &OS) {
1487 emitSourceFileHeader("Attribute dumper", OS);
1490 " switch (A->getKind()) {\n"
1492 " llvm_unreachable(\"Unknown attribute kind!\");\n"
1494 std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
1495 for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end();
1498 if (!R.getValueAsBit("ASTNode"))
1500 OS << " case attr::" << R.getName() << ": {\n";
1501 Args = R.getValueAsListOfDefs("Args");
1502 if (!Args.empty()) {
1503 OS << " const " << R.getName() << "Attr *SA = cast<" << R.getName()
1505 for (std::vector<Record*>::iterator I = Args.begin(), E = Args.end();
1507 createArgument(**I, R.getName())->writeDump(OS);
1509 // Code for detecting the last child.
1510 OS << " bool OldMoreChildren = hasMoreChildren();\n";
1511 OS << " bool MoreChildren = OldMoreChildren;\n";
1513 for (std::vector<Record*>::iterator I = Args.begin(), E = Args.end();
1515 // More code for detecting the last child.
1516 OS << " MoreChildren = OldMoreChildren";
1517 for (std::vector<Record*>::iterator Next = I + 1; Next != E; ++Next) {
1519 createArgument(**Next, R.getName())->writeHasChildren(OS);
1522 OS << " setMoreChildren(MoreChildren);\n";
1524 createArgument(**I, R.getName())->writeDumpChildren(OS);
1527 // Reset the last child.
1528 OS << " setMoreChildren(OldMoreChildren);\n";
1537 } // end namespace clang