llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang Author: Rahul Joshi (jurahul) <details> <summary>Changes</summary> Change `Record::getSuperClasses` to return a const pointer to the superclass records. This is a part of effort to have better const correctness in TableGen backends: https://discourse.llvm.org/t/psa-planned-changes-to-tablegen-getallderiveddefinitions-api-potential-downstream-breakages/81089 --- Full diff: https://github.com/llvm/llvm-project/pull/110845.diff 9 Files Affected: - (modified) clang/utils/TableGen/ClangAttrEmitter.cpp (+7-9) - (modified) llvm/docs/TableGen/BackGuide.rst (+1-1) - (modified) llvm/include/llvm/TableGen/Record.h (+8-8) - (modified) llvm/lib/TableGen/DetailedRecordsBackend.cpp (+2-1) - (modified) llvm/lib/TableGen/Record.cpp (+8-9) - (modified) llvm/lib/TableGen/TGParser.cpp (+4-5) - (modified) llvm/utils/TableGen/CallingConvEmitter.cpp (+1-1) - (modified) llvm/utils/TableGen/Common/CodeGenRegisters.cpp (+2-3) - (modified) mlir/lib/Tools/tblgen-lsp-server/TableGenServer.cpp (+1-1) ``````````diff diff --git a/clang/utils/TableGen/ClangAttrEmitter.cpp b/clang/utils/TableGen/ClangAttrEmitter.cpp index 893a242099454e..28b7ec8f822cf8 100644 --- a/clang/utils/TableGen/ClangAttrEmitter.cpp +++ b/clang/utils/TableGen/ClangAttrEmitter.cpp @@ -1529,9 +1529,8 @@ createArgument(const Record &Arg, StringRef Attr, if (!Ptr) { // Search in reverse order so that the most-derived type is handled first. - ArrayRef<std::pair<Record*, SMRange>> Bases = Search->getSuperClasses(); - for (const auto &Base : reverse(Bases)) { - if ((Ptr = createArgument(Arg, Attr, Base.first))) + for (const auto &[Base, _] : reverse(Search->getSuperClasses())) { + if ((Ptr = createArgument(Arg, Attr, Base))) break; } } @@ -2744,12 +2743,11 @@ static void emitAttributes(const RecordKeeper &Records, raw_ostream &OS, if (!R.getValueAsBit("ASTNode")) continue; - ArrayRef<std::pair<Record *, SMRange>> Supers = R.getSuperClasses(); + ArrayRef<std::pair<const Record *, SMRange>> Supers = R.getSuperClasses(); assert(!Supers.empty() && "Forgot to specify a superclass for the attr"); std::string SuperName; bool Inheritable = false; - for (const auto &Super : reverse(Supers)) { - const Record *R = Super.first; + for (const auto &[R, _] : reverse(Supers)) { if (R->getName() != "TargetSpecificAttr" && R->getName() != "DeclOrTypeAttr" && SuperName.empty()) SuperName = std::string(R->getName()); @@ -3434,7 +3432,7 @@ namespace { } private: - AttrClass *findClassByRecord(Record *R) const { + AttrClass *findClassByRecord(const Record *R) const { for (auto &Class : Classes) { if (Class->TheRecord == R) return Class.get(); @@ -4739,8 +4737,8 @@ 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()) { - if (Class.first->getName().starts_with("Variadic")) { + for (const auto &[Class, _] : Arg->getSuperClasses()) { + if (Class->getName().starts_with("Variadic")) { ArgNames.back().append("..."); break; } diff --git a/llvm/docs/TableGen/BackGuide.rst b/llvm/docs/TableGen/BackGuide.rst index 60677a6dcd627d..c26575272ad692 100644 --- a/llvm/docs/TableGen/BackGuide.rst +++ b/llvm/docs/TableGen/BackGuide.rst @@ -624,7 +624,7 @@ iterates over the pairs in the returned array. .. code-block:: text - ArrayRef<std::pair<Record *, SMRange>> + ArrayRef<std::pair<const Record *, SMRange>> Superclasses = Prototype->getSuperClasses(); for (const auto &SuperPair : Superclasses) { ... diff --git a/llvm/include/llvm/TableGen/Record.h b/llvm/include/llvm/TableGen/Record.h index 93effb153cda80..73fd21bbd7d384 100644 --- a/llvm/include/llvm/TableGen/Record.h +++ b/llvm/include/llvm/TableGen/Record.h @@ -1668,7 +1668,7 @@ class Record { // All superclasses in the inheritance forest in post-order (yes, it // must be a forest; diamond-shaped inheritance is not allowed). - SmallVector<std::pair<Record *, SMRange>, 0> SuperClasses; + SmallVector<std::pair<const Record *, SMRange>, 0> SuperClasses; // Tracks Record instances. Not owned by Record. RecordKeeper &TrackedRecords; @@ -1758,7 +1758,7 @@ class Record { ArrayRef<AssertionInfo> getAssertions() const { return Assertions; } ArrayRef<DumpInfo> getDumps() const { return Dumps; } - ArrayRef<std::pair<Record *, SMRange>> getSuperClasses() const { + ArrayRef<std::pair<const Record *, SMRange>> getSuperClasses() const { return SuperClasses; } @@ -1832,25 +1832,25 @@ class Record { void checkUnusedTemplateArgs(); bool isSubClassOf(const Record *R) const { - for (const auto &SCPair : SuperClasses) - if (SCPair.first == R) + for (const auto &[SC, _] : SuperClasses) + if (SC == R) return true; return false; } bool isSubClassOf(StringRef Name) const { - for (const auto &SCPair : SuperClasses) { - if (const auto *SI = dyn_cast<StringInit>(SCPair.first->getNameInit())) { + for (const auto &[SC, _] : SuperClasses) { + if (const auto *SI = dyn_cast<StringInit>(SC->getNameInit())) { if (SI->getValue() == Name) return true; - } else if (SCPair.first->getNameInitAsString() == Name) { + } else if (SC->getNameInitAsString() == Name) { return true; } } return false; } - void addSuperClass(Record *R, SMRange Range) { + void addSuperClass(const Record *R, SMRange Range) { assert(!CorrespondingDefInit && "changing type of record after it has been referenced"); assert(!isSubClassOf(R) && "Already subclassing record!"); diff --git a/llvm/lib/TableGen/DetailedRecordsBackend.cpp b/llvm/lib/TableGen/DetailedRecordsBackend.cpp index 7d17c4d68c3f12..61fd3634902cc3 100644 --- a/llvm/lib/TableGen/DetailedRecordsBackend.cpp +++ b/llvm/lib/TableGen/DetailedRecordsBackend.cpp @@ -152,7 +152,8 @@ void DetailedRecordsEmitter::printTemplateArgs(const Record &Rec, // are enclosed in parentheses. void DetailedRecordsEmitter::printSuperclasses(const Record &Rec, raw_ostream &OS) { - ArrayRef<std::pair<Record *, SMRange>> Superclasses = Rec.getSuperClasses(); + ArrayRef<std::pair<const Record *, SMRange>> Superclasses = + Rec.getSuperClasses(); if (Superclasses.empty()) { OS << " Superclasses: (none)\n"; return; diff --git a/llvm/lib/TableGen/Record.cpp b/llvm/lib/TableGen/Record.cpp index 4e026bc4f042ee..1366f8e02622f0 100644 --- a/llvm/lib/TableGen/Record.cpp +++ b/llvm/lib/TableGen/Record.cpp @@ -2357,9 +2357,8 @@ DefInit *VarDefInit::instantiate() { NewRec->resolveReferences(R); // Add superclasses. - ArrayRef<std::pair<Record *, SMRange>> SCs = Class->getSuperClasses(); - for (const auto &SCPair : SCs) - NewRec->addSuperClass(SCPair.first, SCPair.second); + for (const auto &[SC, Loc] : Class->getSuperClasses()) + NewRec->addSuperClass(SC, Loc); NewRec->addSuperClass( Class, SMRange(Class->getLoc().back(), Class->getLoc().back())); @@ -2869,7 +2868,7 @@ void Record::setName(Init *NewName) { // so we can step through the direct superclasses in reverse order. bool Record::hasDirectSuperClass(const Record *Superclass) const { - ArrayRef<std::pair<Record *, SMRange>> SCs = getSuperClasses(); + ArrayRef<std::pair<const Record *, SMRange>> SCs = getSuperClasses(); for (int I = SCs.size() - 1; I >= 0; --I) { const Record *SC = SCs[I].first; @@ -2883,10 +2882,10 @@ bool Record::hasDirectSuperClass(const Record *Superclass) const { void Record::getDirectSuperClasses( SmallVectorImpl<const Record *> &Classes) const { - ArrayRef<std::pair<Record *, SMRange>> SCs = getSuperClasses(); + ArrayRef<std::pair<const Record *, SMRange>> SCs = getSuperClasses(); while (!SCs.empty()) { - Record *SC = SCs.back().first; + const Record *SC = SCs.back().first; SCs = SCs.drop_back(1 + SC->getSuperClasses().size()); Classes.push_back(SC); } @@ -2965,11 +2964,11 @@ raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) { } OS << " {"; - ArrayRef<std::pair<Record *, SMRange>> SC = R.getSuperClasses(); + ArrayRef<std::pair<const Record *, SMRange>> SC = R.getSuperClasses(); if (!SC.empty()) { OS << "\t//"; - for (const auto &SuperPair : SC) - OS << " " << SuperPair.first->getNameInitAsString(); + for (const auto &[SC, _] : SC) + OS << " " << SC->getNameInitAsString(); } OS << "\n"; diff --git a/llvm/lib/TableGen/TGParser.cpp b/llvm/lib/TableGen/TGParser.cpp index 91a3617f8579e0..e926393150e48e 100644 --- a/llvm/lib/TableGen/TGParser.cpp +++ b/llvm/lib/TableGen/TGParser.cpp @@ -328,12 +328,11 @@ bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) { // Since everything went well, we can now set the "superclass" list for the // current record. - ArrayRef<std::pair<Record *, SMRange>> SCs = SC->getSuperClasses(); - for (const auto &SCPair : SCs) { - if (CurRec->isSubClassOf(SCPair.first)) + for (const auto &[SC, Loc] : SC->getSuperClasses()) { + if (CurRec->isSubClassOf(SC)) return Error(SubClass.RefRange.Start, - "Already subclass of '" + SCPair.first->getName() + "'!\n"); - CurRec->addSuperClass(SCPair.first, SCPair.second); + "Already subclass of '" + SC->getName() + "'!\n"); + CurRec->addSuperClass(SC, Loc); } if (CurRec->isSubClassOf(SC)) diff --git a/llvm/utils/TableGen/CallingConvEmitter.cpp b/llvm/utils/TableGen/CallingConvEmitter.cpp index bed5aa86846bf4..fefc407c354a5d 100644 --- a/llvm/utils/TableGen/CallingConvEmitter.cpp +++ b/llvm/utils/TableGen/CallingConvEmitter.cpp @@ -110,7 +110,7 @@ void CallingConvEmitter::EmitCallingConv(const Record *CC, raw_ostream &O) { const Record *Action = CCActions->getElementAsRecord(i); SwiftAction = llvm::any_of(Action->getSuperClasses(), - [](const std::pair<Record *, SMRange> &Class) { + [](const std::pair<const Record *, SMRange> &Class) { std::string Name = Class.first->getNameInitAsString(); return StringRef(Name).starts_with("CCIfSwift"); }); diff --git a/llvm/utils/TableGen/Common/CodeGenRegisters.cpp b/llvm/utils/TableGen/Common/CodeGenRegisters.cpp index a39917cba17c73..b53492dafb25b6 100644 --- a/llvm/utils/TableGen/Common/CodeGenRegisters.cpp +++ b/llvm/utils/TableGen/Common/CodeGenRegisters.cpp @@ -697,9 +697,8 @@ struct TupleExpander : SetTheory::Expander { "Register tuple redefines register '" + Name + "'."); // Copy Proto super-classes. - ArrayRef<std::pair<Record *, SMRange>> Supers = Proto->getSuperClasses(); - for (const auto &SuperPair : Supers) - NewReg->addSuperClass(SuperPair.first, SuperPair.second); + for (const auto &[Super, Loc] : Proto->getSuperClasses()) + NewReg->addSuperClass(Super, Loc); // Copy Proto fields. for (unsigned i = 0, e = Proto->getValues().size(); i != e; ++i) { diff --git a/mlir/lib/Tools/tblgen-lsp-server/TableGenServer.cpp b/mlir/lib/Tools/tblgen-lsp-server/TableGenServer.cpp index f7cf4de58a0e08..6c0829191a77ae 100644 --- a/mlir/lib/Tools/tblgen-lsp-server/TableGenServer.cpp +++ b/mlir/lib/Tools/tblgen-lsp-server/TableGenServer.cpp @@ -109,7 +109,7 @@ getBaseValue(const llvm::Record *record, const llvm::RecordVal *value) { // On success, `record` is updated to the new parent record. StringRef valueName = value->getName(); auto findValueInSupers = - [&](const llvm::Record *&record) -> llvm::RecordVal * { + [&](const llvm::Record *&record) -> const llvm::RecordVal * { for (auto [parentRecord, loc] : record->getSuperClasses()) { if (auto *newBase = parentRecord->getValue(valueName)) { record = parentRecord; `````````` </details> https://github.com/llvm/llvm-project/pull/110845 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
