[TableGen] Reduce the amount of storage space used for AddrSpaces in TypeSetByHwMode. NFC

[craig.topper]

Summary

We reserved 16 AddrSpaces in every TypeSetByHwMode. But we only ever
use the first one on targets that make use of the AddrSpace feature.

The vector was populated by pushing for each entry in the ArrayRef
passed to the TypeSetByHwMode constructor. Each entry is a
ValueTypeByHwMode that stores one VT for each HwMode.

The vector is accessed by a loop in TypeSetByHwMode::getValueTypeByHwMode.
That loop is over HwModes with in the TypeSetByHwMode. This is
unrelated to how the vector was created. The entries in the vector
don't represent HwModes.

The targets that use AddrSpace don't make use of HwModes so the
loop in getValueTypeByHwMode will only run 1 iteration. So we only
the first entry in the vector is meaningful used.

This patch simplifies things by storing only 1 AddrSpace in
TypeSetByMode. Reducing the memory used by TypeSetByHwMode.
More work will be needed to support HwModes with AddrSpace if we
need a different AddrSpace for each HwModes.

[craig.topper]

Ping

[arsenm]

llvm/utils/TableGen/CodeGenDAGPatterns.cpp

86–88

I've never really understood TypeSetByHwMode. Currently the address space would largely be unused since it doesn't actually work in SelectionDAG. Would this stop you from parameterizing the same pattern over multiple address spaces, or just swapping out the address space based on the hwmode?

[craig.topper]

llvm/utils/TableGen/CodeGenDAGPatterns.cpp

86–88

TypeSetByHwMode is a set of possible types for each hardware mode.
ValueTypeByHwMode is a single MVT for each hardware mode.

If we needed a different address space for each hardware mode TypeSetByHwMode and ValueTypeByHwMode would both need to store the AddrSpace for each HwMode inside the HwMode map. The PtrValueType class in tablegen would need to support HwMode like ValueTypeByHwMode and RegInfoByHwMode.

If we need to support multiple AddrSpaces with in the possible types for a single hardware mode, that would probably require some enhancement to MachineValueTypeSet.

I don't think either of these were supported before and I don't think this patch makes it worse. I just want to get back the large waste of space. We can add support when we have a use case.

llvm/utils/TableGen/CodeGenDAGPatterns.h

 //===- CodeGenDAGPatterns.h - Read DAG patterns from .td file ---*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
private:
   friend struct const_iterator;
   std::array<WordType,NumWords> Words;
 };
 
 raw_ostream &operator<<(raw_ostream &OS, const MachineValueTypeSet &T);
 
 struct TypeSetByHwMode : public InfoByHwMode<MachineValueTypeSet> {
   using SetType = MachineValueTypeSet;
-  SmallVector<unsigned, 16> AddrSpaces;
+  unsigned AddrSpace = std::numeric_limits<unsigned>::max();
 
   TypeSetByHwMode() = default;
   TypeSetByHwMode(const TypeSetByHwMode &VTS) = default;
   TypeSetByHwMode &operator=(const TypeSetByHwMode &) = default;
   TypeSetByHwMode(MVT::SimpleValueType VT)
     : TypeSetByHwMode(ValueTypeByHwMode(VT)) {}
   TypeSetByHwMode(ValueTypeByHwMode VT)
     : TypeSetByHwMode(ArrayRef<ValueTypeByHwMode>(&VT, 1)) {}

llvm/utils/TableGen/CodeGenDAGPatterns.cpp

 //===- CodeGenDAGPatterns.cpp - Read DAG patterns from .td file -----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //

 
 // --- TypeSetByHwMode
 
 // This is a parameterized type-set class. For each mode there is a list
 // of types that are currently possible for a given tree node. Type
 // inference will apply to each mode separately.
 
 TypeSetByHwMode::TypeSetByHwMode(ArrayRef<ValueTypeByHwMode> VTList) {
-  for (const ValueTypeByHwMode &VVT : VTList) {
+  // Take the address space from the first type in the list.
+  if (!VTList.empty())
+    AddrSpace = VTList[0].PtrAddrSpace;
+
+  for (const ValueTypeByHwMode &VVT : VTList)
     insert(VVT);
-    AddrSpaces.push_back(VVT.PtrAddrSpace);
-  }
 }
 
 bool TypeSetByHwMode::isValueTypeByHwMode(bool AllowEmpty) const {
   for (const auto &I : *this) {
     if (I.second.size() > 1)
       return false;
     if (!AllowEmpty && I.second.empty())
       return false;
   }
   return true;
 }
 
 ValueTypeByHwMode TypeSetByHwMode::getValueTypeByHwMode() const {
   assert(isValueTypeByHwMode(true) &&
          "The type set has multiple types for at least one HW mode");
   ValueTypeByHwMode VVT;
-  auto ASI = AddrSpaces.begin();
+  VVT.PtrAddrSpace = AddrSpace;
 
   for (const auto &I : *this) {
     MVT T = I.second.empty() ? MVT::Other : *I.second.begin();
     VVT.getOrCreateTypeForMode(I.first, T);
-    if (ASI != AddrSpaces.end())
-      VVT.PtrAddrSpace = *ASI++;
   }
   return VVT;
 }
 
 bool TypeSetByHwMode::isPossible() const {
   for (const auto &I : *this)
     if (!I.second.empty())
       return true;