Only store direct superclasses in Record

Author: jayfoad

llvm/include/llvm/TableGen/Record.h

@@ -1630,9 +1630,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;
@@ -1666,8 +1666,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);
 
@@ -1720,15 +1721,22 @@ class Record {
 
   void getSuperClasses(
       SmallVectorImpl<std::pair<const Record *, SMRange>> &Classes) const {
-    Classes.append(SuperClasses);
+    for (const auto &[SC, R] : DirectSuperClasses) {
+      SC->getSuperClasses(Classes);
+      Classes.emplace_back(SC, R);
+    }
   }
 
   /// 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<std::pair<const Record *, SMRange>> &Classes) const;
+      SmallVectorImpl<std::pair<const Record *, SMRange>> &Classes) const {
+    Classes.append(DirectSuperClasses);
+  }
 
   bool isTemplateArg(const Init *Name) const {
     return llvm::is_contained(TemplateArgs, Name);
@@ -1796,29 +1804,32 @@ class Record {
   void checkUnusedTemplateArgs();
 
   bool isSubClassOf(const Record *R) const {
-    for (const auto &[SC, _] : SuperClasses)
-      if (SC == R)
+    for (const auto &[SC, _] : DirectSuperClasses) {
+      if (SC == R || SC->isSubClassOf(R))
         return true;
+    }
     return false;
   }
 
   bool isSubClassOf(StringRef Name) const {
-    for (const auto &[SC, _] : SuperClasses) {
+    for (const auto &[SC, _] : 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.push_back(std::make_pair(R, Range));
+    DirectSuperClasses.emplace_back(R, Range);
   }
 
   /// If there are any field references that refer to fields that have been

llvm/lib/TableGen/Record.cpp

@@ -2398,13 +2398,8 @@ const DefInit *VarDefInit::instantiate() {
 
   NewRec->resolveReferences(R);
 
-  // Add superclasses.
-  SmallVector<std::pair<const Record *, SMRange>> SCs;
-  Class->getSuperClasses(SCs);
-  for (const auto &[SC, Loc] : SCs)
-    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
@@ -2914,46 +2909,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 {
-  SmallVector<std::pair<const Record *, SMRange>> SCs;
-  getSuperClasses(SCs);
-
-  SmallVector<std::pair<const Record *, SMRange>> SSCs;
-
-  for (int I = SCs.size() - 1; I >= 0; --I) {
-    const Record *SC = SCs[I].first;
-    if (SC == Superclass)
-      return true;
-    SC->getSuperClasses(SSCs);
-    I -= SSCs.size();
-    SSCs.clear();
-  }
-
-  return false;
-}
-
-void Record::getDirectSuperClasses(
-    SmallVectorImpl<std::pair<const Record *, SMRange>> &Classes) const {
-  SmallVector<std::pair<const Record *, SMRange>> SCVec;
-  getSuperClasses(SCVec);
-  ArrayRef<std::pair<const Record *, SMRange>> SCs = SCVec;
-
-  SmallVector<std::pair<const Record *, SMRange>> SSCs;
-
-  while (!SCs.empty()) {
-    auto [SC, Range] = SCs.back();
-    SC->getSuperClasses(SSCs);
-    SCs = SCs.drop_back(1 + SSCs.size());
-    SSCs.clear();
-    Classes.emplace_back(SC, Range);
-  }
-}
-
 void Record::resolveReferences(Resolver &R, const RecordVal *SkipVal) {
   const Init *OldName = getNameInit();
   const Init *NewName = Name->resolveReferences(R);

llvm/lib/TableGen/TGParser.cpp

@@ -330,19 +330,10 @@ bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) {
 
   // Since everything went well, we can now set the "superclass" list for the
   // current record.
-  SmallVector<std::pair<const Record *, SMRange>> SCs;
-  SC->getSuperClasses(SCs);
-  for (const auto &[SC, Loc] : SCs) {
-    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;
 }
 
@@ -4005,7 +3996,7 @@ bool TGParser::ParseClass() {
   if (CurRec) {
     // If the body was previously defined, this is an error.
     SmallVector<std::pair<const Record *, SMRange>> SCs;
-    CurRec->getSuperClasses(SCs);
+    CurRec->getDirectSuperClasses(SCs);
     if (!CurRec->getValues().empty() || !SCs.empty() ||
         !CurRec->getTemplateArgs().empty())
       return TokError("Class '" + CurRec->getNameInitAsString() +

llvm/utils/TableGen/Common/CodeGenRegisters.cpp

@@ -704,9 +704,9 @@ struct TupleExpander : SetTheory::Expander {
 
       // Copy Proto super-classes.
       SmallVector<std::pair<const Record *, SMRange>> SCs;
-      Proto->getSuperClasses(SCs);
+      Proto->getDirectSuperClasses(SCs);
       for (const auto &[Super, Loc] : SCs)
-        NewReg->addSuperClass(Super, Loc);
+        NewReg->addDirectSuperClass(Super, Loc);
 
       // Copy Proto fields.
       for (unsigned i = 0, e = Proto->getValues().size(); i != e; ++i) {

llvm/utils/TableGen/SearchableTableEmitter.cpp

@@ -840,7 +840,7 @@ void SearchableTableEmitter::run(raw_ostream &OS) {
   for (auto &NameRec : Records.getClasses()) {
     const Record *Class = NameRec.second.get();
     SmallVector<std::pair<const Record *, SMRange>> SCs;
-    Class->getSuperClasses(SCs);
+    Class->getDirectSuperClasses(SCs);
     if (SCs.size() != 1 || !Class->isSubClassOf(SearchableTable))
       continue;