[SVE] Mark VectorType::getNumElements() deprecated

[ctetreau]

Summary

getNumElements() is being removed from base VectorType in
order to eliminate the class of bugs in which a scalable vector
is accidentally treated like a fixed length vector. Clients of
this function should either call getElementCount(), and handle
the case whre getElementCount().Min is true, or they can cast
to FixedVectorType and call getNumElements() if they are sure
that the vector has fixed width.

Deprecated VectorType functions will be removed after the LLVM 12 branch
point

See: http://lists.llvm.org/pipermail/llvm-dev/2020-March/139811.html

[ctetreau]

rebase

llvm/include/llvm/IR/DerivedTypes.h

 
 public:
   VectorType(const VectorType &) = delete;
   VectorType &operator=(const VectorType &) = delete;
 
   /// Get the number of elements in this vector. It does not make sense to call
   /// this function on a scalable vector, and this will be moved into
   /// FixedVectorType in a future commit
-  unsigned getNumElements() const {
-    ElementCount EC = getElementCount();
-#ifdef STRICT_FIXED_SIZE_VECTORS
-    assert(!EC.isScalable() &&
-           "Request for fixed number of elements from scalable vector");
-    return EC.getKnownMinValue();
-#else
-    if (EC.isScalable())
-      WithColor::warning()
-          << "The code that requested the fixed number of elements has made "
-             "the assumption that this vector is not scalable. This assumption "
-             "was not correct, and this may lead to broken code\n";
-    return EC.getKnownMinValue();
-#endif
-  }
+  LLVM_ATTRIBUTE_DEPRECATED(
+      inline unsigned getNumElements() const,
+      "Calling this function via a base VectorType is deprecated. Either call "
+      "getElementCount() and handle the case where Scalable is true or cast to "
+      "FixedVectorType.");
 
   Type *getElementType() const { return ContainedType; }
 
   /// This static method is the primary way to construct an VectorType.
   static VectorType *get(Type *ElementType, ElementCount EC);
 
   static VectorType *get(Type *ElementType, unsigned NumElements,
                          bool Scalable) {
public:
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool classof(const Type *T) {
     return T->getTypeID() == FixedVectorTyID ||
            T->getTypeID() == ScalableVectorTyID;
   }
 };
 
+unsigned VectorType::getNumElements() const {
+  ElementCount EC = getElementCount();
+#ifdef STRICT_FIXED_SIZE_VECTORS
+  assert(!EC.isScalable() &&
+         "Request for fixed number of elements from scalable vector");
+#else
+  if (EC.isScalable())
+    WithColor::warning()
+        << "The code that requested the fixed number of elements has made the "
+           "assumption that this vector is not scalable. This assumption was "
+           "not correct, and this may lead to broken code\n";
+#endif
+  return EC.getKnownMinValue();
+}
+
 /// Class to represent fixed width SIMD vectors
 class FixedVectorType : public VectorType {
 protected:
   FixedVectorType(Type *ElTy, unsigned NumElts)
       : VectorType(ElTy, NumElts, FixedVectorTyID) {}
 
 public:
   static FixedVectorType *get(Type *ElementType, unsigned NumElts);
public:
 
   static FixedVectorType *getDoubleElementsVectorType(FixedVectorType *VTy) {
     return cast<FixedVectorType>(VectorType::getDoubleElementsVectorType(VTy));
   }
 
   static bool classof(const Type *T) {
     return T->getTypeID() == FixedVectorTyID;
   }
+
+  unsigned getNumElements() const { return ElementQuantity; }
 };
 
 /// Class to represent scalable SIMD vectors
 class ScalableVectorType : public VectorType {
 protected:
   ScalableVectorType(Type *ElTy, unsigned MinNumElts)
       : VectorType(ElTy, MinNumElts, ScalableVectorTyID) {}