[GlobalISel] NFC: Have LLT::getSizeInBits/Bytes return a TypeSize.

[sdesmalen]

Summary

To reflect that the size may be scalable, a TypeSize is returned
instead of an unsigned. In places where the result is used,
it currently relies on an implicit cast of TypeSize -> uint64_t,
which asserts that the type is not scalable.

This patch is NFC for fixed-width vectors.

[aemerson]

LGTM.

[sdesmalen]

Cheers @aemerson!

[thakis]

Looks like this doesn't build with at least some versions of clang: http://45.33.8.238/macm1/12401/step_4.txt

[sdesmalen]

In D104454#2841059, @thakis wrote:

Looks like this doesn't build with at least some versions of clang: http://45.33.8.238/macm1/12401/step_4.txt

Thanks for pointing out. What version of Clang is that build using?

[thakis]

In D104454#2841066, @sdesmalen wrote:

In D104454#2841059, @thakis wrote:

Looks like this doesn't build with at least some versions of clang: http://45.33.8.238/macm1/12401/step_4.txt

Thanks for pointing out. What version of Clang is that build using?

clang version 13.0.0 (https://github.com/llvm/llvm-project/ dad5caa59e6b2bde8d6cf5b64a972c393c526c82)

llvm/include/llvm/CodeGen/GlobalISel/InstructionSelectorImpl.h

case GIM_CheckType: {
         if (handleReject() == RejectAndGiveUp)
           return false;
       }
       break;
     }
     case GIM_CheckPointerToAny: {
       int64_t InsnID = MatchTable[CurrentIdx++];
       int64_t OpIdx = MatchTable[CurrentIdx++];
-      int64_t SizeInBits = MatchTable[CurrentIdx++];
+      uint64_t SizeInBits = MatchTable[CurrentIdx++];
 
       DEBUG_WITH_TYPE(TgtInstructionSelector::getName(),
                       dbgs() << CurrentIdx << ": GIM_CheckPointerToAny(MIs["
                              << InsnID << "]->getOperand(" << OpIdx
                              << "), SizeInBits=" << SizeInBits << ")\n");
       assert(State.MIs[InsnID] != nullptr && "Used insn before defined");
       MachineOperand &MO = State.MIs[InsnID]->getOperand(OpIdx);
       const LLT Ty = MRI.getType(MO.getReg());

llvm/include/llvm/Support/LowLevelTypeImpl.h

return LLT{/*isPointer=*/false, /*isVector=*/true, EC, ScalarSizeInBits,
                /*AddressSpace=*/0};
   }
 
   /// Get a low-level vector of some number of elements and element type.
   static LLT vector(ElementCount EC, LLT ScalarTy) {
     assert(!EC.isScalar() && "invalid number of vector elements");
     assert(!ScalarTy.isVector() && "invalid vector element type");
     return LLT{ScalarTy.isPointer(), /*isVector=*/true, EC,
-               ScalarTy.getSizeInBits(),
+               ScalarTy.getSizeInBits().getFixedSize(),
                ScalarTy.isPointer() ? ScalarTy.getAddressSpace() : 0};
   }
 
   /// Get a low-level fixed-width vector of some number of elements and element
   /// width.
   static LLT fixed_vector(unsigned NumElements, unsigned ScalarSizeInBits) {
     return vector(ElementCount::getFixed(NumElements), ScalarSizeInBits);
   }
public:
   static LLT scalable_vector(unsigned MinNumElements, LLT ScalarTy) {
     return vector(ElementCount::getScalable(MinNumElements), ScalarTy);
   }
 
   static LLT scalarOrVector(ElementCount EC, LLT ScalarTy) {
     return EC.isScalar() ? ScalarTy : LLT::vector(EC, ScalarTy);
   }
 
-  static LLT scalarOrVector(ElementCount EC, unsigned ScalarSize) {
-    return scalarOrVector(EC, LLT::scalar(ScalarSize));
+  static LLT scalarOrVector(ElementCount EC, uint64_t ScalarSize) {
+    assert(ScalarSize <= std::numeric_limits<unsigned>::max() &&
+           "Not enough bits in LLT to represent size");
+    return scalarOrVector(EC, LLT::scalar(static_cast<unsigned>(ScalarSize)));
   }
 
   explicit LLT(bool isPointer, bool isVector, ElementCount EC,
-               unsigned SizeInBits, unsigned AddressSpace) {
+               uint64_t SizeInBits, unsigned AddressSpace) {
     init(isPointer, isVector, EC, SizeInBits, AddressSpace);
   }
   explicit LLT() : IsPointer(false), IsVector(false), RawData(0) {}
 
   explicit LLT(MVT VT);
 
   bool isValid() const { return RawData != 0; }
 
ElementCount getElementCount() const {
     assert(IsVector && "cannot get number of elements on scalar/aggregate");
     return ElementCount::get(IsPointer
                                  ? getFieldValue(PointerVectorElementsFieldInfo)
                                  : getFieldValue(VectorElementsFieldInfo),
                              isScalable());
   }
 
   /// Returns the total size of the type. Must only be called on sized types.
-  unsigned getSizeInBits() const {
+  TypeSize getSizeInBits() const {
     if (isPointer() || isScalar())
-      return getScalarSizeInBits();
-    // FIXME: This should return a TypeSize in order to work for scalable
-    // vectors.
-    return getScalarSizeInBits() * getElementCount().getKnownMinValue();
+      return TypeSize::Fixed(getScalarSizeInBits());
+    auto EC = getElementCount();
+    return TypeSize(getScalarSizeInBits() * EC.getKnownMinValue(),
+                    EC.isScalable());
   }
 
   /// Returns the total size of the type in bytes, i.e. number of whole bytes
   /// needed to represent the size in bits. Must only be called on sized types.
-  unsigned getSizeInBytes() const {
-    return (getSizeInBits() + 7) / 8;
+  TypeSize getSizeInBytes() const {
+    TypeSize BaseSize = getSizeInBits();
+    return {(BaseSize.getKnownMinSize() + 7) / 8, BaseSize.isScalable()};
   }
 
   LLT getScalarType() const {
     return isVector() ? getElementType() : *this;
   }
 
   /// If this type is a vector, return a vector with the same number of elements
   /// but the new element type. Otherwise, return the new element type.
public:
   LLT divide(int Factor) const {
     assert(Factor != 1);
     if (isVector()) {
       assert(getElementCount().isKnownMultipleOf(Factor));
       return scalarOrVector(getElementCount().divideCoefficientBy(Factor),
                             getElementType());
     }
 
-    assert(getSizeInBits() % Factor == 0);
-    return scalar(getSizeInBits() / Factor);
+    assert(getScalarSizeInBits() % Factor == 0);
+    return scalar(getScalarSizeInBits() / Factor);
   }
 
-  bool isByteSized() const { return (getSizeInBits() & 7) == 0; }
+  bool isByteSized() const { return getSizeInBits().isKnownMultipleOf(8); }
 
   unsigned getScalarSizeInBits() const {
     assert(RawData != 0 && "Invalid Type");
     if (!IsVector) {
       if (!IsPointer)
         return getFieldValue(ScalarSizeFieldInfo);
       else
         return getFieldValue(PointerSizeFieldInfo);
private:
   }
   static uint64_t maskAndShift(uint64_t Val, const BitFieldInfo FieldInfo) {
     return maskAndShift(Val, getMask(FieldInfo), FieldInfo[1]);
   }
   uint64_t getFieldValue(const BitFieldInfo FieldInfo) const {
     return getMask(FieldInfo) & (RawData >> FieldInfo[1]);
   }
 
-  void init(bool IsPointer, bool IsVector, ElementCount EC, unsigned SizeInBits,
+  void init(bool IsPointer, bool IsVector, ElementCount EC, uint64_t SizeInBits,
             unsigned AddressSpace) {
+    assert(SizeInBits <= std::numeric_limits<unsigned>::max() &&
+           "Not enough bits in LLT to represent size");
     this->IsPointer = IsPointer;
     this->IsVector = IsVector;
     if (!IsVector) {
       if (!IsPointer)
         RawData = maskAndShift(SizeInBits, ScalarSizeFieldInfo);
       else
         RawData = maskAndShift(SizeInBits, PointerSizeFieldInfo) |
                   maskAndShift(AddressSpace, PointerAddressSpaceFieldInfo);

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

bool IRTranslator::translateMemFunc(const CallInst &CI,
 
   SmallVector<Register, 3> SrcRegs;
 
   unsigned MinPtrSize = UINT_MAX;
   for (auto AI = CI.arg_begin(), AE = CI.arg_end(); std::next(AI) != AE; ++AI) {
     Register SrcReg = getOrCreateVReg(**AI);
     LLT SrcTy = MRI->getType(SrcReg);
     if (SrcTy.isPointer())
-      MinPtrSize = std::min(SrcTy.getSizeInBits(), MinPtrSize);
+      MinPtrSize = std::min<unsigned>(SrcTy.getSizeInBits(), MinPtrSize);
     SrcRegs.push_back(SrcReg);
   }
 
   LLT SizeTy = LLT::scalar(MinPtrSize);
 
   // The size operand should be the minimum of the pointer sizes.
   Register &SizeOpReg = SrcRegs[SrcRegs.size() - 1];
   if (MRI->getType(SizeOpReg) != SizeTy)

llvm/lib/Target/AArch64/GISel/AArch64PostLegalizerCombiner.cpp

assert((Ty == LLT::scalar(32) || Ty == LLT::scalar(64)) &&
          "Unexpected type for G_SEXT_INREG?");
   Register ShiftSrc;
   int64_t ShiftImm;
   if (!mi_match(
           Src, MRI,
           m_OneNonDBGUse(m_any_of(m_GAShr(m_Reg(ShiftSrc), m_ICst(ShiftImm)),
                                   m_GLShr(m_Reg(ShiftSrc), m_ICst(ShiftImm))))))
     return false;
-  if (ShiftImm < 0 || ShiftImm + Width > Ty.getSizeInBits())
+  if (ShiftImm < 0 ||
+      static_cast<uint64_t>(ShiftImm + Width) > Ty.getSizeInBits())
     return false;
   MatchInfo = [=](MachineIRBuilder &B) {
     auto Cst1 = B.buildConstant(Ty, ShiftImm);
     auto Cst2 = B.buildConstant(Ty, Width);
     B.buildInstr(TargetOpcode::G_SBFX, {Dst}, {ShiftSrc, Cst1, Cst2});
   };
   return true;
 }

llvm/unittests/CodeGen/LowLevelTypeTest.cpp

for (auto EC :
       ASSERT_FALSE(VTy.isScalar());
       ASSERT_FALSE(VTy.isPointer());
 
       // Test sizes.
       EXPECT_EQ(S, VTy.getScalarSizeInBits());
       EXPECT_EQ(EC, VTy.getElementCount());
       if (!EC.isScalable())
         EXPECT_EQ(S * EC.getFixedValue(), VTy.getSizeInBits());
+      else
+        EXPECT_EQ(TypeSize::Scalable(S * EC.getKnownMinValue()),
+                  VTy.getSizeInBits());
 
       // Test equality operators.
       EXPECT_TRUE(VTy == VTy);
       EXPECT_FALSE(VTy != VTy);
 
       // Test inequality operators on..
       // ..different kind.
       EXPECT_NE(VTy, STy);

llvm/utils/TableGen/GlobalISelEmitter.cpp

bool operator<(const LLTCodeGen &Other) const {
     if (Ty.isVector() && Ty.getElementCount() != Other.Ty.getElementCount())
       return std::make_tuple(Ty.isScalable(),
                              Ty.getElementCount().getKnownMinValue()) <
              std::make_tuple(Other.Ty.isScalable(),
                              Other.Ty.getElementCount().getKnownMinValue());
 
     assert((!Ty.isVector() || Ty.isScalable() == Other.Ty.isScalable()) &&
            "Unexpected mismatch of scalable property");
-    return Ty.getSizeInBits() < Other.Ty.getSizeInBits();
+    return Ty.isVector()
+               ? std::make_tuple(Ty.isScalable(),
+                                 Ty.getSizeInBits().getKnownMinSize()) <
+                     std::make_tuple(Other.Ty.isScalable(),
+                                     Other.Ty.getSizeInBits().getKnownMinSize())
+               : Ty.getSizeInBits().getFixedSize() <
+                     Other.Ty.getSizeInBits().getFixedSize();
   }
 
   bool operator==(const LLTCodeGen &B) const { return Ty == B.Ty; }
 };
 
 // Track all types that are used so we can emit the corresponding enum.
 std::set<LLTCodeGen> KnownTypes;
 

 Optional<unsigned> GlobalISelEmitter::getMemSizeBitsFromPredicate(const TreePredicateFn &Predicate) {
   Optional<LLTCodeGen> MemTyOrNone =
       MVTToLLT(getValueType(Predicate.getMemoryVT()));
 
   if (!MemTyOrNone)
     return None;
 
   // Align so unusual types like i1 don't get rounded down.
-  return llvm::alignTo(MemTyOrNone->get().getSizeInBits(), 8);
+  return llvm::alignTo(
+      static_cast<unsigned>(MemTyOrNone->get().getSizeInBits()), 8);
 }
 
 Expected<InstructionMatcher &> GlobalISelEmitter::addBuiltinPredicates(
     const Record *SrcGIEquivOrNull, const TreePredicateFn &Predicate,
     InstructionMatcher &InsnMatcher, bool &HasAddedMatcher) {
   if (Predicate.isLoad() || Predicate.isStore() || Predicate.isAtomic()) {
     if (const ListInit *AddrSpaces = Predicate.getAddressSpaces()) {
       SmallVector<unsigned, 4> ParsedAddrSpaces;