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