[mlir][llvm] Move LLVMArrayType to a TypeDef

[Mogball]

Summary

This moves the LLVMArrayType to a TypeDef. The main side-effect of
this change is that the syntax array<4xi32> is no longer allowed. It
was previously parsed and then printed as array<4 x i32>. Now the
syntax must be the latter.

[rriddle]

Sweet! Moving these to TypeDefs has been a long TODO.

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

90–93

style: Can you move this above the field?

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

1012

Is there a TODO we can add here? I think we should try moving over to using this when we can.

[Mogball]

review comments

mlir/include/mlir/Dialect/LLVMIR/CMakeLists.txt

 add_subdirectory(Transforms)
 
 set(LLVM_TARGET_DEFINITIONS LLVMOps.td)
 mlir_tablegen(LLVMOps.h.inc -gen-op-decls)
 mlir_tablegen(LLVMOps.cpp.inc -gen-op-defs)
 mlir_tablegen(LLVMOpsDialect.h.inc -gen-dialect-decls)
 mlir_tablegen(LLVMOpsDialect.cpp.inc -gen-dialect-defs)
 mlir_tablegen(LLVMOpsEnums.h.inc -gen-enum-decls)
 mlir_tablegen(LLVMOpsEnums.cpp.inc -gen-enum-defs)
 mlir_tablegen(LLVMOpsAttrDefs.h.inc -gen-attrdef-decls
               -attrdefs-dialect=llvm)
 mlir_tablegen(LLVMOpsAttrDefs.cpp.inc -gen-attrdef-defs
               -attrdefs-dialect=llvm)
 add_public_tablegen_target(MLIRLLVMOpsIncGen)
 
+set(LLVM_TARGET_DEFINITIONS LLVMTypes.td)
+mlir_tablegen(LLVMTypes.h.inc -gen-typedef-decls -typedefs-dialect=llvm)
+mlir_tablegen(LLVMTypes.cpp.inc -gen-typedef-defs -typedefs-dialect=llvm)
+add_public_tablegen_target(MLIRLLVMTypesIncGen)
+
 set(LLVM_TARGET_DEFINITIONS LLVMIntrinsicOps.td)
 mlir_tablegen(LLVMIntrinsicOps.h.inc -gen-op-decls)
 mlir_tablegen(LLVMIntrinsicOps.cpp.inc -gen-op-defs)
 add_public_tablegen_target(MLIRLLVMIntrinsicOpsIncGen)
 
 add_mlir_doc(LLVMOps LLVMOps Dialects/ -gen-op-doc)
 add_mlir_doc(LLVMIntrinsicOps LLVMIntrinsicOps Dialects/ -gen-op-doc)
 

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

 //===----------------------------------------------------------------------===//
 // LLVM Dialect.
 //===----------------------------------------------------------------------===//
 
 def LLVM_Dialect : Dialect {
   let name = "llvm";
   let cppNamespace = "::mlir::LLVM";
 
-  let useDefaultTypePrinterParser = 1;
   let useDefaultAttributePrinterParser = 1;
   let hasRegionArgAttrVerify = 1;
   let hasRegionResultAttrVerify = 1;
   let hasOperationAttrVerify = 1;
 
   let extraClassDeclaration = [{
     /// Name of the data layout attributes.
     static StringRef getDataLayoutAttrName() { return "llvm.data_layout"; }
let extraClassDeclaration = [{
     static bool isCompatibleType(Type);
 
     /// Name of the attribute mapped to LLVM's 'readnone' function attribute.
     /// It is allowed on any FunctionOpInterface operations.
     static StringRef getReadnoneAttrName() {
       return "llvm.readnone";
     }
 
+    Type parseType(DialectAsmParser &p) const override;
+    void printType(Type, DialectAsmPrinter &p) const override;
+
   private:
+    /// Register all types.
+    void registerTypes();
+
     /// A cache storing compatible LLVM types that have been verified. This
     /// can save us lots of verification time if there are many occurrences
     /// of some deeply-nested aggregate types in the program.
     ThreadLocalCache<DenseSet<Type>> compatibleTypes;
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // LLVM dialect type constraints.
 //===----------------------------------------------------------------------===//
 
 // LLVM dialect type.
 def LLVM_Type : DialectType<LLVM_Dialect,
                             CPred<"::mlir::LLVM::isCompatibleOuterType($_self)">,
                             "LLVM dialect-compatible type">;
 

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

 struct LLVMFunctionTypeStorage;
 struct LLVMPointerTypeStorage;
 struct LLVMStructTypeStorage;
 struct LLVMTypeAndSizeStorage;
 } // namespace detail
 } // namespace LLVM
 } // namespace mlir
 
+//===----------------------------------------------------------------------===//
+// ODS-Generated Declarations
+//===----------------------------------------------------------------------===//
+
 #include "mlir/Dialect/LLVMIR/LLVMTypeInterfaces.h.inc"
 
+#define GET_TYPEDEF_CLASSES
+#include "mlir/Dialect/LLVMIR/LLVMTypes.h.inc"
+
 namespace mlir {
 namespace LLVM {
 
 //===----------------------------------------------------------------------===//
 // Trivial types.
 //===----------------------------------------------------------------------===//
 
 // Batch-define trivial types.
 #define DEFINE_TRIVIAL_LLVM_TYPE(ClassName)                                    \
   class ClassName : public Type::TypeBase<ClassName, Type, TypeStorage> {      \
   public:                                                                      \
     using Base::Base;                                                          \
   }
 
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMVoidType);
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMPPCFP128Type);
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMX86MMXType);
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMTokenType);
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMLabelType);
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMMetadataType);
 
 #undef DEFINE_TRIVIAL_LLVM_TYPE
 
 //===----------------------------------------------------------------------===//
-// LLVMArrayType.
-//===----------------------------------------------------------------------===//
-
-/// LLVM dialect array type. It is an aggregate type representing consecutive
-/// elements in memory, parameterized by the number of elements and the element
-/// type.
-class LLVMArrayType
-    : public Type::TypeBase<LLVMArrayType, Type, detail::LLVMTypeAndSizeStorage,
-                            DataLayoutTypeInterface::Trait,
-                            SubElementTypeInterface::Trait> {
-public:
-  /// Inherit base constructors.
-  using Base::Base;
-  using Base::getChecked;
-
-  /// Checks if the given type can be used inside an array type.
-  static bool isValidElementType(Type type);
-
-  /// Gets or creates an instance of LLVM dialect array type containing
-  /// `numElements` of `elementType`, in the same context as `elementType`.
-  static LLVMArrayType get(Type elementType, unsigned numElements);
-  static LLVMArrayType getChecked(function_ref<InFlightDiagnostic()> emitError,
-                                  Type elementType, unsigned numElements);
-
-  /// Returns the element type of the array.
-  Type getElementType() const;
-
-  /// Returns the number of elements in the array type.
-  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);
-
-  /// Hooks for DataLayoutTypeInterface. Should not be called directly. Obtain a
-  /// DataLayout instance and query it instead.
-  unsigned getTypeSizeInBits(const DataLayout &dataLayout,
-                             DataLayoutEntryListRef params) const;
-
-  unsigned getTypeSize(const DataLayout &dataLayout,
-                       DataLayoutEntryListRef params) const;
-
-  unsigned getABIAlignment(const DataLayout &dataLayout,
-                           DataLayoutEntryListRef params) const;
-
-  unsigned getPreferredAlignment(const DataLayout &dataLayout,
-                                 DataLayoutEntryListRef params) const;
-
-  void walkImmediateSubElements(function_ref<void(Attribute)> walkAttrsFn,
-                                function_ref<void(Type)> walkTypesFn) const;
-  Type replaceImmediateSubElements(ArrayRef<Attribute> replAttrs,
-                                   ArrayRef<Type> replTypes) const;
-};
-
-//===----------------------------------------------------------------------===//
 // LLVMFunctionType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect function type. It consists of a single return type (unlike MLIR
 /// which can have multiple), a list of parameter types and can optionally be
 /// variadic.
 class LLVMFunctionType : public Type::TypeBase<LLVMFunctionType, Type,
                                                detail::LLVMFunctionTypeStorage,

 namespace detail {
 /// Parses an LLVM dialect type.
 Type parseType(DialectAsmParser &parser);
 
 /// Prints an LLVM Dialect type.
 void printType(Type type, AsmPrinter &printer);
 } // namespace detail
 
+/// Parse any MLIR type or a concise syntax for LLVM types.
+ParseResult parsePrettyLLVMType(AsmParser &p, FailureOr<Type> &type);
+/// Print any MLIR type or a concise syntax for LLVM types.
+void printPrettyLLVMType(AsmPrinter &p, Type type);
+
 //===----------------------------------------------------------------------===//
 // Utility functions.
 //===----------------------------------------------------------------------===//
 
 /// Returns `true` if the given type is compatible with the LLVM dialect. This
 /// is an alias to `LLVMDialect::isCompatibleType`.
 bool isCompatibleType(Type type);
 

 enum class PtrDLEntryPos { Size = 0, Abi = 1, Preferred = 2, Index = 3 };
 
 /// Returns the value that corresponds to named position `pos` from the
 /// data layout entry `attr` assuming it's a dense integer elements attribute.
 /// Returns `None` if `pos` is not present in the entry.
 /// Currently only `PtrDLEntryPos::Index` is optional, and all other positions
 /// may be assumed to be present.
 Optional<unsigned> extractPointerSpecValue(Attribute attr, PtrDLEntryPos pos);
+
 } // namespace LLVM
 } // namespace mlir
 
 #endif // MLIR_DIALECT_LLVMIR_LLVMTYPES_H_

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

+//===-- LLVMOps.td - LLVM IR dialect op definition file ----*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVMTYPES_TD
+#define LLVMTYPES_TD
+
+include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
+include "mlir/IR/AttrTypeBase.td"
+include "mlir/IR/SubElementInterfaces.td"
+include "mlir/Interfaces/DataLayoutInterfaces.td"
+
+/// Base class for all LLVM dialect types.
+class LLVMType<string typeName, string typeMnemonic, list<Trait> traits = []>
+    : TypeDef<LLVM_Dialect, typeName, traits> {
+  let mnemonic = typeMnemonic;
+}
+
+//===----------------------------------------------------------------------===//
+// LLVMArrayType
+//===----------------------------------------------------------------------===//
+
+def LLVMArrayType : LLVMType<"LLVMArray", "array", [
+    DeclareTypeInterfaceMethods<DataLayoutTypeInterface, ["getTypeSize"]>,
+    DeclareTypeInterfaceMethods<SubElementTypeInterface>]> {
+  let summary = "LLVM array type";
+  let description = [{
+    The `!llvm.array` type represents a fixed-size array of element types.
+    It is an aggregate type representing consecutive elements in memory,
+    parameterized by the number of elements and the element type.
+
+    Example:
+
+    ```mlir
+    !llvm.array<4 x i32>
+    ```
+  }];
+
+  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 inside an array type.
+    static bool isValidElementType(Type type);
+  }];
+}
+
+#endif // LLVMTYPES_TD

mlir/lib/Dialect/LLVMIR/CMakeLists.txt

 add_subdirectory(Transforms)
 
 add_mlir_dialect_library(MLIRLLVMDialect
   IR/FunctionCallUtils.cpp
   IR/LLVMDialect.cpp
   IR/LLVMIntrinsicOps.cpp
   IR/LLVMTypes.cpp
   IR/LLVMTypeSyntax.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/LLVMIR
 
   DEPENDS
   MLIRLLVMOpsIncGen
+  MLIRLLVMTypesIncGen
   MLIRLLVMIntrinsicOpsIncGen
   MLIRLLVMOpsInterfacesIncGen
   MLIROpenMPOpsIncGen
   intrinsics_gen
 
   LINK_COMPONENTS
   AsmParser
   BitReader

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

if (getPosition() == insertValueOp.getPosition())
       return insertValueOp.getValue();
     unsigned min =
         std::min(getPosition().size(), insertValueOp.getPosition().size());
     // If one is fully prefix of the other, stop propagating back as it will
     // miss dependencies. For instance, %3 should not fold to %f0 in the
     // following example:
     // ```
     //   %1 = llvm.insertvalue %f0, %0[0, 0] :
-    //     !llvm.array<4 x !llvm.array<4xf32>>
+    //     !llvm.array<4 x !llvm.array<4 x f32>>
     //   %2 = llvm.insertvalue %arr, %1[0] :
-    //     !llvm.array<4 x !llvm.array<4xf32>>
-    //   %3 = llvm.extractvalue %2[0, 0] : !llvm.array<4 x !llvm.array<4xf32>>
+    //     !llvm.array<4 x !llvm.array<4 x f32>>
+    //   %3 = llvm.extractvalue %2[0, 0] : !llvm.array<4 x !llvm.array<4 x f32>>
     // ```
     if (getPosition().take_front(min) ==
         insertValueOp.getPosition().take_front(min))
       return result;
 
     // If neither a prefix, nor the exact position, we can extract out of the
     // value being inserted into. Moreover, we can try again if that operand
     // is itself an insertvalue expression.
addTypes<LLVMVoidType,
            LLVMX86MMXType,
            LLVMTokenType,
            LLVMLabelType,
            LLVMMetadataType,
            LLVMFunctionType,
            LLVMPointerType,
            LLVMFixedVectorType,
            LLVMScalableVectorType,
-           LLVMArrayType,
            LLVMStructType>();
   // clang-format on
+  registerTypes();
+
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/LLVMIR/LLVMOps.cpp.inc"
       ,
 #define GET_OP_LIST
 #include "mlir/Dialect/LLVMIR/LLVMIntrinsicOps.cpp.inc"
       >();
 
   // Support unknown operations because not all LLVM operations are registered.
   allowUnknownOperations();
 }
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/LLVMOps.cpp.inc"
 
-/// Parse a type registered to this dialect.
-Type LLVMDialect::parseType(DialectAsmParser &parser) const {
-  return detail::parseType(parser);
-}
-
-/// Print a type registered to this dialect.
-void LLVMDialect::printType(Type type, DialectAsmPrinter &os) const {
-  return detail::printType(type, os);
-}
-
 LogicalResult LLVMDialect::verifyDataLayoutString(
     StringRef descr, llvm::function_ref<void(const Twine &)> reportError) {
   llvm::Expected<llvm::DataLayout> maybeDataLayout =
       llvm::DataLayout::parse(descr);
   if (maybeDataLayout)
     return success();
 
   std::string message;

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

static void printStructType(AsmPrinter &printer, LLVMStructType type) {
   if (type.isIdentified())
     knownStructNames.pop_back();
   printer << ')';
   printer << '>';
 }
 
 /// Prints a type containing a fixed number of elements.
 template <typename TypeTy>
-static void printArrayOrVectorType(AsmPrinter &printer, TypeTy type) {
+static void printVectorType(AsmPrinter &printer, TypeTy type) {
   printer << '<' << type.getNumElements() << " x ";
   dispatchPrint(printer, type.getElementType());
   printer << '>';
 }
 
 /// Prints a function type.
 static void printFunctionType(AsmPrinter &printer, LLVMFunctionType funcType) {
   printer << '<';
if (auto ptrType = type.dyn_cast<LLVMPointerType>()) {
     dispatchPrint(printer, ptrType.getElementType());
     if (ptrType.getAddressSpace() != 0)
       printer << ", " << ptrType.getAddressSpace();
     printer << '>';
     return;
   }
 
   if (auto arrayType = type.dyn_cast<LLVMArrayType>())
-    return printArrayOrVectorType(printer, arrayType);
+    return arrayType.print(printer);
   if (auto vectorType = type.dyn_cast<LLVMFixedVectorType>())
-    return printArrayOrVectorType(printer, vectorType);
+    return printVectorType(printer, vectorType);
 
   if (auto vectorType = type.dyn_cast<LLVMScalableVectorType>()) {
     printer << "<? x " << vectorType.getMinNumElements() << " x ";
     dispatchPrint(printer, vectorType.getElementType());
     printer << '>';
     return;
   }
 
static Type parseVectorType(AsmParser &parser) {
   if (elementType.isSignlessIntOrFloat()) {
     parser.emitError(typePos)
         << "cannot use !llvm.vec for built-in primitives, use 'vector' instead";
     return Type();
   }
   return parser.getChecked<LLVMFixedVectorType>(loc, elementType, dims[0]);
 }
 
-/// Parses an LLVM dialect array type.
-///   llvm-type ::= `array<` integer `x` llvm-type `>`
-static LLVMArrayType parseArrayType(AsmParser &parser) {
-  SmallVector<int64_t, 1> dims;
-  SMLoc sizePos;
-  Type elementType;
-  SMLoc loc = parser.getCurrentLocation();
-  if (parser.parseLess() || parser.getCurrentLocation(&sizePos) ||
-      parser.parseDimensionList(dims, /*allowDynamic=*/false) ||
-      dispatchParse(parser, elementType) || parser.parseGreater())
-    return LLVMArrayType();
-
-  if (dims.size() != 1) {
-    parser.emitError(sizePos) << "expected ? x <type>";
-    return LLVMArrayType();
-  }
-
-  return parser.getChecked<LLVMArrayType>(loc, elementType, dims[0]);
-}
-
 /// 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,
                                        ArrayRef<Type> subtypes, bool isPacked,
                                        AsmParser &parser, SMLoc subtypesLoc) {
   for (Type t : subtypes) {
     if (!LLVMStructType::isValidElementType(t)) {
       parser.emitError(subtypesLoc)
return StringSwitch<function_ref<Type()>>(key)
       .Case("ppc_fp128", [&] { return LLVMPPCFP128Type::get(ctx); })
       .Case("x86_mmx", [&] { return LLVMX86MMXType::get(ctx); })
       .Case("token", [&] { return LLVMTokenType::get(ctx); })
       .Case("label", [&] { return LLVMLabelType::get(ctx); })
       .Case("metadata", [&] { return LLVMMetadataType::get(ctx); })
       .Case("func", [&] { return parseFunctionType(parser); })
       .Case("ptr", [&] { return parsePointerType(parser); })
       .Case("vec", [&] { return parseVectorType(parser); })
-      .Case("array", [&] { return parseArrayType(parser); })
+      .Case("array", [&] { return LLVMArrayType::parse(parser); })
       .Case("struct", [&] { return parseStructType(parser); })
       .Default([&] {
         parser.emitError(keyLoc) << "unknown LLVM type: " << key;
         return Type();
       })();
 }
 
 /// Helper to use in parse lists.
Type mlir::LLVM::detail::parseType(DialectAsmParser &parser) {
   if (!type)
     return type;
   if (!isCompatibleOuterType(type)) {
     parser.emitError(loc) << "unexpected type, expected keyword";
     return nullptr;
   }
   return type;
 }
+
+ParseResult LLVM::parsePrettyLLVMType(AsmParser &p, FailureOr<Type> &type) {
+  type.emplace();
+  return dispatchParse(p, *type);
+}
+
+void LLVM::printPrettyLLVMType(AsmPrinter &p, Type type) {
+  return dispatchPrint(p, type);
+}

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

 #include "llvm/Support/TypeSize.h"
 
 using namespace mlir;
 using namespace mlir::LLVM;
 
 constexpr const static unsigned kBitsInByte = 8;
 
 //===----------------------------------------------------------------------===//
-// Array type.
+// LLVMArrayType
 //===----------------------------------------------------------------------===//
 
 bool LLVMArrayType::isValidElementType(Type type) {
   return !type.isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
                    LLVMFunctionType, LLVMTokenType, LLVMScalableVectorType>();
 }
 
 LLVMArrayType LLVMArrayType::get(Type elementType, unsigned numElements) {
   assert(elementType && "expected non-null subtype");
   return Base::get(elementType.getContext(), elementType, numElements);
 }
 
 LLVMArrayType
 LLVMArrayType::getChecked(function_ref<InFlightDiagnostic()> emitError,
                           Type elementType, unsigned numElements) {
   assert(elementType && "expected non-null subtype");
   return Base::getChecked(emitError, elementType.getContext(), elementType,
                           numElements);
 }
 
-Type LLVMArrayType::getElementType() const { return getImpl()->elementType; }
-
-unsigned LLVMArrayType::getNumElements() const {
-  return getImpl()->numElements;
-}
-
 LogicalResult
 LLVMArrayType::verify(function_ref<InFlightDiagnostic()> emitError,
                       Type elementType, unsigned numElements) {
   if (!isValidElementType(elementType))
     return emitError() << "invalid array element type: " << elementType;
   return success();
 }
 
+//===----------------------------------------------------------------------===//
+// DataLayoutTypeInterface
+
 unsigned LLVMArrayType::getTypeSizeInBits(const DataLayout &dataLayout,
                                           DataLayoutEntryListRef params) const {
   return kBitsInByte * getTypeSize(dataLayout, params);
 }
 
 unsigned LLVMArrayType::getTypeSize(const DataLayout &dataLayout,
                                     DataLayoutEntryListRef params) const {
   return llvm::alignTo(dataLayout.getTypeSize(getElementType()),
                        dataLayout.getTypeABIAlignment(getElementType())) *
          getNumElements();
 }
 
 unsigned LLVMArrayType::getABIAlignment(const DataLayout &dataLayout,
                                         DataLayoutEntryListRef params) const {
   return dataLayout.getTypeABIAlignment(getElementType());
 }
 
 unsigned
 LLVMArrayType::getPreferredAlignment(const DataLayout &dataLayout,
                                      DataLayoutEntryListRef params) const {
   return dataLayout.getTypePreferredAlignment(getElementType());
 }
 
+//===----------------------------------------------------------------------===//
+// SubElementTypeInterface
+
 void LLVMArrayType::walkImmediateSubElements(
     function_ref<void(Attribute)> walkAttrsFn,
     function_ref<void(Type)> walkTypesFn) const {
   walkTypesFn(getElementType());
 }
 
 Type LLVMArrayType::replaceImmediateSubElements(
     ArrayRef<Attribute> replAttrs, ArrayRef<Type> replTypes) const {
return llvm::TypeSwitch<Type, llvm::TypeSize>(type)
         assert((ty.isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
                        LLVMTokenType, LLVMStructType, LLVMArrayType,
                        LLVMPointerType, LLVMFunctionType>()) &&
                "unexpected missing support for primitive type");
         return llvm::TypeSize::Fixed(0);
       });
 }
 
+//===----------------------------------------------------------------------===//
+// ODS-Generated Definitions
+//===----------------------------------------------------------------------===//
+
+/// These are unused for now.
+/// TODO: Move over to these once more types have been migrated to TypeDef.
+LLVM_ATTRIBUTE_UNUSED static OptionalParseResult
+generatedTypeParser(AsmParser &parser, StringRef *mnemonic, Type &value);
+LLVM_ATTRIBUTE_UNUSED static LogicalResult
+generatedTypePrinter(Type def, AsmPrinter &printer);
+
 #include "mlir/Dialect/LLVMIR/LLVMTypeInterfaces.cpp.inc"
+
+#define GET_TYPEDEF_CLASSES
+#include "mlir/Dialect/LLVMIR/LLVMTypes.cpp.inc"
+
+//===----------------------------------------------------------------------===//
+// LLVMDialect
+//===----------------------------------------------------------------------===//
+
+void LLVMDialect::registerTypes() {
+  addTypes<
+#define GET_TYPEDEF_LIST
+#include "mlir/Dialect/LLVMIR/LLVMTypes.cpp.inc"
+      >();
+}
+
+Type LLVMDialect::parseType(DialectAsmParser &parser) const {
+  return detail::parseType(parser);
+}
+
+void LLVMDialect::printType(Type type, DialectAsmPrinter &os) const {
+  return detail::printType(type, os);
+}

mlir/test/CAPI/llvm.c

static void testTypeCreation(MlirContext ctx) {
 
   const char *voidt_text = "!llvm.void";
   MlirType voidt = mlirLLVMVoidTypeGet(ctx);
   MlirType voidt_ref =
       mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(voidt_text));
   // CHECK: !llvm.void: 1
   fprintf(stderr, "%s: %d\n", voidt_text, mlirTypeEqual(voidt, voidt_ref));
 
-  const char *i32_4_text = "!llvm.array<4xi32>";
+  const char *i32_4_text = "!llvm.array<4 x i32>";
   MlirType i32_4 = mlirLLVMArrayTypeGet(i32, 4);
   MlirType i32_4_ref =
       mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(i32_4_text));
-  // CHECK: !llvm.array<4xi32>: 1
+  // CHECK: !llvm.array<4 x i32>: 1
   fprintf(stderr, "%s: %d\n", i32_4_text, mlirTypeEqual(i32_4, i32_4_ref));
 
   const char *i8_i32_i64_text = "!llvm.func<i8 (i32, i64)>";
   const MlirType i32_i64_arr[] = {i32, i64};
   MlirType i8_i32_i64 = mlirLLVMFunctionTypeGet(i8, 2, i32_i64_arr, false);
   MlirType i8_i32_i64_ref =
       mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(i8_i32_i64_text));
   // CHECK: !llvm.func<i8 (i32, i64)>: 1

 int main() {
   MlirContext ctx = mlirContextCreate();
   mlirDialectHandleRegisterDialect(mlirGetDialectHandle__llvm__(), ctx);
   mlirContextGetOrLoadDialect(ctx, mlirStringRefCreateFromCString("llvm"));
   testTypeCreation(ctx);
   mlirContextDestroy(ctx);
   return 0;
 }
-

mlir/test/Dialect/LLVMIR/canonicalize.mlir

llvm.func @fold_extractvalue() -> i32 {
   //     CHECK: llvm.add %[[C0]], %[[C1]]
   %5 = llvm.add %3, %4 : i32
   llvm.return %5 : i32
 }
 
 // -----
 
 // CHECK-LABEL: no_fold_extractvalue
-llvm.func @no_fold_extractvalue(%arr: !llvm.array<4xf32>) -> f32 {
+llvm.func @no_fold_extractvalue(%arr: !llvm.array<4 x f32>) -> f32 {
   %f0 = arith.constant 0.0 : f32
-  %0 = llvm.mlir.undef : !llvm.array<4 x !llvm.array<4xf32>>
+  %0 = llvm.mlir.undef : !llvm.array<4 x !llvm.array<4 x f32>>
 
   // CHECK: insertvalue
   // CHECK: insertvalue
   // CHECK: extractvalue
-  %1 = llvm.insertvalue %f0, %0[0, 0] : !llvm.array<4 x !llvm.array<4xf32>>
-  %2 = llvm.insertvalue %arr, %1[0] : !llvm.array<4 x !llvm.array<4xf32>>
-  %3 = llvm.extractvalue %2[0, 0] : !llvm.array<4 x !llvm.array<4xf32>>
+  %1 = llvm.insertvalue %f0, %0[0, 0] : !llvm.array<4 x !llvm.array<4 x f32>>
+  %2 = llvm.insertvalue %arr, %1[0] : !llvm.array<4 x !llvm.array<4 x f32>>
+  %3 = llvm.extractvalue %2[0, 0] : !llvm.array<4 x !llvm.array<4 x f32>>
 
   llvm.return %3 : f32
 
 }
 // -----
 
 // CHECK-LABEL: fold_unrelated_extractvalue
-llvm.func @fold_unrelated_extractvalue(%arr: !llvm.array<4xf32>) -> f32 {
+llvm.func @fold_unrelated_extractvalue(%arr: !llvm.array<4 x f32>) -> f32 {
   %f0 = arith.constant 0.0 : f32
   // CHECK-NOT: insertvalue
   // CHECK: extractvalue
-  %2 = llvm.insertvalue %f0, %arr[0] : !llvm.array<4xf32>
-  %3 = llvm.extractvalue %2[1] : !llvm.array<4xf32>
+  %2 = llvm.insertvalue %f0, %arr[0] : !llvm.array<4 x f32>
+  %3 = llvm.extractvalue %2[1] : !llvm.array<4 x f32>
   llvm.return %3 : f32
 }
 
 // -----
 
 // CHECK-LABEL: fold_bitcast
 // CHECK-SAME: %[[a0:arg[0-9]+]]
 // CHECK-NEXT: llvm.return %[[a0]]

 }
 
 // -----
 
 // CHECK-LABEL: load_dce
 // CHECK-NEXT: llvm.return
 llvm.func @load_dce(%x : !llvm.ptr<i8>) {
   %0 = llvm.load %x : !llvm.ptr<i8>
-  llvm.return 
+  llvm.return
 }
 
 llvm.mlir.global external @fp() : !llvm.ptr<i8>
 
 // CHECK-LABEL: addr_dce
 // CHECK-NEXT: llvm.return
 llvm.func @addr_dce(%x : !llvm.ptr<i8>) {
   %0 = llvm.mlir.addressof @fp : !llvm.ptr<ptr<i8>>
-  llvm.return 
+  llvm.return
 }
 
 // CHECK-LABEL: alloca_dce
 // CHECK-NEXT: llvm.return
 llvm.func @alloca_dce() {
   %c1_i64 = arith.constant 1 : i64
   %0 = llvm.alloca %c1_i64 x i32 : (i64) -> !llvm.ptr<i32>
-  llvm.return 
+  llvm.return
 }

mlir/test/Dialect/LLVMIR/roundtrip.mlir

// CHECK: "llvm.intr.memcpy.inline"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i64, i1) -> ()
   "llvm.intr.memcpy.inline"(%arg2, %arg3, %sz, %arg4) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i64, i1) -> ()
 
 // CHECK:  llvm.return
   llvm.return
 }
 
 // CHECK-LABEL: @gep
 llvm.func @gep(%ptr: !llvm.ptr<struct<(i32, struct<(i32, f32)>)>>, %idx: i64,
-               %ptr2: !llvm.ptr<struct<(array<10xf32>)>>) {
+               %ptr2: !llvm.ptr<struct<(array<10 x f32>)>>) {
   // CHECK: llvm.getelementptr %{{.*}}[%{{.*}}, 1, 0] : (!llvm.ptr<struct<(i32, struct<(i32, f32)>)>>, i64) -> !llvm.ptr<i32>
   llvm.getelementptr %ptr[%idx, 1, 0] : (!llvm.ptr<struct<(i32, struct<(i32, f32)>)>>, i64) -> !llvm.ptr<i32>
   // CHECK: llvm.getelementptr %{{.*}}[%{{.*}}, 0, %{{.*}}] : (!llvm.ptr<struct<(array<10 x f32>)>>, i64, i64) -> !llvm.ptr<f32>
   llvm.getelementptr %ptr2[%idx, 0, %idx] : (!llvm.ptr<struct<(array<10 x f32>)>>, i64, i64) -> !llvm.ptr<f32>
   llvm.return
 }
 
 // An larger self-contained function.

mlir/test/Target/LLVMIR/llvmir.mlir

 llvm.mlir.global available_externally @available_externally(42 : i32) : i32
 // CHECK: @linkonce = linkonce global i32 42
 llvm.mlir.global linkonce @linkonce(42 : i32) : i32
 // CHECK: @weak = weak global i32 42
 llvm.mlir.global weak @weak(42 : i32) : i32
 // CHECK: @common = common global i32 0
 llvm.mlir.global common @common(0 : i32) : i32
 // CHECK: @appending = appending global [3 x i32] [i32 1, i32 2, i32 3]
-llvm.mlir.global appending @appending(dense<[1,2,3]> : tensor<3xi32>) : !llvm.array<3xi32>
+llvm.mlir.global appending @appending(dense<[1,2,3]> : tensor<3xi32>) : !llvm.array<3 x i32>
 // CHECK: @extern_weak = extern_weak global i32
 llvm.mlir.global extern_weak @extern_weak() : i32
 // CHECK: @linkonce_odr = linkonce_odr global i32 42
 llvm.mlir.global linkonce_odr @linkonce_odr(42 : i32) : i32
 // CHECK: @weak_odr = weak_odr global i32 42
 llvm.mlir.global weak_odr @weak_odr(42 : i32) : i32
 // CHECK: @external = external global i32
 llvm.mlir.global external @external() : i32

 // CHECK-NEXT: fneg float %0
   %19 = llvm.fneg %arg0 : f32
 
   llvm.return %10 : !llvm.struct<(f32, i32)>
 }
 
 // CHECK-LABEL: @gep
 llvm.func @gep(%ptr: !llvm.ptr<struct<(i32, struct<(i32, f32)>)>>, %idx: i64,
-               %ptr2: !llvm.ptr<struct<(array<10xf32>)>>) {
+               %ptr2: !llvm.ptr<struct<(array<10 x f32>)>>) {
   // CHECK: = getelementptr { i32, { i32, float } }, ptr %{{.*}}, i64 %{{.*}}, i32 1, i32 0
   llvm.getelementptr %ptr[%idx, 1, 0] : (!llvm.ptr<struct<(i32, struct<(i32, f32)>)>>, i64) -> !llvm.ptr<i32>
   // CHECK: = getelementptr { [10 x float] }, ptr %{{.*}}, i64 %{{.*}}, i32 0, i64 %{{.*}}
-  llvm.getelementptr %ptr2[%idx, 0, %idx] : (!llvm.ptr<struct<(array<10xf32>)>>, i64, i64) -> !llvm.ptr<f32>
+  llvm.getelementptr %ptr2[%idx, 0, %idx] : (!llvm.ptr<struct<(array<10 x f32>)>>, i64, i64) -> !llvm.ptr<f32>
   llvm.return
 }
 
 //
 // Indirect function calls
 //
 
 // CHECK-LABEL: define void @indirect_const_call(i64 {{%.*}})