[mlir][llvm] More LLVMFixed/ScalableVectorType to TypeDef

[Mogball]

Summary

This keeps the current parser, however, since the mnemonic vec is
overloaded for both of these types.

Depends on D136499

mlir/include/mlir/Dialect/LLVMIR/LLVMTypes.h

public:
 
   void walkImmediateSubElements(function_ref<void(Attribute)> walkAttrsFn,
                                 function_ref<void(Type)> walkTypesFn) const;
   Type replaceImmediateSubElements(ArrayRef<Attribute> replAttrs,
                                    ArrayRef<Type> replTypes) const;
 };
 
 //===----------------------------------------------------------------------===//
-// LLVMFixedVectorType.
-//===----------------------------------------------------------------------===//
-
-/// LLVM dialect fixed vector type, represents a sequence of elements of known
-/// length that can be processed as one.
-class LLVMFixedVectorType
-    : public Type::TypeBase<LLVMFixedVectorType, Type,
-                            detail::LLVMTypeAndSizeStorage,
-                            SubElementTypeInterface::Trait> {
-public:
-  /// Inherit base constructor.
-  using Base::Base;
-  using Base::getChecked;
-
-  /// Gets or creates a fixed vector type containing `numElements` of
-  /// `elementType` in the same context as `elementType`.
-  static LLVMFixedVectorType get(Type elementType, unsigned numElements);
-  static LLVMFixedVectorType
-  getChecked(function_ref<InFlightDiagnostic()> emitError, Type elementType,
-             unsigned numElements);
-
-  /// Checks if the given type can be used in a vector type. This type supports
-  /// only a subset of LLVM dialect types that don't have a built-in
-  /// counter-part, e.g., pointers.
-  static bool isValidElementType(Type type);
-
-  /// Returns the element type of the vector.
-  Type getElementType() const;
-
-  /// Returns the number of elements in the fixed vector.
-  unsigned getNumElements() const;
-
-  /// Verifies that the type about to be constructed is well-formed.
-  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
-                              Type elementType, unsigned numElements);
-
-  void walkImmediateSubElements(function_ref<void(Attribute)> walkAttrsFn,
-                                function_ref<void(Type)> walkTypesFn) const;
-  Type replaceImmediateSubElements(ArrayRef<Attribute> replAttrs,
-                                   ArrayRef<Type> replTypes) const;
-};
-
-//===----------------------------------------------------------------------===//
-// LLVMScalableVectorType.
-//===----------------------------------------------------------------------===//
-
-/// 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.
-class LLVMScalableVectorType
-    : public Type::TypeBase<LLVMScalableVectorType, Type,
-                            detail::LLVMTypeAndSizeStorage,
-                            SubElementTypeInterface::Trait> {
-public:
-  /// Inherit base constructor.
-  using Base::Base;
-  using Base::getChecked;
-
-  /// Gets or creates a scalable vector type containing a non-zero multiple of
-  /// `minNumElements` of `elementType` in the same context as `elementType`.
-  static LLVMScalableVectorType get(Type elementType, unsigned minNumElements);
-  static LLVMScalableVectorType
-  getChecked(function_ref<InFlightDiagnostic()> emitError, Type elementType,
-             unsigned minNumElements);
-
-  /// Checks if the given type can be used in a vector type.
-  static bool isValidElementType(Type type);
-
-  /// Returns the element type of the vector.
-  Type getElementType() const;
-
-  /// Returns the scaling factor of the number of elements in the vector. The
-  /// vector contains at least the resulting number of elements, or any non-zero
-  /// multiple of this number.
-  unsigned getMinNumElements() const;
-
-  /// Verifies that the type about to be constructed is well-formed.
-  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
-                              Type elementType, unsigned minNumElements);
-
-  void walkImmediateSubElements(function_ref<void(Attribute)> walkAttrsFn,
-                                function_ref<void(Type)> walkTypesFn) const;
-  Type replaceImmediateSubElements(ArrayRef<Attribute> replAttrs,
-                                   ArrayRef<Type> replTypes) const;
-};
-
-//===----------------------------------------------------------------------===//
 // Printing and parsing.
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 /// Parses an LLVM dialect type.
 Type parseType(DialectAsmParser &parser);
 
 /// Prints an LLVM Dialect type.

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

let extraClassDeclaration = [{
     /// pointed-to type.
     bool isOpaque() const { return !getElementType(); }
 
     /// Checks if the given type can have a pointer type pointing to it.
     static bool isValidElementType(Type type);
   }];
 }
 
+//===----------------------------------------------------------------------===//
+// LLVMFixedVectorType
+//===----------------------------------------------------------------------===//
+
+def LLVMFixedVectorType : LLVMType<"LLVMFixedVector", "vec", [
+    DeclareTypeInterfaceMethods<SubElementTypeInterface>]> {
+  let summary = "LLVM fixed 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 parameters = (ins "Type":$elementType, "unsigned":$numElements);
+  let assemblyFormat = [{
+    `<` $numElements `x` ` ` custom<PrettyLLVMType>($elementType) `>`
+  }];
+
+  let genVerifyDecl = 1;
+
+  let builders = [
+    TypeBuilderWithInferredContext<(ins "Type":$elementType,
+                                        "unsigned":$numElements)>
+  ];
+
+  let extraClassDeclaration = [{
+    /// Checks if the given type can be used in a vector type.
+    static bool isValidElementType(Type type);
+  }];
+}
+
+//===----------------------------------------------------------------------===//
+// LLVMScalableVectorType
+//===----------------------------------------------------------------------===//
+
+def LLVMScalableVectorType : LLVMType<"LLVMScalableVector", "vec", [
+    DeclareTypeInterfaceMethods<SubElementTypeInterface>]> {
+  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 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);
+  }];
+}
+
 #endif // LLVMTYPES_TD

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

void LLVMDialect::initialize() {
 
   // clang-format off
   addTypes<LLVMVoidType,
            LLVMPPCFP128Type,
            LLVMX86MMXType,
            LLVMTokenType,
            LLVMLabelType,
            LLVMMetadataType,
-           LLVMFixedVectorType,
-           LLVMScalableVectorType,
            LLVMStructType>();
   // clang-format on
   registerTypes();
 
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/LLVMIR/LLVMOps.cpp.inc"
       ,

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

static void printStructType(AsmPrinter &printer, LLVMStructType type) {
   llvm::interleaveComma(type.getBody(), printer.getStream(),
                         [&](Type subtype) { dispatchPrint(printer, subtype); });
   if (type.isIdentified())
     knownStructNames.pop_back();
   printer << ')';
   printer << '>';
 }
 
-/// Prints a type containing a fixed number of elements.
-template <typename TypeTy>
-static void printVectorType(AsmPrinter &printer, TypeTy type) {
-  printer << '<' << type.getNumElements() << " x ";
-  dispatchPrint(printer, type.getElementType());
-  printer << '>';
-}
-
 /// Prints the given LLVM dialect type recursively. This leverages closedness of
 /// the LLVM dialect type system to avoid printing the dialect prefix
 /// repeatedly. For recursive structures, only prints the name of the structure
 /// when printing a self-reference. Note that this does not apply to sibling
 /// references. For example,
 ///   struct<"a", (ptr<struct<"a">>)>
 ///   struct<"c", (ptr<struct<"b", (ptr<struct<"c">>)>>,
 ///                ptr<struct<"b", (ptr<struct<"c">>)>>)>
 /// note that "b" is printed twice.
 void mlir::LLVM::detail::printType(Type type, AsmPrinter &printer) {
   if (!type) {
     printer << "<<NULL-TYPE>>";
     return;
   }
 
   printer << getTypeKeyword(type);
 
-  if (auto ptrType = type.dyn_cast<LLVMPointerType>())
-    return ptrType.print(printer);
-
-  if (auto arrayType = type.dyn_cast<LLVMArrayType>())
-    return arrayType.print(printer);
-  if (auto vectorType = type.dyn_cast<LLVMFixedVectorType>())
-    return printVectorType(printer, vectorType);
-
-  if (auto vectorType = type.dyn_cast<LLVMScalableVectorType>()) {
-    printer << "<? x " << vectorType.getMinNumElements() << " x ";
-    dispatchPrint(printer, vectorType.getElementType());
-    printer << '>';
-    return;
-  }
-
-  if (auto structType = type.dyn_cast<LLVMStructType>())
-    return printStructType(printer, structType);
-
-  if (auto funcType = type.dyn_cast<LLVMFunctionType>())
-    return funcType.print(printer);
+  llvm::TypeSwitch<Type>(type)
+      .Case<LLVMPointerType, LLVMArrayType, LLVMFixedVectorType,
+            LLVMScalableVectorType, LLVMFunctionType>(
+          [&](auto type) { type.print(printer); })
+      .Case([&](LLVMStructType structType) {
+        printStructType(printer, structType);
+      });
 }
 
 //===----------------------------------------------------------------------===//
 // Parsing.
 //===----------------------------------------------------------------------===//
 
 static ParseResult dispatchParse(AsmParser &parser, Type &type);
 

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

 LLVMFixedVectorType
 LLVMFixedVectorType::getChecked(function_ref<InFlightDiagnostic()> emitError,
                                 Type elementType, unsigned numElements) {
   assert(elementType && "expected non-null subtype");
   return Base::getChecked(emitError, elementType.getContext(), elementType,
                           numElements);
 }
 
-Type LLVMFixedVectorType::getElementType() const {
-  return static_cast<detail::LLVMTypeAndSizeStorage *>(impl)->elementType;
-}
-
-unsigned LLVMFixedVectorType::getNumElements() const {
-  return getImpl()->numElements;
-}
-
 bool LLVMFixedVectorType::isValidElementType(Type type) {
   return type.isa<LLVMPointerType, LLVMPPCFP128Type>();
 }
 
 LogicalResult
 LLVMFixedVectorType::verify(function_ref<InFlightDiagnostic()> emitError,
                             Type elementType, unsigned numElements) {
   return verifyVectorConstructionInvariants<LLVMFixedVectorType>(

 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);
 }
 
-Type LLVMScalableVectorType::getElementType() const {
-  return static_cast<detail::LLVMTypeAndSizeStorage *>(impl)->elementType;
-}
-
-unsigned LLVMScalableVectorType::getMinNumElements() const {
-  return getImpl()->numElements;
-}
-
 bool LLVMScalableVectorType::isValidElementType(Type type) {
   if (auto intType = type.dyn_cast<IntegerType>())
     return intType.isSignless();
 
   return isCompatibleFloatingPointType(type) || type.isa<LLVMPointerType>();
 }
 
 LogicalResult