diff options
Diffstat (limited to 'contrib/llvm/tools/clang/utils/TableGen/ClangAttrEmitter.cpp')
| -rw-r--r-- | contrib/llvm/tools/clang/utils/TableGen/ClangAttrEmitter.cpp | 2252 |
1 files changed, 1638 insertions, 614 deletions
diff --git a/contrib/llvm/tools/clang/utils/TableGen/ClangAttrEmitter.cpp b/contrib/llvm/tools/clang/utils/TableGen/ClangAttrEmitter.cpp index 653d7b79e282..1790dcbd8d33 100644 --- a/contrib/llvm/tools/clang/utils/TableGen/ClangAttrEmitter.cpp +++ b/contrib/llvm/tools/clang/utils/TableGen/ClangAttrEmitter.cpp @@ -12,35 +12,63 @@ //===----------------------------------------------------------------------===// #include "llvm/ADT/SmallString.h" -#include "llvm/ADT/StringSwitch.h" +#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallSet.h" +#include "llvm/ADT/StringSwitch.h" +#include "llvm/TableGen/Error.h" #include "llvm/TableGen/Record.h" #include "llvm/TableGen/StringMatcher.h" #include "llvm/TableGen/TableGenBackend.h" #include <algorithm> #include <cctype> +#include <memory> +#include <set> +#include <sstream> using namespace llvm; -static const std::vector<StringRef> -getValueAsListOfStrings(Record &R, StringRef FieldName) { - ListInit *List = R.getValueAsListInit(FieldName); - assert (List && "Got a null ListInit"); - - std::vector<StringRef> Strings; - Strings.reserve(List->getSize()); +class FlattenedSpelling { + std::string V, N, NS; + bool K; + +public: + FlattenedSpelling(const std::string &Variety, const std::string &Name, + const std::string &Namespace, bool KnownToGCC) : + V(Variety), N(Name), NS(Namespace), K(KnownToGCC) {} + explicit FlattenedSpelling(const Record &Spelling) : + V(Spelling.getValueAsString("Variety")), + N(Spelling.getValueAsString("Name")) { + + assert(V != "GCC" && "Given a GCC spelling, which means this hasn't been" + "flattened!"); + if (V == "CXX11" || V == "Pragma") + NS = Spelling.getValueAsString("Namespace"); + bool Unset; + K = Spelling.getValueAsBitOrUnset("KnownToGCC", Unset); + } - for (ListInit::const_iterator i = List->begin(), e = List->end(); - i != e; - ++i) { - assert(*i && "Got a null element in a ListInit"); - if (StringInit *S = dyn_cast<StringInit>(*i)) - Strings.push_back(S->getValue()); - else - assert(false && "Got a non-string, non-code element in a ListInit"); + const std::string &variety() const { return V; } + const std::string &name() const { return N; } + const std::string &nameSpace() const { return NS; } + bool knownToGCC() const { return K; } +}; + +std::vector<FlattenedSpelling> GetFlattenedSpellings(const Record &Attr) { + std::vector<Record *> Spellings = Attr.getValueAsListOfDefs("Spellings"); + std::vector<FlattenedSpelling> Ret; + + for (const auto &Spelling : Spellings) { + if (Spelling->getValueAsString("Variety") == "GCC") { + // Gin up two new spelling objects to add into the list. + Ret.push_back(FlattenedSpelling("GNU", Spelling->getValueAsString("Name"), + "", true)); + Ret.push_back(FlattenedSpelling( + "CXX11", Spelling->getValueAsString("Name"), "gnu", true)); + } else + Ret.push_back(FlattenedSpelling(*Spelling)); } - return Strings; + return Ret; } static std::string ReadPCHRecord(StringRef type) { @@ -50,7 +78,6 @@ static std::string ReadPCHRecord(StringRef type) { .Case("TypeSourceInfo *", "GetTypeSourceInfo(F, Record, Idx)") .Case("Expr *", "ReadExpr(F)") .Case("IdentifierInfo *", "GetIdentifierInfo(F, Record, Idx)") - .Case("SourceLocation", "ReadSourceLocation(F, Record, Idx)") .Default("Record[Idx++]"); } @@ -64,8 +91,6 @@ static std::string WritePCHRecord(StringRef type, StringRef name) { .Case("Expr *", "AddStmt(" + std::string(name) + ");\n") .Case("IdentifierInfo *", "AddIdentifierRef(" + std::string(name) + ", Record);\n") - .Case("SourceLocation", - "AddSourceLocation(" + std::string(name) + ", Record);\n") .Default("Record.push_back(" + std::string(name) + ");\n"); } @@ -82,6 +107,17 @@ static StringRef NormalizeAttrName(StringRef AttrName) { return AttrName; } +// Normalize the name by removing any and all leading and trailing underscores. +// This is different from NormalizeAttrName in that it also handles names like +// _pascal and __pascal. +static StringRef NormalizeNameForSpellingComparison(StringRef Name) { + while (Name.startswith("_")) + Name = Name.substr(1, Name.size()); + while (Name.endswith("_")) + Name = Name.substr(0, Name.size() - 1); + return Name; +} + // Normalize attribute spelling only if the spelling has both leading // and trailing underscores. For example, __ms_struct__ will be // normalized to "ms_struct"; __cdecl will remain intact. @@ -93,6 +129,37 @@ static StringRef NormalizeAttrSpelling(StringRef AttrSpelling) { return AttrSpelling; } +typedef std::vector<std::pair<std::string, const Record *>> ParsedAttrMap; + +static ParsedAttrMap getParsedAttrList(const RecordKeeper &Records, + ParsedAttrMap *Dupes = nullptr) { + std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr"); + std::set<std::string> Seen; + ParsedAttrMap R; + for (const auto *Attr : Attrs) { + if (Attr->getValueAsBit("SemaHandler")) { + std::string AN; + if (Attr->isSubClassOf("TargetSpecificAttr") && + !Attr->isValueUnset("ParseKind")) { + AN = Attr->getValueAsString("ParseKind"); + + // If this attribute has already been handled, it does not need to be + // handled again. + if (Seen.find(AN) != Seen.end()) { + if (Dupes) + Dupes->push_back(std::make_pair(AN, Attr)); + continue; + } + Seen.insert(AN); + } else + AN = NormalizeAttrName(Attr->getName()).str(); + + R.push_back(std::make_pair(AN, Attr)); + } + } + return R; +} + namespace { class Argument { std::string lowerName, upperName; @@ -100,7 +167,7 @@ namespace { bool isOpt; public: - Argument(Record &Arg, StringRef Attr) + Argument(const Record &Arg, StringRef Attr) : lowerName(Arg.getValueAsString("Name")), upperName(lowerName), attrName(Attr), isOpt(false) { if (!lowerName.empty()) { @@ -120,6 +187,7 @@ namespace { // These functions print the argument contents formatted in different ways. virtual void writeAccessors(raw_ostream &OS) const = 0; virtual void writeAccessorDefinitions(raw_ostream &OS) const {} + virtual void writeASTVisitorTraversal(raw_ostream &OS) const {} virtual void writeCloneArgs(raw_ostream &OS) const = 0; virtual void writeTemplateInstantiationArgs(raw_ostream &OS) const = 0; virtual void writeTemplateInstantiation(raw_ostream &OS) const {} @@ -138,53 +206,57 @@ namespace { virtual bool isEnumArg() const { return false; } virtual bool isVariadicEnumArg() const { return false; } + + virtual void writeImplicitCtorArgs(raw_ostream &OS) const { + OS << getUpperName(); + } }; class SimpleArgument : public Argument { std::string type; public: - SimpleArgument(Record &Arg, StringRef Attr, std::string T) + SimpleArgument(const Record &Arg, StringRef Attr, std::string T) : Argument(Arg, Attr), type(T) {} std::string getType() const { return type; } - void writeAccessors(raw_ostream &OS) const { + void writeAccessors(raw_ostream &OS) const override { OS << " " << type << " get" << getUpperName() << "() const {\n"; OS << " return " << getLowerName() << ";\n"; OS << " }"; } - void writeCloneArgs(raw_ostream &OS) const { + void writeCloneArgs(raw_ostream &OS) const override { OS << getLowerName(); } - void writeTemplateInstantiationArgs(raw_ostream &OS) const { + void writeTemplateInstantiationArgs(raw_ostream &OS) const override { OS << "A->get" << getUpperName() << "()"; } - void writeCtorInitializers(raw_ostream &OS) const { + void writeCtorInitializers(raw_ostream &OS) const override { OS << getLowerName() << "(" << getUpperName() << ")"; } - void writeCtorDefaultInitializers(raw_ostream &OS) const { + void writeCtorDefaultInitializers(raw_ostream &OS) const override { OS << getLowerName() << "()"; } - void writeCtorParameters(raw_ostream &OS) const { + void writeCtorParameters(raw_ostream &OS) const override { OS << type << " " << getUpperName(); } - void writeDeclarations(raw_ostream &OS) const { + void writeDeclarations(raw_ostream &OS) const override { OS << type << " " << getLowerName() << ";"; } - void writePCHReadDecls(raw_ostream &OS) const { + void writePCHReadDecls(raw_ostream &OS) const override { std::string read = ReadPCHRecord(type); OS << " " << type << " " << getLowerName() << " = " << read << ";\n"; } - void writePCHReadArgs(raw_ostream &OS) const { + void writePCHReadArgs(raw_ostream &OS) const override { OS << getLowerName(); } - void writePCHWrite(raw_ostream &OS) const { + void writePCHWrite(raw_ostream &OS) const override { OS << " " << WritePCHRecord(type, "SA->get" + std::string(getUpperName()) + "()"); } - void writeValue(raw_ostream &OS) const { + void writeValue(raw_ostream &OS) const override { if (type == "FunctionDecl *") { OS << "\" << get" << getUpperName() << "()->getNameInfo().getAsString() << \""; @@ -192,13 +264,11 @@ namespace { OS << "\" << get" << getUpperName() << "()->getName() << \""; } else if (type == "TypeSourceInfo *") { OS << "\" << get" << getUpperName() << "().getAsString() << \""; - } else if (type == "SourceLocation") { - OS << "\" << get" << getUpperName() << "().getRawEncoding() << \""; } else { OS << "\" << get" << getUpperName() << "() << \""; } } - void writeDump(raw_ostream &OS) const { + void writeDump(raw_ostream &OS) const override { if (type == "FunctionDecl *") { OS << " OS << \" \";\n"; OS << " dumpBareDeclRef(SA->get" << getUpperName() << "());\n"; @@ -208,9 +278,6 @@ namespace { } else if (type == "TypeSourceInfo *") { OS << " OS << \" \" << SA->get" << getUpperName() << "().getAsString();\n"; - } else if (type == "SourceLocation") { - OS << " OS << \" \";\n"; - OS << " SA->get" << getUpperName() << "().print(OS, *SM);\n"; } else if (type == "bool") { OS << " if (SA->get" << getUpperName() << "()) OS << \" " << getUpperName() << "\";\n"; @@ -222,13 +289,29 @@ namespace { } }; + class DefaultSimpleArgument : public SimpleArgument { + int64_t Default; + + public: + DefaultSimpleArgument(const Record &Arg, StringRef Attr, + std::string T, int64_t Default) + : SimpleArgument(Arg, Attr, T), Default(Default) {} + + void writeAccessors(raw_ostream &OS) const override { + SimpleArgument::writeAccessors(OS); + + OS << "\n\n static const " << getType() << " Default" << getUpperName() + << " = " << Default << ";"; + } + }; + class StringArgument : public Argument { public: - StringArgument(Record &Arg, StringRef Attr) + StringArgument(const Record &Arg, StringRef Attr) : Argument(Arg, Attr) {} - void writeAccessors(raw_ostream &OS) const { + void writeAccessors(raw_ostream &OS) const override { OS << " llvm::StringRef get" << getUpperName() << "() const {\n"; OS << " return llvm::StringRef(" << getLowerName() << ", " << getLowerName() << "Length);\n"; @@ -245,45 +328,45 @@ namespace { << getLowerName() << "Length);\n"; OS << " }"; } - void writeCloneArgs(raw_ostream &OS) const { + void writeCloneArgs(raw_ostream &OS) const override { OS << "get" << getUpperName() << "()"; } - void writeTemplateInstantiationArgs(raw_ostream &OS) const { + void writeTemplateInstantiationArgs(raw_ostream &OS) const override { OS << "A->get" << getUpperName() << "()"; } - void writeCtorBody(raw_ostream &OS) const { + void writeCtorBody(raw_ostream &OS) const override { OS << " std::memcpy(" << getLowerName() << ", " << getUpperName() << ".data(), " << getLowerName() << "Length);"; } - void writeCtorInitializers(raw_ostream &OS) const { + void writeCtorInitializers(raw_ostream &OS) const override { OS << getLowerName() << "Length(" << getUpperName() << ".size())," << getLowerName() << "(new (Ctx, 1) char[" << getLowerName() << "Length])"; } - void writeCtorDefaultInitializers(raw_ostream &OS) const { + void writeCtorDefaultInitializers(raw_ostream &OS) const override { OS << getLowerName() << "Length(0)," << getLowerName() << "(0)"; } - void writeCtorParameters(raw_ostream &OS) const { + void writeCtorParameters(raw_ostream &OS) const override { OS << "llvm::StringRef " << getUpperName(); } - void writeDeclarations(raw_ostream &OS) const { + void writeDeclarations(raw_ostream &OS) const override { OS << "unsigned " << getLowerName() << "Length;\n"; OS << "char *" << getLowerName() << ";"; } - void writePCHReadDecls(raw_ostream &OS) const { + void writePCHReadDecls(raw_ostream &OS) const override { OS << " std::string " << getLowerName() << "= ReadString(Record, Idx);\n"; } - void writePCHReadArgs(raw_ostream &OS) const { + void writePCHReadArgs(raw_ostream &OS) const override { OS << getLowerName(); } - void writePCHWrite(raw_ostream &OS) const { + void writePCHWrite(raw_ostream &OS) const override { OS << " AddString(SA->get" << getUpperName() << "(), Record);\n"; } - void writeValue(raw_ostream &OS) const { + void writeValue(raw_ostream &OS) const override { OS << "\\\"\" << get" << getUpperName() << "() << \"\\\""; } - void writeDump(raw_ostream &OS) const { + void writeDump(raw_ostream &OS) const override { OS << " OS << \" \\\"\" << SA->get" << getUpperName() << "() << \"\\\"\";\n"; } @@ -291,11 +374,11 @@ namespace { class AlignedArgument : public Argument { public: - AlignedArgument(Record &Arg, StringRef Attr) + AlignedArgument(const Record &Arg, StringRef Attr) : Argument(Arg, Attr) {} - void writeAccessors(raw_ostream &OS) const { + void writeAccessors(raw_ostream &OS) const override { OS << " bool is" << getUpperName() << "Dependent() const;\n"; OS << " unsigned get" << getUpperName() << "(ASTContext &Ctx) const;\n"; @@ -314,7 +397,7 @@ namespace { OS << " return " << getLowerName() << "Type;\n"; OS << " }"; } - void writeAccessorDefinitions(raw_ostream &OS) const { + void writeAccessorDefinitions(raw_ostream &OS) const override { OS << "bool " << getAttrName() << "Attr::is" << getUpperName() << "Dependent() const {\n"; OS << " if (is" << getLowerName() << "Expr)\n"; @@ -342,17 +425,17 @@ namespace { OS << " return 0; // FIXME\n"; OS << "}\n"; } - void writeCloneArgs(raw_ostream &OS) const { + void writeCloneArgs(raw_ostream &OS) const override { OS << "is" << getLowerName() << "Expr, is" << getLowerName() << "Expr ? static_cast<void*>(" << getLowerName() << "Expr) : " << getLowerName() << "Type"; } - void writeTemplateInstantiationArgs(raw_ostream &OS) const { + void writeTemplateInstantiationArgs(raw_ostream &OS) const override { // FIXME: move the definition in Sema::InstantiateAttrs to here. // In the meantime, aligned attributes are cloned. } - void writeCtorBody(raw_ostream &OS) const { + void writeCtorBody(raw_ostream &OS) const override { OS << " if (is" << getLowerName() << "Expr)\n"; OS << " " << getLowerName() << "Expr = reinterpret_cast<Expr *>(" << getUpperName() << ");\n"; @@ -361,26 +444,29 @@ namespace { << "Type = reinterpret_cast<TypeSourceInfo *>(" << getUpperName() << ");"; } - void writeCtorInitializers(raw_ostream &OS) const { + void writeCtorInitializers(raw_ostream &OS) const override { OS << "is" << getLowerName() << "Expr(Is" << getUpperName() << "Expr)"; } - void writeCtorDefaultInitializers(raw_ostream &OS) const { + void writeCtorDefaultInitializers(raw_ostream &OS) const override { OS << "is" << getLowerName() << "Expr(false)"; } - void writeCtorParameters(raw_ostream &OS) const { + void writeCtorParameters(raw_ostream &OS) const override { OS << "bool Is" << getUpperName() << "Expr, void *" << getUpperName(); } - void writeDeclarations(raw_ostream &OS) const { + void writeImplicitCtorArgs(raw_ostream &OS) const override { + OS << "Is" << getUpperName() << "Expr, " << getUpperName(); + } + void writeDeclarations(raw_ostream &OS) const override { OS << "bool is" << getLowerName() << "Expr;\n"; OS << "union {\n"; OS << "Expr *" << getLowerName() << "Expr;\n"; OS << "TypeSourceInfo *" << getLowerName() << "Type;\n"; OS << "};"; } - void writePCHReadArgs(raw_ostream &OS) const { + void writePCHReadArgs(raw_ostream &OS) const override { OS << "is" << getLowerName() << "Expr, " << getLowerName() << "Ptr"; } - void writePCHReadDecls(raw_ostream &OS) const { + void writePCHReadDecls(raw_ostream &OS) const override { OS << " bool is" << getLowerName() << "Expr = Record[Idx++];\n"; OS << " void *" << getLowerName() << "Ptr;\n"; OS << " if (is" << getLowerName() << "Expr)\n"; @@ -389,7 +475,7 @@ namespace { OS << " " << getLowerName() << "Ptr = GetTypeSourceInfo(F, Record, Idx);\n"; } - void writePCHWrite(raw_ostream &OS) const { + void writePCHWrite(raw_ostream &OS) const override { OS << " Record.push_back(SA->is" << getUpperName() << "Expr());\n"; OS << " if (SA->is" << getUpperName() << "Expr())\n"; OS << " AddStmt(SA->get" << getUpperName() << "Expr());\n"; @@ -397,14 +483,16 @@ namespace { OS << " AddTypeSourceInfo(SA->get" << getUpperName() << "Type(), Record);\n"; } - void writeValue(raw_ostream &OS) const { - OS << "\";\n" - << " " << getLowerName() << "Expr->printPretty(OS, 0, Policy);\n" - << " OS << \""; + void writeValue(raw_ostream &OS) const override { + OS << "\";\n"; + OS << " assert(is" << getLowerName() << "Expr && " << getLowerName() + << "Expr != nullptr);\n"; + OS << " " << getLowerName() << "Expr->printPretty(OS, 0, Policy);\n"; + OS << " OS << \""; } - void writeDump(raw_ostream &OS) const { + void writeDump(raw_ostream &OS) const override { } - void writeDumpChildren(raw_ostream &OS) const { + void writeDumpChildren(raw_ostream &OS) const override { OS << " if (SA->is" << getUpperName() << "Expr()) {\n"; OS << " lastChild();\n"; OS << " dumpStmt(SA->get" << getUpperName() << "Expr());\n"; @@ -412,148 +500,157 @@ namespace { OS << " dumpType(SA->get" << getUpperName() << "Type()->getType());\n"; } - void writeHasChildren(raw_ostream &OS) const { + void writeHasChildren(raw_ostream &OS) const override { OS << "SA->is" << getUpperName() << "Expr()"; } }; class VariadicArgument : public Argument { - std::string type; + std::string Type, ArgName, ArgSizeName, RangeName; public: - VariadicArgument(Record &Arg, StringRef Attr, std::string T) - : Argument(Arg, Attr), type(T) - {} + VariadicArgument(const Record &Arg, StringRef Attr, std::string T) + : Argument(Arg, Attr), Type(T), ArgName(getLowerName().str() + "_"), + ArgSizeName(ArgName + "Size"), RangeName(getLowerName()) {} - std::string getType() const { return type; } + std::string getType() const { return Type; } - void writeAccessors(raw_ostream &OS) const { - OS << " typedef " << type << "* " << getLowerName() << "_iterator;\n"; - OS << " " << getLowerName() << "_iterator " << getLowerName() - << "_begin() const {\n"; - OS << " return " << getLowerName() << ";\n"; - OS << " }\n"; - OS << " " << getLowerName() << "_iterator " << getLowerName() - << "_end() const {\n"; - OS << " return " << getLowerName() << " + " << getLowerName() - << "Size;\n"; - OS << " }\n"; - OS << " unsigned " << getLowerName() << "_size() const {\n" - << " return " << getLowerName() << "Size;\n"; - OS << " }"; - } - void writeCloneArgs(raw_ostream &OS) const { - OS << getLowerName() << ", " << getLowerName() << "Size"; - } - void writeTemplateInstantiationArgs(raw_ostream &OS) const { + void writeAccessors(raw_ostream &OS) const override { + std::string IteratorType = getLowerName().str() + "_iterator"; + std::string BeginFn = getLowerName().str() + "_begin()"; + std::string EndFn = getLowerName().str() + "_end()"; + + OS << " typedef " << Type << "* " << IteratorType << ";\n"; + OS << " " << IteratorType << " " << BeginFn << " const {" + << " return " << ArgName << "; }\n"; + OS << " " << IteratorType << " " << EndFn << " const {" + << " return " << ArgName << " + " << ArgSizeName << "; }\n"; + OS << " unsigned " << getLowerName() << "_size() const {" + << " return " << ArgSizeName << "; }\n"; + OS << " llvm::iterator_range<" << IteratorType << "> " << RangeName + << "() const { return llvm::make_range(" << BeginFn << ", " << EndFn + << "); }\n"; + } + void writeCloneArgs(raw_ostream &OS) const override { + OS << ArgName << ", " << ArgSizeName; + } + void writeTemplateInstantiationArgs(raw_ostream &OS) const override { // This isn't elegant, but we have to go through public methods... OS << "A->" << getLowerName() << "_begin(), " << "A->" << getLowerName() << "_size()"; } - void writeCtorBody(raw_ostream &OS) const { - // FIXME: memcpy is not safe on non-trivial types. - OS << " std::memcpy(" << getLowerName() << ", " << getUpperName() - << ", " << getLowerName() << "Size * sizeof(" << getType() << "));\n"; + void writeCtorBody(raw_ostream &OS) const override { + OS << " std::copy(" << getUpperName() << ", " << getUpperName() + << " + " << ArgSizeName << ", " << ArgName << ");"; } - void writeCtorInitializers(raw_ostream &OS) const { - OS << getLowerName() << "Size(" << getUpperName() << "Size), " - << getLowerName() << "(new (Ctx, 16) " << getType() << "[" - << getLowerName() << "Size])"; + void writeCtorInitializers(raw_ostream &OS) const override { + OS << ArgSizeName << "(" << getUpperName() << "Size), " + << ArgName << "(new (Ctx, 16) " << getType() << "[" + << ArgSizeName << "])"; } - void writeCtorDefaultInitializers(raw_ostream &OS) const { - OS << getLowerName() << "Size(0), " << getLowerName() << "(0)"; + void writeCtorDefaultInitializers(raw_ostream &OS) const override { + OS << ArgSizeName << "(0), " << ArgName << "(nullptr)"; } - void writeCtorParameters(raw_ostream &OS) const { + void writeCtorParameters(raw_ostream &OS) const override { OS << getType() << " *" << getUpperName() << ", unsigned " << getUpperName() << "Size"; } - void writeDeclarations(raw_ostream &OS) const { - OS << " unsigned " << getLowerName() << "Size;\n"; - OS << " " << getType() << " *" << getLowerName() << ";"; + void writeImplicitCtorArgs(raw_ostream &OS) const override { + OS << getUpperName() << ", " << getUpperName() << "Size"; } - void writePCHReadDecls(raw_ostream &OS) const { + void writeDeclarations(raw_ostream &OS) const override { + OS << " unsigned " << ArgSizeName << ";\n"; + OS << " " << getType() << " *" << ArgName << ";"; + } + void writePCHReadDecls(raw_ostream &OS) const override { OS << " unsigned " << getLowerName() << "Size = Record[Idx++];\n"; - OS << " SmallVector<" << type << ", 4> " << getLowerName() + OS << " SmallVector<" << Type << ", 4> " << getLowerName() << ";\n"; OS << " " << getLowerName() << ".reserve(" << getLowerName() << "Size);\n"; OS << " for (unsigned i = " << getLowerName() << "Size; i; --i)\n"; - std::string read = ReadPCHRecord(type); + std::string read = ReadPCHRecord(Type); OS << " " << getLowerName() << ".push_back(" << read << ");\n"; } - void writePCHReadArgs(raw_ostream &OS) const { + void writePCHReadArgs(raw_ostream &OS) const override { OS << getLowerName() << ".data(), " << getLowerName() << "Size"; } - void writePCHWrite(raw_ostream &OS) const{ + void writePCHWrite(raw_ostream &OS) const override { OS << " Record.push_back(SA->" << getLowerName() << "_size());\n"; - OS << " for (" << getAttrName() << "Attr::" << getLowerName() - << "_iterator i = SA->" << getLowerName() << "_begin(), e = SA->" - << getLowerName() << "_end(); i != e; ++i)\n"; - OS << " " << WritePCHRecord(type, "(*i)"); + OS << " for (auto &Val : SA->" << RangeName << "())\n"; + OS << " " << WritePCHRecord(Type, "Val"); } - void writeValue(raw_ostream &OS) const { + void writeValue(raw_ostream &OS) const override { OS << "\";\n"; OS << " bool isFirst = true;\n" - << " for (" << getAttrName() << "Attr::" << getLowerName() - << "_iterator i = " << getLowerName() << "_begin(), e = " - << getLowerName() << "_end(); i != e; ++i) {\n" + << " for (const auto &Val : " << RangeName << "()) {\n" << " if (isFirst) isFirst = false;\n" << " else OS << \", \";\n" - << " OS << *i;\n" + << " OS << Val;\n" << " }\n"; OS << " OS << \""; } - void writeDump(raw_ostream &OS) const { - OS << " for (" << getAttrName() << "Attr::" << getLowerName() - << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->" - << getLowerName() << "_end(); I != E; ++I)\n"; - OS << " OS << \" \" << *I;\n"; + void writeDump(raw_ostream &OS) const override { + OS << " for (const auto &Val : SA->" << RangeName << "())\n"; + OS << " OS << \" \" << Val;\n"; } }; + // Unique the enums, but maintain the original declaration ordering. + std::vector<std::string> + uniqueEnumsInOrder(const std::vector<std::string> &enums) { + std::vector<std::string> uniques; + std::set<std::string> unique_set(enums.begin(), enums.end()); + for (const auto &i : enums) { + std::set<std::string>::iterator set_i = unique_set.find(i); + if (set_i != unique_set.end()) { + uniques.push_back(i); + unique_set.erase(set_i); + } + } + return uniques; + } + class EnumArgument : public Argument { std::string type; - std::vector<StringRef> values, enums, uniques; + std::vector<std::string> values, enums, uniques; public: - EnumArgument(Record &Arg, StringRef Attr) + EnumArgument(const Record &Arg, StringRef Attr) : Argument(Arg, Attr), type(Arg.getValueAsString("Type")), - values(getValueAsListOfStrings(Arg, "Values")), - enums(getValueAsListOfStrings(Arg, "Enums")), - uniques(enums) + values(Arg.getValueAsListOfStrings("Values")), + enums(Arg.getValueAsListOfStrings("Enums")), + uniques(uniqueEnumsInOrder(enums)) { - // Calculate the various enum values - std::sort(uniques.begin(), uniques.end()); - uniques.erase(std::unique(uniques.begin(), uniques.end()), uniques.end()); // FIXME: Emit a proper error assert(!uniques.empty()); } - bool isEnumArg() const { return true; } + bool isEnumArg() const override { return true; } - void writeAccessors(raw_ostream &OS) const { + void writeAccessors(raw_ostream &OS) const override { OS << " " << type << " get" << getUpperName() << "() const {\n"; OS << " return " << getLowerName() << ";\n"; OS << " }"; } - void writeCloneArgs(raw_ostream &OS) const { + void writeCloneArgs(raw_ostream &OS) const override { OS << getLowerName(); } - void writeTemplateInstantiationArgs(raw_ostream &OS) const { + void writeTemplateInstantiationArgs(raw_ostream &OS) const override { OS << "A->get" << getUpperName() << "()"; } - void writeCtorInitializers(raw_ostream &OS) const { + void writeCtorInitializers(raw_ostream &OS) const override { OS << getLowerName() << "(" << getUpperName() << ")"; } - void writeCtorDefaultInitializers(raw_ostream &OS) const { + void writeCtorDefaultInitializers(raw_ostream &OS) const override { OS << getLowerName() << "(" << type << "(0))"; } - void writeCtorParameters(raw_ostream &OS) const { + void writeCtorParameters(raw_ostream &OS) const override { OS << type << " " << getUpperName(); } - void writeDeclarations(raw_ostream &OS) const { - std::vector<StringRef>::const_iterator i = uniques.begin(), - e = uniques.end(); + void writeDeclarations(raw_ostream &OS) const override { + std::vector<std::string>::const_iterator i = uniques.begin(), + e = uniques.end(); // The last one needs to not have a comma. --e; @@ -566,26 +663,25 @@ namespace { OS << "private:\n"; OS << " " << type << " " << getLowerName() << ";"; } - void writePCHReadDecls(raw_ostream &OS) const { + void writePCHReadDecls(raw_ostream &OS) const override { OS << " " << getAttrName() << "Attr::" << type << " " << getLowerName() << "(static_cast<" << getAttrName() << "Attr::" << type << ">(Record[Idx++]));\n"; } - void writePCHReadArgs(raw_ostream &OS) const { + void writePCHReadArgs(raw_ostream &OS) const override { OS << getLowerName(); } - void writePCHWrite(raw_ostream &OS) const { + void writePCHWrite(raw_ostream &OS) const override { OS << "Record.push_back(SA->get" << getUpperName() << "());\n"; } - void writeValue(raw_ostream &OS) const { + void writeValue(raw_ostream &OS) const override { OS << "\" << get" << getUpperName() << "() << \""; } - void writeDump(raw_ostream &OS) const { + void writeDump(raw_ostream &OS) const override { OS << " switch(SA->get" << getUpperName() << "()) {\n"; - for (std::vector<StringRef>::const_iterator I = uniques.begin(), - E = uniques.end(); I != E; ++I) { - OS << " case " << getAttrName() << "Attr::" << *I << ":\n"; - OS << " OS << \" " << *I << "\";\n"; + for (const auto &I : uniques) { + OS << " case " << getAttrName() << "Attr::" << I << ":\n"; + OS << " OS << \" " << I << "\";\n"; OS << " break;\n"; } OS << " }\n"; @@ -595,7 +691,7 @@ namespace { OS << " static bool ConvertStrTo" << type << "(StringRef Val, "; OS << type << " &Out) {\n"; OS << " Optional<" << type << "> R = llvm::StringSwitch<Optional<"; - OS << type << "> >(Val)\n"; + OS << type << ">>(Val)\n"; for (size_t I = 0; I < enums.size(); ++I) { OS << " .Case(\"" << values[I] << "\", "; OS << getAttrName() << "Attr::" << enums[I] << ")\n"; @@ -610,30 +706,26 @@ namespace { class VariadicEnumArgument: public VariadicArgument { std::string type, QualifiedTypeName; - std::vector<StringRef> values, enums, uniques; + std::vector<std::string> values, enums, uniques; public: - VariadicEnumArgument(Record &Arg, StringRef Attr) + VariadicEnumArgument(const Record &Arg, StringRef Attr) : VariadicArgument(Arg, Attr, Arg.getValueAsString("Type")), type(Arg.getValueAsString("Type")), - values(getValueAsListOfStrings(Arg, "Values")), - enums(getValueAsListOfStrings(Arg, "Enums")), - uniques(enums) + values(Arg.getValueAsListOfStrings("Values")), + enums(Arg.getValueAsListOfStrings("Enums")), + uniques(uniqueEnumsInOrder(enums)) { - // Calculate the various enum values - std::sort(uniques.begin(), uniques.end()); - uniques.erase(std::unique(uniques.begin(), uniques.end()), uniques.end()); - QualifiedTypeName = getAttrName().str() + "Attr::" + type; // FIXME: Emit a proper error assert(!uniques.empty()); } - bool isVariadicEnumArg() const { return true; } + bool isVariadicEnumArg() const override { return true; } - void writeDeclarations(raw_ostream &OS) const { - std::vector<StringRef>::const_iterator i = uniques.begin(), - e = uniques.end(); + void writeDeclarations(raw_ostream &OS) const override { + std::vector<std::string>::const_iterator i = uniques.begin(), + e = uniques.end(); // The last one needs to not have a comma. --e; @@ -647,21 +739,20 @@ namespace { VariadicArgument::writeDeclarations(OS); } - void writeDump(raw_ostream &OS) const { + void writeDump(raw_ostream &OS) const override { OS << " for (" << getAttrName() << "Attr::" << getLowerName() << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->" << getLowerName() << "_end(); I != E; ++I) {\n"; OS << " switch(*I) {\n"; - for (std::vector<StringRef>::const_iterator UI = uniques.begin(), - UE = uniques.end(); UI != UE; ++UI) { - OS << " case " << getAttrName() << "Attr::" << *UI << ":\n"; - OS << " OS << \" " << *UI << "\";\n"; + for (const auto &UI : uniques) { + OS << " case " << getAttrName() << "Attr::" << UI << ":\n"; + OS << " OS << \" " << UI << "\";\n"; OS << " break;\n"; } OS << " }\n"; OS << " }\n"; } - void writePCHReadDecls(raw_ostream &OS) const { + void writePCHReadDecls(raw_ostream &OS) const override { OS << " unsigned " << getLowerName() << "Size = Record[Idx++];\n"; OS << " SmallVector<" << QualifiedTypeName << ", 4> " << getLowerName() << ";\n"; @@ -671,7 +762,7 @@ namespace { OS << " " << getLowerName() << ".push_back(" << "static_cast<" << QualifiedTypeName << ">(Record[Idx++]));\n"; } - void writePCHWrite(raw_ostream &OS) const{ + void writePCHWrite(raw_ostream &OS) const override { OS << " Record.push_back(SA->" << getLowerName() << "_size());\n"; OS << " for (" << getAttrName() << "Attr::" << getLowerName() << "_iterator i = SA->" << getLowerName() << "_begin(), e = SA->" @@ -682,7 +773,7 @@ namespace { OS << " static bool ConvertStrTo" << type << "(StringRef Val, "; OS << type << " &Out) {\n"; OS << " Optional<" << type << "> R = llvm::StringSwitch<Optional<"; - OS << type << "> >(Val)\n"; + OS << type << ">>(Val)\n"; for (size_t I = 0; I < enums.size(); ++I) { OS << " .Case(\"" << values[I] << "\", "; OS << getAttrName() << "Attr::" << enums[I] << ")\n"; @@ -697,11 +788,11 @@ namespace { class VersionArgument : public Argument { public: - VersionArgument(Record &Arg, StringRef Attr) + VersionArgument(const Record &Arg, StringRef Attr) : Argument(Arg, Attr) {} - void writeAccessors(raw_ostream &OS) const { + void writeAccessors(raw_ostream &OS) const override { OS << " VersionTuple get" << getUpperName() << "() const {\n"; OS << " return " << getLowerName() << ";\n"; OS << " }\n"; @@ -710,55 +801,59 @@ namespace { OS << " " << getLowerName() << " = V;\n"; OS << " }"; } - void writeCloneArgs(raw_ostream &OS) const { + void writeCloneArgs(raw_ostream &OS) const override { OS << "get" << getUpperName() << "()"; } - void writeTemplateInstantiationArgs(raw_ostream &OS) const { + void writeTemplateInstantiationArgs(raw_ostream &OS) const override { OS << "A->get" << getUpperName() << "()"; } - void writeCtorBody(raw_ostream &OS) const { - } - void writeCtorInitializers(raw_ostream &OS) const { + void writeCtorInitializers(raw_ostream &OS) const override { OS << getLowerName() << "(" << getUpperName() << ")"; } - void writeCtorDefaultInitializers(raw_ostream &OS) const { + void writeCtorDefaultInitializers(raw_ostream &OS) const override { OS << getLowerName() << "()"; } - void writeCtorParameters(raw_ostream &OS) const { + void writeCtorParameters(raw_ostream &OS) const override { OS << "VersionTuple " << getUpperName(); } - void writeDeclarations(raw_ostream &OS) const { + void writeDeclarations(raw_ostream &OS) const override { OS << "VersionTuple " << getLowerName() << ";\n"; } - void writePCHReadDecls(raw_ostream &OS) const { + void writePCHReadDecls(raw_ostream &OS) const override { OS << " VersionTuple " << getLowerName() << "= ReadVersionTuple(Record, Idx);\n"; } - void writePCHReadArgs(raw_ostream &OS) const { + void writePCHReadArgs(raw_ostream &OS) const override { OS << getLowerName(); } - void writePCHWrite(raw_ostream &OS) const { + void writePCHWrite(raw_ostream &OS) const override { OS << " AddVersionTuple(SA->get" << getUpperName() << "(), Record);\n"; } - void writeValue(raw_ostream &OS) const { + void writeValue(raw_ostream &OS) const override { OS << getLowerName() << "=\" << get" << getUpperName() << "() << \""; } - void writeDump(raw_ostream &OS) const { + void writeDump(raw_ostream &OS) const override { OS << " OS << \" \" << SA->get" << getUpperName() << "();\n"; } }; class ExprArgument : public SimpleArgument { public: - ExprArgument(Record &Arg, StringRef Attr) + ExprArgument(const Record &Arg, StringRef Attr) : SimpleArgument(Arg, Attr, "Expr *") {} - void writeTemplateInstantiationArgs(raw_ostream &OS) const { + void writeASTVisitorTraversal(raw_ostream &OS) const override { + OS << " if (!" + << "getDerived().TraverseStmt(A->get" << getUpperName() << "()))\n"; + OS << " return false;\n"; + } + + void writeTemplateInstantiationArgs(raw_ostream &OS) const override { OS << "tempInst" << getUpperName(); } - void writeTemplateInstantiation(raw_ostream &OS) const { + void writeTemplateInstantiation(raw_ostream &OS) const override { OS << " " << getType() << " tempInst" << getUpperName() << ";\n"; OS << " {\n"; OS << " EnterExpressionEvaluationContext " @@ -766,32 +861,44 @@ namespace { OS << " ExprResult " << "Result = S.SubstExpr(" << "A->get" << getUpperName() << "(), TemplateArgs);\n"; OS << " tempInst" << getUpperName() << " = " - << "Result.takeAs<Expr>();\n"; + << "Result.getAs<Expr>();\n"; OS << " }\n"; } - void writeDump(raw_ostream &OS) const { - } + void writeDump(raw_ostream &OS) const override {} - void writeDumpChildren(raw_ostream &OS) const { + void writeDumpChildren(raw_ostream &OS) const override { OS << " lastChild();\n"; OS << " dumpStmt(SA->get" << getUpperName() << "());\n"; } - void writeHasChildren(raw_ostream &OS) const { OS << "true"; } + void writeHasChildren(raw_ostream &OS) const override { OS << "true"; } }; class VariadicExprArgument : public VariadicArgument { public: - VariadicExprArgument(Record &Arg, StringRef Attr) + VariadicExprArgument(const Record &Arg, StringRef Attr) : VariadicArgument(Arg, Attr, "Expr *") {} - void writeTemplateInstantiationArgs(raw_ostream &OS) const { + void writeASTVisitorTraversal(raw_ostream &OS) const override { + OS << " {\n"; + OS << " " << getType() << " *I = A->" << getLowerName() + << "_begin();\n"; + OS << " " << getType() << " *E = A->" << getLowerName() + << "_end();\n"; + OS << " for (; I != E; ++I) {\n"; + OS << " if (!getDerived().TraverseStmt(*I))\n"; + OS << " return false;\n"; + OS << " }\n"; + OS << " }\n"; + } + + void writeTemplateInstantiationArgs(raw_ostream &OS) const override { OS << "tempInst" << getUpperName() << ", " << "A->" << getLowerName() << "_size()"; } - void writeTemplateInstantiation(raw_ostream &OS) const { + void writeTemplateInstantiation(raw_ostream &OS) const override { OS << " " << getType() << " *tempInst" << getUpperName() << " = new (C, 16) " << getType() << "[A->" << getLowerName() << "_size()];\n"; @@ -806,15 +913,14 @@ namespace { << "_end();\n"; OS << " for (; I != E; ++I, ++TI) {\n"; OS << " ExprResult Result = S.SubstExpr(*I, TemplateArgs);\n"; - OS << " *TI = Result.takeAs<Expr>();\n"; + OS << " *TI = Result.getAs<Expr>();\n"; OS << " }\n"; OS << " }\n"; } - void writeDump(raw_ostream &OS) const { - } + void writeDump(raw_ostream &OS) const override {} - void writeDumpChildren(raw_ostream &OS) const { + void writeDumpChildren(raw_ostream &OS) const override { OS << " for (" << getAttrName() << "Attr::" << getLowerName() << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->" << getLowerName() << "_end(); I != E; ++I) {\n"; @@ -824,7 +930,7 @@ namespace { OS << " }\n"; } - void writeHasChildren(raw_ostream &OS) const { + void writeHasChildren(raw_ostream &OS) const override { OS << "SA->" << getLowerName() << "_begin() != " << "SA->" << getLowerName() << "_end()"; } @@ -832,11 +938,11 @@ namespace { class TypeArgument : public SimpleArgument { public: - TypeArgument(Record &Arg, StringRef Attr) + TypeArgument(const Record &Arg, StringRef Attr) : SimpleArgument(Arg, Attr, "TypeSourceInfo *") {} - void writeAccessors(raw_ostream &OS) const { + void writeAccessors(raw_ostream &OS) const override { OS << " QualType get" << getUpperName() << "() const {\n"; OS << " return " << getLowerName() << "->getType();\n"; OS << " }"; @@ -844,22 +950,23 @@ namespace { OS << " return " << getLowerName() << ";\n"; OS << " }"; } - void writeTemplateInstantiationArgs(raw_ostream &OS) const { + void writeTemplateInstantiationArgs(raw_ostream &OS) const override { OS << "A->get" << getUpperName() << "Loc()"; } - void writePCHWrite(raw_ostream &OS) const { + void writePCHWrite(raw_ostream &OS) const override { OS << " " << WritePCHRecord( getType(), "SA->get" + std::string(getUpperName()) + "Loc()"); } }; } -static Argument *createArgument(Record &Arg, StringRef Attr, - Record *Search = 0) { +static std::unique_ptr<Argument> +createArgument(const Record &Arg, StringRef Attr, + const Record *Search = nullptr) { if (!Search) Search = &Arg; - Argument *Ptr = 0; + Argument *Ptr = nullptr; llvm::StringRef ArgName = Search->getName(); if (ArgName == "AlignedArgument") Ptr = new AlignedArgument(Arg, Attr); @@ -869,15 +976,19 @@ static Argument *createArgument(Record &Arg, StringRef Attr, Ptr = new SimpleArgument(Arg, Attr, "FunctionDecl *"); else if (ArgName == "IdentifierArgument") Ptr = new SimpleArgument(Arg, Attr, "IdentifierInfo *"); + else if (ArgName == "DefaultBoolArgument") + Ptr = new DefaultSimpleArgument(Arg, Attr, "bool", + Arg.getValueAsBit("Default")); else if (ArgName == "BoolArgument") Ptr = new SimpleArgument(Arg, Attr, "bool"); + else if (ArgName == "DefaultIntArgument") + Ptr = new DefaultSimpleArgument(Arg, Attr, "int", + Arg.getValueAsInt("Default")); else if (ArgName == "IntArgument") Ptr = new SimpleArgument(Arg, Attr, "int"); else if (ArgName == "StringArgument") Ptr = new StringArgument(Arg, Attr); else if (ArgName == "TypeArgument") Ptr = new TypeArgument(Arg, Attr); else if (ArgName == "UnsignedArgument") Ptr = new SimpleArgument(Arg, Attr, "unsigned"); - else if (ArgName == "SourceLocArgument") - Ptr = new SimpleArgument(Arg, Attr, "SourceLocation"); else if (ArgName == "VariadicUnsignedArgument") Ptr = new VariadicArgument(Arg, Attr, "unsigned"); else if (ArgName == "VariadicEnumArgument") @@ -888,10 +999,10 @@ static Argument *createArgument(Record &Arg, StringRef Attr, Ptr = new VersionArgument(Arg, Attr); if (!Ptr) { + // Search in reverse order so that the most-derived type is handled first. std::vector<Record*> Bases = Search->getSuperClasses(); - for (std::vector<Record*>::iterator i = Bases.begin(), e = Bases.end(); - i != e; ++i) { - Ptr = createArgument(Arg, Attr, *i); + for (const auto *Base : llvm::make_range(Bases.rbegin(), Bases.rend())) { + Ptr = createArgument(Arg, Attr, Base).release(); if (Ptr) break; } @@ -900,7 +1011,7 @@ static Argument *createArgument(Record &Arg, StringRef Attr, if (Ptr && Arg.getValueAsBit("Optional")) Ptr->setOptional(true); - return Ptr; + return std::unique_ptr<Argument>(Ptr); } static void writeAvailabilityValue(raw_ostream &OS) { @@ -912,14 +1023,39 @@ static void writeAvailabilityValue(raw_ostream &OS) { << " OS << \""; } -static void writePrettyPrintFunction(Record &R, std::vector<Argument*> &Args, - raw_ostream &OS) { - std::vector<Record*> Spellings = R.getValueAsListOfDefs("Spellings"); +static void writeGetSpellingFunction(Record &R, raw_ostream &OS) { + std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R); + + OS << "const char *" << R.getName() << "Attr::getSpelling() const {\n"; + if (Spellings.empty()) { + OS << " return \"(No spelling)\";\n}\n\n"; + return; + } + + OS << " switch (SpellingListIndex) {\n" + " default:\n" + " llvm_unreachable(\"Unknown attribute spelling!\");\n" + " return \"(No spelling)\";\n"; + + for (unsigned I = 0; I < Spellings.size(); ++I) + OS << " case " << I << ":\n" + " return \"" << Spellings[I].name() << "\";\n"; + // End of the switch statement. + OS << " }\n"; + // End of the getSpelling function. + OS << "}\n\n"; +} + +static void +writePrettyPrintFunction(Record &R, + const std::vector<std::unique_ptr<Argument>> &Args, + raw_ostream &OS) { + std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R); OS << "void " << R.getName() << "Attr::printPretty(" << "raw_ostream &OS, const PrintingPolicy &Policy) const {\n"; - if (Spellings.size() == 0) { + if (Spellings.empty()) { OS << "}\n\n"; return; } @@ -936,8 +1072,8 @@ static void writePrettyPrintFunction(Record &R, std::vector<Argument*> &Args, // The actual spelling of the name and namespace (if applicable) // of an attribute without considering prefix and suffix. llvm::SmallString<64> Spelling; - std::string Name = Spellings[I]->getValueAsString("Name"); - std::string Variety = Spellings[I]->getValueAsString("Variety"); + std::string Name = Spellings[I].name(); + std::string Variety = Spellings[I].variety(); if (Variety == "GNU") { Prefix = " __attribute__(("; @@ -945,8 +1081,8 @@ static void writePrettyPrintFunction(Record &R, std::vector<Argument*> &Args, } else if (Variety == "CXX11") { Prefix = " [["; Suffix = "]]"; - std::string Namespace = Spellings[I]->getValueAsString("Namespace"); - if (Namespace != "") { + std::string Namespace = Spellings[I].nameSpace(); + if (!Namespace.empty()) { Spelling += Namespace; Spelling += "::"; } @@ -956,6 +1092,14 @@ static void writePrettyPrintFunction(Record &R, std::vector<Argument*> &Args, } else if (Variety == "Keyword") { Prefix = " "; Suffix = ""; + } else if (Variety == "Pragma") { + Prefix = "#pragma "; + Suffix = "\n"; + std::string Namespace = Spellings[I].nameSpace(); + if (!Namespace.empty()) { + Spelling += Namespace; + Spelling += " "; + } } else { llvm_unreachable("Unknown attribute syntax variety!"); } @@ -966,18 +1110,27 @@ static void writePrettyPrintFunction(Record &R, std::vector<Argument*> &Args, " case " << I << " : {\n" " OS << \"" + Prefix.str() + Spelling.str(); - if (Args.size()) OS << "("; + if (Variety == "Pragma") { + OS << " \";\n"; + OS << " printPrettyPragma(OS, Policy);\n"; + OS << " break;\n"; + OS << " }\n"; + continue; + } + + if (!Args.empty()) + OS << "("; if (Spelling == "availability") { writeAvailabilityValue(OS); } else { - for (std::vector<Argument*>::const_iterator I = Args.begin(), - E = Args.end(); I != E; ++ I) { + for (auto I = Args.begin(), E = Args.end(); I != E; ++ I) { if (I != Args.begin()) OS << ", "; (*I)->writeValue(OS); } } - if (Args.size()) OS << ")"; + if (!Args.empty()) + OS << ")"; OS << Suffix.str() + "\";\n"; OS << @@ -992,19 +1145,18 @@ static void writePrettyPrintFunction(Record &R, std::vector<Argument*> &Args, } /// \brief Return the index of a spelling in a spelling list. -static unsigned getSpellingListIndex(const std::vector<Record*> &SpellingList, - const Record &Spelling) { +static unsigned +getSpellingListIndex(const std::vector<FlattenedSpelling> &SpellingList, + const FlattenedSpelling &Spelling) { assert(SpellingList.size() && "Spelling list is empty!"); for (unsigned Index = 0; Index < SpellingList.size(); ++Index) { - Record *S = SpellingList[Index]; - if (S->getValueAsString("Variety") != Spelling.getValueAsString("Variety")) + const FlattenedSpelling &S = SpellingList[Index]; + if (S.variety() != Spelling.variety()) continue; - if (S->getValueAsString("Variety") == "CXX11" && - S->getValueAsString("Namespace") != - Spelling.getValueAsString("Namespace")) + if (S.nameSpace() != Spelling.nameSpace()) continue; - if (S->getValueAsString("Name") != Spelling.getValueAsString("Name")) + if (S.name() != Spelling.name()) continue; return Index; @@ -1013,21 +1165,19 @@ static unsigned getSpellingListIndex(const std::vector<Record*> &SpellingList, llvm_unreachable("Unknown spelling!"); } -static void writeAttrAccessorDefinition(Record &R, raw_ostream &OS) { +static void writeAttrAccessorDefinition(const Record &R, raw_ostream &OS) { std::vector<Record*> Accessors = R.getValueAsListOfDefs("Accessors"); - for (std::vector<Record*>::const_iterator I = Accessors.begin(), - E = Accessors.end(); I != E; ++I) { - Record *Accessor = *I; + for (const auto *Accessor : Accessors) { std::string Name = Accessor->getValueAsString("Name"); - std::vector<Record*> Spellings = Accessor->getValueAsListOfDefs( - "Spellings"); - std::vector<Record*> SpellingList = R.getValueAsListOfDefs("Spellings"); + std::vector<FlattenedSpelling> Spellings = + GetFlattenedSpellings(*Accessor); + std::vector<FlattenedSpelling> SpellingList = GetFlattenedSpellings(R); assert(SpellingList.size() && "Attribute with empty spelling list can't have accessors!"); OS << " bool " << Name << "() const { return SpellingListIndex == "; for (unsigned Index = 0; Index < Spellings.size(); ++Index) { - OS << getSpellingListIndex(SpellingList, *Spellings[Index]); + OS << getSpellingListIndex(SpellingList, Spellings[Index]); if (Index != Spellings.size() -1) OS << " ||\n SpellingListIndex == "; else @@ -1036,6 +1186,173 @@ static void writeAttrAccessorDefinition(Record &R, raw_ostream &OS) { } } +static bool +SpellingNamesAreCommon(const std::vector<FlattenedSpelling>& Spellings) { + assert(!Spellings.empty() && "An empty list of spellings was provided"); + std::string FirstName = NormalizeNameForSpellingComparison( + Spellings.front().name()); + for (const auto &Spelling : + llvm::make_range(std::next(Spellings.begin()), Spellings.end())) { + std::string Name = NormalizeNameForSpellingComparison(Spelling.name()); + if (Name != FirstName) + return false; + } + return true; +} + +typedef std::map<unsigned, std::string> SemanticSpellingMap; +static std::string +CreateSemanticSpellings(const std::vector<FlattenedSpelling> &Spellings, + SemanticSpellingMap &Map) { + // The enumerants are automatically generated based on the variety, + // namespace (if present) and name for each attribute spelling. However, + // care is taken to avoid trampling on the reserved namespace due to + // underscores. + std::string Ret(" enum Spelling {\n"); + std::set<std::string> Uniques; + unsigned Idx = 0; + for (auto I = Spellings.begin(), E = Spellings.end(); I != E; ++I, ++Idx) { + const FlattenedSpelling &S = *I; + std::string Variety = S.variety(); + std::string Spelling = S.name(); + std::string Namespace = S.nameSpace(); + std::string EnumName = ""; + + EnumName += (Variety + "_"); + if (!Namespace.empty()) + EnumName += (NormalizeNameForSpellingComparison(Namespace).str() + + "_"); + EnumName += NormalizeNameForSpellingComparison(Spelling); + + // Even if the name is not unique, this spelling index corresponds to a + // particular enumerant name that we've calculated. + Map[Idx] = EnumName; + + // Since we have been stripping underscores to avoid trampling on the + // reserved namespace, we may have inadvertently created duplicate + // enumerant names. These duplicates are not considered part of the + // semantic spelling, and can be elided. + if (Uniques.find(EnumName) != Uniques.end()) + continue; + + Uniques.insert(EnumName); + if (I != Spellings.begin()) + Ret += ",\n"; + Ret += " " + EnumName; + } + Ret += "\n };\n\n"; + return Ret; +} + +void WriteSemanticSpellingSwitch(const std::string &VarName, + const SemanticSpellingMap &Map, + raw_ostream &OS) { + OS << " switch (" << VarName << ") {\n default: " + << "llvm_unreachable(\"Unknown spelling list index\");\n"; + for (const auto &I : Map) + OS << " case " << I.first << ": return " << I.second << ";\n"; + OS << " }\n"; +} + +// Emits the LateParsed property for attributes. +static void emitClangAttrLateParsedList(RecordKeeper &Records, raw_ostream &OS) { + OS << "#if defined(CLANG_ATTR_LATE_PARSED_LIST)\n"; + std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"); + + for (const auto *Attr : Attrs) { + bool LateParsed = Attr->getValueAsBit("LateParsed"); + + if (LateParsed) { + std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr); + + // FIXME: Handle non-GNU attributes + for (const auto &I : Spellings) { + if (I.variety() != "GNU") + continue; + OS << ".Case(\"" << I.name() << "\", " << LateParsed << ")\n"; + } + } + } + OS << "#endif // CLANG_ATTR_LATE_PARSED_LIST\n\n"; +} + +/// \brief Emits the first-argument-is-type property for attributes. +static void emitClangAttrTypeArgList(RecordKeeper &Records, raw_ostream &OS) { + OS << "#if defined(CLANG_ATTR_TYPE_ARG_LIST)\n"; + std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr"); + + for (const auto *Attr : Attrs) { + // Determine whether the first argument is a type. + std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args"); + if (Args.empty()) + continue; + + if (Args[0]->getSuperClasses().back()->getName() != "TypeArgument") + continue; + + // All these spellings take a single type argument. + std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr); + std::set<std::string> Emitted; + for (const auto &S : Spellings) { + if (Emitted.insert(S.name()).second) + OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n"; + } + } + OS << "#endif // CLANG_ATTR_TYPE_ARG_LIST\n\n"; +} + +/// \brief Emits the parse-arguments-in-unevaluated-context property for +/// attributes. +static void emitClangAttrArgContextList(RecordKeeper &Records, raw_ostream &OS) { + OS << "#if defined(CLANG_ATTR_ARG_CONTEXT_LIST)\n"; + ParsedAttrMap Attrs = getParsedAttrList(Records); + for (const auto &I : Attrs) { + const Record &Attr = *I.second; + + if (!Attr.getValueAsBit("ParseArgumentsAsUnevaluated")) + continue; + + // All these spellings take are parsed unevaluated. + std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr); + std::set<std::string> Emitted; + for (const auto &S : Spellings) { + if (Emitted.insert(S.name()).second) + OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n"; + } + } + OS << "#endif // CLANG_ATTR_ARG_CONTEXT_LIST\n\n"; +} + +static bool isIdentifierArgument(Record *Arg) { + return !Arg->getSuperClasses().empty() && + llvm::StringSwitch<bool>(Arg->getSuperClasses().back()->getName()) + .Case("IdentifierArgument", true) + .Case("EnumArgument", true) + .Default(false); +} + +// Emits the first-argument-is-identifier property for attributes. +static void emitClangAttrIdentifierArgList(RecordKeeper &Records, raw_ostream &OS) { + OS << "#if defined(CLANG_ATTR_IDENTIFIER_ARG_LIST)\n"; + std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"); + + for (const auto *Attr : Attrs) { + // Determine whether the first argument is an identifier. + std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args"); + if (Args.empty() || !isIdentifierArgument(Args[0])) + continue; + + // All these spellings take an identifier argument. + std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr); + std::set<std::string> Emitted; + for (const auto &S : Spellings) { + if (Emitted.insert(S.name()).second) + OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n"; + } + } + OS << "#endif // CLANG_ATTR_IDENTIFIER_ARG_LIST\n\n"; +} + namespace clang { // Emits the class definitions for attributes. @@ -1047,9 +1364,19 @@ void EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS) { std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"); - for (std::vector<Record*>::iterator i = Attrs.begin(), e = Attrs.end(); - i != e; ++i) { - Record &R = **i; + for (const auto *Attr : Attrs) { + const Record &R = *Attr; + + // FIXME: Currently, documentation is generated as-needed due to the fact + // that there is no way to allow a generated project "reach into" the docs + // directory (for instance, it may be an out-of-tree build). However, we want + // to ensure that every attribute has a Documentation field, and produce an + // error if it has been neglected. Otherwise, the on-demand generation which + // happens server-side will fail. This code is ensuring that functionality, + // even though this Emitter doesn't technically need the documentation. + // When attribute documentation can be generated as part of the build + // itself, this code can be removed. + (void)R.getValueAsListOfDefs("Documentation"); if (!R.getValueAsBit("ASTNode")) continue; @@ -1057,9 +1384,8 @@ void EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS) { const std::vector<Record *> Supers = R.getSuperClasses(); assert(!Supers.empty() && "Forgot to specify a superclass for the attr"); std::string SuperName; - for (std::vector<Record *>::const_reverse_iterator I = Supers.rbegin(), - E = Supers.rend(); I != E; ++I) { - const Record &R = **I; + for (const auto *Super : llvm::make_range(Supers.rbegin(), Supers.rend())) { + const Record &R = *Super; if (R.getName() != "TargetSpecificAttr" && SuperName.empty()) SuperName = R.getName(); } @@ -1067,52 +1393,78 @@ void EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS) { OS << "class " << R.getName() << "Attr : public " << SuperName << " {\n"; std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args"); - std::vector<Argument*> Args; - std::vector<Argument*>::iterator ai, ae; + std::vector<std::unique_ptr<Argument>> Args; Args.reserve(ArgRecords.size()); - for (std::vector<Record*>::iterator ri = ArgRecords.begin(), - re = ArgRecords.end(); - ri != re; ++ri) { - Record &ArgRecord = **ri; - Argument *Arg = createArgument(ArgRecord, R.getName()); - assert(Arg); - Args.push_back(Arg); - - Arg->writeDeclarations(OS); + for (const auto *ArgRecord : ArgRecords) { + Args.emplace_back(createArgument(*ArgRecord, R.getName())); + Args.back()->writeDeclarations(OS); OS << "\n\n"; } - ae = Args.end(); + OS << "\npublic:\n"; + + std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R); + + // If there are zero or one spellings, all spelling-related functionality + // can be elided. If all of the spellings share the same name, the spelling + // functionality can also be elided. + bool ElideSpelling = (Spellings.size() <= 1) || + SpellingNamesAreCommon(Spellings); + + // This maps spelling index values to semantic Spelling enumerants. + SemanticSpellingMap SemanticToSyntacticMap; + + if (!ElideSpelling) + OS << CreateSemanticSpellings(Spellings, SemanticToSyntacticMap); + + OS << " static " << R.getName() << "Attr *CreateImplicit("; + OS << "ASTContext &Ctx"; + if (!ElideSpelling) + OS << ", Spelling S"; + for (auto const &ai : Args) { + OS << ", "; + ai->writeCtorParameters(OS); + } + OS << ", SourceRange Loc = SourceRange()"; + OS << ") {\n"; + OS << " " << R.getName() << "Attr *A = new (Ctx) " << R.getName(); + OS << "Attr(Loc, Ctx, "; + for (auto const &ai : Args) { + ai->writeImplicitCtorArgs(OS); + OS << ", "; + } + OS << (ElideSpelling ? "0" : "S") << ");\n"; + OS << " A->setImplicit(true);\n"; + OS << " return A;\n }\n\n"; - OS << "\n public:\n"; OS << " " << R.getName() << "Attr(SourceRange R, ASTContext &Ctx\n"; bool HasOpt = false; - for (ai = Args.begin(); ai != ae; ++ai) { + for (auto const &ai : Args) { OS << " , "; - (*ai)->writeCtorParameters(OS); + ai->writeCtorParameters(OS); OS << "\n"; - if ((*ai)->isOptional()) + if (ai->isOptional()) HasOpt = true; } OS << " , "; - OS << "unsigned SI = 0\n"; + OS << "unsigned SI\n"; OS << " )\n"; OS << " : " << SuperName << "(attr::" << R.getName() << ", R, SI)\n"; - for (ai = Args.begin(); ai != ae; ++ai) { + for (auto const &ai : Args) { OS << " , "; - (*ai)->writeCtorInitializers(OS); + ai->writeCtorInitializers(OS); OS << "\n"; } OS << " {\n"; - for (ai = Args.begin(); ai != ae; ++ai) { - (*ai)->writeCtorBody(OS); + for (auto const &ai : Args) { + ai->writeCtorBody(OS); OS << "\n"; } OS << " }\n\n"; @@ -1121,54 +1473,61 @@ void EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS) { // optional arguments as well. if (HasOpt) { OS << " " << R.getName() << "Attr(SourceRange R, ASTContext &Ctx\n"; - for (ai = Args.begin(); ai != ae; ++ai) { - if (!(*ai)->isOptional()) { + for (auto const &ai : Args) { + if (!ai->isOptional()) { OS << " , "; - (*ai)->writeCtorParameters(OS); + ai->writeCtorParameters(OS); OS << "\n"; } } OS << " , "; - OS << "unsigned SI = 0\n"; + OS << "unsigned SI\n"; OS << " )\n"; OS << " : " << SuperName << "(attr::" << R.getName() << ", R, SI)\n"; - for (ai = Args.begin(); ai != ae; ++ai) { + for (auto const &ai : Args) { OS << " , "; - (*ai)->writeCtorDefaultInitializers(OS); + ai->writeCtorDefaultInitializers(OS); OS << "\n"; } OS << " {\n"; - for (ai = Args.begin(); ai != ae; ++ai) { - if (!(*ai)->isOptional()) { - (*ai)->writeCtorBody(OS); + for (auto const &ai : Args) { + if (!ai->isOptional()) { + ai->writeCtorBody(OS); OS << "\n"; } } OS << " }\n\n"; } - OS << " virtual " << R.getName() << "Attr *clone (ASTContext &C) const;\n"; - OS << " virtual void printPretty(raw_ostream &OS,\n" - << " const PrintingPolicy &Policy) const;\n"; + OS << " " << R.getName() << "Attr *clone(ASTContext &C) const override;\n"; + OS << " void printPretty(raw_ostream &OS,\n" + << " const PrintingPolicy &Policy) const override;\n"; + OS << " const char *getSpelling() const override;\n"; + + if (!ElideSpelling) { + assert(!SemanticToSyntacticMap.empty() && "Empty semantic mapping list"); + OS << " Spelling getSemanticSpelling() const {\n"; + WriteSemanticSpellingSwitch("SpellingListIndex", SemanticToSyntacticMap, + OS); + OS << " }\n"; + } writeAttrAccessorDefinition(R, OS); - for (ai = Args.begin(); ai != ae; ++ai) { - (*ai)->writeAccessors(OS); + for (auto const &ai : Args) { + ai->writeAccessors(OS); OS << "\n\n"; - if ((*ai)->isEnumArg()) { - EnumArgument *EA = (EnumArgument *)*ai; - EA->writeConversion(OS); - } else if ((*ai)->isVariadicEnumArg()) { - VariadicEnumArgument *VEA = (VariadicEnumArgument *)*ai; - VEA->writeConversion(OS); - } + if (ai->isEnumArg()) + static_cast<const EnumArgument *>(ai.get())->writeConversion(OS); + else if (ai->isVariadicEnumArg()) + static_cast<const VariadicEnumArgument *>(ai.get()) + ->writeConversion(OS); } OS << R.getValueAsString("AdditionalMembers"); @@ -1178,114 +1537,53 @@ void EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS) { << "attr::" << R.getName() << "; }\n"; bool LateParsed = R.getValueAsBit("LateParsed"); - OS << " virtual bool isLateParsed() const { return " + OS << " bool isLateParsed() const override { return " << LateParsed << "; }\n"; + if (R.getValueAsBit("DuplicatesAllowedWhileMerging")) + OS << " bool duplicatesAllowed() const override { return true; }\n\n"; + OS << "};\n\n"; } OS << "#endif\n"; } -static bool isIdentifierArgument(Record *Arg) { - return !Arg->getSuperClasses().empty() && - llvm::StringSwitch<bool>(Arg->getSuperClasses().back()->getName()) - .Case("IdentifierArgument", true) - .Case("EnumArgument", true) - .Default(false); -} - -/// \brief Emits the first-argument-is-type property for attributes. -void EmitClangAttrTypeArgList(RecordKeeper &Records, raw_ostream &OS) { - emitSourceFileHeader("llvm::StringSwitch code to match attributes with a " - "type argument", OS); - - std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr"); - - for (std::vector<Record *>::iterator I = Attrs.begin(), E = Attrs.end(); - I != E; ++I) { - Record &Attr = **I; - - // Determine whether the first argument is a type. - std::vector<Record *> Args = Attr.getValueAsListOfDefs("Args"); - if (Args.empty()) - continue; - - if (Args[0]->getSuperClasses().back()->getName() != "TypeArgument") - continue; - - // All these spellings take a single type argument. - std::vector<Record*> Spellings = Attr.getValueAsListOfDefs("Spellings"); - std::set<std::string> Emitted; - for (std::vector<Record*>::const_iterator I = Spellings.begin(), - E = Spellings.end(); I != E; ++I) { - if (Emitted.insert((*I)->getValueAsString("Name")).second) - OS << ".Case(\"" << (*I)->getValueAsString("Name") << "\", " - << "true" << ")\n"; - } - } -} - -// Emits the first-argument-is-identifier property for attributes. -void EmitClangAttrIdentifierArgList(RecordKeeper &Records, raw_ostream &OS) { - emitSourceFileHeader("llvm::StringSwitch code to match attributes with " - "an identifier argument", OS); - - std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"); - - for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end(); - I != E; ++I) { - Record &Attr = **I; - - // Determine whether the first argument is an identifier. - std::vector<Record *> Args = Attr.getValueAsListOfDefs("Args"); - if (Args.empty() || !isIdentifierArgument(Args[0])) - continue; - - // All these spellings take an identifier argument. - std::vector<Record*> Spellings = Attr.getValueAsListOfDefs("Spellings"); - std::set<std::string> Emitted; - for (std::vector<Record*>::const_iterator I = Spellings.begin(), - E = Spellings.end(); I != E; ++I) { - if (Emitted.insert((*I)->getValueAsString("Name")).second) - OS << ".Case(\"" << (*I)->getValueAsString("Name") << "\", " - << "true" << ")\n"; - } - } -} - // Emits the class method definitions for attributes. void EmitClangAttrImpl(RecordKeeper &Records, raw_ostream &OS) { emitSourceFileHeader("Attribute classes' member function definitions", OS); std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"); - std::vector<Record*>::iterator i = Attrs.begin(), e = Attrs.end(), ri, re; - std::vector<Argument*>::iterator ai, ae; - for (; i != e; ++i) { - Record &R = **i; + for (auto *Attr : Attrs) { + Record &R = *Attr; if (!R.getValueAsBit("ASTNode")) continue; - + std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args"); - std::vector<Argument*> Args; - for (ri = ArgRecords.begin(), re = ArgRecords.end(); ri != re; ++ri) - Args.push_back(createArgument(**ri, R.getName())); + std::vector<std::unique_ptr<Argument>> Args; + for (const auto *Arg : ArgRecords) + Args.emplace_back(createArgument(*Arg, R.getName())); - for (ai = Args.begin(), ae = Args.end(); ai != ae; ++ai) - (*ai)->writeAccessorDefinitions(OS); + for (auto const &ai : Args) + ai->writeAccessorDefinitions(OS); OS << R.getName() << "Attr *" << R.getName() << "Attr::clone(ASTContext &C) const {\n"; - OS << " return new (C) " << R.getName() << "Attr(getLocation(), C"; - for (ai = Args.begin(); ai != ae; ++ai) { + OS << " auto *A = new (C) " << R.getName() << "Attr(getLocation(), C"; + for (auto const &ai : Args) { OS << ", "; - (*ai)->writeCloneArgs(OS); + ai->writeCloneArgs(OS); } - OS << ", getSpellingListIndex());\n}\n\n"; + OS << ", getSpellingListIndex());\n"; + OS << " A->Inherited = Inherited;\n"; + OS << " A->IsPackExpansion = IsPackExpansion;\n"; + OS << " A->Implicit = Implicit;\n"; + OS << " return A;\n}\n\n"; writePrettyPrintFunction(R, Args, OS); + writeGetSpellingFunction(R, OS); } } @@ -1335,46 +1633,30 @@ void EmitClangAttrList(RecordKeeper &Records, raw_ostream &OS) { " INHERITABLE_PARAM_ATTR(NAME)\n"; OS << "#endif\n\n"; - OS << "#ifndef MS_INHERITANCE_ATTR\n"; - OS << "#define MS_INHERITANCE_ATTR(NAME) INHERITABLE_ATTR(NAME)\n"; - OS << "#endif\n\n"; - - OS << "#ifndef LAST_MS_INHERITANCE_ATTR\n"; - OS << "#define LAST_MS_INHERITANCE_ATTR(NAME)" - " MS_INHERITANCE_ATTR(NAME)\n"; - OS << "#endif\n\n"; - Record *InhClass = Records.getClass("InheritableAttr"); Record *InhParamClass = Records.getClass("InheritableParamAttr"); - Record *MSInheritanceClass = Records.getClass("MSInheritanceAttr"); std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), - NonInhAttrs, InhAttrs, InhParamAttrs, MSInhAttrs; - for (std::vector<Record*>::iterator i = Attrs.begin(), e = Attrs.end(); - i != e; ++i) { - if (!(*i)->getValueAsBit("ASTNode")) + NonInhAttrs, InhAttrs, InhParamAttrs; + for (auto *Attr : Attrs) { + if (!Attr->getValueAsBit("ASTNode")) continue; - if ((*i)->isSubClassOf(InhParamClass)) - InhParamAttrs.push_back(*i); - else if ((*i)->isSubClassOf(MSInheritanceClass)) - MSInhAttrs.push_back(*i); - else if ((*i)->isSubClassOf(InhClass)) - InhAttrs.push_back(*i); + if (Attr->isSubClassOf(InhParamClass)) + InhParamAttrs.push_back(Attr); + else if (Attr->isSubClassOf(InhClass)) + InhAttrs.push_back(Attr); else - NonInhAttrs.push_back(*i); + NonInhAttrs.push_back(Attr); } EmitAttrList(OS, "INHERITABLE_PARAM_ATTR", InhParamAttrs); - EmitAttrList(OS, "MS_INHERITANCE_ATTR", MSInhAttrs); EmitAttrList(OS, "INHERITABLE_ATTR", InhAttrs); EmitAttrList(OS, "ATTR", NonInhAttrs); OS << "#undef LAST_ATTR\n"; OS << "#undef INHERITABLE_ATTR\n"; - OS << "#undef MS_INHERITANCE_ATTR\n"; OS << "#undef LAST_INHERITABLE_ATTR\n"; OS << "#undef LAST_INHERITABLE_PARAM_ATTR\n"; - OS << "#undef LAST_MS_INHERITANCE_ATTR\n"; OS << "#undef ATTR\n"; } @@ -1385,37 +1667,36 @@ void EmitClangAttrPCHRead(RecordKeeper &Records, raw_ostream &OS) { Record *InhClass = Records.getClass("InheritableAttr"); std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), ArgRecords; - std::vector<Record*>::iterator i = Attrs.begin(), e = Attrs.end(), ai, ae; - std::vector<Argument*> Args; - std::vector<Argument*>::iterator ri, re; + std::vector<std::unique_ptr<Argument>> Args; OS << " switch (Kind) {\n"; OS << " default:\n"; - OS << " assert(0 && \"Unknown attribute!\");\n"; - OS << " break;\n"; - for (; i != e; ++i) { - Record &R = **i; + OS << " llvm_unreachable(\"Unknown attribute!\");\n"; + for (const auto *Attr : Attrs) { + const Record &R = *Attr; if (!R.getValueAsBit("ASTNode")) continue; OS << " case attr::" << R.getName() << ": {\n"; if (R.isSubClassOf(InhClass)) OS << " bool isInherited = Record[Idx++];\n"; + OS << " bool isImplicit = Record[Idx++];\n"; + OS << " unsigned Spelling = Record[Idx++];\n"; ArgRecords = R.getValueAsListOfDefs("Args"); Args.clear(); - for (ai = ArgRecords.begin(), ae = ArgRecords.end(); ai != ae; ++ai) { - Argument *A = createArgument(**ai, R.getName()); - Args.push_back(A); - A->writePCHReadDecls(OS); + for (const auto *Arg : ArgRecords) { + Args.emplace_back(createArgument(*Arg, R.getName())); + Args.back()->writePCHReadDecls(OS); } OS << " New = new (Context) " << R.getName() << "Attr(Range, Context"; - for (ri = Args.begin(), re = Args.end(); ri != re; ++ri) { + for (auto const &ri : Args) { OS << ", "; - (*ri)->writePCHReadArgs(OS); + ri->writePCHReadArgs(OS); } - OS << ");\n"; + OS << ", Spelling);\n"; if (R.isSubClassOf(InhClass)) OS << " cast<InheritableAttr>(New)->setInherited(isInherited);\n"; + OS << " New->setImplicit(isImplicit);\n"; OS << " break;\n"; OS << " }\n"; } @@ -1428,14 +1709,13 @@ void EmitClangAttrPCHWrite(RecordKeeper &Records, raw_ostream &OS) { Record *InhClass = Records.getClass("InheritableAttr"); std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args; - std::vector<Record*>::iterator i = Attrs.begin(), e = Attrs.end(), ai, ae; OS << " switch (A->getKind()) {\n"; OS << " default:\n"; OS << " llvm_unreachable(\"Unknown attribute kind!\");\n"; OS << " break;\n"; - for (; i != e; ++i) { - Record &R = **i; + for (const auto *Attr : Attrs) { + const Record &R = *Attr; if (!R.getValueAsBit("ASTNode")) continue; OS << " case attr::" << R.getName() << ": {\n"; @@ -1445,31 +1725,128 @@ void EmitClangAttrPCHWrite(RecordKeeper &Records, raw_ostream &OS) { << "Attr>(A);\n"; if (R.isSubClassOf(InhClass)) OS << " Record.push_back(SA->isInherited());\n"; - for (ai = Args.begin(), ae = Args.end(); ai != ae; ++ai) - createArgument(**ai, R.getName())->writePCHWrite(OS); + OS << " Record.push_back(A->isImplicit());\n"; + OS << " Record.push_back(A->getSpellingListIndex());\n"; + + for (const auto *Arg : Args) + createArgument(*Arg, R.getName())->writePCHWrite(OS); OS << " break;\n"; OS << " }\n"; } OS << " }\n"; } -// Emits the list of spellings for attributes. -void EmitClangAttrSpellingList(RecordKeeper &Records, raw_ostream &OS) { - emitSourceFileHeader("llvm::StringSwitch code to match all known attributes", - OS); +static void GenerateHasAttrSpellingStringSwitch( + const std::vector<Record *> &Attrs, raw_ostream &OS, + const std::string &Variety = "", const std::string &Scope = "") { + for (const auto *Attr : Attrs) { + // It is assumed that there will be an llvm::Triple object named T within + // scope that can be used to determine whether the attribute exists in + // a given target. + std::string Test; + if (Attr->isSubClassOf("TargetSpecificAttr")) { + const Record *R = Attr->getValueAsDef("Target"); + std::vector<std::string> Arches = R->getValueAsListOfStrings("Arches"); + + Test += "("; + for (auto AI = Arches.begin(), AE = Arches.end(); AI != AE; ++AI) { + std::string Part = *AI; + Test += "T.getArch() == llvm::Triple::" + Part; + if (AI + 1 != AE) + Test += " || "; + } + Test += ")"; + + std::vector<std::string> OSes; + if (!R->isValueUnset("OSes")) { + Test += " && ("; + std::vector<std::string> OSes = R->getValueAsListOfStrings("OSes"); + for (auto AI = OSes.begin(), AE = OSes.end(); AI != AE; ++AI) { + std::string Part = *AI; + + Test += "T.getOS() == llvm::Triple::" + Part; + if (AI + 1 != AE) + Test += " || "; + } + Test += ")"; + } + + // If this is the C++11 variety, also add in the LangOpts test. + if (Variety == "CXX11") + Test += " && LangOpts.CPlusPlus11"; + } else if (Variety == "CXX11") + // C++11 mode should be checked against LangOpts, which is presumed to be + // present in the caller. + Test = "LangOpts.CPlusPlus11"; + else + Test = "true"; - std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"); - - for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end(); I != E; ++I) { - Record &Attr = **I; + std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr); + for (const auto &S : Spellings) + if (Variety.empty() || (Variety == S.variety() && + (Scope.empty() || Scope == S.nameSpace()))) + OS << " .Case(\"" << S.name() << "\", " << Test << ")\n"; + } + OS << " .Default(false);\n"; +} - std::vector<Record*> Spellings = Attr.getValueAsListOfDefs("Spellings"); +// Emits the list of spellings for attributes. +void EmitClangAttrHasAttrImpl(RecordKeeper &Records, raw_ostream &OS) { + emitSourceFileHeader("Code to implement the __has_attribute logic", OS); - for (std::vector<Record*>::const_iterator I = Spellings.begin(), E = Spellings.end(); I != E; ++I) { - OS << ".Case(\"" << (*I)->getValueAsString("Name") << "\", true)\n"; + // Separate all of the attributes out into four group: generic, C++11, GNU, + // and declspecs. Then generate a big switch statement for each of them. + std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr"); + std::vector<Record *> Declspec, GNU, Pragma; + std::map<std::string, std::vector<Record *>> CXX; + + // Walk over the list of all attributes, and split them out based on the + // spelling variety. + for (auto *R : Attrs) { + std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*R); + for (const auto &SI : Spellings) { + std::string Variety = SI.variety(); + if (Variety == "GNU") + GNU.push_back(R); + else if (Variety == "Declspec") + Declspec.push_back(R); + else if (Variety == "CXX11") + CXX[SI.nameSpace()].push_back(R); + else if (Variety == "Pragma") + Pragma.push_back(R); } } + OS << "switch (Syntax) {\n"; + OS << "case AttrSyntax::Generic:\n"; + OS << " return llvm::StringSwitch<bool>(Name)\n"; + GenerateHasAttrSpellingStringSwitch(Attrs, OS); + OS << "case AttrSyntax::GNU:\n"; + OS << " return llvm::StringSwitch<bool>(Name)\n"; + GenerateHasAttrSpellingStringSwitch(GNU, OS, "GNU"); + OS << "case AttrSyntax::Declspec:\n"; + OS << " return llvm::StringSwitch<bool>(Name)\n"; + GenerateHasAttrSpellingStringSwitch(Declspec, OS, "Declspec"); + OS << "case AttrSyntax::Pragma:\n"; + OS << " return llvm::StringSwitch<bool>(Name)\n"; + GenerateHasAttrSpellingStringSwitch(Pragma, OS, "Pragma"); + OS << "case AttrSyntax::CXX: {\n"; + // C++11-style attributes are further split out based on the Scope. + for (std::map<std::string, std::vector<Record *>>::iterator I = CXX.begin(), + E = CXX.end(); + I != E; ++I) { + if (I != CXX.begin()) + OS << " else "; + if (I->first.empty()) + OS << "if (!Scope || Scope->getName() == \"\") {\n"; + else + OS << "if (Scope->getName() == \"" << I->first << "\") {\n"; + OS << " return llvm::StringSwitch<bool>(Name)\n"; + GenerateHasAttrSpellingStringSwitch(I->second, OS, "CXX11", I->first); + OS << "}"; + } + OS << "\n}\n"; + OS << "}\n"; } void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS) { @@ -1477,88 +1854,105 @@ void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS) { "into internal identifiers", OS); OS << - " unsigned Index = 0;\n" " switch (AttrKind) {\n" " default:\n" " llvm_unreachable(\"Unknown attribute kind!\");\n" " break;\n"; - std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"); - for (std::vector<Record*>::const_iterator I = Attrs.begin(), E = Attrs.end(); - I != E; ++I) { - Record &R = **I; - // We only care about attributes that participate in Sema checking, so - // skip those attributes that are not able to make their way to Sema. - if (!R.getValueAsBit("SemaHandler")) - continue; - - std::vector<Record*> Spellings = R.getValueAsListOfDefs("Spellings"); - // Each distinct spelling yields an attribute kind. - if (R.getValueAsBit("DistinctSpellings")) { - for (unsigned I = 0; I < Spellings.size(); ++ I) { - OS << - " case AT_" << Spellings[I]->getValueAsString("Name") << ": \n" - " Index = " << I << ";\n" - " break;\n"; - } - } else { - OS << " case AT_" << R.getName() << " : {\n"; - for (unsigned I = 0; I < Spellings.size(); ++ I) { - SmallString<16> Namespace; - if (Spellings[I]->getValueAsString("Variety") == "CXX11") - Namespace = Spellings[I]->getValueAsString("Namespace"); - else - Namespace = ""; - - OS << " if (Name == \"" - << Spellings[I]->getValueAsString("Name") << "\" && " - << "SyntaxUsed == " - << StringSwitch<unsigned>(Spellings[I]->getValueAsString("Variety")) - .Case("GNU", 0) - .Case("CXX11", 1) - .Case("Declspec", 2) - .Case("Keyword", 3) - .Default(0) - << " && Scope == \"" << Namespace << "\")\n" - << " return " << I << ";\n"; - } - - OS << " break;\n"; - OS << " }\n"; + ParsedAttrMap Attrs = getParsedAttrList(Records); + for (const auto &I : Attrs) { + const Record &R = *I.second; + std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R); + OS << " case AT_" << I.first << ": {\n"; + for (unsigned I = 0; I < Spellings.size(); ++ I) { + OS << " if (Name == \"" << Spellings[I].name() << "\" && " + << "SyntaxUsed == " + << StringSwitch<unsigned>(Spellings[I].variety()) + .Case("GNU", 0) + .Case("CXX11", 1) + .Case("Declspec", 2) + .Case("Keyword", 3) + .Case("Pragma", 4) + .Default(0) + << " && Scope == \"" << Spellings[I].nameSpace() << "\")\n" + << " return " << I << ";\n"; } + + OS << " break;\n"; + OS << " }\n"; } OS << " }\n"; - OS << " return Index;\n"; + OS << " return 0;\n"; } -// Emits the LateParsed property for attributes. -void EmitClangAttrLateParsedList(RecordKeeper &Records, raw_ostream &OS) { - emitSourceFileHeader("llvm::StringSwitch code to match late parsed " - "attributes", OS); +// Emits code used by RecursiveASTVisitor to visit attributes +void EmitClangAttrASTVisitor(RecordKeeper &Records, raw_ostream &OS) { + emitSourceFileHeader("Used by RecursiveASTVisitor to visit attributes.", OS); std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"); - for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end(); - I != E; ++I) { - Record &Attr = **I; + // Write method declarations for Traverse* methods. + // We emit this here because we only generate methods for attributes that + // are declared as ASTNodes. + OS << "#ifdef ATTR_VISITOR_DECLS_ONLY\n\n"; + for (const auto *Attr : Attrs) { + const Record &R = *Attr; + if (!R.getValueAsBit("ASTNode")) + continue; + OS << " bool Traverse" + << R.getName() << "Attr(" << R.getName() << "Attr *A);\n"; + OS << " bool Visit" + << R.getName() << "Attr(" << R.getName() << "Attr *A) {\n" + << " return true; \n" + << " };\n"; + } + OS << "\n#else // ATTR_VISITOR_DECLS_ONLY\n\n"; - bool LateParsed = Attr.getValueAsBit("LateParsed"); + // Write individual Traverse* methods for each attribute class. + for (const auto *Attr : Attrs) { + const Record &R = *Attr; + if (!R.getValueAsBit("ASTNode")) + continue; - if (LateParsed) { - std::vector<Record*> Spellings = - Attr.getValueAsListOfDefs("Spellings"); + OS << "template <typename Derived>\n" + << "bool VISITORCLASS<Derived>::Traverse" + << R.getName() << "Attr(" << R.getName() << "Attr *A) {\n" + << " if (!getDerived().VisitAttr(A))\n" + << " return false;\n" + << " if (!getDerived().Visit" << R.getName() << "Attr(A))\n" + << " return false;\n"; - // FIXME: Handle non-GNU attributes - for (std::vector<Record*>::const_iterator I = Spellings.begin(), - E = Spellings.end(); I != E; ++I) { - if ((*I)->getValueAsString("Variety") != "GNU") - continue; - OS << ".Case(\"" << (*I)->getValueAsString("Name") << "\", " - << LateParsed << ")\n"; - } - } + std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args"); + for (const auto *Arg : ArgRecords) + createArgument(*Arg, R.getName())->writeASTVisitorTraversal(OS); + + OS << " return true;\n"; + OS << "}\n\n"; + } + + // Write generic Traverse routine + OS << "template <typename Derived>\n" + << "bool VISITORCLASS<Derived>::TraverseAttr(Attr *A) {\n" + << " if (!A)\n" + << " return true;\n" + << "\n" + << " switch (A->getKind()) {\n" + << " default:\n" + << " return true;\n"; + + for (const auto *Attr : Attrs) { + const Record &R = *Attr; + if (!R.getValueAsBit("ASTNode")) + continue; + + OS << " case attr::" << R.getName() << ":\n" + << " return getDerived().Traverse" << R.getName() << "Attr(" + << "cast<" << R.getName() << "Attr>(A));\n"; } + OS << " }\n"; // end case + OS << "}\n"; // end function + OS << "#endif // ATTR_VISITOR_DECLS_ONLY\n"; } // Emits code to instantiate dependent attributes on templates. @@ -1576,9 +1970,8 @@ void EmitClangAttrTemplateInstantiate(RecordKeeper &Records, raw_ostream &OS) { << " default:\n" << " break;\n"; - for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end(); - I != E; ++I) { - Record &R = **I; + for (const auto *Attr : Attrs) { + const Record &R = *Attr; if (!R.getValueAsBit("ASTNode")) continue; @@ -1602,29 +1995,21 @@ void EmitClangAttrTemplateInstantiate(RecordKeeper &Records, raw_ostream &OS) { } std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args"); - std::vector<Argument*> Args; - std::vector<Argument*>::iterator ai, ae; + std::vector<std::unique_ptr<Argument>> Args; Args.reserve(ArgRecords.size()); - for (std::vector<Record*>::iterator ri = ArgRecords.begin(), - re = ArgRecords.end(); - ri != re; ++ri) { - Record &ArgRecord = **ri; - Argument *Arg = createArgument(ArgRecord, R.getName()); - assert(Arg); - Args.push_back(Arg); - } - ae = Args.end(); + for (const auto *ArgRecord : ArgRecords) + Args.emplace_back(createArgument(*ArgRecord, R.getName())); + + for (auto const &ai : Args) + ai->writeTemplateInstantiation(OS); - for (ai = Args.begin(); ai != ae; ++ai) { - (*ai)->writeTemplateInstantiation(OS); - } OS << " return new (C) " << R.getName() << "Attr(A->getLocation(), C"; - for (ai = Args.begin(); ai != ae; ++ai) { + for (auto const &ai : Args) { OS << ", "; - (*ai)->writeTemplateInstantiationArgs(OS); + ai->writeTemplateInstantiationArgs(OS); } - OS << ");\n }\n"; + OS << ", A->getSpellingListIndex());\n }\n"; } OS << " } // end switch\n" << " llvm_unreachable(\"Unknown attribute!\");\n" @@ -1634,39 +2019,6 @@ void EmitClangAttrTemplateInstantiate(RecordKeeper &Records, raw_ostream &OS) { << "} // end namespace clang\n"; } -typedef std::vector<std::pair<std::string, Record *> > ParsedAttrMap; - -static ParsedAttrMap getParsedAttrList(const RecordKeeper &Records) { - std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"); - ParsedAttrMap R; - for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end(); - I != E; ++I) { - Record &Attr = **I; - - bool SemaHandler = Attr.getValueAsBit("SemaHandler"); - bool DistinctSpellings = Attr.getValueAsBit("DistinctSpellings"); - - if (SemaHandler) { - if (DistinctSpellings) { - std::vector<Record*> Spellings = Attr.getValueAsListOfDefs("Spellings"); - - for (std::vector<Record*>::const_iterator I = Spellings.begin(), - E = Spellings.end(); I != E; ++I) { - std::string AttrName = (*I)->getValueAsString("Name"); - - StringRef Spelling = NormalizeAttrName(AttrName); - R.push_back(std::make_pair(Spelling.str(), &Attr)); - } - } else { - StringRef AttrName = Attr.getName(); - AttrName = NormalizeAttrName(AttrName); - R.push_back(std::make_pair(AttrName.str(), *I)); - } - } - } - return R; -} - // Emits the list of parsed attributes. void EmitClangAttrParsedAttrList(RecordKeeper &Records, raw_ostream &OS) { emitSourceFileHeader("List of all attributes that Clang recognizes", OS); @@ -1676,47 +2028,467 @@ void EmitClangAttrParsedAttrList(RecordKeeper &Records, raw_ostream &OS) { OS << "#endif\n\n"; ParsedAttrMap Names = getParsedAttrList(Records); - for (ParsedAttrMap::iterator I = Names.begin(), E = Names.end(); I != E; - ++I) { - OS << "PARSED_ATTR(" << I->first << ")\n"; + for (const auto &I : Names) { + OS << "PARSED_ATTR(" << I.first << ")\n"; } } -static void emitArgInfo(const Record &R, raw_ostream &OS) { +static void emitArgInfo(const Record &R, std::stringstream &OS) { // This function will count the number of arguments specified for the // attribute and emit the number of required arguments followed by the // number of optional arguments. std::vector<Record *> Args = R.getValueAsListOfDefs("Args"); unsigned ArgCount = 0, OptCount = 0; - for (std::vector<Record *>::const_iterator I = Args.begin(), E = Args.end(); - I != E; ++I) { - const Record &Arg = **I; - Arg.getValueAsBit("Optional") ? ++OptCount : ++ArgCount; + for (const auto *Arg : Args) { + Arg->getValueAsBit("Optional") ? ++OptCount : ++ArgCount; } OS << ArgCount << ", " << OptCount; } +static void GenerateDefaultAppertainsTo(raw_ostream &OS) { + OS << "static bool defaultAppertainsTo(Sema &, const AttributeList &,"; + OS << "const Decl *) {\n"; + OS << " return true;\n"; + OS << "}\n\n"; +} + +static std::string CalculateDiagnostic(const Record &S) { + // If the SubjectList object has a custom diagnostic associated with it, + // return that directly. + std::string CustomDiag = S.getValueAsString("CustomDiag"); + if (!CustomDiag.empty()) + return CustomDiag; + + // Given the list of subjects, determine what diagnostic best fits. + enum { + Func = 1U << 0, + Var = 1U << 1, + ObjCMethod = 1U << 2, + Param = 1U << 3, + Class = 1U << 4, + GenericRecord = 1U << 5, + Type = 1U << 6, + ObjCIVar = 1U << 7, + ObjCProp = 1U << 8, + ObjCInterface = 1U << 9, + Block = 1U << 10, + Namespace = 1U << 11, + Field = 1U << 12, + CXXMethod = 1U << 13, + ObjCProtocol = 1U << 14 + }; + uint32_t SubMask = 0; + + std::vector<Record *> Subjects = S.getValueAsListOfDefs("Subjects"); + for (const auto *Subject : Subjects) { + const Record &R = *Subject; + std::string Name; + + if (R.isSubClassOf("SubsetSubject")) { + PrintError(R.getLoc(), "SubsetSubjects should use a custom diagnostic"); + // As a fallback, look through the SubsetSubject to see what its base + // type is, and use that. This needs to be updated if SubsetSubjects + // are allowed within other SubsetSubjects. + Name = R.getValueAsDef("Base")->getName(); + } else + Name = R.getName(); + + uint32_t V = StringSwitch<uint32_t>(Name) + .Case("Function", Func) + .Case("Var", Var) + .Case("ObjCMethod", ObjCMethod) + .Case("ParmVar", Param) + .Case("TypedefName", Type) + .Case("ObjCIvar", ObjCIVar) + .Case("ObjCProperty", ObjCProp) + .Case("Record", GenericRecord) + .Case("ObjCInterface", ObjCInterface) + .Case("ObjCProtocol", ObjCProtocol) + .Case("Block", Block) + .Case("CXXRecord", Class) + .Case("Namespace", Namespace) + .Case("Field", Field) + .Case("CXXMethod", CXXMethod) + .Default(0); + if (!V) { + // Something wasn't in our mapping, so be helpful and let the developer + // know about it. + PrintFatalError(R.getLoc(), "Unknown subject type: " + R.getName()); + return ""; + } + + SubMask |= V; + } + + switch (SubMask) { + // For the simple cases where there's only a single entry in the mask, we + // don't have to resort to bit fiddling. + case Func: return "ExpectedFunction"; + case Var: return "ExpectedVariable"; + case Param: return "ExpectedParameter"; + case Class: return "ExpectedClass"; + case CXXMethod: + // FIXME: Currently, this maps to ExpectedMethod based on existing code, + // but should map to something a bit more accurate at some point. + case ObjCMethod: return "ExpectedMethod"; + case Type: return "ExpectedType"; + case ObjCInterface: return "ExpectedObjectiveCInterface"; + case ObjCProtocol: return "ExpectedObjectiveCProtocol"; + + // "GenericRecord" means struct, union or class; check the language options + // and if not compiling for C++, strip off the class part. Note that this + // relies on the fact that the context for this declares "Sema &S". + case GenericRecord: + return "(S.getLangOpts().CPlusPlus ? ExpectedStructOrUnionOrClass : " + "ExpectedStructOrUnion)"; + case Func | ObjCMethod | Block: return "ExpectedFunctionMethodOrBlock"; + case Func | ObjCMethod | Class: return "ExpectedFunctionMethodOrClass"; + case Func | Param: + case Func | ObjCMethod | Param: return "ExpectedFunctionMethodOrParameter"; + case Func | ObjCMethod: return "ExpectedFunctionOrMethod"; + case Func | Var: return "ExpectedVariableOrFunction"; + + // If not compiling for C++, the class portion does not apply. + case Func | Var | Class: + return "(S.getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass : " + "ExpectedVariableOrFunction)"; + + case ObjCMethod | ObjCProp: return "ExpectedMethodOrProperty"; + case ObjCProtocol | ObjCInterface: + return "ExpectedObjectiveCInterfaceOrProtocol"; + case Field | Var: return "ExpectedFieldOrGlobalVar"; + } + + PrintFatalError(S.getLoc(), + "Could not deduce diagnostic argument for Attr subjects"); + + return ""; +} + +static std::string GetSubjectWithSuffix(const Record *R) { + std::string B = R->getName(); + if (B == "DeclBase") + return "Decl"; + return B + "Decl"; +} +static std::string GenerateCustomAppertainsTo(const Record &Subject, + raw_ostream &OS) { + std::string FnName = "is" + Subject.getName(); + + // If this code has already been generated, simply return the previous + // instance of it. + static std::set<std::string> CustomSubjectSet; + std::set<std::string>::iterator I = CustomSubjectSet.find(FnName); + if (I != CustomSubjectSet.end()) + return *I; + + Record *Base = Subject.getValueAsDef("Base"); + + // Not currently support custom subjects within custom subjects. + if (Base->isSubClassOf("SubsetSubject")) { + PrintFatalError(Subject.getLoc(), + "SubsetSubjects within SubsetSubjects is not supported"); + return ""; + } + + OS << "static bool " << FnName << "(const Decl *D) {\n"; + OS << " if (const " << GetSubjectWithSuffix(Base) << " *S = dyn_cast<"; + OS << GetSubjectWithSuffix(Base); + OS << ">(D))\n"; + OS << " return " << Subject.getValueAsString("CheckCode") << ";\n"; + OS << " return false;\n"; + OS << "}\n\n"; + + CustomSubjectSet.insert(FnName); + return FnName; +} + +static std::string GenerateAppertainsTo(const Record &Attr, raw_ostream &OS) { + // If the attribute does not contain a Subjects definition, then use the + // default appertainsTo logic. + if (Attr.isValueUnset("Subjects")) + return "defaultAppertainsTo"; + + const Record *SubjectObj = Attr.getValueAsDef("Subjects"); + std::vector<Record*> Subjects = SubjectObj->getValueAsListOfDefs("Subjects"); + + // If the list of subjects is empty, it is assumed that the attribute + // appertains to everything. + if (Subjects.empty()) + return "defaultAppertainsTo"; + + bool Warn = SubjectObj->getValueAsDef("Diag")->getValueAsBit("Warn"); + + // Otherwise, generate an appertainsTo check specific to this attribute which + // checks all of the given subjects against the Decl passed in. Return the + // name of that check to the caller. + std::string FnName = "check" + Attr.getName() + "AppertainsTo"; + std::stringstream SS; + SS << "static bool " << FnName << "(Sema &S, const AttributeList &Attr, "; + SS << "const Decl *D) {\n"; + SS << " if ("; + for (auto I = Subjects.begin(), E = Subjects.end(); I != E; ++I) { + // If the subject has custom code associated with it, generate a function + // for it. The function cannot be inlined into this check (yet) because it + // requires the subject to be of a specific type, and were that information + // inlined here, it would not support an attribute with multiple custom + // subjects. + if ((*I)->isSubClassOf("SubsetSubject")) { + SS << "!" << GenerateCustomAppertainsTo(**I, OS) << "(D)"; + } else { + SS << "!isa<" << GetSubjectWithSuffix(*I) << ">(D)"; + } + + if (I + 1 != E) + SS << " && "; + } + SS << ") {\n"; + SS << " S.Diag(Attr.getLoc(), diag::"; + SS << (Warn ? "warn_attribute_wrong_decl_type" : + "err_attribute_wrong_decl_type"); + SS << ")\n"; + SS << " << Attr.getName() << "; + SS << CalculateDiagnostic(*SubjectObj) << ";\n"; + SS << " return false;\n"; + SS << " }\n"; + SS << " return true;\n"; + SS << "}\n\n"; + + OS << SS.str(); + return FnName; +} + +static void GenerateDefaultLangOptRequirements(raw_ostream &OS) { + OS << "static bool defaultDiagnoseLangOpts(Sema &, "; + OS << "const AttributeList &) {\n"; + OS << " return true;\n"; + OS << "}\n\n"; +} + +static std::string GenerateLangOptRequirements(const Record &R, + raw_ostream &OS) { + // If the attribute has an empty or unset list of language requirements, + // return the default handler. + std::vector<Record *> LangOpts = R.getValueAsListOfDefs("LangOpts"); + if (LangOpts.empty()) + return "defaultDiagnoseLangOpts"; + + // Generate the test condition, as well as a unique function name for the + // diagnostic test. The list of options should usually be short (one or two + // options), and the uniqueness isn't strictly necessary (it is just for + // codegen efficiency). + std::string FnName = "check", Test; + for (auto I = LangOpts.begin(), E = LangOpts.end(); I != E; ++I) { + std::string Part = (*I)->getValueAsString("Name"); + Test += "S.LangOpts." + Part; + if (I + 1 != E) + Test += " || "; + FnName += Part; + } + FnName += "LangOpts"; + + // If this code has already been generated, simply return the previous + // instance of it. + static std::set<std::string> CustomLangOptsSet; + std::set<std::string>::iterator I = CustomLangOptsSet.find(FnName); + if (I != CustomLangOptsSet.end()) + return *I; + + OS << "static bool " << FnName << "(Sema &S, const AttributeList &Attr) {\n"; + OS << " if (" << Test << ")\n"; + OS << " return true;\n\n"; + OS << " S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) "; + OS << "<< Attr.getName();\n"; + OS << " return false;\n"; + OS << "}\n\n"; + + CustomLangOptsSet.insert(FnName); + return FnName; +} + +static void GenerateDefaultTargetRequirements(raw_ostream &OS) { + OS << "static bool defaultTargetRequirements(const llvm::Triple &) {\n"; + OS << " return true;\n"; + OS << "}\n\n"; +} + +static std::string GenerateTargetRequirements(const Record &Attr, + const ParsedAttrMap &Dupes, + raw_ostream &OS) { + // If the attribute is not a target specific attribute, return the default + // target handler. + if (!Attr.isSubClassOf("TargetSpecificAttr")) + return "defaultTargetRequirements"; + + // Get the list of architectures to be tested for. + const Record *R = Attr.getValueAsDef("Target"); + std::vector<std::string> Arches = R->getValueAsListOfStrings("Arches"); + if (Arches.empty()) { + PrintError(Attr.getLoc(), "Empty list of target architectures for a " + "target-specific attr"); + return "defaultTargetRequirements"; + } + + // If there are other attributes which share the same parsed attribute kind, + // such as target-specific attributes with a shared spelling, collapse the + // duplicate architectures. This is required because a shared target-specific + // attribute has only one AttributeList::Kind enumeration value, but it + // applies to multiple target architectures. In order for the attribute to be + // considered valid, all of its architectures need to be included. + if (!Attr.isValueUnset("ParseKind")) { + std::string APK = Attr.getValueAsString("ParseKind"); + for (const auto &I : Dupes) { + if (I.first == APK) { + std::vector<std::string> DA = I.second->getValueAsDef("Target") + ->getValueAsListOfStrings("Arches"); + std::copy(DA.begin(), DA.end(), std::back_inserter(Arches)); + } + } + } + + std::string FnName = "isTarget", Test = "("; + for (auto I = Arches.begin(), E = Arches.end(); I != E; ++I) { + std::string Part = *I; + Test += "Arch == llvm::Triple::" + Part; + if (I + 1 != E) + Test += " || "; + FnName += Part; + } + Test += ")"; + + // If the target also requires OS testing, generate those tests as well. + bool UsesOS = false; + if (!R->isValueUnset("OSes")) { + UsesOS = true; + + // We know that there was at least one arch test, so we need to and in the + // OS tests. + Test += " && ("; + std::vector<std::string> OSes = R->getValueAsListOfStrings("OSes"); + for (auto I = OSes.begin(), E = OSes.end(); I != E; ++I) { + std::string Part = *I; + + Test += "OS == llvm::Triple::" + Part; + if (I + 1 != E) + Test += " || "; + FnName += Part; + } + Test += ")"; + } + + // If this code has already been generated, simply return the previous + // instance of it. + static std::set<std::string> CustomTargetSet; + std::set<std::string>::iterator I = CustomTargetSet.find(FnName); + if (I != CustomTargetSet.end()) + return *I; + + OS << "static bool " << FnName << "(const llvm::Triple &T) {\n"; + OS << " llvm::Triple::ArchType Arch = T.getArch();\n"; + if (UsesOS) + OS << " llvm::Triple::OSType OS = T.getOS();\n"; + OS << " return " << Test << ";\n"; + OS << "}\n\n"; + + CustomTargetSet.insert(FnName); + return FnName; +} + +static void GenerateDefaultSpellingIndexToSemanticSpelling(raw_ostream &OS) { + OS << "static unsigned defaultSpellingIndexToSemanticSpelling(" + << "const AttributeList &Attr) {\n"; + OS << " return UINT_MAX;\n"; + OS << "}\n\n"; +} + +static std::string GenerateSpellingIndexToSemanticSpelling(const Record &Attr, + raw_ostream &OS) { + // If the attribute does not have a semantic form, we can bail out early. + if (!Attr.getValueAsBit("ASTNode")) + return "defaultSpellingIndexToSemanticSpelling"; + + std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr); + + // If there are zero or one spellings, or all of the spellings share the same + // name, we can also bail out early. + if (Spellings.size() <= 1 || SpellingNamesAreCommon(Spellings)) + return "defaultSpellingIndexToSemanticSpelling"; + + // Generate the enumeration we will use for the mapping. + SemanticSpellingMap SemanticToSyntacticMap; + std::string Enum = CreateSemanticSpellings(Spellings, SemanticToSyntacticMap); + std::string Name = Attr.getName() + "AttrSpellingMap"; + + OS << "static unsigned " << Name << "(const AttributeList &Attr) {\n"; + OS << Enum; + OS << " unsigned Idx = Attr.getAttributeSpellingListIndex();\n"; + WriteSemanticSpellingSwitch("Idx", SemanticToSyntacticMap, OS); + OS << "}\n\n"; + + return Name; +} + +static bool IsKnownToGCC(const Record &Attr) { + // Look at the spellings for this subject; if there are any spellings which + // claim to be known to GCC, the attribute is known to GCC. + std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr); + for (const auto &I : Spellings) { + if (I.knownToGCC()) + return true; + } + return false; +} + /// Emits the parsed attribute helpers void EmitClangAttrParsedAttrImpl(RecordKeeper &Records, raw_ostream &OS) { emitSourceFileHeader("Parsed attribute helpers", OS); - ParsedAttrMap Attrs = getParsedAttrList(Records); + // Get the list of parsed attributes, and accept the optional list of + // duplicates due to the ParseKind. + ParsedAttrMap Dupes; + ParsedAttrMap Attrs = getParsedAttrList(Records, &Dupes); + + // Generate the default appertainsTo, target and language option diagnostic, + // and spelling list index mapping methods. + GenerateDefaultAppertainsTo(OS); + GenerateDefaultLangOptRequirements(OS); + GenerateDefaultTargetRequirements(OS); + GenerateDefaultSpellingIndexToSemanticSpelling(OS); + + // Generate the appertainsTo diagnostic methods and write their names into + // another mapping. At the same time, generate the AttrInfoMap object + // contents. Due to the reliance on generated code, use separate streams so + // that code will not be interleaved. + std::stringstream SS; + for (auto I = Attrs.begin(), E = Attrs.end(); I != E; ++I) { + // TODO: If the attribute's kind appears in the list of duplicates, that is + // because it is a target-specific attribute that appears multiple times. + // It would be beneficial to test whether the duplicates are "similar + // enough" to each other to not cause problems. For instance, check that + // the spellings are identical, and custom parsing rules match, etc. - OS << "static const ParsedAttrInfo AttrInfoMap[AttributeList::UnknownAttribute + 1] = {\n"; - for (ParsedAttrMap::iterator I = Attrs.begin(), E = Attrs.end(); I != E; - ++I) { // We need to generate struct instances based off ParsedAttrInfo from // AttributeList.cpp. - OS << " { "; - emitArgInfo(*I->second, OS); - OS << ", " << I->second->getValueAsBit("HasCustomParsing"); - OS << " }"; + SS << " { "; + emitArgInfo(*I->second, SS); + SS << ", " << I->second->getValueAsBit("HasCustomParsing"); + SS << ", " << I->second->isSubClassOf("TargetSpecificAttr"); + SS << ", " << I->second->isSubClassOf("TypeAttr"); + SS << ", " << IsKnownToGCC(*I->second); + SS << ", " << GenerateAppertainsTo(*I->second, OS); + SS << ", " << GenerateLangOptRequirements(*I->second, OS); + SS << ", " << GenerateTargetRequirements(*I->second, Dupes, OS); + SS << ", " << GenerateSpellingIndexToSemanticSpelling(*I->second, OS); + SS << " }"; if (I + 1 != E) - OS << ","; - - OS << " // AT_" << I->first << "\n"; + SS << ","; + + SS << " // AT_" << I->first << "\n"; } + + OS << "static const ParsedAttrInfo AttrInfoMap[AttributeList::UnknownAttribute + 1] = {\n"; + OS << SS.str(); OS << "};\n\n"; } @@ -1724,50 +2496,80 @@ void EmitClangAttrParsedAttrImpl(RecordKeeper &Records, raw_ostream &OS) { void EmitClangAttrParsedAttrKinds(RecordKeeper &Records, raw_ostream &OS) { emitSourceFileHeader("Attribute name matcher", OS); - std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"); + std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr"); + std::vector<StringMatcher::StringPair> GNU, Declspec, CXX11, Keywords, Pragma; + std::set<std::string> Seen; + for (const auto *A : Attrs) { + const Record &Attr = *A; - std::vector<StringMatcher::StringPair> Matches; - for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end(); - I != E; ++I) { - Record &Attr = **I; - bool SemaHandler = Attr.getValueAsBit("SemaHandler"); bool Ignored = Attr.getValueAsBit("Ignored"); - bool DistinctSpellings = Attr.getValueAsBit("DistinctSpellings"); if (SemaHandler || Ignored) { - std::vector<Record*> Spellings = Attr.getValueAsListOfDefs("Spellings"); - - for (std::vector<Record*>::const_iterator I = Spellings.begin(), - E = Spellings.end(); I != E; ++I) { - std::string RawSpelling = (*I)->getValueAsString("Name"); - StringRef AttrName = NormalizeAttrName(DistinctSpellings - ? StringRef(RawSpelling) - : StringRef(Attr.getName())); - - SmallString<64> Spelling; - if ((*I)->getValueAsString("Variety") == "CXX11") { - Spelling += (*I)->getValueAsString("Namespace"); + // Attribute spellings can be shared between target-specific attributes, + // and can be shared between syntaxes for the same attribute. For + // instance, an attribute can be spelled GNU<"interrupt"> for an ARM- + // specific attribute, or MSP430-specific attribute. Additionally, an + // attribute can be spelled GNU<"dllexport"> and Declspec<"dllexport"> + // for the same semantic attribute. Ultimately, we need to map each of + // these to a single AttributeList::Kind value, but the StringMatcher + // class cannot handle duplicate match strings. So we generate a list of + // string to match based on the syntax, and emit multiple string matchers + // depending on the syntax used. + std::string AttrName; + if (Attr.isSubClassOf("TargetSpecificAttr") && + !Attr.isValueUnset("ParseKind")) { + AttrName = Attr.getValueAsString("ParseKind"); + if (Seen.find(AttrName) != Seen.end()) + continue; + Seen.insert(AttrName); + } else + AttrName = NormalizeAttrName(StringRef(Attr.getName())).str(); + + std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr); + for (const auto &S : Spellings) { + std::string RawSpelling = S.name(); + std::vector<StringMatcher::StringPair> *Matches = nullptr; + std::string Spelling, Variety = S.variety(); + if (Variety == "CXX11") { + Matches = &CXX11; + Spelling += S.nameSpace(); Spelling += "::"; - } - Spelling += NormalizeAttrSpelling(RawSpelling); + } else if (Variety == "GNU") + Matches = &GNU; + else if (Variety == "Declspec") + Matches = &Declspec; + else if (Variety == "Keyword") + Matches = &Keywords; + else if (Variety == "Pragma") + Matches = &Pragma; + assert(Matches && "Unsupported spelling variety found"); + + Spelling += NormalizeAttrSpelling(RawSpelling); if (SemaHandler) - Matches.push_back( - StringMatcher::StringPair( - StringRef(Spelling), - "return AttributeList::AT_" + AttrName.str() + ";")); + Matches->push_back(StringMatcher::StringPair(Spelling, + "return AttributeList::AT_" + AttrName + ";")); else - Matches.push_back( - StringMatcher::StringPair( - StringRef(Spelling), - "return AttributeList::IgnoredAttribute;")); + Matches->push_back(StringMatcher::StringPair(Spelling, + "return AttributeList::IgnoredAttribute;")); } } } - OS << "static AttributeList::Kind getAttrKind(StringRef Name) {\n"; - StringMatcher("Name", Matches, OS).Emit(); - OS << "return AttributeList::UnknownAttribute;\n" + OS << "static AttributeList::Kind getAttrKind(StringRef Name, "; + OS << "AttributeList::Syntax Syntax) {\n"; + OS << " if (AttributeList::AS_GNU == Syntax) {\n"; + StringMatcher("Name", GNU, OS).Emit(); + OS << " } else if (AttributeList::AS_Declspec == Syntax) {\n"; + StringMatcher("Name", Declspec, OS).Emit(); + OS << " } else if (AttributeList::AS_CXX11 == Syntax) {\n"; + StringMatcher("Name", CXX11, OS).Emit(); + OS << " } else if (AttributeList::AS_Keyword == Syntax) {\n"; + StringMatcher("Name", Keywords, OS).Emit(); + OS << " } else if (AttributeList::AS_Pragma == Syntax) {\n"; + StringMatcher("Name", Pragma, OS).Emit(); + OS << " }\n"; + OS << " return AttributeList::UnknownAttribute;\n" << "}\n"; } @@ -1781,36 +2583,41 @@ void EmitClangAttrDump(RecordKeeper &Records, raw_ostream &OS) { " llvm_unreachable(\"Unknown attribute kind!\");\n" " break;\n"; std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args; - for (std::vector<Record*>::iterator I = Attrs.begin(), E = Attrs.end(); - I != E; ++I) { - Record &R = **I; + for (const auto *Attr : Attrs) { + const Record &R = *Attr; if (!R.getValueAsBit("ASTNode")) continue; OS << " case attr::" << R.getName() << ": {\n"; + + // If the attribute has a semantically-meaningful name (which is determined + // by whether there is a Spelling enumeration for it), then write out the + // spelling used for the attribute. + std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R); + if (Spellings.size() > 1 && !SpellingNamesAreCommon(Spellings)) + OS << " OS << \" \" << A->getSpelling();\n"; + Args = R.getValueAsListOfDefs("Args"); if (!Args.empty()) { OS << " const " << R.getName() << "Attr *SA = cast<" << R.getName() << "Attr>(A);\n"; - for (std::vector<Record*>::iterator I = Args.begin(), E = Args.end(); - I != E; ++I) - createArgument(**I, R.getName())->writeDump(OS); + for (const auto *Arg : Args) + createArgument(*Arg, R.getName())->writeDump(OS); // Code for detecting the last child. OS << " bool OldMoreChildren = hasMoreChildren();\n"; - OS << " bool MoreChildren = OldMoreChildren;\n"; + OS << " bool MoreChildren;\n"; - for (std::vector<Record*>::iterator I = Args.begin(), E = Args.end(); - I != E; ++I) { + for (auto AI = Args.begin(), AE = Args.end(); AI != AE; ++AI) { // More code for detecting the last child. OS << " MoreChildren = OldMoreChildren"; - for (std::vector<Record*>::iterator Next = I + 1; Next != E; ++Next) { + for (auto Next = AI + 1; Next != AE; ++Next) { OS << " || "; createArgument(**Next, R.getName())->writeHasChildren(OS); } OS << ";\n"; OS << " setMoreChildren(MoreChildren);\n"; - createArgument(**I, R.getName())->writeDumpChildren(OS); + createArgument(**AI, R.getName())->writeDumpChildren(OS); } // Reset the last child. @@ -1823,4 +2630,221 @@ void EmitClangAttrDump(RecordKeeper &Records, raw_ostream &OS) { OS << " }\n"; } +void EmitClangAttrParserStringSwitches(RecordKeeper &Records, + raw_ostream &OS) { + emitSourceFileHeader("Parser-related llvm::StringSwitch cases", OS); + emitClangAttrArgContextList(Records, OS); + emitClangAttrIdentifierArgList(Records, OS); + emitClangAttrTypeArgList(Records, OS); + emitClangAttrLateParsedList(Records, OS); +} + +class DocumentationData { +public: + const Record *Documentation; + const Record *Attribute; + + DocumentationData(const Record &Documentation, const Record &Attribute) + : Documentation(&Documentation), Attribute(&Attribute) {} +}; + +static void WriteCategoryHeader(const Record *DocCategory, + raw_ostream &OS) { + const std::string &Name = DocCategory->getValueAsString("Name"); + OS << Name << "\n" << std::string(Name.length(), '=') << "\n"; + + // If there is content, print that as well. + std::string ContentStr = DocCategory->getValueAsString("Content"); + if (!ContentStr.empty()) { + // Trim leading and trailing newlines and spaces. + StringRef Content(ContentStr); + while (Content.startswith("\r") || Content.startswith("\n") || + Content.startswith(" ") || Content.startswith("\t")) + Content = Content.substr(1); + while (Content.endswith("\r") || Content.endswith("\n") || + Content.endswith(" ") || Content.endswith("\t")) + Content = Content.substr(0, Content.size() - 1); + OS << Content; + } + OS << "\n\n"; +} + +enum SpellingKind { + GNU = 1 << 0, + CXX11 = 1 << 1, + Declspec = 1 << 2, + Keyword = 1 << 3, + Pragma = 1 << 4 +}; + +static void WriteDocumentation(const DocumentationData &Doc, + raw_ostream &OS) { + // FIXME: there is no way to have a per-spelling category for the attribute + // documentation. This may not be a limiting factor since the spellings + // should generally be consistently applied across the category. + + std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Doc.Attribute); + + // Determine the heading to be used for this attribute. + std::string Heading = Doc.Documentation->getValueAsString("Heading"); + bool CustomHeading = !Heading.empty(); + if (Heading.empty()) { + // If there's only one spelling, we can simply use that. + if (Spellings.size() == 1) + Heading = Spellings.begin()->name(); + else { + std::set<std::string> Uniques; + for (auto I = Spellings.begin(), E = Spellings.end(); + I != E && Uniques.size() <= 1; ++I) { + std::string Spelling = NormalizeNameForSpellingComparison(I->name()); + Uniques.insert(Spelling); + } + // If the semantic map has only one spelling, that is sufficient for our + // needs. + if (Uniques.size() == 1) + Heading = *Uniques.begin(); + } + } + + // If the heading is still empty, it is an error. + if (Heading.empty()) + PrintFatalError(Doc.Attribute->getLoc(), + "This attribute requires a heading to be specified"); + + // Gather a list of unique spellings; this is not the same as the semantic + // spelling for the attribute. Variations in underscores and other non- + // semantic characters are still acceptable. + std::vector<std::string> Names; + + unsigned SupportedSpellings = 0; + for (const auto &I : Spellings) { + SpellingKind Kind = StringSwitch<SpellingKind>(I.variety()) + .Case("GNU", GNU) + .Case("CXX11", CXX11) + .Case("Declspec", Declspec) + .Case("Keyword", Keyword) + .Case("Pragma", Pragma); + + // Mask in the supported spelling. + SupportedSpellings |= Kind; + + std::string Name; + if (Kind == CXX11 && !I.nameSpace().empty()) + Name = I.nameSpace() + "::"; + Name += I.name(); + + // If this name is the same as the heading, do not add it. + if (Name != Heading) + Names.push_back(Name); + } + + // Print out the heading for the attribute. If there are alternate spellings, + // then display those after the heading. + if (!CustomHeading && !Names.empty()) { + Heading += " ("; + for (auto I = Names.begin(), E = Names.end(); I != E; ++I) { + if (I != Names.begin()) + Heading += ", "; + Heading += *I; + } + Heading += ")"; + } + OS << Heading << "\n" << std::string(Heading.length(), '-') << "\n"; + + if (!SupportedSpellings) + PrintFatalError(Doc.Attribute->getLoc(), + "Attribute has no supported spellings; cannot be " + "documented"); + + // List what spelling syntaxes the attribute supports. + OS << ".. csv-table:: Supported Syntaxes\n"; + OS << " :header: \"GNU\", \"C++11\", \"__declspec\", \"Keyword\","; + OS << " \"Pragma\"\n\n"; + OS << " \""; + if (SupportedSpellings & GNU) OS << "X"; + OS << "\",\""; + if (SupportedSpellings & CXX11) OS << "X"; + OS << "\",\""; + if (SupportedSpellings & Declspec) OS << "X"; + OS << "\",\""; + if (SupportedSpellings & Keyword) OS << "X"; + OS << "\", \""; + if (SupportedSpellings & Pragma) OS << "X"; + OS << "\"\n\n"; + + // If the attribute is deprecated, print a message about it, and possibly + // provide a replacement attribute. + if (!Doc.Documentation->isValueUnset("Deprecated")) { + OS << "This attribute has been deprecated, and may be removed in a future " + << "version of Clang."; + const Record &Deprecated = *Doc.Documentation->getValueAsDef("Deprecated"); + std::string Replacement = Deprecated.getValueAsString("Replacement"); + if (!Replacement.empty()) + OS << " This attribute has been superseded by ``" + << Replacement << "``."; + OS << "\n\n"; + } + + std::string ContentStr = Doc.Documentation->getValueAsString("Content"); + // Trim leading and trailing newlines and spaces. + StringRef Content(ContentStr); + while (Content.startswith("\r") || Content.startswith("\n") || + Content.startswith(" ") || Content.startswith("\t")) + Content = Content.substr(1); + while (Content.endswith("\r") || Content.endswith("\n") || + Content.endswith(" ") || Content.endswith("\t")) + Content = Content.substr(0, Content.size() - 1); + OS << Content; + + OS << "\n\n\n"; +} + +void EmitClangAttrDocs(RecordKeeper &Records, raw_ostream &OS) { + // Get the documentation introduction paragraph. + const Record *Documentation = Records.getDef("GlobalDocumentation"); + if (!Documentation) { + PrintFatalError("The Documentation top-level definition is missing, " + "no documentation will be generated."); + return; + } + + OS << Documentation->getValueAsString("Intro") << "\n"; + + // Gather the Documentation lists from each of the attributes, based on the + // category provided. + std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr"); + std::map<const Record *, std::vector<DocumentationData>> SplitDocs; + for (const auto *A : Attrs) { + const Record &Attr = *A; + std::vector<Record *> Docs = Attr.getValueAsListOfDefs("Documentation"); + for (const auto *D : Docs) { + const Record &Doc = *D; + const Record *Category = Doc.getValueAsDef("Category"); + // If the category is "undocumented", then there cannot be any other + // documentation categories (otherwise, the attribute would become + // documented). + std::string Cat = Category->getValueAsString("Name"); + bool Undocumented = Cat == "Undocumented"; + if (Undocumented && Docs.size() > 1) + PrintFatalError(Doc.getLoc(), + "Attribute is \"Undocumented\", but has multiple " + "documentation categories"); + + if (!Undocumented) + SplitDocs[Category].push_back(DocumentationData(Doc, Attr)); + } + } + + // Having split the attributes out based on what documentation goes where, + // we can begin to generate sections of documentation. + for (const auto &I : SplitDocs) { + WriteCategoryHeader(I.first, OS); + + // Walk over each of the attributes in the category and write out their + // documentation. + for (const auto &Doc : I.second) + WriteDocumentation(Doc, OS); + } +} + } // end namespace clang |