[SVE] Cleanup prior to introdution of FixedVectorType

[ctetreau]

Summary

Remove asserting getters from base Type. The existence of these
functions make the VectorTyes refactor more difficult while adding
little value.

[ctetreau]

run clang-format

[ctetreau]

make lints work

[efriedma]

My thoughts, in no particular order:

1. This is orthogonal to splitting VectorType, as far as I can tell. Ty->getVectorNumElements() works equally well whether the implementation asserts it's a VectorType that isn't scalable, or asserts it's a FixedVectorType.
2. This needs to be split up; it's way too long to read, and it's mixing functional and non-functional changes.
3. It might make sense to add helpers to remove the use of cast<> in more places. For example, the inputs of a shufflevector are guaranteed to be vectors.
4. Some of the changes are leading to really crazy indentation because the cast<> is more characters.

[ctetreau]

Fix MLIR

[ctetreau]

1. This is orthogonal to splitting VectorType, as far as I can tell. Ty->getVectorNumElements() works equally well whether the implementation asserts it's a VectorType that isn't scalable, or asserts it's a FixedVectorType.

While it's not strictly neccesary, the refactor will be more straightforward with this change. Before, we would have:

unsigned n = t->getVectorNumElements();

After the VectorTypes refactor, if t is not a FixedLengthVector, then this code will still compile but fail at runtime. However with:

unsigned n = cast<VectorType>(t)->getNumElements();

... it will be a compile time failure.

Realistically, it would need to be at least renamed to getFixedVectorNumElements anyways to avoid confusion.

2. This needs to be split up; it's way too long to read, and it's mixing functional and non-functional changes.

I can split it up into a few chunks that make the corrections a bit at a time, then a final change to get rid of the functions

3. It might make sense to add helpers to remove the use of cast<> in more places. For example, the inputs of a shufflevector are guaranteed to be vectors.

It seems to me that we use base Type for basically everything when we could use concrete subclasses. As you can see in my patch, I fixed a few, but ideally functions would just return a VectorType if they have a VectorType. The issue is pervasive, and is enabled by the existence of these functions. This is a deep rabbit hole that I don't really want to go down in this patch.

4. Some of the changes are leading to really crazy indentation because the cast<> is more characters.

While I agree, there's not much we can do about that. Really, the problem is that we have these crazy complicated if statements that check 15 things at once.

[ctetreau]

Split commit up into multiple smaller commits:

1 commit per llvm library, 1 for clang, and 1 for mlir. Plus one final commit to remove the functions from Type

[ctetreau]

attempt to stack all commits

llvm/include/llvm/IR/DerivedTypes.h

public:
   }
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool classof(const Type *T) {
     return T->getTypeID() == VectorTyID;
   }
 };
 
-unsigned Type::getVectorNumElements() const {
-  return cast<VectorType>(this)->getNumElements();
-}
-
-bool Type::getVectorIsScalable() const {
-  return cast<VectorType>(this)->isScalable();
-}
-
-ElementCount Type::getVectorElementCount() const {
-  return cast<VectorType>(this)->getElementCount();
-}
-
 /// Class to represent pointers.
 class PointerType : public Type {
   explicit PointerType(Type *ElType, unsigned AddrSpace);
 
   Type *PointeeTy;
 
 public:
   PointerType(const PointerType &) = delete;
Type *Type::getExtendedType() const {
   return cast<IntegerType>(this)->getExtendedType();
 }
 
 Type *Type::getWithNewBitWidth(unsigned NewBitWidth) const {
   assert(
       isIntOrIntVectorTy() &&
       "Original type expected to be a vector of integers or a scalar integer.");
   Type *NewType = getIntNTy(getContext(), NewBitWidth);
-  if (isVectorTy())
-    NewType = VectorType::get(NewType, getVectorElementCount());
+  if (auto *VTy = dyn_cast<VectorType>(this))
+    NewType = VectorType::get(NewType, VTy->getElementCount());
   return NewType;
 }
 
 unsigned Type::getPointerAddressSpace() const {
   return cast<PointerType>(getScalarType())->getAddressSpace();
 }
 
 } // end namespace llvm
 
 #endif // LLVM_IR_DERIVEDTYPES_H

llvm/include/llvm/IR/Type.h

public:
 
   /// Return the width of the mantissa of this type. This is only valid on
   /// floating-point types. If the FP type does not have a stable mantissa (e.g.
   /// ppc long double), this method returns -1.
   int getFPMantissaWidth() const;
 
   /// If this is a vector type, return the element type, otherwise return
   /// 'this'.
-  Type *getScalarType() const {
-    if (isVectorTy())
-      return getVectorElementType();
-    return const_cast<Type*>(this);
-  }
+  Type *getScalarType() const;
 
   //===--------------------------------------------------------------------===//
   // Type Iteration support.
   //
   using subtype_iterator = Type * const *;
 
   subtype_iterator subtype_begin() const { return ContainedTys; }
   subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];}
Type *getContainedType(unsigned i) const {
     return ContainedTys[i];
   }
 
   /// Return the number of types in the derived type.
   unsigned getNumContainedTypes() const { return NumContainedTys; }
 
   //===--------------------------------------------------------------------===//
   // Helper methods corresponding to subclass methods.  This forces a cast to
-  // the specified subclass and calls its accessor.  "getVectorNumElements" (for
-  // example) is shorthand for cast<VectorType>(Ty)->getNumElements().  This is
+  // the specified subclass and calls its accessor.  "getArrayNumElements" (for
+  // example) is shorthand for cast<ArrayType>(Ty)->getNumElements().  This is
   // only intended to cover the core methods that are frequently used, helper
   // methods should not be added here.
 
   inline unsigned getIntegerBitWidth() const;
 
   inline Type *getFunctionParamType(unsigned i) const;
   inline unsigned getFunctionNumParams() const;
   inline bool isFunctionVarArg() const;
public:
 
   inline uint64_t getArrayNumElements() const;
 
   Type *getArrayElementType() const {
     assert(getTypeID() == ArrayTyID);
     return ContainedTys[0];
   }
 
-  inline bool getVectorIsScalable() const;
-  inline unsigned getVectorNumElements() const;
-  inline ElementCount getVectorElementCount() const;
-  Type *getVectorElementType() const {
-    assert(getTypeID() == VectorTyID);
-    return ContainedTys[0];
-  }
-
   Type *getPointerElementType() const {
     assert(getTypeID() == PointerTyID);
     return ContainedTys[0];
   }
 
   /// Given an integer or vector type, change the lane bitwidth to NewBitwidth,
   /// whilst keeping the old number of lanes.
   inline Type *getWithNewBitWidth(unsigned NewBitWidth) const;

llvm/lib/IR/Type.cpp

int Type::getFPMantissaWidth() const {
   if (getTypeID() == FloatTyID) return 24;
   if (getTypeID() == DoubleTyID) return 53;
   if (getTypeID() == X86_FP80TyID) return 64;
   if (getTypeID() == FP128TyID) return 113;
   assert(getTypeID() == PPC_FP128TyID && "unknown fp type");
   return -1;
 }
 
+Type *Type::getScalarType() const {
+  if (isVectorTy())
+    return cast<VectorType>(this)->getElementType();
+  return const_cast<Type *>(this);
+}
+
 bool Type::isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited) const {
   if (auto *ATy = dyn_cast<ArrayType>(this))
     return ATy->getElementType()->isSized(Visited);
 
   if (auto *VTy = dyn_cast<VectorType>(this))
     return VTy->getElementType()->isSized(Visited);
 
   return cast<StructType>(this)->isSized(Visited);