Author: Jay Foad Date: 2025-04-24T18:57:51+01:00 New Revision: 2bc6f9d4b6ff1d838f1c2d50cacbab6ba2f20bc9
URL: https://github.com/llvm/llvm-project/commit/2bc6f9d4b6ff1d838f1c2d50cacbab6ba2f20bc9 DIFF: https://github.com/llvm/llvm-project/commit/2bc6f9d4b6ff1d838f1c2d50cacbab6ba2f20bc9.diff LOG: [TableGen] Only store direct superclasses in Record (#123072) In Record only store the direct superclasses instead of all superclasses. getSuperClasses recurses to find all superclasses when necessary. This gives a small reduction in memory usage. On lib/Target/X86/X86.td I measured about 2.0% reduction in total bytes allocated (measured by valgrind) and 1.3% reduction in peak memory usage (measured by /usr/bin/time -v). --------- Co-authored-by: Min-Yih Hsu <m...@myhsu.dev> Added: Modified: clang/utils/TableGen/ClangAttrEmitter.cpp clang/utils/TableGen/NeonEmitter.cpp llvm/docs/TableGen/BackGuide.rst llvm/include/llvm/TableGen/Record.h llvm/lib/TableGen/DetailedRecordsBackend.cpp llvm/lib/TableGen/JSONBackend.cpp llvm/lib/TableGen/Record.cpp llvm/lib/TableGen/SetTheory.cpp llvm/lib/TableGen/TGParser.cpp llvm/utils/TableGen/CallingConvEmitter.cpp llvm/utils/TableGen/Common/CodeGenRegisters.cpp llvm/utils/TableGen/SearchableTableEmitter.cpp mlir/lib/Tools/tblgen-lsp-server/TableGenServer.cpp mlir/tools/mlir-tblgen/OmpOpGen.cpp mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp mlir/tools/mlir-tblgen/TosaUtilsGen.cpp Removed: ################################################################################ diff --git a/clang/utils/TableGen/ClangAttrEmitter.cpp b/clang/utils/TableGen/ClangAttrEmitter.cpp index bc5033ed3c89a..00df99d04d873 100644 --- a/clang/utils/TableGen/ClangAttrEmitter.cpp +++ b/clang/utils/TableGen/ClangAttrEmitter.cpp @@ -1526,7 +1526,8 @@ createArgument(const Record &Arg, StringRef Attr, if (!Ptr) { // Search in reverse order so that the most-derived type is handled first. - for (const auto &[Base, _] : reverse(Search->getSuperClasses())) { + std::vector<const Record *> SCs = Search->getSuperClasses(); + for (const Record *Base : reverse(SCs)) { if ((Ptr = createArgument(Arg, Attr, Base))) break; } @@ -1856,17 +1857,16 @@ static LateAttrParseKind getLateAttrParseKind(const Record *Attr) { auto *LAPK = Attr->getValueAsDef(LateParsedStr); // Typecheck the `LateParsed` field. - SmallVector<const Record *, 1> SuperClasses; - LAPK->getDirectSuperClasses(SuperClasses); - if (SuperClasses.size() != 1) + if (LAPK->getDirectSuperClasses().size() != 1) PrintFatalError(Attr, "Field `" + Twine(LateParsedStr) + "`should only have one super class"); - if (SuperClasses[0]->getName() != LateAttrParseKindStr) + const Record *SuperClass = LAPK->getDirectSuperClasses()[0].first; + if (SuperClass->getName() != LateAttrParseKindStr) PrintFatalError( Attr, "Field `" + Twine(LateParsedStr) + "`should only have type `" + Twine(LateAttrParseKindStr) + "` but found type `" + - SuperClasses[0]->getName() + "`"); + SuperClass->getName() + "`"); // Get Kind and verify the enum name matches the name in `Attr.td`. unsigned Kind = LAPK->getValueAsInt(KindFieldStr); @@ -2465,8 +2465,8 @@ static void emitStringSwitchCases(std::map<StringRef, FSIVecTy> &Map, } static bool isTypeArgument(const Record *Arg) { - return !Arg->getSuperClasses().empty() && - Arg->getSuperClasses().back().first->getName() == "TypeArgument"; + return !Arg->getDirectSuperClasses().empty() && + Arg->getDirectSuperClasses().back().first->getName() == "TypeArgument"; } /// Emits the first-argument-is-type property for attributes. @@ -2507,8 +2507,9 @@ static void emitClangAttrArgContextList(const RecordKeeper &Records, } static bool isIdentifierArgument(const Record *Arg) { - return !Arg->getSuperClasses().empty() && - StringSwitch<bool>(Arg->getSuperClasses().back().first->getName()) + return !Arg->getDirectSuperClasses().empty() && + StringSwitch<bool>( + Arg->getDirectSuperClasses().back().first->getName()) .Case("IdentifierArgument", true) .Case("EnumArgument", true) .Case("VariadicEnumArgument", true) @@ -2516,33 +2517,35 @@ static bool isIdentifierArgument(const Record *Arg) { } static bool isVariadicIdentifierArgument(const Record *Arg) { - return !Arg->getSuperClasses().empty() && - StringSwitch<bool>(Arg->getSuperClasses().back().first->getName()) + return !Arg->getDirectSuperClasses().empty() && + StringSwitch<bool>( + Arg->getDirectSuperClasses().back().first->getName()) .Case("VariadicIdentifierArgument", true) .Case("VariadicParamOrParamIdxArgument", true) .Default(false); } static bool isVariadicExprArgument(const Record *Arg) { - return !Arg->getSuperClasses().empty() && - StringSwitch<bool>(Arg->getSuperClasses().back().first->getName()) + return !Arg->getDirectSuperClasses().empty() && + StringSwitch<bool>( + Arg->getDirectSuperClasses().back().first->getName()) .Case("VariadicExprArgument", true) .Default(false); } static bool isStringLiteralArgument(const Record *Arg) { - if (Arg->getSuperClasses().empty()) + if (Arg->getDirectSuperClasses().empty()) return false; - StringRef ArgKind = Arg->getSuperClasses().back().first->getName(); + StringRef ArgKind = Arg->getDirectSuperClasses().back().first->getName(); if (ArgKind == "EnumArgument") return Arg->getValueAsBit("IsString"); return ArgKind == "StringArgument"; } static bool isVariadicStringLiteralArgument(const Record *Arg) { - if (Arg->getSuperClasses().empty()) + if (Arg->getDirectSuperClasses().empty()) return false; - StringRef ArgKind = Arg->getSuperClasses().back().first->getName(); + StringRef ArgKind = Arg->getDirectSuperClasses().back().first->getName(); if (ArgKind == "VariadicEnumArgument") return Arg->getValueAsBit("IsString"); return ArgKind == "VariadicStringArgument"; @@ -2631,8 +2634,9 @@ static void emitClangAttrStrictIdentifierArgList(const RecordKeeper &Records, } static bool keywordThisIsaIdentifierInArgument(const Record *Arg) { - return !Arg->getSuperClasses().empty() && - StringSwitch<bool>(Arg->getSuperClasses().back().first->getName()) + return !Arg->getDirectSuperClasses().empty() && + StringSwitch<bool>( + Arg->getDirectSuperClasses().back().first->getName()) .Case("VariadicParamOrParamIdxArgument", true) .Default(false); } @@ -2718,11 +2722,11 @@ static void emitAttributes(const RecordKeeper &Records, raw_ostream &OS, if (!R.getValueAsBit("ASTNode")) continue; - ArrayRef<std::pair<const Record *, SMRange>> Supers = R.getSuperClasses(); + std::vector<const Record *> Supers = R.getSuperClasses(); assert(!Supers.empty() && "Forgot to specify a superclass for the attr"); std::string SuperName; bool Inheritable = false; - for (const auto &[R, _] : reverse(Supers)) { + for (const Record *R : reverse(Supers)) { if (R->getName() != "TargetSpecificAttr" && R->getName() != "DeclOrTypeAttr" && SuperName.empty()) SuperName = R->getName().str(); @@ -3419,10 +3423,10 @@ namespace { AttrClass *findSuperClass(const Record *R) const { // TableGen flattens the superclass list, so we just need to walk it // in reverse. - auto SuperClasses = R->getSuperClasses(); - for (signed i = 0, e = SuperClasses.size(); i != e; ++i) { - auto SuperClass = findClassByRecord(SuperClasses[e - i - 1].first); - if (SuperClass) return SuperClass; + std::vector<const Record *> SuperClasses = R->getSuperClasses(); + for (const Record *R : reverse(SuperClasses)) { + if (AttrClass *SuperClass = findClassByRecord(R)) + return SuperClass; } return nullptr; } @@ -4661,8 +4665,9 @@ static void GenerateHandleDeclAttribute(const Record &Attr, raw_ostream &OS) { } static bool isParamExpr(const Record *Arg) { - return !Arg->getSuperClasses().empty() && - StringSwitch<bool>(Arg->getSuperClasses().back().first->getName()) + return !Arg->getDirectSuperClasses().empty() && + StringSwitch<bool>( + Arg->getDirectSuperClasses().back().first->getName()) .Case("ExprArgument", true) .Case("VariadicExprArgument", true) .Default(false); @@ -4785,7 +4790,7 @@ void EmitClangAttrParsedAttrImpl(const RecordKeeper &Records, raw_ostream &OS) { if (Arg->getValueAsBitOrUnset("Fake", UnusedUnset)) continue; ArgNames.push_back(Arg->getValueAsString("Name").str()); - for (const auto &[Class, _] : Arg->getSuperClasses()) { + for (const Record *Class : Arg->getSuperClasses()) { if (Class->getName().starts_with("Variadic")) { ArgNames.back().append("..."); break; diff --git a/clang/utils/TableGen/NeonEmitter.cpp b/clang/utils/TableGen/NeonEmitter.cpp index c8cd214417efe..6b0fa1648e583 100644 --- a/clang/utils/TableGen/NeonEmitter.cpp +++ b/clang/utils/TableGen/NeonEmitter.cpp @@ -2029,8 +2029,8 @@ void NeonEmitter::createIntrinsic(const Record *R, std::vector<TypeSpec> TypeSpecs = TypeSpec::fromTypeSpecs(Types); ClassKind CK = ClassNone; - if (R->getSuperClasses().size() >= 2) - CK = ClassMap[R->getSuperClasses()[1].first]; + if (!R->getDirectSuperClasses().empty()) + CK = ClassMap[R->getDirectSuperClasses()[0].first]; std::vector<std::pair<TypeSpec, TypeSpec>> NewTypeSpecs; if (!CartesianProductWith.empty()) { diff --git a/llvm/docs/TableGen/BackGuide.rst b/llvm/docs/TableGen/BackGuide.rst index c26575272ad69..4828f9b7c183a 100644 --- a/llvm/docs/TableGen/BackGuide.rst +++ b/llvm/docs/TableGen/BackGuide.rst @@ -610,29 +610,28 @@ functions returns null. Getting Record Superclasses =========================== -The ``Record`` class provides a function to obtain the superclasses of a -record. It is named ``getSuperClasses`` and returns an ``ArrayRef`` of an -array of ``std::pair`` pairs. The superclasses are in post-order: the order -in which the superclasses were visited while copying their fields into the -record. Each pair consists of a pointer to the ``Record`` instance for a -superclass record and an instance of the ``SMRange`` class. The range -indicates the source file locations of the beginning and end of the class -definition. - -This example obtains the superclasses of the ``Prototype`` record and then -iterates over the pairs in the returned array. +The ``Record`` class provides a function to obtain the direct superclasses +of a record. It is named ``getDirectSuperClasses`` and returns an +``ArrayRef`` of an array of ``std::pair`` pairs. Each pair consists of a +pointer to the ``Record`` instance for a superclass record and an instance +of the ``SMRange`` class. The range indicates the source file locations of +the beginning and end of the class definition. + +This example obtains the direct superclasses of the ``Prototype`` record and +then iterates over the pairs in the returned array. .. code-block:: text ArrayRef<std::pair<const Record *, SMRange>> - Superclasses = Prototype->getSuperClasses(); - for (const auto &SuperPair : Superclasses) { + Superclasses = Prototype->getDirectSuperClasses(); + for (const auto &[Super, Range] : Superclasses) { ... } -The ``Record`` class also provides a function, ``getDirectSuperClasses``, to -append the *direct* superclasses of a record to a given vector of type -``SmallVectorImpl<Record *>``. +The ``Record`` class also provides a function, ``getSuperClasses``, to +return a vector of *all* superclasses of a record. The superclasses are in +post-order: the order in which the superclasses were visited while copying +their fields into the record. Emitting Text to the Output Stream ================================== diff --git a/llvm/include/llvm/TableGen/Record.h b/llvm/include/llvm/TableGen/Record.h index d3771a3731673..0a10f6a74d009 100644 --- a/llvm/include/llvm/TableGen/Record.h +++ b/llvm/include/llvm/TableGen/Record.h @@ -1667,9 +1667,9 @@ class Record { SmallVector<AssertionInfo, 0> Assertions; SmallVector<DumpInfo, 0> Dumps; - // All superclasses in the inheritance forest in post-order (yes, it + // Direct superclasses, which are roots of the inheritance forest (yes, it // must be a forest; diamond-shaped inheritance is not allowed). - SmallVector<std::pair<const Record *, SMRange>, 0> SuperClasses; + SmallVector<std::pair<const Record *, SMRange>, 0> DirectSuperClasses; // Tracks Record instances. Not owned by Record. RecordKeeper &TrackedRecords; @@ -1703,8 +1703,9 @@ class Record { Record(const Record &O) : Name(O.Name), Locs(O.Locs), TemplateArgs(O.TemplateArgs), Values(O.Values), Assertions(O.Assertions), - SuperClasses(O.SuperClasses), TrackedRecords(O.TrackedRecords), - ID(getNewUID(O.getRecords())), Kind(O.Kind) {} + DirectSuperClasses(O.DirectSuperClasses), + TrackedRecords(O.TrackedRecords), ID(getNewUID(O.getRecords())), + Kind(O.Kind) {} static unsigned getNewUID(RecordKeeper &RK); @@ -1755,15 +1756,30 @@ class Record { ArrayRef<AssertionInfo> getAssertions() const { return Assertions; } ArrayRef<DumpInfo> getDumps() const { return Dumps; } - ArrayRef<std::pair<const Record *, SMRange>> getSuperClasses() const { - return SuperClasses; + /// Append all superclasses in post-order to \p Classes. + void getSuperClasses(std::vector<const Record *> &Classes) const { + for (const Record *SC : make_first_range(DirectSuperClasses)) { + SC->getSuperClasses(Classes); + Classes.push_back(SC); + } + } + + /// Return all superclasses in post-order. + std::vector<const Record *> getSuperClasses() const { + std::vector<const Record *> Classes; + getSuperClasses(Classes); + return Classes; } /// Determine whether this record has the specified direct superclass. - bool hasDirectSuperClass(const Record *SuperClass) const; + bool hasDirectSuperClass(const Record *SuperClass) const { + return is_contained(make_first_range(DirectSuperClasses), SuperClass); + } - /// Append the direct superclasses of this record to Classes. - void getDirectSuperClasses(SmallVectorImpl<const Record *> &Classes) const; + /// Return the direct superclasses of this record. + ArrayRef<std::pair<const Record *, SMRange>> getDirectSuperClasses() const { + return DirectSuperClasses; + } bool isTemplateArg(const Init *Name) const { return llvm::is_contained(TemplateArgs, Name); @@ -1831,29 +1847,32 @@ class Record { void checkUnusedTemplateArgs(); bool isSubClassOf(const Record *R) const { - for (const auto &[SC, _] : SuperClasses) - if (SC == R) + for (const Record *SC : make_first_range(DirectSuperClasses)) { + if (SC == R || SC->isSubClassOf(R)) return true; + } return false; } bool isSubClassOf(StringRef Name) const { - for (const auto &[SC, _] : SuperClasses) { + for (const Record *SC : make_first_range(DirectSuperClasses)) { if (const auto *SI = dyn_cast<StringInit>(SC->getNameInit())) { if (SI->getValue() == Name) return true; } else if (SC->getNameInitAsString() == Name) { return true; } + if (SC->isSubClassOf(Name)) + return true; } return false; } - void addSuperClass(const Record *R, SMRange Range) { + void addDirectSuperClass(const Record *R, SMRange Range) { assert(!CorrespondingDefInit && "changing type of record after it has been referenced"); assert(!isSubClassOf(R) && "Already subclassing record!"); - SuperClasses.emplace_back(R, Range); + DirectSuperClasses.emplace_back(R, Range); } /// If there are any field references that refer to fields that have been diff --git a/llvm/lib/TableGen/DetailedRecordsBackend.cpp b/llvm/lib/TableGen/DetailedRecordsBackend.cpp index 4a337248c941a..cf697599e53a2 100644 --- a/llvm/lib/TableGen/DetailedRecordsBackend.cpp +++ b/llvm/lib/TableGen/DetailedRecordsBackend.cpp @@ -152,15 +152,14 @@ void DetailedRecordsEmitter::printTemplateArgs(const Record &Rec, // are enclosed in parentheses. void DetailedRecordsEmitter::printSuperclasses(const Record &Rec, raw_ostream &OS) { - ArrayRef<std::pair<const Record *, SMRange>> Superclasses = - Rec.getSuperClasses(); + std::vector<const Record *> Superclasses = Rec.getSuperClasses(); if (Superclasses.empty()) { OS << " Superclasses: (none)\n"; return; } OS << " Superclasses:"; - for (const auto &[ClassRec, Loc] : Superclasses) { + for (const Record *ClassRec : Superclasses) { if (Rec.hasDirectSuperClass(ClassRec)) OS << formatv(" {0}", ClassRec->getNameInitAsString()); else diff --git a/llvm/lib/TableGen/JSONBackend.cpp b/llvm/lib/TableGen/JSONBackend.cpp index d648019ac46e8..d7ab043cb8c90 100644 --- a/llvm/lib/TableGen/JSONBackend.cpp +++ b/llvm/lib/TableGen/JSONBackend.cpp @@ -151,7 +151,7 @@ void JSONEmitter::run(raw_ostream &OS) { json::Array SuperClasses; // Add this def to the instance list for each of its superclasses. - for (const auto &[SuperClass, Loc] : Def->getSuperClasses()) { + for (const Record *SuperClass : Def->getSuperClasses()) { std::string SuperName = SuperClass->getNameInitAsString(); SuperClasses.push_back(SuperName); InstanceLists[SuperName].push_back(Name); diff --git a/llvm/lib/TableGen/Record.cpp b/llvm/lib/TableGen/Record.cpp index 0fdf78976b691..c0f2fd957a505 100644 --- a/llvm/lib/TableGen/Record.cpp +++ b/llvm/lib/TableGen/Record.cpp @@ -336,7 +336,7 @@ static const RecordRecTy *resolveRecordTypes(const RecordRecTy *T1, if (T2->isSubClassOf(R)) { CommonSuperClasses.push_back(R); } else { - R->getDirectSuperClasses(Stack); + append_range(Stack, make_first_range(R->getDirectSuperClasses())); } } @@ -2482,11 +2482,8 @@ const DefInit *VarDefInit::instantiate() { NewRec->resolveReferences(R); - // Add superclasses. - for (const auto &[SC, Loc] : Class->getSuperClasses()) - NewRec->addSuperClass(SC, Loc); - - NewRec->addSuperClass( + // Add superclass. + NewRec->addDirectSuperClass( Class, SMRange(Class->getLoc().back(), Class->getLoc().back())); // Resolve internal references and store in record keeper @@ -2962,7 +2959,7 @@ void Record::checkName() { const RecordRecTy *Record::getType() const { SmallVector<const Record *, 4> DirectSCs; - getDirectSuperClasses(DirectSCs); + append_range(DirectSCs, make_first_range(getDirectSuperClasses())); return RecordRecTy::get(TrackedRecords, DirectSCs); } @@ -2994,35 +2991,6 @@ void Record::setName(const Init *NewName) { // this. See TGParser::ParseDef and TGParser::ParseDefm. } -// NOTE for the next two functions: -// Superclasses are in post-order, so the final one is a direct -// superclass. All of its transitive superclases immediately precede it, -// so we can step through the direct superclasses in reverse order. - -bool Record::hasDirectSuperClass(const Record *Superclass) const { - ArrayRef<std::pair<const Record *, SMRange>> SCs = getSuperClasses(); - - for (int I = SCs.size() - 1; I >= 0; --I) { - const Record *SC = SCs[I].first; - if (SC == Superclass) - return true; - I -= SC->getSuperClasses().size(); - } - - return false; -} - -void Record::getDirectSuperClasses( - SmallVectorImpl<const Record *> &Classes) const { - ArrayRef<std::pair<const Record *, SMRange>> SCs = getSuperClasses(); - - while (!SCs.empty()) { - const Record *SC = SCs.back().first; - SCs = SCs.drop_back(1 + SC->getSuperClasses().size()); - Classes.push_back(SC); - } -} - void Record::resolveReferences(Resolver &R, const RecordVal *SkipVal) { const Init *OldName = getNameInit(); const Init *NewName = Name->resolveReferences(R); @@ -3096,10 +3064,10 @@ raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) { } OS << " {"; - ArrayRef<std::pair<const Record *, SMRange>> SC = R.getSuperClasses(); - if (!SC.empty()) { + std::vector<const Record *> SCs = R.getSuperClasses(); + if (!SCs.empty()) { OS << "\t//"; - for (const auto &[SC, _] : SC) + for (const Record *SC : SCs) OS << " " << SC->getNameInitAsString(); } OS << "\n"; diff --git a/llvm/lib/TableGen/SetTheory.cpp b/llvm/lib/TableGen/SetTheory.cpp index 22ebff77037a8..fefe03b440c85 100644 --- a/llvm/lib/TableGen/SetTheory.cpp +++ b/llvm/lib/TableGen/SetTheory.cpp @@ -312,7 +312,7 @@ const RecVec *SetTheory::expand(const Record *Set) { return &I->second; // This is the first time we see Set. Find a suitable expander. - for (const auto &[SuperClass, Loc] : Set->getSuperClasses()) { + for (const Record *SuperClass : Set->getSuperClasses()) { // Skip unnamed superclasses. if (!isa<StringInit>(SuperClass->getNameInit())) continue; diff --git a/llvm/lib/TableGen/TGParser.cpp b/llvm/lib/TableGen/TGParser.cpp index 3d914b94ff62f..423daf6bd5d07 100644 --- a/llvm/lib/TableGen/TGParser.cpp +++ b/llvm/lib/TableGen/TGParser.cpp @@ -332,17 +332,10 @@ bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) { // Since everything went well, we can now set the "superclass" list for the // current record. - for (const auto &[SC, Loc] : SC->getSuperClasses()) { - if (CurRec->isSubClassOf(SC)) - return Error(SubClass.RefRange.Start, - "Already subclass of '" + SC->getName() + "'!\n"); - CurRec->addSuperClass(SC, Loc); - } - if (CurRec->isSubClassOf(SC)) return Error(SubClass.RefRange.Start, "Already subclass of '" + SC->getName() + "'!\n"); - CurRec->addSuperClass(SC, SubClass.RefRange); + CurRec->addDirectSuperClass(SC, SubClass.RefRange); return false; } @@ -4056,7 +4049,7 @@ bool TGParser::ParseClass() { if (CurRec) { // If the body was previously defined, this is an error. if (!CurRec->getValues().empty() || - !CurRec->getSuperClasses().empty() || + !CurRec->getDirectSuperClasses().empty() || !CurRec->getTemplateArgs().empty()) return TokError("Class '" + CurRec->getNameInitAsString() + "' already defined"); diff --git a/llvm/utils/TableGen/CallingConvEmitter.cpp b/llvm/utils/TableGen/CallingConvEmitter.cpp index b315aa7d86fe9..c94d294db547a 100644 --- a/llvm/utils/TableGen/CallingConvEmitter.cpp +++ b/llvm/utils/TableGen/CallingConvEmitter.cpp @@ -110,11 +110,10 @@ void CallingConvEmitter::emitCallingConv(const Record *CC, raw_ostream &O) { for (unsigned I = 0, E = CCActions->size(); I != E; ++I) { const Record *Action = CCActions->getElementAsRecord(I); SwiftAction = - llvm::any_of(Action->getSuperClasses(), - [](const std::pair<const Record *, SMRange> &Class) { - std::string Name = Class.first->getNameInitAsString(); - return StringRef(Name).starts_with("CCIfSwift"); - }); + llvm::any_of(Action->getSuperClasses(), [](const Record *Class) { + std::string Name = Class->getNameInitAsString(); + return StringRef(Name).starts_with("CCIfSwift"); + }); O << "\n"; emitAction(Action, indent(2), O); diff --git a/llvm/utils/TableGen/Common/CodeGenRegisters.cpp b/llvm/utils/TableGen/Common/CodeGenRegisters.cpp index 3479cad10b66c..10d84b5101c3a 100644 --- a/llvm/utils/TableGen/Common/CodeGenRegisters.cpp +++ b/llvm/utils/TableGen/Common/CodeGenRegisters.cpp @@ -704,8 +704,8 @@ struct TupleExpander : SetTheory::Expander { "Register tuple redefines register '" + Name + "'."); // Copy Proto super-classes. - for (const auto &[Super, Loc] : Proto->getSuperClasses()) - NewReg->addSuperClass(Super, Loc); + for (const auto &[Super, Loc] : Proto->getDirectSuperClasses()) + NewReg->addDirectSuperClass(Super, Loc); // Copy Proto fields. for (unsigned i = 0, e = Proto->getValues().size(); i != e; ++i) { diff --git a/llvm/utils/TableGen/SearchableTableEmitter.cpp b/llvm/utils/TableGen/SearchableTableEmitter.cpp index 7251a1ba545d5..2efa04d35faa4 100644 --- a/llvm/utils/TableGen/SearchableTableEmitter.cpp +++ b/llvm/utils/TableGen/SearchableTableEmitter.cpp @@ -834,7 +834,7 @@ void SearchableTableEmitter::run(raw_ostream &OS) { const Record *SearchableTable = Records.getClass("SearchableTable"); for (auto &NameRec : Records.getClasses()) { const Record *Class = NameRec.second.get(); - if (Class->getSuperClasses().size() != 1 || + if (Class->getDirectSuperClasses().size() != 1 || !Class->isSubClassOf(SearchableTable)) continue; diff --git a/mlir/lib/Tools/tblgen-lsp-server/TableGenServer.cpp b/mlir/lib/Tools/tblgen-lsp-server/TableGenServer.cpp index 2d13c9005f4d2..5faeeae839f44 100644 --- a/mlir/lib/Tools/tblgen-lsp-server/TableGenServer.cpp +++ b/mlir/lib/Tools/tblgen-lsp-server/TableGenServer.cpp @@ -113,7 +113,7 @@ getBaseValue(const Record *record, const RecordVal *value) { // On success, `record` is updated to the new parent record. StringRef valueName = value->getName(); auto findValueInSupers = [&](const Record *&record) -> const RecordVal * { - for (auto [parentRecord, loc] : record->getSuperClasses()) { + for (const Record *parentRecord : record->getSuperClasses()) { if (auto *newBase = parentRecord->getValue(valueName)) { record = parentRecord; return newBase; diff --git a/mlir/tools/mlir-tblgen/OmpOpGen.cpp b/mlir/tools/mlir-tblgen/OmpOpGen.cpp index 04f81a4a2dce1..91bc61bcdbb67 100644 --- a/mlir/tools/mlir-tblgen/OmpOpGen.cpp +++ b/mlir/tools/mlir-tblgen/OmpOpGen.cpp @@ -72,11 +72,10 @@ static StringRef extractOmpClauseName(const Record *clause) { assert(ompClause && "base OpenMP records expected to be defined"); StringRef clauseClassName; - SmallVector<const Record *, 1> clauseSuperClasses; - clause->getDirectSuperClasses(clauseSuperClasses); // Check if OpenMP_Clause is a direct superclass. - for (const Record *superClass : clauseSuperClasses) { + for (const Record *superClass : + llvm::make_first_range(clause->getDirectSuperClasses())) { if (superClass == ompClause) { clauseClassName = clause->getName(); break; @@ -85,7 +84,7 @@ static StringRef extractOmpClauseName(const Record *clause) { // Support indirectly-inherited OpenMP_Clauses. if (clauseClassName.empty()) { - for (auto [superClass, _] : clause->getSuperClasses()) { + for (const Record *superClass : clause->getSuperClasses()) { if (superClass->isSubClassOf(ompClause)) { clauseClassName = superClass->getName(); break; @@ -214,7 +213,7 @@ static StringRef translateArgumentType(ArrayRef<SMLoc> loc, const Record *def = cast<DefInit>(init)->getDef(); llvm::StringSet<> superClasses; - for (auto [sc, _] : def->getSuperClasses()) + for (const Record *sc : def->getSuperClasses()) superClasses.insert(sc->getNameInitAsString()); // Handle wrapper-style superclasses. diff --git a/mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp b/mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp index f94ed17aeb4e0..cc0146f9ad0b8 100644 --- a/mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp +++ b/mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp @@ -115,13 +115,12 @@ Availability::Availability(const Record *def) : def(def) { } StringRef Availability::getClass() const { - SmallVector<const Record *, 1> parentClass; - def->getDirectSuperClasses(parentClass); - if (parentClass.size() != 1) { + if (def->getDirectSuperClasses().size() != 1) { PrintFatalError(def->getLoc(), "expected to only have one direct superclass"); } - return parentClass.front()->getName(); + const Record *parentClass = def->getDirectSuperClasses().front().first; + return parentClass->getName(); } StringRef Availability::getInterfaceClassNamespace() const { @@ -205,18 +204,17 @@ static bool emitInterfaceDefs(const RecordKeeper &records, raw_ostream &os) { auto defs = records.getAllDerivedDefinitions("Availability"); SmallVector<const Record *, 1> handledClasses; for (const Record *def : defs) { - SmallVector<const Record *, 1> parent; - def->getDirectSuperClasses(parent); - if (parent.size() != 1) { + if (def->getDirectSuperClasses().size() != 1) { PrintFatalError(def->getLoc(), "expected to only have one direct superclass"); } - if (llvm::is_contained(handledClasses, parent.front())) + const Record *parent = def->getDirectSuperClasses().front().first; + if (llvm::is_contained(handledClasses, parent)) continue; Availability availability(def); emitInterfaceDef(availability, os); - handledClasses.push_back(parent.front()); + handledClasses.push_back(parent); } return false; } @@ -294,18 +292,17 @@ static bool emitInterfaceDecls(const RecordKeeper &records, raw_ostream &os) { auto defs = records.getAllDerivedDefinitions("Availability"); SmallVector<const Record *, 4> handledClasses; for (const Record *def : defs) { - SmallVector<const Record *, 1> parent; - def->getDirectSuperClasses(parent); - if (parent.size() != 1) { + if (def->getDirectSuperClasses().size() != 1) { PrintFatalError(def->getLoc(), "expected to only have one direct superclass"); } - if (llvm::is_contained(handledClasses, parent.front())) + const Record *parent = def->getDirectSuperClasses().front().first; + if (llvm::is_contained(handledClasses, parent)) continue; Availability avail(def); emitInterfaceDecl(avail, os); - handledClasses.push_back(parent.front()); + handledClasses.push_back(parent); } return false; } diff --git a/mlir/tools/mlir-tblgen/TosaUtilsGen.cpp b/mlir/tools/mlir-tblgen/TosaUtilsGen.cpp index ddc149810ebd8..f82edf2aaf5b1 100644 --- a/mlir/tools/mlir-tblgen/TosaUtilsGen.cpp +++ b/mlir/tools/mlir-tblgen/TosaUtilsGen.cpp @@ -100,13 +100,11 @@ Availability::Availability(const llvm::Record *def) : def(def) { } StringRef Availability::getClass() const { - SmallVector<const Record *, 1> parentClass; - def->getDirectSuperClasses(parentClass); - if (parentClass.size() != 1) { + if (def->getDirectSuperClasses().size() != 1) { PrintFatalError(def->getLoc(), "expected to only have one direct superclass"); } - return parentClass.front()->getName(); + return def->getDirectSuperClasses().front().first->getName(); } StringRef Availability::getQueryFnRetType() const { _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
