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