ClangAttrEmitter.cpp

//===-- ClangAttrEmitter.cpp - Generate Clang attribute handling ----------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// These tablegen backends emit Clang attribute processing code
//
//===----------------------------------------------------------------------===//

#include"TableGenBackends.h"
#include"ASTTableGen.h"

#include"llvm/ADT/ArrayRef.h"
#include"llvm/ADT/DenseMap.h"
#include"llvm/ADT/DenseSet.h"
#include"llvm/ADT/MapVector.h"
#include"llvm/ADT/STLExtras.h"
#include"llvm/ADT/SmallString.h"
#include"llvm/ADT/StringExtras.h"
#include"llvm/ADT/StringRef.h"
#include"llvm/ADT/StringSwitch.h"
#include"llvm/Support/ErrorHandling.h"
#include"llvm/Support/raw_ostream.h"
#include"llvm/TableGen/Error.h"
#include"llvm/TableGen/Record.h"
#include"llvm/TableGen/StringMatcher.h"
#include"llvm/TableGen/TableGenBackend.h"
#include<cassert>
#include<cctype>
#include<cstddef>
#include<cstdint>
#include<map>
#include<memory>
#include<optional>
#include<set>
#include<string>
#include<utility>
#include<vector>

usingnamespacellvm;

namespace {

classFlattenedSpelling {
 StringRef V, N, NS;
bool K = false;
const Record &OriginalSpelling;

public:
FlattenedSpelling(StringRef Variety, StringRef Name, StringRef Namespace,
bool KnownToGCC, const Record &OriginalSpelling)
 : V(Variety), N(Name), NS(Namespace), K(KnownToGCC),
OriginalSpelling(OriginalSpelling) {}
explicitFlattenedSpelling(const Record &Spelling)
 : V(Spelling.getValueAsString("Variety")),
 N(Spelling.getValueAsString("Name")), OriginalSpelling(Spelling) {
assert(V != "GCC" && V != "Clang" &&
"Given a GCC spelling, which means this hasn't been flattened!");
if (V == "CXX11" || V == "C23" || V == "Pragma")
 NS = Spelling.getValueAsString("Namespace");
 }

 StringRef variety() const { return V; }
 StringRef name() const { return N; }
 StringRef nameSpace() const { return NS; }
boolknownToGCC() const { return K; }
const Record &getSpellingRecord() const { return OriginalSpelling; }
};

structFlattenedSpellingInfo {
FlattenedSpellingInfo(StringRef Syntax, StringRef Scope,
const std::string &TargetTest, uint32_t ArgMask)
 : Syntax(Syntax), Scope(Scope), TargetTest(TargetTest), ArgMask(ArgMask) {
 }
 StringRef Syntax;
 StringRef Scope;
 std::string TargetTest;
uint32_t ArgMask;
};
using FSIVecTy = std::vector<FlattenedSpellingInfo>;

} // end anonymous namespace

staticboolGenerateTargetSpecificAttrChecks(const Record *R,
 std::vector<StringRef> &Arches,
 std::string &Test,
 std::string *FnName);
staticboolisStringLiteralArgument(const Record *Arg);
staticboolisVariadicStringLiteralArgument(const Record *Arg);

static std::vector<FlattenedSpelling>
GetFlattenedSpellings(const Record &Attr) {
 std::vector<FlattenedSpelling> Ret;

for (constauto &Spelling : Attr.getValueAsListOfDefs("Spellings")) {
 StringRef Variety = Spelling->getValueAsString("Variety");
 StringRef Name = Spelling->getValueAsString("Name");
if (Variety == "GCC") {
 Ret.emplace_back("GNU", Name, "", true, *Spelling);
 Ret.emplace_back("CXX11", Name, "gnu", true, *Spelling);
if (Spelling->getValueAsBit("AllowInC"))
 Ret.emplace_back("C23", Name, "gnu", true, *Spelling);
 } elseif (Variety == "Clang") {
 Ret.emplace_back("GNU", Name, "", false, *Spelling);
 Ret.emplace_back("CXX11", Name, "clang", false, *Spelling);
if (Spelling->getValueAsBit("AllowInC"))
 Ret.emplace_back("C23", Name, "clang", false, *Spelling);
 } elseif (Variety == "ClangGCC") {
 Ret.emplace_back("GNU", Name, "", false, *Spelling);
 Ret.emplace_back("CXX11", Name, "clang", false, *Spelling);
 Ret.emplace_back("CXX11", Name, "gnu", false, *Spelling);
if (Spelling->getValueAsBit("AllowInC")) {
 Ret.emplace_back("C23", Name, "clang", false, *Spelling);
 Ret.emplace_back("C23", Name, "gnu", false, *Spelling);
 }
 } else {
 Ret.push_back(FlattenedSpelling(*Spelling));
 }
 }

return Ret;
}

static std::string ReadPCHRecord(StringRef type) {
return StringSwitch<std::string>(type)
 .EndsWith("Decl *", "Record.readDeclAs<" + type.drop_back().str() + ">()")
 .Case("TypeSourceInfo *", "Record.readTypeSourceInfo()")
 .Case("Expr *", "Record.readExpr()")
 .Case("IdentifierInfo *", "Record.readIdentifier()")
 .Case("StringRef", "Record.readString()")
 .Case("ParamIdx", "ParamIdx::deserialize(Record.readInt())")
 .Case("OMPTraitInfo *", "Record.readOMPTraitInfo()")
 .Default("Record.readInt()");
}

// Get a type that is suitable for storing an object of the specified type.
static StringRef getStorageType(StringRef type) {
return StringSwitch<StringRef>(type)
 .Case("StringRef", "std::string")
 .Default(type);
}

// Assumes that the way to get the value is SA->getname()
static std::string WritePCHRecord(StringRef type, StringRef name) {
return"Record." +
 StringSwitch<std::string>(type)
 .EndsWith("Decl *", "AddDeclRef(" + name.str() + ");\n")
 .Case("TypeSourceInfo *",
"AddTypeSourceInfo(" + name.str() + ");\n")
 .Case("Expr *", "AddStmt(" + name.str() + ");\n")
 .Case("IdentifierInfo *",
"AddIdentifierRef(" + name.str() + ");\n")
 .Case("StringRef", "AddString(" + name.str() + ");\n")
 .Case("ParamIdx", "push_back(" + name.str() + ".serialize());\n")
 .Case("OMPTraitInfo *", "writeOMPTraitInfo(" + name.str() + ");\n")
 .Default("push_back(" + name.str() + ");\n");
}

// Normalize attribute name by removing leading and trailing
// underscores. For example, __foo, foo__, __foo__ would
// become foo.
static StringRef NormalizeAttrName(StringRef AttrName) {
 AttrName.consume_front("__");
 AttrName.consume_back("__");
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) {
return Name.trim("_");
}

// Normalize the spelling of a GNU attribute (i.e. "x" in "__attribute__((x))"),
// removing "__" if it appears at the beginning and end of the attribute's name.
static StringRef NormalizeGNUAttrSpelling(StringRef AttrSpelling) {
if (AttrSpelling.starts_with("__") && AttrSpelling.ends_with("__")) {
 AttrSpelling = AttrSpelling.substr(2, AttrSpelling.size() - 4);
 }

return AttrSpelling;
}

typedef std::vector<std::pair<std::string, const Record *>> ParsedAttrMap;

static ParsedAttrMap getParsedAttrList(const RecordKeeper &Records,
 ParsedAttrMap *Dupes = nullptr,
bool SemaOnly = true) {
 std::set<std::string> Seen;
 ParsedAttrMap R;
for (const Record *Attr : Records.getAllDerivedDefinitions("Attr")) {
if (!SemaOnly || Attr->getValueAsBit("SemaHandler")) {
 std::string AN;
if (Attr->isSubClassOf("TargetSpecificAttr") &&
 !Attr->isValueUnset("ParseKind")) {
 AN = Attr->getValueAsString("ParseKind").str();

// If this attribute has already been handled, it does not need to be
// handled again.
if (!Seen.insert(AN).second) {
if (Dupes)
 Dupes->push_back(std::make_pair(AN, Attr));
continue;
 }
 } else
 AN = NormalizeAttrName(Attr->getName()).str();

 R.push_back(std::make_pair(AN, Attr));
 }
 }
return R;
}

namespace {

classArgument {
 std::string lowerName, upperName;
 StringRef attrName;
bool isOpt;
bool Fake;

public:
Argument(StringRef Arg, StringRef Attr)
 : lowerName(Arg.str()), upperName(lowerName), attrName(Attr),
isOpt(false), Fake(false) {
if (!lowerName.empty()) {
 lowerName[0] = std::tolower(lowerName[0]);
 upperName[0] = std::toupper(upperName[0]);
 }
// Work around MinGW's macro definition of 'interface' to 'struct'. We
// have an attribute argument called 'Interface', so only the lower case
// name conflicts with the macro definition.
if (lowerName == "interface")
 lowerName = "interface_";
 }
Argument(const Record &Arg, StringRef Attr)
 : Argument(Arg.getValueAsString("Name"), Attr) {}
virtual~Argument() = default;

 StringRef getLowerName() const { return lowerName; }
 StringRef getUpperName() const { return upperName; }
 StringRef getAttrName() const { return attrName; }

boolisOptional() const { return isOpt; }
voidsetOptional(bool set) { isOpt = set; }

boolisFake() const { return Fake; }
voidsetFake(bool fake) { Fake = fake; }

// These functions print the argument contents formatted in different ways.
virtualvoidwriteAccessors(raw_ostream &OS) const = 0;
virtualvoidwriteAccessorDefinitions(raw_ostream &OS) const {}
virtualvoidwriteASTVisitorTraversal(raw_ostream &OS) const {}
virtualvoidwriteCloneArgs(raw_ostream &OS) const = 0;
virtualvoidwriteTemplateInstantiationArgs(raw_ostream &OS) const = 0;
virtualvoidwriteTemplateInstantiation(raw_ostream &OS) const {}
virtualvoidwriteCtorBody(raw_ostream &OS) const {}
virtualvoidwriteCtorInitializers(raw_ostream &OS) const = 0;
virtualvoidwriteCtorDefaultInitializers(raw_ostream &OS) const = 0;
virtualvoidwriteCtorParameters(raw_ostream &OS) const = 0;
virtualvoidwriteDeclarations(raw_ostream &OS) const = 0;
virtualvoidwritePCHReadArgs(raw_ostream &OS) const = 0;
virtualvoidwritePCHReadDecls(raw_ostream &OS) const = 0;
virtualvoidwritePCHWrite(raw_ostream &OS) const = 0;
virtual std::string getIsOmitted() const { return"false"; }
virtualvoidwriteValue(raw_ostream &OS) const = 0;
virtualvoidwriteDump(raw_ostream &OS) const = 0;
virtualvoidwriteDumpChildren(raw_ostream &OS) const {}
virtualvoidwriteHasChildren(raw_ostream &OS) const { OS << "false"; }

virtualboolisEnumArg() const { returnfalse; }
virtualboolisVariadicEnumArg() const { returnfalse; }
virtualboolisVariadic() const { returnfalse; }

virtualvoidwriteImplicitCtorArgs(raw_ostream &OS) const {
 OS << getUpperName();
 }
 };

classSimpleArgument : publicArgument {
 std::string type;

public:
SimpleArgument(const Record &Arg, StringRef Attr, std::string T)
 : Argument(Arg, Attr), type(std::move(T)) {}

 std::string getType() const { return type; }

voidwriteAccessors(raw_ostream &OS) constoverride {
 OS << "" << type << " get" << getUpperName() << "() const {\n";
 OS << " return " << getLowerName() << ";\n";
 OS << " }";
 }

voidwriteCloneArgs(raw_ostream &OS) constoverride {
 OS << getLowerName();
 }

voidwriteTemplateInstantiationArgs(raw_ostream &OS) constoverride {
 OS << "A->get" << getUpperName() << "()";
 }

voidwriteCtorInitializers(raw_ostream &OS) constoverride {
 OS << getLowerName() << "(" << getUpperName() << ")";
 }

voidwriteCtorDefaultInitializers(raw_ostream &OS) constoverride {
 OS << getLowerName() << "()";
 }

voidwriteCtorParameters(raw_ostream &OS) constoverride {
 OS << type << "" << getUpperName();
 }

voidwriteDeclarations(raw_ostream &OS) constoverride {
 OS << type << "" << getLowerName() << ";";
 }

voidwritePCHReadDecls(raw_ostream &OS) constoverride {
 std::string read = ReadPCHRecord(type);
 OS << "" << type << "" << getLowerName() << " = " << read << ";\n";
 }

voidwritePCHReadArgs(raw_ostream &OS) constoverride {
 OS << getLowerName();
 }

voidwritePCHWrite(raw_ostream &OS) constoverride {
 OS << ""
 << WritePCHRecord(type, "SA->get" + getUpperName().str() + "()");
 }

 std::string getIsOmitted() constoverride {
auto IsOneOf = [](StringRef subject, auto... list) {
return ((subject == list) || ...);
 };

if (IsOneOf(type, "IdentifierInfo *", "Expr *"))
return"!get" + getUpperName().str() + "()";
if (IsOneOf(type, "TypeSourceInfo *"))
return"!get" + getUpperName().str() + "Loc()";
if (IsOneOf(type, "ParamIdx"))
return"!get" + getUpperName().str() + "().isValid()";

assert(IsOneOf(type, "unsigned", "int", "bool", "FunctionDecl *",
"VarDecl *"));
return"false";
 }

voidwriteValue(raw_ostream &OS) constoverride {
if (type == "FunctionDecl *")
 OS << "\" << get" << getUpperName()
 << "()->getNameInfo().getAsString() << \"";
elseif (type == "IdentifierInfo *")
// Some non-optional (comma required) identifier arguments can be the
// empty string but are then recorded as a nullptr.
 OS << "\" << (get" << getUpperName() << "() ? get" << getUpperName()
 << "()->getName() : \"\") << \"";
elseif (type == "VarDecl *")
 OS << "\" << get" << getUpperName() << "()->getName() << \"";
elseif (type == "TypeSourceInfo *")
 OS << "\" << get" << getUpperName() << "().getAsString() << \"";
elseif (type == "ParamIdx")
 OS << "\" << get" << getUpperName() << "().getSourceIndex() << \"";
else
 OS << "\" << get" << getUpperName() << "() << \"";
 }

voidwriteDump(raw_ostream &OS) constoverride {
if (StringRef(type).ends_with("Decl *")) {
 OS << " OS << \"\";\n";
 OS << " dumpBareDeclRef(SA->get" << getUpperName() << "());\n";
 } elseif (type == "IdentifierInfo *") {
// Some non-optional (comma required) identifier arguments can be the
// empty string but are then recorded as a nullptr.
 OS << " if (SA->get" << getUpperName() << "())\n"
 << " OS << \"\" << SA->get" << getUpperName()
 << "()->getName();\n";
 } elseif (type == "TypeSourceInfo *") {
if (isOptional())
 OS << " if (SA->get" << getUpperName() << "Loc())";
 OS << " OS << \"\" << SA->get" << getUpperName()
 << "().getAsString();\n";
 } elseif (type == "bool") {
 OS << " if (SA->get" << getUpperName() << "()) OS << \""
 << getUpperName() << "\";\n";
 } elseif (type == "int" || type == "unsigned") {
 OS << " OS << \"\" << SA->get" << getUpperName() << "();\n";
 } elseif (type == "ParamIdx") {
if (isOptional())
 OS << " if (SA->get" << getUpperName() << "().isValid())\n";
 OS << " OS << \"\" << SA->get" << getUpperName()
 << "().getSourceIndex();\n";
 } elseif (type == "OMPTraitInfo *") {
 OS << " OS << \"\" << SA->get" << getUpperName() << "();\n";
 } else {
llvm_unreachable("Unknown SimpleArgument type!");
 }
 }
 };

classDefaultSimpleArgument : publicSimpleArgument {
int64_t Default;

public:
DefaultSimpleArgument(const Record &Arg, StringRef Attr,
 std::string T, int64_t Default)
 : SimpleArgument(Arg, Attr, T), Default(Default) {}

voidwriteAccessors(raw_ostream &OS) constoverride {
SimpleArgument::writeAccessors(OS);

 OS << "\n\n static const " << getType() << " Default" << getUpperName()
 << " = ";
if (getType() == "bool")
 OS << (Default != 0 ? "true" : "false");
else
 OS << Default;
 OS << ";";
 }
 };

classStringArgument : publicArgument {
public:
StringArgument(const Record &Arg, StringRef Attr)
 : Argument(Arg, Attr)
 {}

voidwriteAccessors(raw_ostream &OS) constoverride {
 OS << " llvm::StringRef get" << getUpperName() << "() const {\n";
 OS << " return llvm::StringRef(" << getLowerName() << ", "
 << getLowerName() << "Length);\n";
 OS << " }\n";
 OS << " unsigned get" << getUpperName() << "Length() const {\n";
 OS << " return " << getLowerName() << "Length;\n";
 OS << " }\n";
 OS << " void set" << getUpperName()
 << "(ASTContext &C, llvm::StringRef S) {\n";
 OS << "" << getLowerName() << "Length = S.size();\n";
 OS << " this->" << getLowerName() << " = new (C, 1) char ["
 << getLowerName() << "Length];\n";
 OS << " if (!S.empty())\n";
 OS << " std::memcpy(this->" << getLowerName() << ", S.data(), "
 << getLowerName() << "Length);\n";
 OS << " }";
 }

voidwriteCloneArgs(raw_ostream &OS) constoverride {
 OS << "get" << getUpperName() << "()";
 }

voidwriteTemplateInstantiationArgs(raw_ostream &OS) constoverride {
 OS << "A->get" << getUpperName() << "()";
 }

voidwriteCtorBody(raw_ostream &OS) constoverride {
 OS << " if (!" << getUpperName() << ".empty())\n";
 OS << " std::memcpy(" << getLowerName() << ", " << getUpperName()
 << ".data(), " << getLowerName() << "Length);\n";
 }

voidwriteCtorInitializers(raw_ostream &OS) constoverride {
 OS << getLowerName() << "Length(" << getUpperName() << ".size()),"
 << getLowerName() << "(new (Ctx, 1) char[" << getLowerName()
 << "Length])";
 }

voidwriteCtorDefaultInitializers(raw_ostream &OS) constoverride {
 OS << getLowerName() << "Length(0)," << getLowerName() << "(nullptr)";
 }

voidwriteCtorParameters(raw_ostream &OS) constoverride {
 OS << "llvm::StringRef " << getUpperName();
 }

voidwriteDeclarations(raw_ostream &OS) constoverride {
 OS << "unsigned " << getLowerName() << "Length;\n";
 OS << "char *" << getLowerName() << ";";
 }

voidwritePCHReadDecls(raw_ostream &OS) constoverride {
 OS << " std::string " << getLowerName()
 << "= Record.readString();\n";
 }

voidwritePCHReadArgs(raw_ostream &OS) constoverride {
 OS << getLowerName();
 }

voidwritePCHWrite(raw_ostream &OS) constoverride {
 OS << " Record.AddString(SA->get" << getUpperName() << "());\n";
 }

voidwriteValue(raw_ostream &OS) constoverride {
 OS << "\\\"\" << get" << getUpperName() << "() << \"\\\"";
 }

voidwriteDump(raw_ostream &OS) constoverride {
 OS << " OS << \"\\\"\" << SA->get" << getUpperName()
 << "() << \"\\\"\";\n";
 }
 };

classAlignedArgument : publicArgument {
public:
AlignedArgument(const Record &Arg, StringRef Attr)
 : Argument(Arg, Attr)
 {}

voidwriteAccessors(raw_ostream &OS) constoverride {
 OS << " bool is" << getUpperName() << "Dependent() const;\n";
 OS << " bool is" << getUpperName() << "ErrorDependent() const;\n";

 OS << " unsigned get" << getUpperName() << "(ASTContext &Ctx) const;\n";

 OS << " bool is" << getUpperName() << "Expr() const {\n";
 OS << " return is" << getLowerName() << "Expr;\n";
 OS << " }\n";

 OS << " Expr *get" << getUpperName() << "Expr() const {\n";
 OS << " assert(is" << getLowerName() << "Expr);\n";
 OS << " return " << getLowerName() << "Expr;\n";
 OS << " }\n";

 OS << " TypeSourceInfo *get" << getUpperName() << "Type() const {\n";
 OS << " assert(!is" << getLowerName() << "Expr);\n";
 OS << " return " << getLowerName() << "Type;\n";
 OS << " }";

 OS << " std::optional<unsigned> getCached" << getUpperName()
 << "Value() const {\n";
 OS << " return " << getLowerName() << "Cache;\n";
 OS << " }";

 OS << " void setCached" << getUpperName()
 << "Value(unsigned AlignVal) {\n";
 OS << "" << getLowerName() << "Cache = AlignVal;\n";
 OS << " }";
 }

voidwriteAccessorDefinitions(raw_ostream &OS) constoverride {
 OS << "bool " << getAttrName() << "Attr::is" << getUpperName()
 << "Dependent() const {\n";
 OS << " if (is" << getLowerName() << "Expr)\n";
 OS << " return " << getLowerName() << "Expr && (" << getLowerName()
 << "Expr->isValueDependent() || " << getLowerName()
 << "Expr->isTypeDependent());\n";
 OS << " else\n";
 OS << " return " << getLowerName()
 << "Type->getType()->isDependentType();\n";
 OS << "}\n";

 OS << "bool " << getAttrName() << "Attr::is" << getUpperName()
 << "ErrorDependent() const {\n";
 OS << " if (is" << getLowerName() << "Expr)\n";
 OS << " return " << getLowerName() << "Expr && " << getLowerName()
 << "Expr->containsErrors();\n";
 OS << " return " << getLowerName()
 << "Type->getType()->containsErrors();\n";
 OS << "}\n";
 }

voidwriteASTVisitorTraversal(raw_ostream &OS) constoverride {
 StringRef Name = getUpperName();
 OS << " if (A->is" << Name << "Expr()) {\n"
 << " if (!getDerived().TraverseStmt(A->get" << Name << "Expr()))\n"
 << " return false;\n"
 << " } else if (auto *TSI = A->get" << Name << "Type()) {\n"
 << " if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))\n"
 << " return false;\n"
 << " }\n";
 }

voidwriteCloneArgs(raw_ostream &OS) constoverride {
 OS << "is" << getLowerName() << "Expr, is" << getLowerName()
 << "Expr ? static_cast<void*>(" << getLowerName()
 << "Expr) : " << getLowerName()
 << "Type";
 }

voidwriteTemplateInstantiationArgs(raw_ostream &OS) constoverride {
// FIXME: move the definition in Sema::InstantiateAttrs to here.
// In the meantime, aligned attributes are cloned.
 }

voidwriteCtorBody(raw_ostream &OS) constoverride {
 OS << " if (is" << getLowerName() << "Expr)\n";
 OS << "" << getLowerName() << "Expr = reinterpret_cast<Expr *>("
 << getUpperName() << ");\n";
 OS << " else\n";
 OS << "" << getLowerName()
 << "Type = reinterpret_cast<TypeSourceInfo *>(" << getUpperName()
 << ");\n";
 }

voidwriteCtorInitializers(raw_ostream &OS) constoverride {
 OS << "is" << getLowerName() << "Expr(Is" << getUpperName() << "Expr)";
 }

voidwriteCtorDefaultInitializers(raw_ostream &OS) constoverride {
 OS << "is" << getLowerName() << "Expr(false)";
 }

voidwriteCtorParameters(raw_ostream &OS) constoverride {
 OS << "bool Is" << getUpperName() << "Expr, void *" << getUpperName();
 }

voidwriteImplicitCtorArgs(raw_ostream &OS) constoverride {
 OS << "Is" << getUpperName() << "Expr, " << getUpperName();
 }

voidwriteDeclarations(raw_ostream &OS) constoverride {
 OS << "bool is" << getLowerName() << "Expr;\n";
 OS << "union {\n";
 OS << "Expr *" << getLowerName() << "Expr;\n";
 OS << "TypeSourceInfo *" << getLowerName() << "Type;\n";
 OS << "};\n";
 OS << "std::optional<unsigned> " << getLowerName() << "Cache;\n";
 }

voidwritePCHReadArgs(raw_ostream &OS) constoverride {
 OS << "is" << getLowerName() << "Expr, " << getLowerName() << "Ptr";
 }

voidwritePCHReadDecls(raw_ostream &OS) constoverride {
 OS << " bool is" << getLowerName() << "Expr = Record.readInt();\n";
 OS << " void *" << getLowerName() << "Ptr;\n";
 OS << " if (is" << getLowerName() << "Expr)\n";
 OS << "" << getLowerName() << "Ptr = Record.readExpr();\n";
 OS << " else\n";
 OS << "" << getLowerName()
 << "Ptr = Record.readTypeSourceInfo();\n";
 }

voidwritePCHWrite(raw_ostream &OS) constoverride {
 OS << " Record.push_back(SA->is" << getUpperName() << "Expr());\n";
 OS << " if (SA->is" << getUpperName() << "Expr())\n";
 OS << " Record.AddStmt(SA->get" << getUpperName() << "Expr());\n";
 OS << " else\n";
 OS << " Record.AddTypeSourceInfo(SA->get" << getUpperName()
 << "Type());\n";
 }

 std::string getIsOmitted() constoverride {
return"!((is" + getLowerName().str() + "Expr && " +
getLowerName().str() + "Expr) || (!is" + getLowerName().str() +
"Expr && " + getLowerName().str() + "Type))";
 }

voidwriteValue(raw_ostream &OS) constoverride {
 OS << "\";\n";
 OS << " if (is" << getLowerName() << "Expr && " << getLowerName()
 << "Expr)";
 OS << "" << getLowerName()
 << "Expr->printPretty(OS, nullptr, Policy);\n";
 OS << " if (!is" << getLowerName() << "Expr && " << getLowerName()
 << "Type)";
 OS << "" << getLowerName()
 << "Type->getType().print(OS, Policy);\n";
 OS << " OS << \"";
 }

voidwriteDump(raw_ostream &OS) constoverride {
 OS << " if (!SA->is" << getUpperName() << "Expr())\n";
 OS << " dumpType(SA->get" << getUpperName()
 << "Type()->getType());\n";
 }

voidwriteDumpChildren(raw_ostream &OS) constoverride {
 OS << " if (SA->is" << getUpperName() << "Expr())\n";
 OS << " Visit(SA->get" << getUpperName() << "Expr());\n";
 }

voidwriteHasChildren(raw_ostream &OS) constoverride {
 OS << "SA->is" << getUpperName() << "Expr()";
 }
 };

classVariadicArgument : publicArgument {
 std::string Type, ArgName, ArgSizeName, RangeName;

protected:
// Assumed to receive a parameter: raw_ostream OS.
virtualvoidwriteValueImpl(raw_ostream &OS) const {
 OS << " OS << Val;\n";
 }
// Assumed to receive a parameter: raw_ostream OS.
virtualvoidwriteDumpImpl(raw_ostream &OS) const {
 OS << " OS << \"\" << Val;\n";
 }

public:
VariadicArgument(const Record &Arg, StringRef Attr, std::string T)
 : Argument(Arg, Attr), Type(std::move(T)),
ArgName(getLowerName().str() + "_"), ArgSizeName(ArgName + "Size"),
 RangeName(getLowerName().str()) {}

VariadicArgument(StringRef Arg, StringRef Attr, std::string T)
 : Argument(Arg, Attr), Type(std::move(T)),
 ArgName(getLowerName().str() + "_"), ArgSizeName(ArgName + "Size"),
 RangeName(getLowerName().str()) {}

const std::string &getType() const { return Type; }
const std::string &getArgName() const { return ArgName; }
const std::string &getArgSizeName() const { return ArgSizeName; }
boolisVariadic() constoverride { returntrue; }

voidwriteAccessors(raw_ostream &OS) constoverride {
 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";
 }

voidwriteSetter(raw_ostream &OS) const {
 OS << " void set" << getUpperName() << "(ASTContext &Ctx, ";
writeCtorParameters(OS);
 OS << ") {\n";
 OS << "" << ArgSizeName << " = " << getUpperName() << "Size;\n";
 OS << "" << ArgName << " = new (Ctx, 16) " << getType() << "["
 << ArgSizeName << "];\n";
 OS << "";
writeCtorBody(OS);
 OS << " }\n";
 }

voidwriteCloneArgs(raw_ostream &OS) constoverride {
 OS << ArgName << ", " << ArgSizeName;
 }

voidwriteTemplateInstantiationArgs(raw_ostream &OS) constoverride {
// This isn't elegant, but we have to go through public methods...
 OS << "A->" << getLowerName() << "_begin(), "
 << "A->" << getLowerName() << "_size()";
 }

voidwriteASTVisitorTraversal(raw_ostream &OS) constoverride {
// FIXME: Traverse the elements.
 }

voidwriteCtorBody(raw_ostream &OS) constoverride {
 OS << " std::copy(" << getUpperName() << ", " << getUpperName() << " + "
 << ArgSizeName << ", " << ArgName << ");\n";
 }

voidwriteCtorInitializers(raw_ostream &OS) constoverride {
 OS << ArgSizeName << "(" << getUpperName() << "Size), "
 << ArgName << "(new (Ctx, 16) " << getType() << "["
 << ArgSizeName << "])";
 }

voidwriteCtorDefaultInitializers(raw_ostream &OS) constoverride {
 OS << ArgSizeName << "(0), " << ArgName << "(nullptr)";
 }

voidwriteCtorParameters(raw_ostream &OS) constoverride {
 OS << getType() << " *" << getUpperName() << ", unsigned "
 << getUpperName() << "Size";
 }

voidwriteImplicitCtorArgs(raw_ostream &OS) constoverride {
 OS << getUpperName() << ", " << getUpperName() << "Size";
 }

voidwriteDeclarations(raw_ostream &OS) constoverride {
 OS << " unsigned " << ArgSizeName << ";\n";
 OS << "" << getType() << " *" << ArgName << ";";
 }

voidwritePCHReadDecls(raw_ostream &OS) constoverride {
 OS << " unsigned " << getLowerName() << "Size = Record.readInt();\n";
 OS << " SmallVector<" << getType() << ", 4> "
 << getLowerName() << ";\n";
 OS << "" << getLowerName() << ".reserve(" << getLowerName()
 << "Size);\n";

// If we can't store the values in the current type (if it's something
// like StringRef), store them in a different type and convert the
// container afterwards.
 std::string StorageType = getStorageType(getType()).str();
 std::string StorageName = getLowerName().str();
if (StorageType != getType()) {
 StorageName += "Storage";
 OS << " SmallVector<" << StorageType << ", 4> "
 << StorageName << ";\n";
 OS << "" << StorageName << ".reserve(" << getLowerName()
 << "Size);\n";
 }

 OS << " for (unsigned i = 0; i != " << getLowerName() << "Size; ++i)\n";
 std::string read = ReadPCHRecord(Type);
 OS << "" << StorageName << ".push_back(" << read << ");\n";

if (StorageType != getType()) {
 OS << " for (unsigned i = 0; i != " << getLowerName() << "Size; ++i)\n";
 OS << "" << getLowerName() << ".push_back("
 << StorageName << "[i]);\n";
 }
 }

voidwritePCHReadArgs(raw_ostream &OS) constoverride {
 OS << getLowerName() << ".data(), " << getLowerName() << "Size";
 }

voidwritePCHWrite(raw_ostream &OS) constoverride {
 OS << " Record.push_back(SA->" << getLowerName() << "_size());\n";
 OS << " for (auto &Val : SA->" << RangeName << "())\n";
 OS << "" << WritePCHRecord(Type, "Val");
 }

voidwriteValue(raw_ostream &OS) constoverride {
 OS << "\";\n";
 OS << " for (const auto &Val : " << RangeName << "()) {\n"
 << " DelimitAttributeArgument(OS, IsFirstArgument);\n";
writeValueImpl(OS);
 OS << " }\n";
 OS << " OS << \"";
 }

voidwriteDump(raw_ostream &OS) constoverride {
 OS << " for (const auto &Val : SA->" << RangeName << "())\n";
writeDumpImpl(OS);
 }
 };

classVariadicOMPInteropInfoArgument : publicVariadicArgument {
public:
VariadicOMPInteropInfoArgument(const Record &Arg, StringRef Attr)
 : VariadicArgument(Arg, Attr, "OMPInteropInfo") {}

voidwriteDump(raw_ostream &OS) constoverride {
 OS << " for (" << getAttrName() << "Attr::" << getLowerName()
 << "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
 << getLowerName() << "_end(); I != E; ++I) {\n";
 OS << " if (I->IsTarget && I->IsTargetSync)\n";
 OS << " OS << \" Target_TargetSync\";\n";
 OS << " else if (I->IsTarget)\n";
 OS << " OS << \" Target\";\n";
 OS << " else\n";
 OS << " OS << \" TargetSync\";\n";
 OS << " }\n";
 }

voidwritePCHReadDecls(raw_ostream &OS) constoverride {
 OS << " unsigned " << getLowerName() << "Size = Record.readInt();\n";
 OS << " SmallVector<OMPInteropInfo, 4> " << getLowerName() << ";\n";
 OS << "" << getLowerName() << ".reserve(" << getLowerName()
 << "Size);\n";
 OS << " for (unsigned I = 0, E = " << getLowerName() << "Size; ";
 OS << "I != E; ++I) {\n";
 OS << " bool IsTarget = Record.readBool();\n";
 OS << " bool IsTargetSync = Record.readBool();\n";
 OS << "" << getLowerName()
 << ".emplace_back(IsTarget, IsTargetSync);\n";
 OS << " }\n";
 }

voidwritePCHWrite(raw_ostream &OS) constoverride {
 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 << " Record.writeBool(I->IsTarget);\n";
 OS << " Record.writeBool(I->IsTargetSync);\n";
 OS << " }\n";
 }
 };

classVariadicParamIdxArgument : publicVariadicArgument {
public:
VariadicParamIdxArgument(const Record &Arg, StringRef Attr)
 : VariadicArgument(Arg, Attr, "ParamIdx") {}

public:
voidwriteValueImpl(raw_ostream &OS) constoverride {
 OS << " OS << Val.getSourceIndex();\n";
 }

voidwriteDumpImpl(raw_ostream &OS) constoverride {
 OS << " OS << \"\" << Val.getSourceIndex();\n";
 }
 };

structVariadicParamOrParamIdxArgument : publicVariadicArgument {
VariadicParamOrParamIdxArgument(const Record &Arg, StringRef Attr)
 : VariadicArgument(Arg, Attr, "int") {}
 };

// Unique the enums, but maintain the original declaration ordering.
 std::vector<StringRef>
uniqueEnumsInOrder(const std::vector<StringRef> &enums) {
 std::vector<StringRef> uniques;
 SmallDenseSet<StringRef, 8> unique_set;
for (constauto &i : enums) {
if (unique_set.insert(i).second)
 uniques.push_back(i);
 }
return uniques;
 }

classEnumArgument : publicArgument {
 std::string fullType;
 StringRef shortType;
 std::vector<StringRef> values, enums, uniques;
bool isExternal;
bool isCovered;

public:
EnumArgument(const Record &Arg, StringRef Attr)
 : Argument(Arg, Attr), values(Arg.getValueAsListOfStrings("Values")),
enums(Arg.getValueAsListOfStrings("Enums")),
 uniques(uniqueEnumsInOrder(enums)),
 isExternal(Arg.getValueAsBit("IsExternalType")),
 isCovered(Arg.getValueAsBit("IsCovered")) {
 StringRef Type = Arg.getValueAsString("Type");
 shortType = isExternal ? Type.rsplit("::").second : Type;
// If shortType didn't contain :: at all rsplit will give us an empty
// string.
if (shortType.empty())
 shortType = Type;
 fullType = isExternal ? Type : (getAttrName() + "Attr::" + Type).str();

// FIXME: Emit a proper error
assert(!uniques.empty());
 }

boolisEnumArg() constoverride { returntrue; }

voidwriteAccessors(raw_ostream &OS) constoverride {
 OS << "" << fullType << " get" << getUpperName() << "() const {\n";
 OS << " return " << getLowerName() << ";\n";
 OS << " }";
 }

voidwriteCloneArgs(raw_ostream &OS) constoverride {
 OS << getLowerName();
 }

voidwriteTemplateInstantiationArgs(raw_ostream &OS) constoverride {
 OS << "A->get" << getUpperName() << "()";
 }
voidwriteCtorInitializers(raw_ostream &OS) constoverride {
 OS << getLowerName() << "(" << getUpperName() << ")";
 }
voidwriteCtorDefaultInitializers(raw_ostream &OS) constoverride {
 OS << getLowerName() << "(" << fullType << "(0))";
 }
voidwriteCtorParameters(raw_ostream &OS) constoverride {
 OS << fullType << "" << getUpperName();
 }
voidwriteDeclarations(raw_ostream &OS) constoverride {
if (!isExternal) {
auto i = uniques.cbegin(), e = uniques.cend();
// The last one needs to not have a comma.
 --e;

 OS << "public:\n";
 OS << " enum " << shortType << " {\n";
for (; i != e; ++i)
 OS << "" << *i << ",\n";
 OS << "" << *e << "\n";
 OS << " };\n";
 }

 OS << "private:\n";
 OS << "" << fullType << "" << getLowerName() << ";";
 }

voidwritePCHReadDecls(raw_ostream &OS) constoverride {
 OS << "" << fullType << "" << getLowerName() << "(static_cast<"
 << fullType << ">(Record.readInt()));\n";
 }

voidwritePCHReadArgs(raw_ostream &OS) constoverride {
 OS << getLowerName();
 }

voidwritePCHWrite(raw_ostream &OS) constoverride {
 OS << "Record.push_back(static_cast<uint64_t>(SA->get" << getUpperName()
 << "()));\n";
 }

voidwriteValue(raw_ostream &OS) constoverride {
// FIXME: this isn't 100% correct -- some enum arguments require printing
// as a string literal, while others require printing as an identifier.
// Tablegen currently does not distinguish between the two forms.