Revert "CodeGen: Eliminate dynamic relocations in the register superclass tables. (#119122)"

Reverting due to UBSan failures in X86RegisterInfo::getLargestLegalSuperClass

This reverts commit c487381.

Author: resistor

llvm/include/llvm/CodeGen/TargetRegisterInfo.h

@@ -41,10 +41,12 @@ class RegScavenger;
 class VirtRegMap;
 class LiveIntervals;
 class LiveInterval;
+
 class TargetRegisterClass {
 public:
   using iterator = const MCPhysReg *;
   using const_iterator = const MCPhysReg *;
+  using sc_iterator = const TargetRegisterClass* const *;
 
   // Instance variables filled by tablegen, do not use!
   const MCRegisterClass *MC;
@@ -65,8 +67,7 @@ class TargetRegisterClass {
   /// Whether a combination of subregisters can cover every register in the
   /// class. See also the CoveredBySubRegs description in Target.td.
   const bool CoveredBySubRegs;
-  const unsigned *SuperClasses;
-  const uint16_t SuperClassesSize;
+  const sc_iterator SuperClasses;
   ArrayRef<MCPhysReg> (*OrderFunc)(const MachineFunction&);
 
   /// Return the register class ID number.
@@ -174,16 +175,18 @@ class TargetRegisterClass {
     return SuperRegIndices;
   }
 
-  /// Returns a list of super-classes.  The
+  /// Returns a NULL-terminated list of super-classes.  The
   /// classes are ordered by ID which is also a topological ordering from large
   /// to small classes.  The list does NOT include the current class.
-  ArrayRef<unsigned> superclasses() const {
-    return ArrayRef(SuperClasses, SuperClassesSize);
+  sc_iterator getSuperClasses() const {
+    return SuperClasses;
   }
 
   /// Return true if this TargetRegisterClass is a subset
   /// class of at least one other TargetRegisterClass.
-  bool isASubClass() const { return SuperClasses != nullptr; }
+  bool isASubClass() const {
+    return SuperClasses[0] != nullptr;
+  }
 
   /// Returns the preferred order for allocating registers from this register
   /// class in MF. The raw order comes directly from the .td file and may

llvm/lib/Target/ARM/ARMBaseRegisterInfo.cpp

@@ -262,31 +262,30 @@ bool ARMBaseRegisterInfo::isInlineAsmReadOnlyReg(const MachineFunction &MF,
 const TargetRegisterClass *
 ARMBaseRegisterInfo::getLargestLegalSuperClass(const TargetRegisterClass *RC,
                                                const MachineFunction &MF) const {
-  unsigned SuperID = RC->getID();
-  auto I = RC->superclasses().begin();
-  auto E = RC->superclasses().end();
+  const TargetRegisterClass *Super = RC;
+  TargetRegisterClass::sc_iterator I = RC->getSuperClasses();
   do {
-    switch (SuperID) {
+    switch (Super->getID()) {
     case ARM::GPRRegClassID:
     case ARM::SPRRegClassID:
     case ARM::DPRRegClassID:
     case ARM::GPRPairRegClassID:
-      return getRegClass(SuperID);
+      return Super;
     case ARM::QPRRegClassID:
     case ARM::QQPRRegClassID:
     case ARM::QQQQPRRegClassID:
       if (MF.getSubtarget<ARMSubtarget>().hasNEON())
-        return getRegClass(SuperID);
+        return Super;
       break;
     case ARM::MQPRRegClassID:
     case ARM::MQQPRRegClassID:
     case ARM::MQQQQPRRegClassID:
       if (MF.getSubtarget<ARMSubtarget>().hasMVEIntegerOps())
-        return getRegClass(SuperID);
+        return Super;
       break;
     }
-    SuperID = (I != E) ? *I++ : ~0U;
-  } while (SuperID != ~0U);
+    Super = *I++;
+  } while (Super);
   return RC;
 }
 

llvm/lib/Target/Hexagon/HexagonRegisterInfo.cpp

@@ -431,9 +431,8 @@ unsigned HexagonRegisterInfo::getHexagonSubRegIndex(
       return WSub[GenIdx];
   }
 
-  if (!RC.superclasses().empty())
-    return getHexagonSubRegIndex(*getRegClass(*RC.superclasses().begin()),
-                                 GenIdx);
+  if (const TargetRegisterClass *SuperRC = *RC.getSuperClasses())
+    return getHexagonSubRegIndex(*SuperRC, GenIdx);
 
   llvm_unreachable("Invalid register class");
 }

llvm/lib/Target/PowerPC/PPCRegisterInfo.cpp

@@ -692,23 +692,21 @@ PPCRegisterInfo::getLargestLegalSuperClass(const TargetRegisterClass *RC,
         InflateGPRC++;
     }
 
-    for (unsigned SuperID : RC->superclasses()) {
-      if (getRegSizeInBits(*getRegClass(SuperID)) != getRegSizeInBits(*RC))
+    for (const auto *I = RC->getSuperClasses(); *I; ++I) {
+      if (getRegSizeInBits(**I) != getRegSizeInBits(*RC))
         continue;
 
-      switch (SuperID) {
+      switch ((*I)->getID()) {
       case PPC::VSSRCRegClassID:
-        return Subtarget.hasP8Vector() ? getRegClass(SuperID)
-                                       : DefaultSuperclass;
+        return Subtarget.hasP8Vector() ? *I : DefaultSuperclass;
       case PPC::VSFRCRegClassID:
       case PPC::VSRCRegClassID:
-        return getRegClass(SuperID);
+        return *I;
       case PPC::VSRpRCRegClassID:
-        return Subtarget.pairedVectorMemops() ? getRegClass(SuperID)
-                                              : DefaultSuperclass;
+        return Subtarget.pairedVectorMemops() ? *I : DefaultSuperclass;
       case PPC::ACCRCRegClassID:
       case PPC::UACCRCRegClassID:
-        return Subtarget.hasMMA() ? getRegClass(SuperID) : DefaultSuperclass;
+        return Subtarget.hasMMA() ? *I : DefaultSuperclass;
       }
     }
   }

llvm/lib/Target/X86/X86RegisterInfo.cpp

@@ -123,8 +123,7 @@ X86RegisterInfo::getLargestLegalSuperClass(const TargetRegisterClass *RC,
   const X86Subtarget &Subtarget = MF.getSubtarget<X86Subtarget>();
 
   const TargetRegisterClass *Super = RC;
-  auto I = RC->superclasses().begin();
-  auto E = RC->superclasses().end();
+  TargetRegisterClass::sc_iterator I = RC->getSuperClasses();
   do {
     switch (Super->getID()) {
     case X86::FR32RegClassID:
@@ -173,8 +172,7 @@ X86RegisterInfo::getLargestLegalSuperClass(const TargetRegisterClass *RC,
       if (getRegSizeInBits(*Super) == getRegSizeInBits(*RC))
         return Super;
     }
-    Super = (I != E) ? getRegClass(*I) : nullptr;
-    ++I;
+    Super = *I++;
   } while (Super);
   return RC;
 }

llvm/unittests/CodeGen/MachineInstrTest.cpp

@@ -584,7 +584,7 @@ TEST(MachineInstrTest, SpliceOperands) {
   // test tied operands
   MCRegisterClass MRC{
       0, 0, 0, 0, 0, 0, 0, 0, /*Allocatable=*/true, /*BaseClass=*/true};
-  TargetRegisterClass RC{&MRC, 0, 0, {}, 0, 0, 0, 0, 0, 0, 0, 0};
+  TargetRegisterClass RC{&MRC, 0, 0, {}, 0, 0, 0, 0, 0, 0, 0};
   // MachineRegisterInfo will be very upset if these registers aren't
   // allocatable.
   assert(RC.isAllocatable() && "unusable TargetRegisterClass");

llvm/utils/TableGen/RegisterInfoEmitter.cpp

@@ -1286,6 +1286,9 @@ void RegisterInfoEmitter::runTargetDesc(raw_ostream &OS) {
     }
     OS << "};\n";
 
+    OS << "\nstatic const TargetRegisterClass *const "
+       << "NullRegClasses[] = { nullptr };\n\n";
+
     // Emit register class bit mask tables. The first bit mask emitted for a
     // register class, RC, is the set of sub-classes, including RC itself.
     //
@@ -1337,18 +1340,19 @@ void RegisterInfoEmitter::runTargetDesc(raw_ostream &OS) {
     SuperRegIdxSeqs.emit(OS, printSubRegIndex);
     OS << "};\n\n";
 
-    // Emit super-class lists.
+    // Emit NULL terminated super-class lists.
     for (const auto &RC : RegisterClasses) {
       ArrayRef<CodeGenRegisterClass *> Supers = RC.getSuperClasses();
 
-      // Skip classes without supers.
+      // Skip classes without supers.  We can reuse NullRegClasses.
       if (Supers.empty())
         continue;
 
-      OS << "static unsigned const " << RC.getName() << "Superclasses[] = {\n";
+      OS << "static const TargetRegisterClass *const " << RC.getName()
+         << "Superclasses[] = {\n";
       for (const auto *Super : Supers)
-        OS << "  " << Super->getQualifiedIdName() << ",\n";
-      OS << "};\n\n";
+        OS << "  &" << Super->getQualifiedName() << "RegClass,\n";
+      OS << "  nullptr\n};\n\n";
     }
 
     // Emit methods.
@@ -1402,10 +1406,9 @@ void RegisterInfoEmitter::runTargetDesc(raw_ostream &OS) {
          << (RC.CoveredBySubRegs ? "true" : "false")
          << ", /* CoveredBySubRegs */\n    ";
       if (RC.getSuperClasses().empty())
-        OS << "nullptr, ";
+        OS << "NullRegClasses,\n    ";
       else
-        OS << RC.getName() << "Superclasses,  ";
-      OS << RC.getSuperClasses().size() << ",\n    ";
+        OS << RC.getName() << "Superclasses,\n    ";
       if (RC.AltOrderSelect.empty())
         OS << "nullptr\n";
       else