delete scalable vec type

Author: matthias-springer

mlir/docs/Dialects/LLVM.md

@@ -327,18 +327,7 @@ multiple of some fixed size in case of _scalable_ vectors, and the element type.
 Vectors cannot be nested and only 1D vectors are supported. Scalable vectors are
 still considered 1D.
 
-The LLVM dialect uses built-in vector types for _fixed_-size vectors of built-in
-types, and provides additional types for scalable vectors of any types
-(`LLVMScalableVectorType`):
-
-```
-  llvm-vec-type ::= `!llvm.vec<` (`?` `x`)? integer-literal `x` type `>`
-```
-
-Note that the sets of element types supported by built-in and LLVM dialect
-vector types are mutually exclusive, e.g., the built-in vector type does not
-accept `!llvm.ptr` and the LLVM dialect fixed-width vector type does not
-accept `i32`.
+The LLVM dialect uses built-in vector type.
 
 The following functions are provided to operate on any kind of the vector types
 compatible with the LLVM dialect:
@@ -358,8 +347,8 @@ compatible with the LLVM dialect:
 
 ```mlir
 vector<42 x i32>                   // Vector of 42 32-bit integers.
-!llvm.vec<42 x ptr>                // Vector of 42 pointers.
-!llvm.vec<? x 4 x i32>             // Scalable vector of 32-bit integers with
+vector<42 x !llvm.ptr>             // Vector of 42 pointers.
+vector<[4] x i32>                  // Scalable vector of 32-bit integers with
                                    // size divisible by 4.
 !llvm.array<2 x vector<2 x i32>>   // Array of 2 vectors of 2 32-bit integers.
 !llvm.array<2 x vec<2 x ptr>> // Array of 2 vectors of 2 pointers.

mlir/include/mlir/Dialect/LLVMIR/LLVMTypes.td

@@ -289,38 +289,6 @@ def LLVMPointerType : LLVMType<"LLVMPointer", "ptr", [
   ];
 }
 
-//===----------------------------------------------------------------------===//
-// LLVMScalableVectorType
-//===----------------------------------------------------------------------===//
-
-def LLVMScalableVectorType : LLVMType<"LLVMScalableVector", "vec"> {
-  let summary = "LLVM scalable vector type";
-  let description = [{
-    LLVM dialect scalable vector type, represents a sequence of elements of
-    unknown length that is known to be divisible by some constant. These
-    elements can be processed as one in SIMD context.
-  }];
-
-  let typeName = "llvm.scalable_vec";
-
-  let parameters = (ins "Type":$elementType, "unsigned":$minNumElements);
-  let assemblyFormat = [{
-    `<` `?` `x` $minNumElements `x` ` ` custom<PrettyLLVMType>($elementType) `>`
-  }];
-
-  let genVerifyDecl = 1;
-
-  let builders = [
-    TypeBuilderWithInferredContext<(ins "Type":$elementType,
-                                        "unsigned":$minNumElements)>
-  ];
-
-  let extraClassDeclaration = [{
-    /// Checks if the given type can be used in a vector type.
-    static bool isValidElementType(Type type);
-  }];
-}
-
 //===----------------------------------------------------------------------===//
 // LLVMTargetExtType
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

@@ -684,8 +684,6 @@ GEPIndicesAdaptor<ValueRange> GEPOp::getIndices() {
 static Type extractVectorElementType(Type type) {
   if (auto vectorType = llvm::dyn_cast<VectorType>(type))
     return vectorType.getElementType();
-  if (auto scalableVectorType = llvm::dyn_cast<LLVMScalableVectorType>(type))
-    return scalableVectorType.getElementType();
   return type;
 }
 
@@ -723,10 +721,9 @@ static void destructureIndices(Type currType, ArrayRef<GEPArg> indices,
       continue;
 
     currType = TypeSwitch<Type, Type>(currType)
-                   .Case<VectorType, LLVMScalableVectorType, LLVMArrayType>(
-                       [](auto containerType) {
-                         return containerType.getElementType();
-                       })
+                   .Case<VectorType, LLVMArrayType>([](auto containerType) {
+                     return containerType.getElementType();
+                   })
                    .Case([&](LLVMStructType structType) -> Type {
                      int64_t memberIndex = rawConstantIndices.back();
                      if (memberIndex >= 0 && static_cast<size_t>(memberIndex) <
@@ -835,7 +832,7 @@ verifyStructIndices(Type baseGEPType, unsigned indexPos,
         return verifyStructIndices(elementTypes[gepIndex], indexPos + 1,
                                    indices, emitOpError);
       })
-      .Case<VectorType, LLVMScalableVectorType, LLVMArrayType>(
+      .Case<VectorType, LLVMArrayType>(
           [&](auto containerType) -> LogicalResult {
             return verifyStructIndices(containerType.getElementType(),
                                        indexPos + 1, indices, emitOpError);
@@ -3113,16 +3110,12 @@ static int64_t getNumElements(Type t) {
   if (auto arrayType = dyn_cast<LLVM::LLVMArrayType>(t))
     return arrayType.getNumElements() *
            getNumElements(arrayType.getElementType());
-  assert(!isa<LLVM::LLVMScalableVectorType>(t) &&
-         "number of elements of a scalable vector type is unknown");
   return 1;
 }
 
 /// Check if the given type is a scalable vector type or a vector/array type
 /// that contains a nested scalable vector type.
 static bool hasScalableVectorType(Type t) {
-  if (isa<LLVM::LLVMScalableVectorType>(t))
-    return true;
   if (auto vecType = dyn_cast<VectorType>(t)) {
     if (vecType.isScalable())
       return true;
@@ -3458,7 +3451,7 @@ LogicalResult LLVM::BitcastOp::verify() {
   if (!resultType)
     return success();
 
-  auto isVector = llvm::IsaPred<VectorType, LLVMScalableVectorType>;
+  auto isVector = llvm::IsaPred<VectorType>;
 
   // Due to bitcast requiring both operands to be of the same size, it is not
   // possible for only one of the two to be a pointer of vectors.

mlir/lib/Dialect/LLVMIR/IR/LLVMMemorySlot.cpp

@@ -134,12 +134,6 @@ static bool isSupportedTypeForConversion(Type type) {
   if (isa<LLVM::LLVMStructType, LLVM::LLVMArrayType>(type))
     return false;
 
-  // LLVM vector types are only used for either pointers or target specific
-  // types. These types cannot be casted in the general case, thus the memory
-  // optimizations do not support them.
-  if (isa<LLVM::LLVMScalableVectorType>(type))
-    return false;
-
   if (auto vectorType = dyn_cast<VectorType>(type)) {
     // Vectors of pointers cannot be casted.
     if (isa<LLVM::LLVMPointerType>(vectorType.getElementType()))

mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp

@@ -40,7 +40,6 @@ static StringRef getTypeKeyword(Type type) {
       .Case<LLVMMetadataType>([&](Type) { return "metadata"; })
       .Case<LLVMFunctionType>([&](Type) { return "func"; })
       .Case<LLVMPointerType>([&](Type) { return "ptr"; })
-      .Case<LLVMScalableVectorType>([&](Type) { return "vec"; })
       .Case<LLVMArrayType>([&](Type) { return "array"; })
       .Case<LLVMStructType>([&](Type) { return "struct"; })
       .Case<LLVMTargetExtType>([&](Type) { return "target"; })
@@ -103,9 +102,8 @@ void mlir::LLVM::detail::printType(Type type, AsmPrinter &printer) {
   printer << getTypeKeyword(type);
 
   llvm::TypeSwitch<Type>(type)
-      .Case<LLVMPointerType, LLVMArrayType, LLVMScalableVectorType,
-            LLVMFunctionType, LLVMTargetExtType, LLVMStructType>(
-          [&](auto type) { type.print(printer); });
+      .Case<LLVMPointerType, LLVMArrayType, LLVMFunctionType, LLVMTargetExtType,
+            LLVMStructType>([&](auto type) { type.print(printer); });
 }
 
 //===----------------------------------------------------------------------===//
@@ -114,41 +112,6 @@ void mlir::LLVM::detail::printType(Type type, AsmPrinter &printer) {
 
 static ParseResult dispatchParse(AsmParser &parser, Type &type);
 
-/// Parses an LLVM dialect vector type.
-///   llvm-type ::= `vec<` `? x`? integer `x` llvm-type `>`
-/// Supports both fixed and scalable vectors.
-static Type parseVectorType(AsmParser &parser) {
-  SmallVector<int64_t, 2> dims;
-  SMLoc dimPos, typePos;
-  Type elementType;
-  SMLoc loc = parser.getCurrentLocation();
-  if (parser.parseLess() || parser.getCurrentLocation(&dimPos) ||
-      parser.parseDimensionList(dims, /*allowDynamic=*/true) ||
-      parser.getCurrentLocation(&typePos) ||
-      dispatchParse(parser, elementType) || parser.parseGreater())
-    return Type();
-
-  // We parsed a generic dimension list, but vectors only support two forms:
-  //  - single non-dynamic entry in the list (fixed vector);
-  //  - two elements, the first dynamic (indicated by ShapedType::kDynamic)
-  //  and the second
-  //    non-dynamic (scalable vector).
-  if (dims.empty() || dims.size() > 2 ||
-      ((dims.size() == 2) ^ (ShapedType::isDynamic(dims[0]))) ||
-      (dims.size() == 2 && ShapedType::isDynamic(dims[1]))) {
-    parser.emitError(dimPos)
-        << "expected '? x <integer> x <type>' or '<integer> x <type>'";
-    return Type();
-  }
-
-  bool isScalable = dims.size() == 2;
-  if (!isScalable) {
-    parser.emitError(dimPos) << "expected scalable vector";
-    return Type();
-  }
-  return parser.getChecked<LLVMScalableVectorType>(loc, elementType, dims[1]);
-}
-
 /// Attempts to set the body of an identified structure type. Reports a parsing
 /// error at `subtypesLoc` in case of failure.
 static LLVMStructType trySetStructBody(LLVMStructType type,
@@ -307,7 +270,6 @@ static Type dispatchParse(AsmParser &parser, bool allowAny = true) {
       .Case("metadata", [&] { return LLVMMetadataType::get(ctx); })
       .Case("func", [&] { return LLVMFunctionType::parse(parser); })
       .Case("ptr", [&] { return LLVMPointerType::parse(parser); })
-      .Case("vec", [&] { return parseVectorType(parser); })
       .Case("array", [&] { return LLVMArrayType::parse(parser); })
       .Case("struct", [&] { return LLVMStructType::parse(parser); })
       .Case("target", [&] { return LLVMTargetExtType::parse(parser); })

mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp

@@ -150,8 +150,7 @@ generatedTypePrinter(Type def, AsmPrinter &printer);
 
 bool LLVMArrayType::isValidElementType(Type type) {
   return !llvm::isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
-                    LLVMFunctionType, LLVMTokenType, LLVMScalableVectorType>(
-      type);
+                    LLVMFunctionType, LLVMTokenType>(type);
 }
 
 LLVMArrayType LLVMArrayType::get(Type elementType, uint64_t numElements) {
@@ -657,53 +656,6 @@ LogicalResult LLVMStructType::verifyEntries(DataLayoutEntryListRef entries,
   return mlir::success();
 }
 
-//===----------------------------------------------------------------------===//
-// LLVMScalableVectorType.
-//===----------------------------------------------------------------------===//
-
-/// Verifies that the type about to be constructed is well-formed.
-template <typename VecTy>
-static LogicalResult
-verifyVectorConstructionInvariants(function_ref<InFlightDiagnostic()> emitError,
-                                   Type elementType, unsigned numElements) {
-  if (numElements == 0)
-    return emitError() << "the number of vector elements must be positive";
-
-  if (!VecTy::isValidElementType(elementType))
-    return emitError() << "invalid vector element type";
-
-  return success();
-}
-
-LLVMScalableVectorType LLVMScalableVectorType::get(Type elementType,
-                                                   unsigned minNumElements) {
-  assert(elementType && "expected non-null subtype");
-  return Base::get(elementType.getContext(), elementType, minNumElements);
-}
-
-LLVMScalableVectorType
-LLVMScalableVectorType::getChecked(function_ref<InFlightDiagnostic()> emitError,
-                                   Type elementType, unsigned minNumElements) {
-  assert(elementType && "expected non-null subtype");
-  return Base::getChecked(emitError, elementType.getContext(), elementType,
-                          minNumElements);
-}
-
-bool LLVMScalableVectorType::isValidElementType(Type type) {
-  if (auto intType = llvm::dyn_cast<IntegerType>(type))
-    return intType.isSignless();
-
-  return isCompatibleFloatingPointType(type) ||
-         llvm::isa<LLVMPointerType>(type);
-}
-
-LogicalResult
-LLVMScalableVectorType::verify(function_ref<InFlightDiagnostic()> emitError,
-                               Type elementType, unsigned numElements) {
-  return verifyVectorConstructionInvariants<LLVMScalableVectorType>(
-      emitError, elementType, numElements);
-}
-
 //===----------------------------------------------------------------------===//
 // LLVMTargetExtType.
 //===----------------------------------------------------------------------===//
@@ -762,7 +714,6 @@ bool mlir::LLVM::isCompatibleOuterType(Type type) {
       LLVMPointerType,
       LLVMStructType,
       LLVMTokenType,
-      LLVMScalableVectorType,
       LLVMTargetExtType,
       LLVMVoidType,
       LLVMX86AMXType
@@ -810,7 +761,6 @@ static bool isCompatibleImpl(Type type, DenseSet<Type> &compatibleTypes) {
           })
           // clang-format off
           .Case<
-              LLVMScalableVectorType,
               LLVMArrayType
           >([&](auto containerType) {
             return isCompatible(containerType.getElementType());
@@ -857,9 +807,6 @@ bool mlir::LLVM::isCompatibleFloatingPointType(Type type) {
 }
 
 bool mlir::LLVM::isCompatibleVectorType(Type type) {
-  if (llvm::isa<LLVMScalableVectorType>(type))
-    return true;
-
   if (auto vecType = llvm::dyn_cast<VectorType>(type)) {
     if (vecType.getRank() != 1)
       return false;
@@ -874,8 +821,7 @@ bool mlir::LLVM::isCompatibleVectorType(Type type) {
 
 Type mlir::LLVM::getVectorElementType(Type type) {
   return llvm::TypeSwitch<Type, Type>(type)
-      .Case<LLVMScalableVectorType, VectorType>(
-          [](auto ty) { return ty.getElementType(); })
+      .Case<VectorType>([](auto ty) { return ty.getElementType(); })
       .Default([](Type) -> Type {
         llvm_unreachable("incompatible with LLVM vector type");
       });
@@ -888,37 +834,22 @@ llvm::ElementCount mlir::LLVM::getVectorNumElements(Type type) {
           return llvm::ElementCount::getScalable(ty.getNumElements());
         return llvm::ElementCount::getFixed(ty.getNumElements());
       })
-      .Case([](LLVMScalableVectorType ty) {
-        return llvm::ElementCount::getScalable(ty.getMinNumElements());
-      })
       .Default([](Type) -> llvm::ElementCount {
         llvm_unreachable("incompatible with LLVM vector type");
       });
 }
 
 bool mlir::LLVM::isScalableVectorType(Type vectorType) {
-  assert((llvm::isa<LLVMScalableVectorType, VectorType>(vectorType)) &&
+  assert(llvm::isa<VectorType>(vectorType) &&
          "expected LLVM-compatible vector type");
-  return llvm::isa<LLVMScalableVectorType>(vectorType) ||
-         llvm::cast<VectorType>(vectorType).isScalable();
+  return llvm::cast<VectorType>(vectorType).isScalable();
 }
 
 Type mlir::LLVM::getVectorType(Type elementType, unsigned numElements,
                                bool isScalable) {
-  if (!isScalable) {
-    // Non-scalable vectors always use the MLIR vector type.
-    assert(VectorType::isValidElementType(elementType) &&
-           "incompatible element type");
-    return VectorType::get(numElements, elementType, {false});
-  }
-
-  // This is a scalable vector.
-  if (VectorType::isValidElementType(elementType))
-    return VectorType::get(numElements, elementType, {true});
-  assert(LLVMScalableVectorType::isValidElementType(elementType) &&
-         "neither the MLIR vector type nor LLVMScalableVectorType is "
-         "compatible with the specified element type");
-  return LLVMScalableVectorType::get(elementType, numElements);
+  assert(VectorType::isValidElementType(elementType) &&
+         "incompatible element type");
+  return VectorType::get(numElements, elementType, {isScalable});
 }
 
 Type mlir::LLVM::getVectorType(Type elementType,
@@ -937,15 +868,6 @@ Type mlir::LLVM::getFixedVectorType(Type elementType, unsigned numElements) {
 }
 
 Type mlir::LLVM::getScalableVectorType(Type elementType, unsigned numElements) {
-  bool useLLVM = LLVMScalableVectorType::isValidElementType(elementType);
-  bool useBuiltIn = VectorType::isValidElementType(elementType);
-  (void)useBuiltIn;
-  assert((useLLVM ^ useBuiltIn) && "expected LLVM-compatible scalable-vector "
-                                   "type to be either builtin or LLVM dialect "
-                                   "type");
-  if (useLLVM)
-    return LLVMScalableVectorType::get(elementType, numElements);
-
   // LLVM vectors are always 1-D, hence only 1 bool is required to mark it as
   // scalable/non-scalable.
   return VectorType::get(numElements, elementType, /*scalableDims=*/true);

mlir/lib/Target/LLVMIR/TypeFromLLVM.cpp

@@ -130,8 +130,8 @@ class TypeFromLLVMIRTranslatorImpl {
 
   /// Translates the given scalable-vector type.
   Type translate(llvm::ScalableVectorType *type) {
-    return LLVM::LLVMScalableVectorType::get(
-        translateType(type->getElementType()), type->getMinNumElements());
+    return LLVM::getScalableVectorType(translateType(type->getElementType()),
+                                       type->getMinNumElements());
   }
 
   /// Translates the given target extension type.