[SVE] Remove VectorType::getBitWidth()

[ctetreau]

Summary

• VectorType::getBitWidth() is just an unsafe version of

getPrimitiveSizeInBits() that assumes all vectors are fixed width.

[efriedma]

Makes sense.

llvm/lib/IR/Type.cpp

78

This seems a little messy. Maybe separate the vector/vector case from the vector/mmx case?

[ctetreau]

address code review issues

[efriedma]

LGTM

[ctetreau]

rebase

[ctetreau]

rebase

[ctetreau]

rebase

[ctetreau]

Make this commit not depend on the existence of FixedVectorType

[efriedma]

llvm/lib/IR/Type.cpp

92

I think you broke this in the process of making it not depend on FixedVectorType?

[ctetreau]

catch stragglers

[ctetreau]

llvm/lib/IR/Type.cpp

92

Yes I did, good catch. If only there were a FixedVectorType :)

[ctetreau]

fix dumdum

[efriedma]

LGTM. Please make a note to clean up Type::canLosslesslyBitCastTo later.

[ctetreau]

In D77833#1995390, @efriedma wrote:

LGTM. Please make a note to clean up Type::canLosslesslyBitCastTo later.

It's cleaned up in D77587 which I plan to merge right after this goes in

llvm/include/llvm/IR/DerivedTypes.h

public:
   /// Return an ElementCount instance to represent the (possibly scalable)
   /// number of elements in the vector.
   ElementCount getElementCount() const {
     uint64_t MinimumEltCnt = getNumElements();
     assert(MinimumEltCnt <= UINT_MAX && "Too many elements in vector");
     return EC;
   }
 
-  /// Return the minimum number of bits in the Vector type.
-  /// Returns zero when the vector is a vector of pointers.
-  unsigned getBitWidth() const {
-    return getNumElements() * getElementType()->getPrimitiveSizeInBits();
-  }
-
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool classof(const Type *T) {
     return T->getTypeID() == FixedVectorTyID ||
            T->getTypeID() == ScalableVectorTyID;
   }
 };
 
 bool Type::isVectorTy() const { return isa<VectorType>(this); }

llvm/lib/IR/Type.cpp

bool Type::canLosslesslyBitCastTo(Type *Ty) const {
   if (this == Ty)
     return true;
 
   // They are not convertible unless they are at least first class types
   if (!this->isFirstClassType() || !Ty->isFirstClassType())
     return false;
 
   // Vector -> Vector conversions are always lossless if the two vector types
-  // have the same size, otherwise not.  Also, 64-bit vector types can be
+  // have the same size, otherwise not.  Also, 64-bit fixed vector types can be
   // converted to x86mmx.
-  if (auto *thisPTy = dyn_cast<VectorType>(this)) {
-    if (auto *thatPTy = dyn_cast<VectorType>(Ty))
-      return thisPTy->getBitWidth() == thatPTy->getBitWidth();
-    if (Ty->getTypeID() == Type::X86_MMXTyID &&
-        thisPTy->getBitWidth() == 64)
+  if (isa<VectorType>(this)) {
+    TypeSize ThisTypeSize = getPrimitiveSizeInBits();
+    if (isa<VectorType>(Ty))
+      return ThisTypeSize == Ty->getPrimitiveSizeInBits();
+    if (Ty->getTypeID() == Type::X86_MMXTyID && !ThisTypeSize.isScalable() &&
+        ThisTypeSize.getFixedSize() == 64)
       return true;
   }
 
   if (this->getTypeID() == Type::X86_MMXTyID)
-    if (auto *thatPTy = dyn_cast<VectorType>(Ty))
-      if (thatPTy->getBitWidth() == 64)
+    if (isa<FixedVectorType>(Ty)) {
+      TypeSize ThatTypeSize = Ty->getPrimitiveSizeInBits();
+      if (ThatTypeSize.getFixedSize() == 64)
         return true;
+    }
 
   // At this point we have only various mismatches of the first class types
   // remaining and ptr->ptr. Just select the lossless conversions. Everything
   // else is not lossless. Conservatively assume we can't losslessly convert
   // between pointers with different address spaces.
   if (auto *PTy = dyn_cast<PointerType>(this)) {
     if (auto *OtherPTy = dyn_cast<PointerType>(Ty))
       return PTy->getAddressSpace() == OtherPTy->getAddressSpace();
     return false;
   }
   return false;  // Other types have no identity values
 }
 
TypeSize Type::getPrimitiveSizeInBits() const {
   case Type::FP128TyID: return TypeSize::Fixed(128);
   case Type::PPC_FP128TyID: return TypeSize::Fixed(128);
   case Type::X86_MMXTyID: return TypeSize::Fixed(64);
   case Type::IntegerTyID:
     return TypeSize::Fixed(cast<IntegerType>(this)->getBitWidth());
   case Type::FixedVectorTyID:
   case Type::ScalableVectorTyID: {
     const VectorType *VTy = cast<VectorType>(this);
-    return TypeSize(VTy->getBitWidth(), isa<ScalableVectorType>(VTy));
+    ElementCount EC = VTy->getElementCount();
+    TypeSize ETS = VTy->getElementType()->getPrimitiveSizeInBits();
+    assert(!ETS.isScalable() && "Vector type should have fixed-width elements");
+    return {ETS.getFixedSize() * EC.Min, EC.Scalable};
   }
   default: return TypeSize::Fixed(0);
   }
 }
 
 unsigned Type::getScalarSizeInBits() const {
   // It is safe to assume that the scalar types have a fixed size.
   return getScalarType()->getPrimitiveSizeInBits().getFixedSize();