[mlir] Remove LLVMType, LLVM dialect types now derive Type directly

[ftynse]

Summary

BEGIN_PUBLIC
[mlir] Remove LLVMType, LLVM dialect types now derive Type directly

This class has become a simple isa hook with no proper functionality.
Removing will allow us to eventually make the LLVM dialect type infrastructure
open, i.e., support non-LLVM types inside container types, which itself will
make the type conversion more progressive.

Introduce a call LLVM::isCompatibleType to be used instead of
isa<LLVMType>. For now, this is strictly equivalent.
END_PUBLIC

Depends On D93681

[mehdi_amini]

mlir/docs/Tutorials/Toy/Ch-6.md

40

It isn't clear

43

I don't think this is correct, shouldn't it be something like: LLVM::LLVMIntegerType::get(context, 32);?
(also I think it belongs to the parent revision)

[ftynse]

Rebase

[ftynse]

Address review

[ftynse]

Address review

mlir/docs/Tutorials/Toy/Ch-6.md

static FlatSymbolRefAttr getOrInsertPrintf(PatternRewriter &rewriter,
                                            ModuleOp module,
                                            LLVM::LLVMDialect *llvmDialect) {
   auto *context = module.getContext();
   if (module.lookupSymbol<LLVM::LLVMFuncOp>("printf"))
     return SymbolRefAttr::get("printf", context);
 
   // Create a function declaration for printf, the signature is:
   //   * `i32 (i8*, ...)`
-  auto llvmI32Ty = LLVM::LLVMType::getInt32Ty(llvmDialect);
-  auto llvmI8PtrTy = LLVM::LLVMType::getInt8PtrTy(llvmDialect);
-  auto llvmFnType = LLVM::LLVMType::getFunctionTy(llvmI32Ty, llvmI8PtrTy,
+  auto llvmI32Ty = Type::getInt32Ty(llvmDialect);
+  auto llvmI8PtrTy = Type::getInt8PtrTy(llvmDialect);
+  auto llvmFnType = Type::getFunctionTy(llvmI32Ty, llvmI8PtrTy,
                                                   /*isVarArg=*/true);
 
   // Insert the printf function into the body of the parent module.
   PatternRewriter::InsertionGuard insertGuard(rewriter);
   rewriter.setInsertionPointToStart(module.getBody());
   rewriter.create<LLVM::LLVMFuncOp>(module.getLoc(), "printf", llvmFnType);
   return SymbolRefAttr::get("printf", context);
 }
 ```

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h

 
 class BaseMemRefType;
 class ComplexType;
 class LLVMTypeConverter;
 class UnrankedMemRefType;
 
 namespace LLVM {
 class LLVMDialect;
-class LLVMType;
 class LLVMPointerType;
 } // namespace LLVM
 
 /// Callback to convert function argument types. It converts a MemRef function
 /// argument to a list of non-aggregate types containing descriptor
 /// information, and an UnrankedmemRef function argument to a list containing
 /// the rank and a pointer to a descriptor struct.
 LogicalResult structFuncArgTypeConverter(LLVMTypeConverter &converter,
public:
   LLVMTypeConverter(MLIRContext *ctx);
 
   /// Create an LLVMTypeConverter using custom LowerToLLVMOptions.
   LLVMTypeConverter(MLIRContext *ctx, const LowerToLLVMOptions &options);
 
   /// Convert a function type.  The arguments and results are converted one by
   /// one and results are packed into a wrapped LLVM IR structure type. `result`
   /// is populated with argument mapping.
-  LLVM::LLVMType convertFunctionSignature(FunctionType funcTy, bool isVariadic,
-                                          SignatureConversion &result);
+  Type convertFunctionSignature(FunctionType funcTy, bool isVariadic,
 
   /// Convert a non-empty list of types to be returned from a function into a
   /// supported LLVM IR type.  In particular, if more than one value is
   /// returned, create an LLVM IR structure type with elements that correspond
   /// to each of the MLIR types converted with `convertType`.
   Type packFunctionResults(ArrayRef<Type> types);
 
   /// Convert a type in the context of the default or bare pointer calling
public:
   /// Promote the LLVM struct representation of one MemRef descriptor to stack
   /// and use pointer to struct to avoid the complexity of the platform-specific
   /// C/C++ ABI lowering related to struct argument passing.
   Value promoteOneMemRefDescriptor(Location loc, Value operand,
                                    OpBuilder &builder);
 
   /// Converts the function type to a C-compatible format, in particular using
   /// pointers to memref descriptors for arguments.
-  LLVM::LLVMType convertFunctionTypeCWrapper(FunctionType type);
+  Type convertFunctionTypeCWrapper(FunctionType type);
 
   /// Returns the data layout to use during and after conversion.
   const llvm::DataLayout &getDataLayout() { return options.dataLayout; }
 
   /// Gets the LLVM representation of the index type. The returned type is an
   /// integer type with the size configured for this type converter.
-  LLVM::LLVMType getIndexType();
+  Type getIndexType();
 
   /// Gets the bitwidth of the index type when converted to LLVM.
   unsigned getIndexTypeBitwidth() { return options.indexBitwidth; }
 
   /// Gets the pointer bitwidth.
   unsigned getPointerBitwidth(unsigned addressSpace = 0);
 
 protected:
private:
   ///
   /// For example, memref<?x?xf32> is converted to the following list:
   /// - `!llvm<"float*">` (allocated pointer),
   /// - `!llvm<"float*">` (aligned pointer),
   /// - `!llvm.i64` (offset),
   /// - `!llvm.i64`, `!llvm.i64` (sizes),
   /// - `!llvm.i64`, `!llvm.i64` (strides).
   /// These types can be recomposed to a memref descriptor struct.
-  SmallVector<LLVM::LLVMType, 5>
-  getMemRefDescriptorFields(MemRefType type, bool unpackAggregates);
+  SmallVector<Type, 5> getMemRefDescriptorFields(MemRefType type,
+                                                 bool unpackAggregates);
 
   /// Convert an unranked memref type into a list of non-aggregate LLVM IR types
   /// that will form the unranked memref descriptor. In particular, this list
   /// contains:
   /// - an integer rank, followed by
   /// - a pointer to the memref descriptor struct.
   /// For example, memref<*xf32> is converted to the following list:
   /// !llvm.i64 (rank)
   /// !llvm<"i8*"> (type-erased pointer).
   /// These types can be recomposed to a unranked memref descriptor struct.
-  SmallVector<LLVM::LLVMType, 2> getUnrankedMemRefDescriptorFields();
+  SmallVector<Type, 2> getUnrankedMemRefDescriptorFields();
 
   // Convert an unranked memref type to an LLVM type that captures the
   // runtime rank and a pointer to the static ranked memref desc
   Type convertUnrankedMemRefType(UnrankedMemRefType type);
 
   /// Convert a memref type to a bare pointer to the memref element type.
   Type convertMemRefToBarePtr(BaseMemRefType type);
 
public:
 
   /// TODO: The following accessors don't take alignment rules between elements
   /// of the descriptor struct into account. For some architectures, it might be
   /// necessary to extend them and to use `llvm::DataLayout` contained in
   /// `LLVMTypeConverter`.
 
   /// Builds IR extracting the allocated pointer from the descriptor.
   static Value allocatedPtr(OpBuilder &builder, Location loc,
-                            Value memRefDescPtr, LLVM::LLVMType elemPtrPtrType);
+                            Value memRefDescPtr, Type elemPtrPtrType);
   /// Builds IR inserting the allocated pointer into the descriptor.
   static void setAllocatedPtr(OpBuilder &builder, Location loc,
-                              Value memRefDescPtr,
-                              LLVM::LLVMType elemPtrPtrType,
+                              Value memRefDescPtr, Type elemPtrPtrType,
                               Value allocatedPtr);
 
   /// Builds IR extracting the aligned pointer from the descriptor.
   static Value alignedPtr(OpBuilder &builder, Location loc,
                           LLVMTypeConverter &typeConverter, Value memRefDescPtr,
-                          LLVM::LLVMType elemPtrPtrType);
+                          Type elemPtrPtrType);
   /// Builds IR inserting the aligned pointer into the descriptor.
   static void setAlignedPtr(OpBuilder &builder, Location loc,
                             LLVMTypeConverter &typeConverter,
-                            Value memRefDescPtr, LLVM::LLVMType elemPtrPtrType,
+                            Value memRefDescPtr, Type elemPtrPtrType,
                             Value alignedPtr);
 
   /// Builds IR extracting the offset from the descriptor.
   static Value offset(OpBuilder &builder, Location loc,
                       LLVMTypeConverter &typeConverter, Value memRefDescPtr,
-                      LLVM::LLVMType elemPtrPtrType);
+                      Type elemPtrPtrType);
   /// Builds IR inserting the offset into the descriptor.
   static void setOffset(OpBuilder &builder, Location loc,
                         LLVMTypeConverter &typeConverter, Value memRefDescPtr,
-                        LLVM::LLVMType elemPtrPtrType, Value offset);
+                        Type elemPtrPtrType, Value offset);
 
   /// Builds IR extracting the pointer to the first element of the size array.
   static Value sizeBasePtr(OpBuilder &builder, Location loc,
                            LLVMTypeConverter &typeConverter,
                            Value memRefDescPtr,
                            LLVM::LLVMPointerType elemPtrPtrType);
   /// Builds IR extracting the size[index] from the descriptor.
   static Value size(OpBuilder &builder, Location loc,

 protected:
   /// Returns the LLVM dialect.
   LLVM::LLVMDialect &getDialect() const;
 
   LLVMTypeConverter *getTypeConverter() const;
 
   /// Gets the MLIR type wrapping the LLVM integer type whose bit width is
   /// defined by the used type converter.
-  LLVM::LLVMType getIndexType() const;
+  Type getIndexType() const;
 
   /// Gets the MLIR type wrapping the LLVM integer type whose bit width
   /// corresponds to that of a LLVM pointer type.
-  LLVM::LLVMType getIntPtrType(unsigned addressSpace = 0) const;
+  Type getIntPtrType(unsigned addressSpace = 0) const;
 
   /// Gets the MLIR type wrapping the LLVM void type.
-  LLVM::LLVMType getVoidType() const;
+  Type getVoidType() const;
 
   /// Get the MLIR type wrapping the LLVM i8* type.
-  LLVM::LLVMType getVoidPtrType() const;
+  Type getVoidPtrType() const;
 
   /// Create an LLVM dialect operation defining the given index constant.
   Value createIndexConstant(ConversionPatternRewriter &builder, Location loc,
                             uint64_t value) const;
 
   // This is a strided getElementPtr variant that linearizes subscripts as:
   //   `base_offset + index_0 * stride_0 + ... + index_n * stride_n`.
   Value getStridedElementPtr(Location loc, MemRefType type, Value memRefDesc,

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

 }
 
 //===----------------------------------------------------------------------===//
 // LLVM dialect type constraints.
 //===----------------------------------------------------------------------===//
 
 // LLVM dialect type.
 def LLVM_Type : DialectType<LLVM_Dialect,
-                            CPred<"$_self.isa<::mlir::LLVM::LLVMType>()">,
-                            "LLVM dialect type">;
+                            CPred<"::mlir::LLVM::isCompatibleType($_self)">,
+                            "LLVM dialect-compatible type">;
 
 // Type constraint accepting LLVM integer types.
 def LLVM_AnyInteger : Type<
   CPred<"$_self.isa<::mlir::LLVM::LLVMIntegerType>()">,
   "LLVM integer type">;
 
 // Type constraints accepting LLVM integer type of a specific width.
 class LLVM_IntBase<int width> :
list<string> lst = !foreach(x, values,
                               !subst("$0", !cast<string>(x), pattern));
 }
 
 // Patterns with code obtaining the LLVM IR type of the given operand or result
 // of operation. "$0" is expected to be replaced by the position of the operand
 // or result in the operation.
 def LLVM_IntrPatterns {
   string operand =
-    [{convertType(opInst.getOperand($0).getType().cast<LLVM::LLVMType>())}];
+    [{convertType(opInst.getOperand($0).getType())}];
   string result =
-    [{convertType(opInst.getResult($0).getType().cast<LLVM::LLVMType>())}];
+    [{convertType(opInst.getResult($0).getType())}];
   string structResult =
     [{convertType(opInst.getResult(0).getType().cast<LLVM::LLVMStructType>()
                                                    .getBody()[$0])}];
 }
 
 
 // Base class for LLVM intrinsics operation. It is similar to LLVM_Op, but
 // provides the "llvmBuilder" field for constructing the intrinsic.

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

def LLVM_ZeroResultOpBuilder :
   }]>;
 
 // Compatibility builder that takes an instance of wrapped llvm::VoidType
 // to indicate no result.
 def LLVM_VoidResultTypeOpBuilder :
   OpBuilderDAG<(ins "Type":$resultType, "ValueRange":$operands,
     CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
   [{
-    auto llvmType = resultType.dyn_cast<LLVMType>(); (void)llvmType;
-    assert(llvmType && "result must be an LLVM type");
-    assert(llvmType.isa<LLVMVoidType>() &&
+    assert(isCompatibleType(resultType) && "result must be an LLVM type");
+    assert(resultType.isa<LLVMVoidType>() &&
            "for zero-result operands, only 'void' is accepted as result type");
     build($_builder, $_state, operands, attributes);
   }]>;
 
 
 // Opaque builder used for terminator operations that contain successors.
 def LLVM_TerminatorPassthroughOpBuilder :
   OpBuilderDAG<(ins "ValueRange":$operands, "SuccessorRange":$destinations,
def LLVM_CallOp : LLVM_Op<"call"> {
   }];
   let arguments = (ins OptionalAttr<FlatSymbolRefAttr>:$callee,
                    Variadic<LLVM_Type>);
   let results = (outs Variadic<LLVM_Type>);
   let builders = [
     OpBuilderDAG<(ins "LLVMFuncOp":$func, "ValueRange":$operands,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
     [{
-      LLVMType resultType = func.getType().getReturnType();
+      Type resultType = func.getType().getReturnType();
       if (!resultType.isa<LLVM::LLVMVoidType>())
         $_state.addTypes(resultType);
       $_state.addAttribute("callee", $_builder.getSymbolRefAttr(func));
       $_state.addAttributes(attributes);
       $_state.addOperands(operands);
     }]>];
   let verifier = [{ return ::verify(*this); }];
   let parser = [{ return parseCallOp(parser, result); }];
let description = [{
     }
 
     // Define the global.
     llvm.mlir.global @const(42 : i32) : !llvm.i32
     ```
   }];
 
   let builders = [
-    OpBuilderDAG<(ins "LLVMType":$resType, "StringRef":$name,
-      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
-    [{
-      $_state.addAttribute("global_name",$_builder.getSymbolRefAttr(name));
-      $_state.addAttributes(attrs);
-      $_state.addTypes(resType);}]>,
     OpBuilderDAG<(ins "GlobalOp":$global,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
     [{
       build($_builder, $_state,
             LLVM::LLVMPointerType::get(global.getType(), global.addr_space()),
-            global.sym_name(), attrs);}]>,
+            global.sym_name());
+      $_state.addAttributes(attrs);
+    }]>,
     OpBuilderDAG<(ins "LLVMFuncOp":$func,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
     [{
       build($_builder, $_state,
-            LLVM::LLVMPointerType::get(func.getType()), func.getName(), attrs);}]>
+            LLVM::LLVMPointerType::get(func.getType()), func.getName());
+      $_state.addAttributes(attrs);
+    }]>
   ];
 
   let extraClassDeclaration = [{
     /// Return the llvm.mlir.global operation that defined the value referenced
     /// here.
     GlobalOp getGlobal();
 
     /// Return the llvm.func operation that is referenced here.
let description = [{
     // By default, "external" linkage is assumed and the global participates in
     // symbol resolution at link-time.
     llvm.mlir.global @glob(0 : f32) : !llvm.float
     ```
   }];
   let regions = (region AnyRegion:$initializer);
 
   let builders = [
-    OpBuilderDAG<(ins "LLVMType":$type, "bool":$isConstant, "Linkage":$linkage,
+    OpBuilderDAG<(ins "Type":$type, "bool":$isConstant, "Linkage":$linkage,
       "StringRef":$name, "Attribute":$value, CArg<"unsigned", "0">:$addrSpace,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = [{
     /// Return the LLVM type of the global.
-    LLVMType getType() {
-      return type().cast<LLVMType>();
+    Type getType() {
+      return type();
     }
     /// Return the initializer attribute if it exists, or a null attribute.
     Attribute getValueOrNull() {
       return value().getValueOr(Attribute());
     }
     /// Return the initializer region. This may be empty, but if it is not it
     /// terminates in an `llvm.return` op with the initializer value.
     Region &getInitializerRegion() {
let arguments = (ins DefaultValuedAttr<Linkage, "Linkage::External">:$linkage,
                    OptionalAttr<FlatSymbolRefAttr>:$personality,
                    OptionalAttr<ArrayAttr>:$passthrough);
 
   let regions = (region AnyRegion:$body);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
-    OpBuilderDAG<(ins "StringRef":$name, "LLVMType":$type,
+    OpBuilderDAG<(ins "StringRef":$name, "Type":$type,
       CArg<"Linkage", "Linkage::External">:$linkage,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs,
       CArg<"ArrayRef<MutableDictionaryAttr>", "{}">:$argAttrs)>
   ];
 
   let extraClassDeclaration = [{
     // Add an entry block to an empty function, and set up the block arguments
     // to match the signature of the function.

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

 class LLVMHalfType;
 class LLVMFloatType;
 class LLVMDoubleType;
 class LLVMFP128Type;
 class LLVMX86FP80Type;
 class LLVMIntegerType;
 
 //===----------------------------------------------------------------------===//
-// LLVMType.
-//===----------------------------------------------------------------------===//
-
-/// Base class for LLVM dialect types.
-///
-/// The LLVM dialect in MLIR fully reflects the LLVM IR type system, prodiving a
-/// separate MLIR type for each LLVM IR type. All types are represented as
-/// separate subclasses and are compatible with the isa/cast infrastructure.
-///
-/// The LLVM dialect type system is closed: parametric types can only refer to
-/// other LLVM dialect types. This is consistent with LLVM IR and enables a more
-/// concise pretty-printing format.
-///
-/// Similarly to other MLIR types, LLVM dialect types are owned by the MLIR
-/// context, have an immutable identifier (for most types except identified
-/// structs, the entire type is the identifier) and are thread-safe.
-///
-/// This class is a thin common base class for different types available in the
-/// LLVM dialect. It intentionally does not provide the API similar to
-/// llvm::Type to avoid confusion and highlight potentially expensive operations
-/// (e.g., type creation in MLIR takes a lock, so it's better to cache types).
-class LLVMType : public Type {
-public:
-  /// Inherit base constructors.
-  using Type::Type;
-
-  /// Support for PointerLikeTypeTraits.
-  using Type::getAsOpaquePointer;
-  static LLVMType getFromOpaquePointer(const void *ptr) {
-    return LLVMType(static_cast<ImplType *>(const_cast<void *>(ptr)));
-  }
-
-  /// Support for isa/cast.
-  static bool classof(Type type);
-
-  LLVMDialect &getDialect();
-};
-
-//===----------------------------------------------------------------------===//
 // Trivial types.
 //===----------------------------------------------------------------------===//
 
 // Batch-define trivial types.
 #define DEFINE_TRIVIAL_LLVM_TYPE(ClassName)                                    \
-  class ClassName : public Type::TypeBase<ClassName, LLVMType, TypeStorage> {  \
+  class ClassName : public Type::TypeBase<ClassName, Type, TypeStorage> {      \
   public:                                                                      \
     using Base::Base;                                                          \
   }
 
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMVoidType);
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMHalfType);
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMBFloatType);
 DEFINE_TRIVIAL_LLVM_TYPE(LLVMFloatType);

 
 //===----------------------------------------------------------------------===//
 // 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, LLVMType,
+class LLVMArrayType : public Type::TypeBase<LLVMArrayType, Type,
                                             detail::LLVMTypeAndSizeStorage> {
 public:
   /// Inherit base constructors.
   using Base::Base;
 
   /// Checks if the given type can be used inside an array type.
-  static bool isValidElementType(LLVMType 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(LLVMType elementType, unsigned numElements);
-  static LLVMArrayType getChecked(Location loc, LLVMType elementType,
+  static LLVMArrayType get(Type elementType, unsigned numElements);
+  static LLVMArrayType getChecked(Location loc, Type elementType,
                                   unsigned numElements);
 
   /// Returns the element type of the array.
-  LLVMType getElementType();
+  Type getElementType();
 
   /// Returns the number of elements in the array type.
   unsigned getNumElements();
 
   /// Verifies that the type about to be constructed is well-formed.
   static LogicalResult verifyConstructionInvariants(Location loc,
-                                                    LLVMType elementType,
+                                                    Type elementType,
                                                     unsigned numElements);
 };
 
 //===----------------------------------------------------------------------===//
 // 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, LLVMType,
+    : public Type::TypeBase<LLVMFunctionType, Type,
                             detail::LLVMFunctionTypeStorage> {
 public:
   /// Inherit base constructors.
   using Base::Base;
 
   /// Checks if the given type can be used an argument in a function type.
-  static bool isValidArgumentType(LLVMType type);
+  static bool isValidArgumentType(Type type);
 
   /// Checks if the given type can be used as a result in a function type.
-  static bool isValidResultType(LLVMType type);
+  static bool isValidResultType(Type type);
 
   /// Returns whether the function is variadic.
   bool isVarArg();
 
   /// Gets or creates an instance of LLVM dialect function in the same context
   /// as the `result` type.
-  static LLVMFunctionType get(LLVMType result, ArrayRef<LLVMType> arguments,
+  static LLVMFunctionType get(Type result, ArrayRef<Type> arguments,
                               bool isVarArg = false);
-  static LLVMFunctionType getChecked(Location loc, LLVMType result,
-                                     ArrayRef<LLVMType> arguments,
+  static LLVMFunctionType getChecked(Location loc, Type result,
+                                     ArrayRef<Type> arguments,
                                      bool isVarArg = false);
 
   /// Returns the result type of the function.
-  LLVMType getReturnType();
+  Type getReturnType();
 
   /// Returns the number of arguments to the function.
   unsigned getNumParams();
 
   /// Returns `i`-th argument of the function. Asserts on out-of-bounds.
-  LLVMType getParamType(unsigned i);
+  Type getParamType(unsigned i);
 
   /// Returns a list of argument types of the function.
-  ArrayRef<LLVMType> getParams();
-  ArrayRef<LLVMType> params() { return getParams(); }
+  ArrayRef<Type> getParams();
+  ArrayRef<Type> params() { return getParams(); }
 
   /// Verifies that the type about to be constructed is well-formed.
-  static LogicalResult
-  verifyConstructionInvariants(Location loc, LLVMType result,
-                               ArrayRef<LLVMType> arguments, bool);
+  static LogicalResult verifyConstructionInvariants(Location loc, Type result,
+                                                    ArrayRef<Type> arguments,
+                                                    bool);
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMIntegerType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect signless integer type parameterized by bitwidth.
-class LLVMIntegerType : public Type::TypeBase<LLVMIntegerType, LLVMType,
+class LLVMIntegerType : public Type::TypeBase<LLVMIntegerType, Type,
                                               detail::LLVMIntegerTypeStorage> {
 public:
   /// Inherit base constructor.
   using Base::Base;
 
   /// Gets or creates an instance of the integer of the specified `bitwidth` in
   /// the given context.
   static LLVMIntegerType get(MLIRContext *ctx, unsigned bitwidth);

 
 //===----------------------------------------------------------------------===//
 // LLVMPointerType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect pointer type. This type typically represents a reference to an
 /// object in memory. It is parameterized by the element type and the address
 /// space.
-class LLVMPointerType : public Type::TypeBase<LLVMPointerType, LLVMType,
+class LLVMPointerType : public Type::TypeBase<LLVMPointerType, Type,
                                               detail::LLVMPointerTypeStorage> {
 public:
   /// Inherit base constructors.
   using Base::Base;
 
   /// Checks if the given type can have a pointer type pointing to it.
-  static bool isValidElementType(LLVMType type);
+  static bool isValidElementType(Type type);
 
   /// Gets or creates an instance of LLVM dialect pointer type pointing to an
   /// object of `pointee` type in the given address space. The pointer type is
   /// created in the same context as `pointee`.
-  static LLVMPointerType get(LLVMType pointee, unsigned addressSpace = 0);
-  static LLVMPointerType getChecked(Location loc, LLVMType pointee,
+  static LLVMPointerType get(Type pointee, unsigned addressSpace = 0);
+  static LLVMPointerType getChecked(Location loc, Type pointee,
                                     unsigned addressSpace = 0);
 
   /// Returns the pointed-to type.
-  LLVMType getElementType();
+  Type getElementType();
 
   /// Returns the address space of the pointer.
   unsigned getAddressSpace();
 
   /// Verifies that the type about to be constructed is well-formed.
-  static LogicalResult verifyConstructionInvariants(Location loc,
-                                                    LLVMType pointee, unsigned);
+  static LogicalResult verifyConstructionInvariants(Location loc, Type pointee,
+                                                    unsigned);
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMStructType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect structure type representing a collection of different-typed
 /// elements manipulated together. Structured can optionally be packed, meaning

 /// caller does not intend to ever set the body (e.g. forward-declarations of
 /// structs from another module) and wants to disallow further modification of
 /// the body. For intentionally-opaque structs or non-opaque structs with the
 /// body, one is not allowed to set another body (however, one can set exactly
 /// the same body).
 ///
 /// Note that the packedness of the struct takes place in uniquing of literal
 /// structs, but does not in uniquing of identified structs.
-class LLVMStructType : public Type::TypeBase<LLVMStructType, LLVMType,
+class LLVMStructType : public Type::TypeBase<LLVMStructType, Type,
                                              detail::LLVMStructTypeStorage> {
 public:
   /// Inherit base constructors.
   using Base::Base;
 
   /// Checks if the given type can be contained in a structure type.
-  static bool isValidElementType(LLVMType type);
+  static bool isValidElementType(Type type);
 
   /// Gets or creates an identified struct with the given name in the provided
   /// context. Note that unlike llvm::StructType::create, this function will
   /// _NOT_ rename a struct in case a struct with the same name already exists
   /// in the context. Instead, it will just return the existing struct,
   /// similarly to the rest of MLIR type ::get methods.
   static LLVMStructType getIdentified(MLIRContext *context, StringRef name);
   static LLVMStructType getIdentifiedChecked(Location loc, StringRef name);
 
   /// Gets a new identified struct with the given body. The body _cannot_ be
   /// changed later. If a struct with the given name already exists, renames
   /// the struct by appending a `.` followed by a number to the name. Renaming
   /// happens even if the existing struct has the same body.
   static LLVMStructType getNewIdentified(MLIRContext *context, StringRef name,
-                                         ArrayRef<LLVMType> elements,
+                                         ArrayRef<Type> elements,
                                          bool isPacked = false);
 
   /// Gets or creates a literal struct with the given body in the provided
   /// context.
-  static LLVMStructType getLiteral(MLIRContext *context,
-                                   ArrayRef<LLVMType> types,
+  static LLVMStructType getLiteral(MLIRContext *context, ArrayRef<Type> types,
                                    bool isPacked = false);
-  static LLVMStructType getLiteralChecked(Location loc,
-                                          ArrayRef<LLVMType> types,
+  static LLVMStructType getLiteralChecked(Location loc, ArrayRef<Type> types,
                                           bool isPacked = false);
 
   /// Gets or creates an intentionally-opaque identified struct. Such a struct
   /// cannot have its body set. To create an opaque struct with a mutable body,
   /// use `getIdentified`. Note that unlike llvm::StructType::create, this
   /// function will _NOT_ rename a struct in case a struct with the same name
   /// already exists in the context. Instead, it will just return the existing
   /// struct, similarly to the rest of MLIR type ::get methods.
   static LLVMStructType getOpaque(StringRef name, MLIRContext *context);
   static LLVMStructType getOpaqueChecked(Location loc, StringRef name);
 
   /// Set the body of an identified struct. Returns failure if the body could
   /// not be set, e.g. if the struct already has a body or if it was marked as
   /// intentionally opaque. This might happen in a multi-threaded context when a
   /// different thread modified the struct after it was created. Most callers
   /// are likely to assert this always succeeds, but it is possible to implement
   /// a local renaming scheme based on the result of this call.
-  LogicalResult setBody(ArrayRef<LLVMType> types, bool isPacked);
+  LogicalResult setBody(ArrayRef<Type> types, bool isPacked);
 
   /// Checks if a struct is packed.
   bool isPacked();
 
   /// Checks if a struct is identified.
   bool isIdentified();
 
   /// Checks if a struct is opaque.
   bool isOpaque();
 
   /// Checks if a struct is initialized.
   bool isInitialized();
 
   /// Returns the name of an identified struct.
   StringRef getName();
 
   /// Returns the list of element types contained in a non-opaque struct.
-  ArrayRef<LLVMType> getBody();
+  ArrayRef<Type> getBody();
 
   /// Verifies that the type about to be constructed is well-formed.
   static LogicalResult verifyConstructionInvariants(Location, StringRef, bool);
-  static LogicalResult
-  verifyConstructionInvariants(Location loc, ArrayRef<LLVMType> types, bool);
+  static LogicalResult verifyConstructionInvariants(Location loc,
+                                                    ArrayRef<Type> types, bool);
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMVectorType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect vector type, represents a sequence of elements that can be
 /// processed as one, typically in SIMD context. This is a base class for fixed
 /// and scalable vectors.
-class LLVMVectorType : public LLVMType {
+class LLVMVectorType : public Type {
 public:
   /// Inherit base constructor.
-  using LLVMType::LLVMType;
+  using Type::Type;
 
   /// Support type casting functionality.
   static bool classof(Type type);
 
   /// Checks if the given type can be used in a vector type.
-  static bool isValidElementType(LLVMType type);
+  static bool isValidElementType(Type type);
 
   /// Returns the element type of the vector.
-  LLVMType getElementType();
+  Type getElementType();
 
   /// Returns the number of elements in the vector.
   llvm::ElementCount getElementCount();
 
   /// Verifies that the type about to be constructed is well-formed.
   static LogicalResult verifyConstructionInvariants(Location loc,
-                                                    LLVMType elementType,
+                                                    Type elementType,
                                                     unsigned numElements);
 };
 
 //===----------------------------------------------------------------------===//
 // 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, LLVMVectorType,
                             detail::LLVMTypeAndSizeStorage> {
 public:
   /// Inherit base constructor.
   using Base::Base;
   using LLVMVectorType::verifyConstructionInvariants;
 
   /// Gets or creates a fixed vector type containing `numElements` of
   /// `elementType` in the same context as `elementType`.
-  static LLVMFixedVectorType get(LLVMType elementType, unsigned numElements);
-  static LLVMFixedVectorType getChecked(Location loc, LLVMType elementType,
+  static LLVMFixedVectorType get(Type elementType, unsigned numElements);
+  static LLVMFixedVectorType getChecked(Location loc, Type elementType,
                                         unsigned numElements);
 
   /// Returns the number of elements in the fixed vector.
   unsigned getNumElements();
 };
 
 //===----------------------------------------------------------------------===//
 // 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, LLVMVectorType,
                             detail::LLVMTypeAndSizeStorage> {
 public:
   /// Inherit base constructor.
   using Base::Base;
   using LLVMVectorType::verifyConstructionInvariants;
 
   /// 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(LLVMType elementType,
-                                    unsigned minNumElements);
-  static LLVMScalableVectorType getChecked(Location loc, LLVMType elementType,
+  static LLVMScalableVectorType get(Type elementType, unsigned minNumElements);
+  static LLVMScalableVectorType getChecked(Location loc, Type elementType,
                                            unsigned minNumElements);
 
   /// 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();
 };
 
 //===----------------------------------------------------------------------===//
 // Printing and parsing.
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 /// Parses an LLVM dialect type.
-LLVMType parseType(DialectAsmParser &parser);
+Type parseType(DialectAsmParser &parser);
 
 /// Prints an LLVM Dialect type.
-void printType(LLVMType type, DialectAsmPrinter &printer);
+void printType(Type type, DialectAsmPrinter &printer);
 } // namespace detail
 
 //===----------------------------------------------------------------------===//
 // Utility functions.
 //===----------------------------------------------------------------------===//
 
 /// Returns `true` if the given type is compatible with the LLVM dialect.
-inline bool isCompatibleType(Type type) { return type.isa<LLVMType>(); }
+inline bool isCompatibleType(Type type) {
+  // clang-format off
+  return type.isa<
+      LLVMArrayType,
+      LLVMBFloatType,
+      LLVMDoubleType,
+      LLVMFP128Type,
+      LLVMFloatType,
+      LLVMFunctionType,
+      LLVMHalfType,
+      LLVMIntegerType,
+      LLVMLabelType,
+      LLVMMetadataType,
+      LLVMPPCFP128Type,
+      LLVMPointerType,
+      LLVMStructType,
+      LLVMTokenType,
+      LLVMVectorType,
+      LLVMVoidType,
+      LLVMX86FP80Type,
+      LLVMX86MMXType
+  >();
+  // clang-format on
+}
 
 inline bool isCompatibleFloatingPointType(Type type) {
   return type.isa<LLVMHalfType, LLVMBFloatType, LLVMFloatType, LLVMDoubleType,
                   LLVMFP128Type, LLVMX86FP80Type>();
 }
 
 /// Returns the size of the given primitive LLVM dialect-compatible type
 /// (including vectors) in bits, for example, the size of !llvm.i16 is 16 and
 /// the size of !llvm.vec<4 x i16> is 64. Returns 0 for non-primitive
 /// (aggregates such as struct) or types that don't have a size (such as void).
 llvm::TypeSize getPrimitiveTypeSizeInBits(Type type);
 
 } // namespace LLVM
 } // namespace mlir
 
-//===----------------------------------------------------------------------===//
-// Support for hashing and containers.
-//===----------------------------------------------------------------------===//
-
-namespace llvm {
-
-// LLVMType instances hash just like pointers.
-template <>
-struct DenseMapInfo<mlir::LLVM::LLVMType> {
-  static mlir::LLVM::LLVMType getEmptyKey() {
-    void *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
-    return mlir::LLVM::LLVMType(
-        static_cast<mlir::LLVM::LLVMType::ImplType *>(pointer));
-  }
-  static mlir::LLVM::LLVMType getTombstoneKey() {
-    void *pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
-    return mlir::LLVM::LLVMType(
-        static_cast<mlir::LLVM::LLVMType::ImplType *>(pointer));
-  }
-  static unsigned getHashValue(mlir::LLVM::LLVMType val) {
-    return mlir::hash_value(val);
-  }
-  static bool isEqual(mlir::LLVM::LLVMType lhs, mlir::LLVM::LLVMType rhs) {
-    return lhs == rhs;
-  }
-};
-
-// LLVMType behaves like a pointer similarly to mlir::Type.
-template <>
-struct PointerLikeTypeTraits<mlir::LLVM::LLVMType> {
-  static inline void *getAsVoidPointer(mlir::LLVM::LLVMType type) {
-    return const_cast<void *>(type.getAsOpaquePointer());
-  }
-  static inline mlir::LLVM::LLVMType getFromVoidPointer(void *ptr) {
-    return mlir::LLVM::LLVMType::getFromOpaquePointer(ptr);
-  }
-  static constexpr int NumLowBitsAvailable =
-      PointerLikeTypeTraits<mlir::Type>::NumLowBitsAvailable;
-};
-
-} // namespace llvm
-
 #endif // MLIR_DIALECT_LLVMIR_LLVMTYPES_H_

mlir/include/mlir/Dialect/LLVMIR/ROCDLOps.td

def ROCDL_MubufLoadOp :
   Results<(outs LLVM_Type:$res)>,
   Arguments<(ins LLVM_Type:$rsrc,
                  LLVM_Type:$vindex,
                  LLVM_Type:$offset,
                  LLVM_Type:$glc,
                  LLVM_Type:$slc)>{
   string llvmBuilder = [{
       $res = createIntrinsicCall(builder,
-          llvm::Intrinsic::amdgcn_buffer_load, {$rsrc, $vindex, $offset, $glc, 
+          llvm::Intrinsic::amdgcn_buffer_load, {$rsrc, $vindex, $offset, $glc,
           $slc}, {$_resultType});
   }];
   let parser = [{ return parseROCDLMubufLoadOp(parser, result); }];
-  let printer = [{ 
+  let printer = [{
     Operation *op = this->getOperation();
     p << op->getName() << " " << op->getOperands()
       << " : " << op->getResultTypes();
   }];
 }
 
 def ROCDL_MubufStoreOp :
   ROCDL_Op<"buffer.store">,
   Arguments<(ins LLVM_Type:$vdata,
                  LLVM_Type:$rsrc,
                  LLVM_Type:$vindex,
                  LLVM_Type:$offset,
                  LLVM_Type:$glc,
                  LLVM_Type:$slc)>{
   string llvmBuilder = [{
-    auto vdataType = convertType(op.vdata().getType().cast<LLVM::LLVMType>());
+    auto vdataType = convertType(op.vdata().getType());
     createIntrinsicCall(builder,
           llvm::Intrinsic::amdgcn_buffer_store, {$vdata, $rsrc, $vindex,
           $offset, $glc, $slc}, {vdataType});
   }];
   let parser = [{ return parseROCDLMubufStoreOp(parser, result); }];
   let printer = [{
     Operation *op = this->getOperation();
     p << op->getName() << " " << op->getOperands()
       << " : " << vdata().getType();
   }];
 }
 
 #endif // ROCDLIR_OPS

mlir/include/mlir/Target/LLVMIR/ModuleTranslation.h

protected:
   void convertOmpOpRegions(Region &region,
                            DenseMap<Value, llvm::Value *> &valueMapping,
                            DenseMap<Block *, llvm::BasicBlock *> &blockMapping,
                            llvm::Instruction *codeGenIPBBTI,
                            llvm::BasicBlock &continuationIP,
                            llvm::IRBuilder<> &builder,
                            LogicalResult &bodyGenStatus);
   /// Converts the type from MLIR LLVM dialect to LLVM.
-  llvm::Type *convertType(LLVMType type);
+  llvm::Type *convertType(Type type);
 
   static std::unique_ptr<llvm::Module>
   prepareLLVMModule(Operation *m, llvm::LLVMContext &llvmContext,
                     StringRef name);
 
   /// A helper to look up remapped operands in the value remapping table.
   SmallVector<llvm::Value *, 8> lookupValues(ValueRange values);
 

mlir/include/mlir/Target/LLVMIR/TypeTranslation.h

 namespace llvm {
 class DataLayout;
 class LLVMContext;
 class Type;
 } // namespace llvm
 
 namespace mlir {
 
+class Type;
 class MLIRContext;
 
 namespace LLVM {
 
-class LLVMType;
-
 namespace detail {
 class TypeToLLVMIRTranslatorImpl;
 class TypeFromLLVMIRTranslatorImpl;
 } // namespace detail
 
 /// Utility class to translate MLIR LLVM dialect types to LLVM IR. Stores the
 /// translation state, in particular any identified structure types that can be
 /// reused in further translation.
 class TypeToLLVMIRTranslator {
 public:
   TypeToLLVMIRTranslator(llvm::LLVMContext &context);
   ~TypeToLLVMIRTranslator();
 
   /// Returns the perferred alignment for the type given the data layout. Note
   /// that this will perform type conversion and store its results for future
   /// uses.
   // TODO: this should be removed when MLIR has proper data layout.
-  unsigned getPreferredAlignment(LLVM::LLVMType type,
-                                 const llvm::DataLayout &layout);
+  unsigned getPreferredAlignment(Type type, const llvm::DataLayout &layout);
 
   /// Translates the given MLIR LLVM dialect type to LLVM IR.
-  llvm::Type *translateType(LLVM::LLVMType type);
+  llvm::Type *translateType(Type type);
 
 private:
   /// Private implementation.
   std::unique_ptr<detail::TypeToLLVMIRTranslatorImpl> impl;
 };
 
 /// Utility class to translate LLVM IR types to the MLIR LLVM dialect. Stores
 /// the translation state, in particular any identified structure types that are
 /// reused across translations.
 class TypeFromLLVMIRTranslator {
 public:
   TypeFromLLVMIRTranslator(MLIRContext &context);
   ~TypeFromLLVMIRTranslator();
 
   /// Translates the given LLVM IR type to the MLIR LLVM dialect.
-  LLVM::LLVMType translateType(llvm::Type *type);
+  Type translateType(llvm::Type *type);
 
 private:
   /// Private implementation.
   std::unique_ptr<detail::TypeFromLLVMIRTranslatorImpl> impl;
 };
 
 } // namespace LLVM
 } // namespace mlir
 
 #endif // MLIR_TARGET_LLVMIR_TYPETRANSLATION_H

mlir/lib/Conversion/ArmSVEToLLVM/ArmSVEToLLVM.cpp

 
 using UmmlaOpLowering =
     OneToOneConvertToLLVMPattern<UmmlaOp, LLVM::aarch64_arm_sve_ummla>;
 
 using VectorScaleOpLowering =
     OneToOneConvertToLLVMPattern<VectorScaleOp, LLVM::vector_scale>;
 
 // Extract an LLVM IR type from the LLVM IR dialect type.
-static LLVM::LLVMType unwrap(Type type) {
+static Type unwrap(Type type) {
   if (!type)
     return nullptr;
   auto *mlirContext = type.getContext();
-  auto wrappedLLVMType = type.dyn_cast<LLVM::LLVMType>();
-  if (!wrappedLLVMType)
+  if (!LLVM::isCompatibleType(type))
     emitError(UnknownLoc::get(mlirContext),
               "conversion resulted in a non-LLVM type");
-  return wrappedLLVMType;
+  return type;
 }
 
 static Optional<Type>
 convertScalableVectorTypeToLLVM(ScalableVectorType svType,
                                 LLVMTypeConverter &converter) {
   auto elementType = unwrap(converter.convertType(svType.getElementType()));
   if (!elementType)
     return {};

mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp

struct AsyncAPI {
 
   static FunctionType awaitAllAndExecuteFunctionType(MLIRContext *ctx) {
     auto hdl = LLVM::LLVMPointerType::get(LLVM::LLVMIntegerType::get(ctx, 8));
     auto resume = LLVM::LLVMPointerType::get(resumeFunctionType(ctx));
     return FunctionType::get(ctx, {GroupType::get(ctx), hdl, resume}, {});
   }
 
   // Auxiliary coroutine resume intrinsic wrapper.
-  static LLVM::LLVMType resumeFunctionType(MLIRContext *ctx) {
+  static Type resumeFunctionType(MLIRContext *ctx) {
     auto voidTy = LLVM::LLVMVoidType::get(ctx);
     auto i8Ptr = LLVM::LLVMPointerType::get(LLVM::LLVMIntegerType::get(ctx, 8));
     return LLVM::LLVMFunctionType::get(voidTy, {i8Ptr}, false);
   }
 };
 } // namespace
 
 // Adds Async Runtime C API declarations to the module.

 static constexpr const char *kCoroSave = "llvm.coro.save";
 static constexpr const char *kCoroSuspend = "llvm.coro.suspend";
 static constexpr const char *kCoroEnd = "llvm.coro.end";
 static constexpr const char *kCoroFree = "llvm.coro.free";
 static constexpr const char *kCoroResume = "llvm.coro.resume";
 
 /// Adds an LLVM function declaration to a module.
 static void addLLVMFuncDecl(ModuleOp module, OpBuilder &builder, StringRef name,
-                            LLVM::LLVMType ret,
-                            ArrayRef<LLVM::LLVMType> params) {
+                            Type ret, ArrayRef<Type> params) {
   if (module.lookupSymbol(name))
     return;
-  LLVM::LLVMType type = LLVM::LLVMFunctionType::get(ret, params);
+  Type type = LLVM::LLVMFunctionType::get(ret, params);
   builder.create<LLVM::LLVMFuncOp>(module.getLoc(), name, type);
 }
 
 /// Adds coroutine intrinsics declarations to the module.
 static void addCoroutineIntrinsicsDeclarations(ModuleOp module) {
   using namespace mlir::LLVM;
 
   MLIRContext *ctx = module.getContext();

mlir/lib/Conversion/GPUCommon/ConvertLaunchFuncToRuntimeCalls.cpp

public:
   }
 
   // Run the dialect converter on the module.
   void runOnOperation() override;
 };
 
 class FunctionCallBuilder {
 public:
-  FunctionCallBuilder(StringRef functionName, LLVM::LLVMType returnType,
-                      ArrayRef<LLVM::LLVMType> argumentTypes)
+  FunctionCallBuilder(StringRef functionName, Type returnType,
+                      ArrayRef<Type> argumentTypes)
       : functionName(functionName),
         functionType(LLVM::LLVMFunctionType::get(returnType, argumentTypes)) {}
   LLVM::CallOp create(Location loc, OpBuilder &builder,
                       ArrayRef<Value> arguments) const;
 
 private:
   StringRef functionName;
   LLVM::LLVMFunctionType functionType;
 };
 
 template <typename OpTy>
 class ConvertOpToGpuRuntimeCallPattern : public ConvertOpToLLVMPattern<OpTy> {
 public:
   explicit ConvertOpToGpuRuntimeCallPattern(LLVMTypeConverter &typeConverter)
       : ConvertOpToLLVMPattern<OpTy>(typeConverter) {}
 
 protected:
   MLIRContext *context = &this->getTypeConverter()->getContext();
 
-  LLVM::LLVMType llvmVoidType = LLVM::LLVMVoidType::get(context);
-  LLVM::LLVMType llvmPointerType =
+  Type llvmVoidType = LLVM::LLVMVoidType::get(context);
+  Type llvmPointerType =
       LLVM::LLVMPointerType::get(LLVM::LLVMIntegerType::get(context, 8));
-  LLVM::LLVMType llvmPointerPointerType =
-      LLVM::LLVMPointerType::get(llvmPointerType);
-  LLVM::LLVMType llvmInt8Type = LLVM::LLVMIntegerType::get(context, 8);
-  LLVM::LLVMType llvmInt32Type = LLVM::LLVMIntegerType::get(context, 32);
-  LLVM::LLVMType llvmInt64Type = LLVM::LLVMIntegerType::get(context, 64);
-  LLVM::LLVMType llvmIntPtrType = LLVM::LLVMIntegerType::get(
+  Type llvmPointerPointerType = LLVM::LLVMPointerType::get(llvmPointerType);
+  Type llvmInt8Type = LLVM::LLVMIntegerType::get(context, 8);
+  Type llvmInt32Type = LLVM::LLVMIntegerType::get(context, 32);
+  Type llvmInt64Type = LLVM::LLVMIntegerType::get(context, 64);
+  Type llvmIntPtrType = LLVM::LLVMIntegerType::get(
       context, this->getTypeConverter()->getPointerBitwidth(0));
 
   FunctionCallBuilder moduleLoadCallBuilder = {
       "mgpuModuleLoad",
       llvmPointerType /* void *module */,
       {llvmPointerType /* void *cubin */}};
   FunctionCallBuilder moduleUnloadCallBuilder = {
       "mgpuModuleUnload", llvmVoidType, {llvmPointerType /* void *module */}};
return builder.create<LLVM::CallOp>(
       loc, const_cast<LLVM::LLVMFunctionType &>(functionType).getReturnType(),
       builder.getSymbolRefAttr(function), arguments);
 }
 
 // Returns whether all operands are of LLVM type.
 static LogicalResult areAllLLVMTypes(Operation *op, ValueRange operands,
                                      ConversionPatternRewriter &rewriter) {
   if (!llvm::all_of(operands, [](Value value) {
-        return value.getType().isa<LLVM::LLVMType>();
+        return LLVM::isCompatibleType(value.getType());
       }))
     return rewriter.notifyMatchFailure(
         op, "Cannot convert if operands aren't of LLVM type.");
   return success();
 }
 
 static LogicalResult
 isAsyncWithOneDependency(ConversionPatternRewriter &rewriter,
Value ConvertLaunchFuncOpToGpuRuntimeCallPattern::generateParamsArray(
     gpu::LaunchFuncOp launchOp, ArrayRef<Value> operands,
     OpBuilder &builder) const {
   auto loc = launchOp.getLoc();
   auto numKernelOperands = launchOp.getNumKernelOperands();
   auto arguments = getTypeConverter()->promoteOperands(
       loc, launchOp.getOperands().take_back(numKernelOperands),
       operands.take_back(numKernelOperands), builder);
   auto numArguments = arguments.size();
-  SmallVector<LLVM::LLVMType, 4> argumentTypes;
+  SmallVector<Type, 4> argumentTypes;
   argumentTypes.reserve(numArguments);
   for (auto argument : arguments)
-    argumentTypes.push_back(argument.getType().cast<LLVM::LLVMType>());
+    argumentTypes.push_back(argument.getType());
   auto structType = LLVM::LLVMStructType::getNewIdentified(context, StringRef(),
                                                            argumentTypes);
   auto one = builder.create<LLVM::ConstantOp>(loc, llvmInt32Type,
                                               builder.getI32IntegerAttr(1));
   auto structPtr = builder.create<LLVM::AllocaOp>(
       loc, LLVM::LLVMPointerType::get(structType), one, /*alignment=*/0);
   auto arraySize = builder.create<LLVM::ConstantOp>(
       loc, llvmInt32Type, builder.getI32IntegerAttr(numArguments));

mlir/lib/Conversion/GPUCommon/GPUOpsLowering.h

for (auto en : llvm::enumerate(gpuFuncOp.getWorkgroupAttributions())) {
       Value attribution = en.value();
 
       auto type = attribution.getType().dyn_cast<MemRefType>();
       assert(type && type.hasStaticShape() && "unexpected type in attribution");
 
       uint64_t numElements = type.getNumElements();
 
       auto elementType = typeConverter->convertType(type.getElementType())
-                             .template cast<LLVM::LLVMType>();
+                             .template cast<Type>();
       auto arrayType = LLVM::LLVMArrayType::get(elementType, numElements);
       std::string name = std::string(
           llvm::formatv("__wg_{0}_{1}", gpuFuncOp.getName(), en.index()));
       auto globalOp = rewriter.create<LLVM::GlobalOp>(
           gpuFuncOp.getLoc(), arrayType, /*isConstant=*/false,
           LLVM::Linkage::Internal, name, /*value=*/Attribute(),
           gpu::GPUDialect::getWorkgroupAddressSpace());
       workgroupBuffers.push_back(globalOp);
auto llvmFuncOp = rewriter.create<LLVM::LLVMFuncOp>(
         assert(type && type.hasStaticShape() &&
                "unexpected type in attribution");
 
         // Explicitly drop memory space when lowering private memory
         // attributions since NVVM models it as `alloca`s in the default
         // memory space and does not support `alloca`s with addrspace(5).
         auto ptrType = LLVM::LLVMPointerType::get(
             typeConverter->convertType(type.getElementType())
-                .template cast<LLVM::LLVMType>(),
+                .template cast<Type>(),
             AllocaAddrSpace);
         Value numElements = rewriter.create<LLVM::ConstantOp>(
             gpuFuncOp.getLoc(), int64Ty,
             rewriter.getI64IntegerAttr(type.getNumElements()));
         Value allocated = rewriter.create<LLVM::AllocaOp>(
             gpuFuncOp.getLoc(), ptrType, numElements, /*alignment=*/0);
         auto descr = MemRefDescriptor::fromStaticShape(
             rewriter, loc, *getTypeConverter(), type, allocated);

mlir/lib/Conversion/GPUCommon/OpToFuncCallLowering.h

explicit OpToFuncCallLowering(LLVMTypeConverter &lowering_, StringRef f32Func,
                                 StringRef f64Func)
       : ConvertOpToLLVMPattern<SourceOp>(lowering_), f32Func(f32Func),
         f64Func(f64Func) {}
 
   LogicalResult
   matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     using LLVM::LLVMFuncOp;
-    using LLVM::LLVMType;
 
     static_assert(
         std::is_base_of<OpTrait::OneResult<SourceOp>, SourceOp>::value,
         "expected single result op");
 
     static_assert(std::is_base_of<OpTrait::SameOperandsAndResultType<SourceOp>,
                                   SourceOp>::value,
                   "expected op with same operand and result types");
 
     SmallVector<Value, 1> castedOperands;
     for (Value operand : operands)
       castedOperands.push_back(maybeCast(operand, rewriter));
 
-    LLVMType resultType =
-        castedOperands.front().getType().cast<LLVM::LLVMType>();
-    LLVMType funcType = getFunctionType(resultType, castedOperands);
+    Type resultType = castedOperands.front().getType();
+    Type funcType = getFunctionType(resultType, castedOperands);
     StringRef funcName = getFunctionName(
         funcType.cast<LLVM::LLVMFunctionType>().getReturnType());
     if (funcName.empty())
       return failure();
 
     LLVMFuncOp funcOp = appendOrGetFuncOp(funcName, funcType, op);
     auto callOp = rewriter.create<LLVM::CallOp>(
         op->getLoc(), resultType, rewriter.getSymbolRefAttr(funcOp),
         castedOperands);
 
     if (resultType == operands.front().getType()) {
       rewriter.replaceOp(op, {callOp.getResult(0)});
       return success();
     }
 
     Value truncated = rewriter.create<LLVM::FPTruncOp>(
         op->getLoc(), operands.front().getType(), callOp.getResult(0));
     rewriter.replaceOp(op, {truncated});
     return success();
   }
 
 private:
   Value maybeCast(Value operand, PatternRewriter &rewriter) const {
-    LLVM::LLVMType type = operand.getType().cast<LLVM::LLVMType>();
+    Type type = operand.getType();
     if (!type.isa<LLVM::LLVMHalfType>())
       return operand;
 
     return rewriter.create<LLVM::FPExtOp>(
         operand.getLoc(), LLVM::LLVMFloatType::get(rewriter.getContext()),
         operand);
   }
 
-  LLVM::LLVMType getFunctionType(LLVM::LLVMType resultType,
-                                 ArrayRef<Value> operands) const {
-    using LLVM::LLVMType;
-    SmallVector<LLVMType, 1> operandTypes;
+  Type getFunctionType(Type resultType, ArrayRef<Value> operands) const {
+    SmallVector<Type, 1> operandTypes;
     for (Value operand : operands) {
-      operandTypes.push_back(operand.getType().cast<LLVMType>());
+      operandTypes.push_back(operand.getType());
     }
     return LLVM::LLVMFunctionType::get(resultType, operandTypes);
   }
 
-  StringRef getFunctionName(LLVM::LLVMType type) const {
+  StringRef getFunctionName(Type type) const {
     if (type.isa<LLVM::LLVMFloatType>())
       return f32Func;
     if (type.isa<LLVM::LLVMDoubleType>())
       return f64Func;
     return "";
   }
 
-  LLVM::LLVMFuncOp appendOrGetFuncOp(StringRef funcName,
-                                     LLVM::LLVMType funcType,
+  LLVM::LLVMFuncOp appendOrGetFuncOp(StringRef funcName, Type funcType,
                                      Operation *op) const {
     using LLVM::LLVMFuncOp;
 
     Operation *funcOp = SymbolTable::lookupNearestSymbolFrom(op, funcName);
     if (funcOp)
       return cast<LLVMFuncOp>(*funcOp);
 
     mlir::OpBuilder b(op->getParentOfType<LLVMFuncOp>());

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

struct GPUShuffleOpLowering : public ConvertOpToLLVMPattern<gpu::ShuffleOp> {
   ///     %shfl_pred = llvm.extractvalue %shfl[1 : index] :
   ///         !llvm<"{ float, i1 }">
   LogicalResult
   matchAndRewrite(gpu::ShuffleOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op->getLoc();
     gpu::ShuffleOpAdaptor adaptor(operands);
 
-    auto valueTy = adaptor.value().getType().cast<LLVM::LLVMType>();
+    auto valueTy = adaptor.value().getType();
     auto int32Type = LLVM::LLVMIntegerType::get(rewriter.getContext(), 32);
     auto predTy = LLVM::LLVMIntegerType::get(rewriter.getContext(), 1);
     auto resultTy = LLVM::LLVMStructType::getLiteral(rewriter.getContext(),
                                                      {valueTy, predTy});
 
     Value one = rewriter.create<LLVM::ConstantOp>(
         loc, int32Type, rewriter.getI32IntegerAttr(1));
     // Bit mask of active lanes: `(1 << activeWidth) - 1`.

mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp

void initializeCachedTypes() {
     llvmFloatType = LLVM::LLVMFloatType::get(&getContext());
     llvmVoidType = LLVM::LLVMVoidType::get(&getContext());
     llvmPointerType = LLVM::LLVMPointerType::get(
         LLVM::LLVMIntegerType::get(&getContext(), 8));
     llvmInt32Type = LLVM::LLVMIntegerType::get(&getContext(), 32);
     llvmInt64Type = LLVM::LLVMIntegerType::get(&getContext(), 64);
   }
 
-  LLVM::LLVMType getMemRefType(uint32_t rank, LLVM::LLVMType elemenType) {
+  Type getMemRefType(uint32_t rank, Type elemenType) {
     // According to the MLIR doc memref argument is converted into a
     // pointer-to-struct argument of type:
     // template <typename Elem, size_t Rank>
     // struct {
     //   Elem *allocated;
     //   Elem *aligned;
     //   int64_t offset;
     //   int64_t sizes[Rank]; // omitted when rank == 0
     //   int64_t strides[Rank]; // omitted when rank == 0
     // };
     auto llvmPtrToElementType = LLVM::LLVMPointerType::get(elemenType);
     auto llvmArrayRankElementSizeType =
         LLVM::LLVMArrayType::get(getInt64Type(), rank);
 
     // Create a type
     // `!llvm<"{ `element-type`*, `element-type`*, i64,
     // [`rank` x i64], [`rank` x i64]}">`.
     return LLVM::LLVMStructType::getLiteral(
         &getContext(),
         {llvmPtrToElementType, llvmPtrToElementType, getInt64Type(),
          llvmArrayRankElementSizeType, llvmArrayRankElementSizeType});
   }
 
-  LLVM::LLVMType getVoidType() { return llvmVoidType; }
-  LLVM::LLVMType getPointerType() { return llvmPointerType; }
-  LLVM::LLVMType getInt32Type() { return llvmInt32Type; }
-  LLVM::LLVMType getInt64Type() { return llvmInt64Type; }
+  Type getVoidType() { return llvmVoidType; }
+  Type getPointerType() { return llvmPointerType; }
+  Type getInt32Type() { return llvmInt32Type; }
+  Type getInt64Type() { return llvmInt64Type; }
 
   /// Creates an LLVM global for the given `name`.
   Value createEntryPointNameConstant(StringRef name, Location loc,
                                      OpBuilder &builder);
 
   /// Declares all needed runtime functions.
   void declareVulkanFunctions(Location loc);
 
private:
   void createBindMemRefCalls(LLVM::CallOp vulkanLaunchCallOp,
                              Value vulkanRuntime);
 
   /// Collects SPIRV attributes from the given `vulkanLaunchCallOp`.
   void collectSPIRVAttributes(LLVM::CallOp vulkanLaunchCallOp);
 
   /// Deduces a rank and element type from the given 'ptrToMemRefDescriptor`.
   LogicalResult deduceMemRefRankAndType(Value ptrToMemRefDescriptor,
-                                        uint32_t &rank, LLVM::LLVMType &type);
+                                        uint32_t &rank, Type &type);
 
   /// Returns a string representation from the given `type`.
-  StringRef stringifyType(LLVM::LLVMType type) {
+  StringRef stringifyType(Type type) {
     if (type.isa<LLVM::LLVMFloatType>())
       return "Float";
     if (type.isa<LLVM::LLVMHalfType>())
       return "Half";
     if (auto intType = type.dyn_cast<LLVM::LLVMIntegerType>()) {
       if (intType.getBitWidth() == 32)
         return "Int32";
       if (intType.getBitWidth() == 16)
         return "Int16";
       if (intType.getBitWidth() == 8)
         return "Int8";
     }
 
     llvm_unreachable("unsupported type");
   }
 
 public:
   void runOnOperation() override;
 
 private:
-  LLVM::LLVMType llvmFloatType;
-  LLVM::LLVMType llvmVoidType;
-  LLVM::LLVMType llvmPointerType;
-  LLVM::LLVMType llvmInt32Type;
-  LLVM::LLVMType llvmInt64Type;
+  Type llvmFloatType;
+  Type llvmVoidType;
+  Type llvmPointerType;
+  Type llvmInt32Type;
+  Type llvmInt64Type;
 
   // TODO: Use an associative array to support multiple vulkan launch calls.
   std::pair<StringAttr, StringAttr> spirvAttributes;
   /// The number of vulkan launch configuration operands, placed at the leading
   /// positions of the operand list.
   static constexpr unsigned kVulkanLaunchNumConfigOperands = 3;
 };
 
for (auto en :
        llvm::enumerate(cInterfaceVulkanLaunchCallOp.getOperands().drop_front(
            kVulkanLaunchNumConfigOperands))) {
     // Create LLVM constant for the descriptor binding index.
     Value descriptorBinding = builder.create<LLVM::ConstantOp>(
         loc, getInt32Type(), builder.getI32IntegerAttr(en.index()));
 
     auto ptrToMemRefDescriptor = en.value();
     uint32_t rank = 0;
-    LLVM::LLVMType type;
+    Type type;
     if (failed(deduceMemRefRankAndType(ptrToMemRefDescriptor, rank, type))) {
       cInterfaceVulkanLaunchCallOp.emitError()
           << "invalid memref descriptor " << ptrToMemRefDescriptor.getType();
       return signalPassFailure();
     }
 
     auto symbolName =
         llvm::formatv("bindMemRef{0}D{1}", rank, stringifyType(type)).str();
builder.create<LLVM::CallOp>(
         builder.getSymbolRefAttr(
             StringRef(symbolName.data(), symbolName.size())),
         ValueRange{vulkanRuntime, descriptorSet, descriptorBinding,
                    ptrToMemRefDescriptor});
   }
 }
 
 LogicalResult VulkanLaunchFuncToVulkanCallsPass::deduceMemRefRankAndType(
-    Value ptrToMemRefDescriptor, uint32_t &rank, LLVM::LLVMType &type) {
+    Value ptrToMemRefDescriptor, uint32_t &rank, Type &type) {
   auto llvmPtrDescriptorTy =
       ptrToMemRefDescriptor.getType().dyn_cast<LLVM::LLVMPointerType>();
   if (!llvmPtrDescriptorTy)
     return failure();
 
   auto llvmDescriptorTy =
       llvmPtrDescriptorTy.getElementType().dyn_cast<LLVM::LLVMStructType>();
   // template <typename Elem, size_t Rank>
void VulkanLaunchFuncToVulkanCallsPass::declareVulkanFunctions(Location loc) {
 
   if (!module.lookupSymbol(kRunOnVulkan)) {
     builder.create<LLVM::LLVMFuncOp>(
         loc, kRunOnVulkan,
         LLVM::LLVMFunctionType::get(getVoidType(), {getPointerType()}));
   }
 
   for (unsigned i = 1; i <= 3; i++) {
-    for (auto type : std::initializer_list<LLVM::LLVMType>{
+    for (auto type : std::initializer_list<Type>{
              LLVM::LLVMFloatType::get(&getContext()),
              LLVM::LLVMIntegerType::get(&getContext(), 32),
              LLVM::LLVMIntegerType::get(&getContext(), 16),
              LLVM::LLVMIntegerType::get(&getContext(), 8),
              LLVM::LLVMHalfType::get(&getContext())}) {
       std::string fnName = "bindMemRef" + std::to_string(i) + "D" +
                            std::string(stringifyType(type));
       if (type.isa<LLVM::LLVMHalfType>())

mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp

 using llvm_ptrtoint = ValueBuilder<LLVM::PtrToIntOp>;
 using llvm_sub = ValueBuilder<LLVM::SubOp>;
 using llvm_undef = ValueBuilder<LLVM::UndefOp>;
 using llvm_urem = ValueBuilder<LLVM::URemOp>;
 using llvm_alloca = ValueBuilder<LLVM::AllocaOp>;
 using llvm_return = OperationBuilder<LLVM::ReturnOp>;
 
 template <typename T>
-static LLVMType getPtrToElementType(T containerType,
-                                    LLVMTypeConverter &lowering) {
-  return lowering.convertType(containerType.getElementType())
-      .template cast<LLVMType>()
-      .getPointerTo();
+static Type getPtrToElementType(T containerType, LLVMTypeConverter &lowering) {
+  return LLVMPointerType::get(
+      lowering.convertType(containerType.getElementType()));
 }
 
 /// Convert the given range descriptor type to the LLVMIR dialect.
 /// Range descriptor contains the range bounds and the step as 64-bit integers.
 ///
 /// struct {
 ///   int64_t min;
 ///   int64_t max;
 ///   int64_t step;
 /// };
 static Type convertRangeType(RangeType t, LLVMTypeConverter &converter) {
   auto *context = t.getContext();
-  auto int64Ty = converter.convertType(IntegerType::get(context, 64))
-                     .cast<LLVM::LLVMType>();
+  auto int64Ty = converter.convertType(IntegerType::get(context, 64));
   return LLVMStructType::getLiteral(context, {int64Ty, int64Ty, int64Ty});
 }
 
 namespace {
 /// EDSC-compatible wrapper for MemRefDescriptor.
 class BaseViewConversionHelper {
 public:
   BaseViewConversionHelper(Type type)
public:
   LogicalResult
   matchAndRewrite(SliceOp sliceOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     edsc::ScopedContext context(rewriter, sliceOp->getLoc());
     SliceOpAdaptor adaptor(operands);
     BaseViewConversionHelper baseDesc(adaptor.view());
 
     auto memRefType = sliceOp.getBaseViewType();
-    auto int64Ty = typeConverter->convertType(rewriter.getIntegerType(64))
-                       .cast<LLVM::LLVMType>();
+    auto int64Ty = typeConverter->convertType(rewriter.getIntegerType(64));
 
     BaseViewConversionHelper desc(
         typeConverter->convertType(sliceOp.getShapedType()));
 
     // TODO: extract sizes and emit asserts.
     SmallVector<Value, 4> strides(memRefType.getRank());
     for (int i = 0, e = memRefType.getRank(); i < e; ++i)
       strides[i] = baseDesc.stride(i);

mlir/lib/Conversion/SPIRVToLLVM/ConvertLaunchFuncToLLVMCalls.cpp

matchAndRewrite(gpu::LaunchFuncOp launchOp, ArrayRef<Value> operands,
     std::string newKernelFuncName = spvModuleName + "_" + kernelFuncName.str();
     auto kernelFunc = module.lookupSymbol<LLVM::LLVMFuncOp>(newKernelFuncName);
     if (!kernelFunc) {
       OpBuilder::InsertionGuard guard(rewriter);
       rewriter.setInsertionPointToStart(module.getBody());
       kernelFunc = rewriter.create<LLVM::LLVMFuncOp>(
           rewriter.getUnknownLoc(), newKernelFuncName,
           LLVM::LLVMFunctionType::get(LLVM::LLVMVoidType::get(context),
-                                      ArrayRef<LLVM::LLVMType>()));
+                                      ArrayRef<Type>()));
       rewriter.setInsertionPoint(launchOp);
     }
 
     // Get all global variables associated with the kernel operands.
     DenseMap<uint32_t, spirv::GlobalVariableOp> globalVariableMap;
     if (failed(getKernelGlobalVariables(spvModule, globalVariableMap)))
       return failure();
 
for (auto operand : llvm::enumerate(kernelOperands)) {
       std::string name =
           createGlobalVariableWithBindName(spirvGlobal, spvModuleName);
       // Check if this variable has already been created.
       auto dstGlobal = module.lookupSymbol<LLVM::GlobalOp>(name);
       if (!dstGlobal) {
         OpBuilder::InsertionGuard guard(rewriter);
         rewriter.setInsertionPointToStart(module.getBody());
         dstGlobal = rewriter.create<LLVM::GlobalOp>(
-            loc, dstGlobalType.cast<LLVM::LLVMType>(),
+            loc, dstGlobalType,
             /*isConstant=*/false, LLVM::Linkage::Linkonce, name, Attribute());
         rewriter.setInsertionPoint(launchOp);
       }
 
       // Copy the data from src operand pointer to dst global variable. Save
       // src, dst and size so that we can copy data back after emulating the
       // kernel call.
       Value dst = rewriter.create<LLVM::AddressOfOp>(loc, dstGlobal);

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp

static unsigned getBitWidth(Type type) {
   auto vecType = type.dyn_cast<VectorType>();
   auto elementType = vecType.getElementType();
   assert(elementType.isIntOrFloat() &&
          "only integers and floats have a bitwidth");
   return elementType.getIntOrFloatBitWidth();
 }
 
 /// Returns the bit width of LLVMType integer or vector.
-static unsigned getLLVMTypeBitWidth(LLVM::LLVMType type) {
+static unsigned getLLVMTypeBitWidth(Type type) {
   auto vectorType = type.dyn_cast<LLVM::LLVMVectorType>();
   return (vectorType ? vectorType.getElementType() : type)
       .cast<LLVM::LLVMIntegerType>()
       .getBitWidth();
 }
 
 /// Creates `IntegerAttribute` with all bits set for given type
 static IntegerAttr minusOneIntegerAttribute(Type type, Builder builder) {

 ///   - `BitFieldInsert`
 ///   - `BitFieldSExtract`
 ///   - `BitFieldUExtract`
 /// Truncates or extends the value. If the bitwidth of the value is the same as
 /// `dstType` bitwidth, the value remains unchanged.
 static Value optionallyTruncateOrExtend(Location loc, Value value, Type dstType,
                                         PatternRewriter &rewriter) {
   auto srcType = value.getType();
-  auto llvmType = dstType.cast<LLVM::LLVMType>();
+  auto llvmType = dstType;
   unsigned targetBitWidth = getLLVMTypeBitWidth(llvmType);
-  unsigned valueBitWidth =
-      srcType.isa<LLVM::LLVMType>()
-          ? getLLVMTypeBitWidth(srcType.cast<LLVM::LLVMType>())
+  unsigned valueBitWidth = LLVM::isCompatibleType(srcType)
+                               ? getLLVMTypeBitWidth(srcType)
                                : getBitWidth(srcType);
 
   if (valueBitWidth < targetBitWidth)
     return rewriter.create<LLVM::ZExtOp>(loc, llvmType, value);
   // If the bit widths of `Count` and `Offset` are greater than the bit width
   // of the target type, they are truncated. Truncation is safe since `Count`
   // and `Offset` must be no more than 64 for op behaviour to be defined. Hence,
   // both values can be expressed in 8 bits.
   if (valueBitWidth > targetBitWidth)

 static Optional<Type>
 convertStructTypeWithOffset(spirv::StructType type,
                             LLVMTypeConverter &converter) {
   if (type != VulkanLayoutUtils::decorateType(type))
     return llvm::None;
 
   auto elementsVector = llvm::to_vector<8>(
       llvm::map_range(type.getElementTypes(), [&](Type elementType) {
-        return converter.convertType(elementType).cast<LLVM::LLVMType>();
+        return converter.convertType(elementType);
       }));
   return LLVM::LLVMStructType::getLiteral(type.getContext(), elementsVector,
                                           /*isPacked=*/false);
 }
 
 /// Converts SPIR-V struct with no offset to packed LLVM struct.
 static Type convertStructTypePacked(spirv::StructType type,
                                     LLVMTypeConverter &converter) {
   auto elementsVector = llvm::to_vector<8>(
       llvm::map_range(type.getElementTypes(), [&](Type elementType) {
-        return converter.convertType(elementType).cast<LLVM::LLVMType>();
+        return converter.convertType(elementType);
       }));
   return LLVM::LLVMStructType::getLiteral(type.getContext(), elementsVector,
                                           /*isPacked=*/true);
 }
 
 /// Creates LLVM dialect constant with the given value.
 static Value createI32ConstantOf(Location loc, PatternRewriter &rewriter,
                                  unsigned value) {
static Optional<Type> convertArrayType(spirv::ArrayType type,
                                        TypeConverter &converter) {
   unsigned stride = type.getArrayStride();
   Type elementType = type.getElementType();
   auto sizeInBytes = elementType.cast<spirv::SPIRVType>().getSizeInBytes();
   if (stride != 0 &&
       !(sizeInBytes.hasValue() && sizeInBytes.getValue() == stride))
     return llvm::None;
 
-  auto llvmElementType =
-      converter.convertType(elementType).cast<LLVM::LLVMType>();
+  auto llvmElementType = converter.convertType(elementType);
   unsigned numElements = type.getNumElements();
   return LLVM::LLVMArrayType::get(llvmElementType, numElements);
 }
 
 /// Converts SPIR-V pointer type to LLVM pointer. Pointer's storage class is not
 /// modelled at the moment.
 static Type convertPointerType(spirv::PointerType type,
                                TypeConverter &converter) {
-  auto pointeeType =
-      converter.convertType(type.getPointeeType()).cast<LLVM::LLVMType>();
+  auto pointeeType = converter.convertType(type.getPointeeType());
   return LLVM::LLVMPointerType::get(pointeeType);
 }
 
 /// Converts SPIR-V runtime array to LLVM array. Since LLVM allows indexing over
 /// the bounds, the runtime array is converted to a 0-sized LLVM array. There is
 /// no modelling of array stride at the moment.
 static Optional<Type> convertRuntimeArrayType(spirv::RuntimeArrayType type,
                                               TypeConverter &converter) {
   if (type.getArrayStride() != 0)
     return llvm::None;
-  auto elementType =
-      converter.convertType(type.getElementType()).cast<LLVM::LLVMType>();
+  auto elementType = converter.convertType(type.getElementType());
   return LLVM::LLVMArrayType::get(elementType, 0);
 }
 
 /// Converts SPIR-V struct to LLVM struct. There is no support of structs with
 /// member decorations. Also, only natural offset is supported.
 static Optional<Type> convertStructType(spirv::StructType type,
                                         LLVMTypeConverter &converter) {
   SmallVector<spirv::StructType::MemberDecorationInfo, 4> memberDecorations;
public:
   using SPIRVToLLVMConversion<spirv::AddressOfOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(spirv::AddressOfOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = typeConverter.convertType(op.pointer().getType());
     if (!dstType)
       return failure();
-    rewriter.replaceOpWithNewOp<LLVM::AddressOfOp>(
-        op, dstType.cast<LLVM::LLVMType>(), op.variable());
+    rewriter.replaceOpWithNewOp<LLVM::AddressOfOp>(op, dstType, op.variable());
     return success();
   }
 };
 
 class BitFieldInsertPattern
     : public SPIRVToLLVMConversion<spirv::BitFieldInsertOp> {
 public:
   using SPIRVToLLVMConversion<spirv::BitFieldInsertOp>::SPIRVToLLVMConversion;
matchAndRewrite(spirv::ExecutionModeOp op, ArrayRef<Value> operands,
     rewriter.setInsertionPointToStart(module.getBody());
 
     // Create a struct type, corresponding to the C struct below.
     // struct {
     //   int32_t executionMode;
     //   int32_t values[];          // optional values
     // };
     auto llvmI32Type = LLVM::LLVMIntegerType::get(context, 32);
-    SmallVector<LLVM::LLVMType, 2> fields;
+    SmallVector<Type, 2> fields;
     fields.push_back(llvmI32Type);
     ArrayAttr values = op.values();
     if (!values.empty()) {
       auto arrayType = LLVM::LLVMArrayType::get(llvmI32Type, values.size());
       fields.push_back(arrayType);
     }
     auto structType = LLVM::LLVMStructType::getLiteral(context, fields);
 
matchAndRewrite(spirv::GlobalVariableOp op, ArrayRef<Value> operands,
     // module and cannot be accessed by other modules. However, a module may be
     // written to export or import functions and global (module scope)
     // variables.". Therefore, map 'Private' storage class to private linkage,
     // 'Input' and 'Output' to external linkage.
     auto linkage = storageClass == spirv::StorageClass::Private
                        ? LLVM::Linkage::Private
                        : LLVM::Linkage::External;
     rewriter.replaceOpWithNewOp<LLVM::GlobalOp>(
-        op, dstType.cast<LLVM::LLVMType>(), isConstant, linkage, op.sym_name(),
-        Attribute());
+        op, dstType, isConstant, linkage, op.sym_name(), Attribute());
     return success();
   }
 };
 
 /// Converts SPIR-V cast ops that do not have straightforward LLVM
 /// equivalent in LLVM dialect.
 template <typename SPIRVOp, typename LLVMExtOp, typename LLVMTruncOp>
 class IndirectCastPattern : public SPIRVToLLVMConversion<SPIRVOp> {

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

 #include "llvm/Support/FormatVariadic.h"
 #include <functional>
 
 using namespace mlir;
 
 #define PASS_NAME "convert-std-to-llvm"
 
 // Extract an LLVM IR type from the LLVM IR dialect type.
-static LLVM::LLVMType unwrap(Type type) {
+static Type unwrap(Type type) {
   if (!type)
     return nullptr;
   auto *mlirContext = type.getContext();
-  auto wrappedLLVMType = type.dyn_cast<LLVM::LLVMType>();
-  if (!wrappedLLVMType)
+  if (!LLVM::isCompatibleType(type))
     emitError(UnknownLoc::get(mlirContext),
-              "conversion resulted in a non-LLVM type");
-  return wrappedLLVMType;
+              "conversion resulted in a non-LLVM type ")
+        << type;
+  return type;
 }
 
 /// Callback to convert function argument types. It converts a MemRef function
 /// argument to a list of non-aggregate types containing descriptor
 /// information, and an UnrankedmemRef function argument to a list containing
 /// the rank and a pointer to a descriptor struct.
 LogicalResult mlir::structFuncArgTypeConverter(LLVMTypeConverter &converter,
                                                Type type,
LLVMTypeConverter::LLVMTypeConverter(MLIRContext *ctx,
   addConversion([&](FunctionType type) { return convertFunctionType(type); });
   addConversion([&](IndexType type) { return convertIndexType(type); });
   addConversion([&](IntegerType type) { return convertIntegerType(type); });
   addConversion([&](MemRefType type) { return convertMemRefType(type); });
   addConversion(
       [&](UnrankedMemRefType type) { return convertUnrankedMemRefType(type); });
   addConversion([&](VectorType type) { return convertVectorType(type); });
 
-  // LLVMType is legal, so add a pass-through conversion.
-  addConversion([](LLVM::LLVMType type) { return type; });
+  // LLVM-compatible types are legal, so add a pass-through conversion.
+  addConversion([](Type type) {
+    return LLVM::isCompatibleType(type) ? llvm::Optional<Type>(type)
+                                        : llvm::None;
+  });
 
   // Materialization for memrefs creates descriptor structs from individual
   // values constituting them, when descriptors are used, i.e. more than one
   // value represents a memref.
   addArgumentMaterialization(
       [&](OpBuilder &builder, UnrankedMemRefType resultType, ValueRange inputs,
           Location loc) -> Optional<Value> {
         if (inputs.size() == 1)
LLVMTypeConverter::LLVMTypeConverter(MLIRContext *ctx,
   });
 }
 
 /// Returns the MLIR context.
 MLIRContext &LLVMTypeConverter::getContext() {
   return *getDialect()->getContext();
 }
 
-LLVM::LLVMType LLVMTypeConverter::getIndexType() {
+Type LLVMTypeConverter::getIndexType() {
   return LLVM::LLVMIntegerType::get(&getContext(), getIndexTypeBitwidth());
 }
 
 unsigned LLVMTypeConverter::getPointerBitwidth(unsigned addressSpace) {
   return options.dataLayout.getPointerSizeInBits(addressSpace);
 }
 
 Type LLVMTypeConverter::convertIndexType(IndexType type) {

 
 // Convert a `ComplexType` to an LLVM type. The result is a complex number
 // struct with entries for the
 //   1. real part and for the
 //   2. imaginary part.
 static constexpr unsigned kRealPosInComplexNumberStruct = 0;
 static constexpr unsigned kImaginaryPosInComplexNumberStruct = 1;
 Type LLVMTypeConverter::convertComplexType(ComplexType type) {
-  auto elementType = convertType(type.getElementType()).cast<LLVM::LLVMType>();
+  auto elementType = convertType(type.getElementType());
   return LLVM::LLVMStructType::getLiteral(&getContext(),
                                           {elementType, elementType});
 }
 
 // Except for signatures, MLIR function types are converted into LLVM
 // pointer-to-function types.
 Type LLVMTypeConverter::convertFunctionType(FunctionType type) {
   SignatureConversion conversion(type.getNumInputs());
-  LLVM::LLVMType converted =
+  Type converted =
       convertFunctionSignature(type, /*isVariadic=*/false, conversion);
   return LLVM::LLVMPointerType::get(converted);
 }
 
 
 // Function types are converted to LLVM Function types by recursively converting
 // argument and result types.  If MLIR Function has zero results, the LLVM
 // Function has one VoidType result.  If MLIR Function has more than one result,
 // they are into an LLVM StructType in their order of appearance.
-LLVM::LLVMType LLVMTypeConverter::convertFunctionSignature(
+Type LLVMTypeConverter::convertFunctionSignature(
     FunctionType funcTy, bool isVariadic,
     LLVMTypeConverter::SignatureConversion &result) {
   // Select the argument converter depending on the calling convention.
   auto funcArgConverter = options.useBarePtrCallConv
                               ? barePtrFuncArgTypeConverter
                               : structFuncArgTypeConverter;
   // Convert argument types one by one and check for errors.
   for (auto &en : llvm::enumerate(funcTy.getInputs())) {
     Type type = en.value();
     SmallVector<Type, 8> converted;
     if (failed(funcArgConverter(*this, type, converted)))
       return {};
     result.addInputs(en.index(), converted);
   }
 
-  SmallVector<LLVM::LLVMType, 8> argTypes;
+  SmallVector<Type, 8> argTypes;
   argTypes.reserve(llvm::size(result.getConvertedTypes()));
   for (Type type : result.getConvertedTypes())
     argTypes.push_back(unwrap(type));
 
   // If function does not return anything, create the void result type,
   // if it returns on element, convert it, otherwise pack the result types into
   // a struct.
-  LLVM::LLVMType resultType =
-      funcTy.getNumResults() == 0
+  Type resultType = funcTy.getNumResults() == 0
                         ? LLVM::LLVMVoidType::get(&getContext())
                         : unwrap(packFunctionResults(funcTy.getResults()));
   if (!resultType)
     return {};
   return LLVM::LLVMFunctionType::get(resultType, argTypes, isVariadic);
 }
 
 /// Converts the function type to a C-compatible format, in particular using
 /// pointers to memref descriptors for arguments.
-LLVM::LLVMType
-LLVMTypeConverter::convertFunctionTypeCWrapper(FunctionType type) {
-  SmallVector<LLVM::LLVMType, 4> inputs;
+Type LLVMTypeConverter::convertFunctionTypeCWrapper(FunctionType type) {
+  SmallVector<Type, 4> inputs;
 
   for (Type t : type.getInputs()) {
-    auto converted = convertType(t).dyn_cast_or_null<LLVM::LLVMType>();
-    if (!converted)
+    auto converted = convertType(t);
+    if (!converted || !LLVM::isCompatibleType(converted))
       return {};
     if (t.isa<MemRefType, UnrankedMemRefType>())
       converted = LLVM::LLVMPointerType::get(converted);
     inputs.push_back(converted);
   }
 
-  LLVM::LLVMType resultType =
-      type.getNumResults() == 0
+  Type resultType = type.getNumResults() == 0
                         ? LLVM::LLVMVoidType::get(&getContext())
                         : unwrap(packFunctionResults(type.getResults()));
   if (!resultType)
     return {};
 
   return LLVM::LLVMFunctionType::get(resultType, inputs);
 }
 
 static constexpr unsigned kAllocatedPtrPosInMemRefDescriptor = 0;
 static constexpr unsigned kAlignedPtrPosInMemRefDescriptor = 1;

 ///  template <typename Elem, typename Index, size_t Rank>
 ///  struct {
 ///    Elem *allocatedPtr;
 ///    Elem *alignedPtr;
 ///    Index offset;
 ///    Index sizes[Rank]; // omitted when rank == 0
 ///    Index strides[Rank]; // omitted when rank == 0
 ///  };
-SmallVector<LLVM::LLVMType, 5>
+SmallVector<Type, 5>
 LLVMTypeConverter::getMemRefDescriptorFields(MemRefType type,
                                              bool unpackAggregates) {
   assert(isStrided(type) &&
          "Non-strided layout maps must have been normalized away");
 
-  LLVM::LLVMType elementType = unwrap(convertType(type.getElementType()));
+  Type elementType = unwrap(convertType(type.getElementType()));
   if (!elementType)
     return {};
   auto ptrTy = LLVM::LLVMPointerType::get(elementType, type.getMemorySpace());
   auto indexTy = getIndexType();
 
-  SmallVector<LLVM::LLVMType, 5> results = {ptrTy, ptrTy, indexTy};
+  SmallVector<Type, 5> results = {ptrTy, ptrTy, indexTy};
   auto rank = type.getRank();
   if (rank == 0)
     return results;
 
   if (unpackAggregates)
     results.insert(results.end(), 2 * rank, indexTy);
   else
     results.insert(results.end(), 2, LLVM::LLVMArrayType::get(indexTy, rank));
   return results;
 }
 
 /// Converts MemRefType to LLVMType. A MemRefType is converted to a struct that
 /// packs the descriptor fields as defined by `getMemRefDescriptorFields`.
 Type LLVMTypeConverter::convertMemRefType(MemRefType type) {
   // When converting a MemRefType to a struct with descriptor fields, do not
   // unpack the `sizes` and `strides` arrays.
-  SmallVector<LLVM::LLVMType, 5> types =
+  SmallVector<Type, 5> types =
       getMemRefDescriptorFields(type, /*unpackAggregates=*/false);
   return LLVM::LLVMStructType::getLiteral(&getContext(), types);
 }
 
 static constexpr unsigned kRankInUnrankedMemRefDescriptor = 0;
 static constexpr unsigned kPtrInUnrankedMemRefDescriptor = 1;
 
 /// Convert an unranked memref type into a list of non-aggregate LLVM IR types
 /// that will form the unranked memref descriptor. In particular, the fields
 /// for an unranked memref descriptor are:
 /// 1. index-typed rank, the dynamic rank of this MemRef
 /// 2. void* ptr, pointer to the static ranked MemRef descriptor. This will be
 ///    stack allocated (alloca) copy of a MemRef descriptor that got casted to
 ///    be unranked.
-SmallVector<LLVM::LLVMType, 2>
-LLVMTypeConverter::getUnrankedMemRefDescriptorFields() {
+SmallVector<Type, 2> LLVMTypeConverter::getUnrankedMemRefDescriptorFields() {
   return {getIndexType(), LLVM::LLVMPointerType::get(
                               LLVM::LLVMIntegerType::get(&getContext(), 8))};
 }
 
 Type LLVMTypeConverter::convertUnrankedMemRefType(UnrankedMemRefType type) {
   return LLVM::LLVMStructType::getLiteral(&getContext(),
                                           getUnrankedMemRefDescriptorFields());
 }
Type LLVMTypeConverter::convertMemRefToBarePtr(BaseMemRefType type) {
 
   for (int64_t stride : strides)
     if (ShapedType::isDynamicStrideOrOffset(stride))
       return {};
 
   if (ShapedType::isDynamicStrideOrOffset(offset))
     return {};
 
-  LLVM::LLVMType elementType = unwrap(convertType(type.getElementType()));
+  Type elementType = unwrap(convertType(type.getElementType()));
   if (!elementType)
     return {};
   return LLVM::LLVMPointerType::get(elementType, type.getMemorySpace());
 }
 
 // Convert an n-D vector type to an LLVM vector type via (n-1)-D array type when
 // n > 1.
 // For example, `vector<4 x f32>` converts to `!llvm.type<"<4 x float>">` and
 // `vector<4 x 8 x 16 f32>` converts to `!llvm<"[4 x [8 x <16 x float>]]">`.
 Type LLVMTypeConverter::convertVectorType(VectorType type) {
   auto elementType = unwrap(convertType(type.getElementType()));
   if (!elementType)
     return {};
-  LLVM::LLVMType vectorType =
+  Type vectorType =
       LLVM::LLVMFixedVectorType::get(elementType, type.getShape().back());
   auto shape = type.getShape();
   for (int i = shape.size() - 2; i >= 0; --i)
     vectorType = LLVM::LLVMArrayType::get(vectorType, shape[i]);
   return vectorType;
 }
 
 /// Convert a type in the context of the default or bare pointer calling
ConvertToLLVMPattern::ConvertToLLVMPattern(StringRef rootOpName,
                                            LLVMTypeConverter &typeConverter,
                                            PatternBenefit benefit)
     : ConversionPattern(rootOpName, benefit, typeConverter, context) {}
 
 //===----------------------------------------------------------------------===//
 // StructBuilder implementation
 //===----------------------------------------------------------------------===//
 
-StructBuilder::StructBuilder(Value v) : value(v) {
+StructBuilder::StructBuilder(Value v) : value(v), structType(v.getType()) {
   assert(value != nullptr && "value cannot be null");
-  structType = value.getType().dyn_cast<LLVM::LLVMType>();
-  assert(structType && "expected llvm type");
+  assert(LLVM::isCompatibleType(structType) && "expected llvm type");
 }
 
 Value StructBuilder::extractPtr(OpBuilder &builder, Location loc,
                                 unsigned pos) {
   Type type = structType.cast<LLVM::LLVMStructType>().getBody()[pos];
   return builder.create<LLVM::ExtractValueOp>(loc, type, value,
                                               builder.getI64ArrayAttr(pos));
 }
 
 void StructBuilder::setPtr(OpBuilder &builder, Location loc, unsigned pos,
                            Value ptr) {
   value = builder.create<LLVM::InsertValueOp>(loc, structType, value, ptr,
                                               builder.getI64ArrayAttr(pos));
 }
 
 //===----------------------------------------------------------------------===//
 // ComplexStructBuilder implementation
 //===----------------------------------------------------------------------===//
 
 ComplexStructBuilder ComplexStructBuilder::undef(OpBuilder &builder,
                                                  Location loc, Type type) {
-  Value val = builder.create<LLVM::UndefOp>(loc, type.cast<LLVM::LLVMType>());
+  Value val = builder.create<LLVM::UndefOp>(loc, type);
   return ComplexStructBuilder(val);
 }
 
 void ComplexStructBuilder::setReal(OpBuilder &builder, Location loc,
                                    Value real) {
   setPtr(builder, loc, kRealPosInComplexNumberStruct, real);
 }
 
indexType = value.getType()
                   .cast<LLVM::LLVMStructType>()
                   .getBody()[kOffsetPosInMemRefDescriptor];
 }
 
 /// Builds IR creating an `undef` value of the descriptor type.
 MemRefDescriptor MemRefDescriptor::undef(OpBuilder &builder, Location loc,
                                          Type descriptorType) {
 
-  Value descriptor =
-      builder.create<LLVM::UndefOp>(loc, descriptorType.cast<LLVM::LLVMType>());
+  Value descriptor = builder.create<LLVM::UndefOp>(loc, descriptorType);
   return MemRefDescriptor(descriptor);
 }
 
 /// Builds IR creating a MemRef descriptor that represents `type` and
 /// populates it with static shape and stride information extracted from the
 /// type.
 MemRefDescriptor
 MemRefDescriptor::fromStaticShape(OpBuilder &builder, Location loc,

 Value MemRefDescriptor::size(OpBuilder &builder, Location loc, unsigned pos) {
   return builder.create<LLVM::ExtractValueOp>(
       loc, indexType, value,
       builder.getI64ArrayAttr({kSizePosInMemRefDescriptor, pos}));
 }
 
 Value MemRefDescriptor::size(OpBuilder &builder, Location loc, Value pos,
                              int64_t rank) {
-  auto indexTy = indexType.cast<LLVM::LLVMType>();
-  auto indexPtrTy = LLVM::LLVMPointerType::get(indexTy);
-  auto arrayTy = LLVM::LLVMArrayType::get(indexTy, rank);
+  auto indexPtrTy = LLVM::LLVMPointerType::get(indexType);
+  auto arrayTy = LLVM::LLVMArrayType::get(indexType, rank);
   auto arrayPtrTy = LLVM::LLVMPointerType::get(arrayTy);
 
   // Copy size values to stack-allocated memory.
   auto zero = createIndexAttrConstant(builder, loc, indexType, 0);
   auto one = createIndexAttrConstant(builder, loc, indexType, 1);
   auto sizes = builder.create<LLVM::ExtractValueOp>(
       loc, arrayTy, value,
       builder.getI64ArrayAttr({kSizePosInMemRefDescriptor}));

 /// Construct a helper for the given descriptor value.
 UnrankedMemRefDescriptor::UnrankedMemRefDescriptor(Value descriptor)
     : StructBuilder(descriptor) {}
 
 /// Builds IR creating an `undef` value of the descriptor type.
 UnrankedMemRefDescriptor UnrankedMemRefDescriptor::undef(OpBuilder &builder,
                                                          Location loc,
                                                          Type descriptorType) {
-  Value descriptor =
-      builder.create<LLVM::UndefOp>(loc, descriptorType.cast<LLVM::LLVMType>());
+  Value descriptor = builder.create<LLVM::UndefOp>(loc, descriptorType);
   return UnrankedMemRefDescriptor(descriptor);
 }
 Value UnrankedMemRefDescriptor::rank(OpBuilder &builder, Location loc) {
   return extractPtr(builder, loc, kRankInUnrankedMemRefDescriptor);
 }
 void UnrankedMemRefDescriptor::setRank(OpBuilder &builder, Location loc,
                                        Value v) {
   setPtr(builder, loc, kRankInUnrankedMemRefDescriptor, v);

 
 void UnrankedMemRefDescriptor::computeSizes(
     OpBuilder &builder, Location loc, LLVMTypeConverter &typeConverter,
     ArrayRef<UnrankedMemRefDescriptor> values, SmallVectorImpl<Value> &sizes) {
   if (values.empty())
     return;
 
   // Cache the index type.
-  LLVM::LLVMType indexType = typeConverter.getIndexType();
+  Type indexType = typeConverter.getIndexType();
 
   // Initialize shared constants.
   Value one = createIndexAttrConstant(builder, loc, indexType, 1);
   Value two = createIndexAttrConstant(builder, loc, indexType, 2);
   Value pointerSize = createIndexAttrConstant(
       builder, loc, indexType, ceilDiv(typeConverter.getPointerBitwidth(), 8));
   Value indexSize =
       createIndexAttrConstant(builder, loc, indexType,
for (UnrankedMemRefDescriptor desc : values) {
     Value allocationSize = builder.create<LLVM::AddOp>(
         loc, indexType, doublePointerSize, rankIndexSize);
     sizes.push_back(allocationSize);
   }
 }
 
 Value UnrankedMemRefDescriptor::allocatedPtr(OpBuilder &builder, Location loc,
                                              Value memRefDescPtr,
-                                             LLVM::LLVMType elemPtrPtrType) {
+                                             Type elemPtrPtrType) {
 
   Value elementPtrPtr =
       builder.create<LLVM::BitcastOp>(loc, elemPtrPtrType, memRefDescPtr);
   return builder.create<LLVM::LoadOp>(loc, elementPtrPtr);
 }
 
 void UnrankedMemRefDescriptor::setAllocatedPtr(OpBuilder &builder, Location loc,
                                                Value memRefDescPtr,
-                                               LLVM::LLVMType elemPtrPtrType,
+                                               Type elemPtrPtrType,
                                                Value allocatedPtr) {
   Value elementPtrPtr =
       builder.create<LLVM::BitcastOp>(loc, elemPtrPtrType, memRefDescPtr);
   builder.create<LLVM::StoreOp>(loc, allocatedPtr, elementPtrPtr);
 }
 
 Value UnrankedMemRefDescriptor::alignedPtr(OpBuilder &builder, Location loc,
                                            LLVMTypeConverter &typeConverter,
                                            Value memRefDescPtr,
-                                           LLVM::LLVMType elemPtrPtrType) {
+                                           Type elemPtrPtrType) {
   Value elementPtrPtr =
       builder.create<LLVM::BitcastOp>(loc, elemPtrPtrType, memRefDescPtr);
 
   Value one =
       createIndexAttrConstant(builder, loc, typeConverter.getIndexType(), 1);
   Value alignedGep = builder.create<LLVM::GEPOp>(
       loc, elemPtrPtrType, elementPtrPtr, ValueRange({one}));
   return builder.create<LLVM::LoadOp>(loc, alignedGep);
 }
 
 void UnrankedMemRefDescriptor::setAlignedPtr(OpBuilder &builder, Location loc,
                                              LLVMTypeConverter &typeConverter,
                                              Value memRefDescPtr,
-                                             LLVM::LLVMType elemPtrPtrType,
+                                             Type elemPtrPtrType,
                                              Value alignedPtr) {
   Value elementPtrPtr =
       builder.create<LLVM::BitcastOp>(loc, elemPtrPtrType, memRefDescPtr);
 
   Value one =
       createIndexAttrConstant(builder, loc, typeConverter.getIndexType(), 1);
   Value alignedGep = builder.create<LLVM::GEPOp>(
       loc, elemPtrPtrType, elementPtrPtr, ValueRange({one}));
   builder.create<LLVM::StoreOp>(loc, alignedPtr, alignedGep);
 }
 
 Value UnrankedMemRefDescriptor::offset(OpBuilder &builder, Location loc,
                                        LLVMTypeConverter &typeConverter,
                                        Value memRefDescPtr,
-                                       LLVM::LLVMType elemPtrPtrType) {
+                                       Type elemPtrPtrType) {
   Value elementPtrPtr =
       builder.create<LLVM::BitcastOp>(loc, elemPtrPtrType, memRefDescPtr);
 
   Value two =
       createIndexAttrConstant(builder, loc, typeConverter.getIndexType(), 2);
   Value offsetGep = builder.create<LLVM::GEPOp>(
       loc, elemPtrPtrType, elementPtrPtr, ValueRange({two}));
   offsetGep = builder.create<LLVM::BitcastOp>(
       loc, LLVM::LLVMPointerType::get(typeConverter.getIndexType()), offsetGep);
   return builder.create<LLVM::LoadOp>(loc, offsetGep);
 }
 
 void UnrankedMemRefDescriptor::setOffset(OpBuilder &builder, Location loc,
                                          LLVMTypeConverter &typeConverter,
                                          Value memRefDescPtr,
-                                         LLVM::LLVMType elemPtrPtrType,
-                                         Value offset) {
+                                         Type elemPtrPtrType, Value offset) {
   Value elementPtrPtr =
       builder.create<LLVM::BitcastOp>(loc, elemPtrPtrType, memRefDescPtr);
 
   Value two =
       createIndexAttrConstant(builder, loc, typeConverter.getIndexType(), 2);
   Value offsetGep = builder.create<LLVM::GEPOp>(
       loc, elemPtrPtrType, elementPtrPtr, ValueRange({two}));
   offsetGep = builder.create<LLVM::BitcastOp>(
       loc, LLVM::LLVMPointerType::get(typeConverter.getIndexType()), offsetGep);
   builder.create<LLVM::StoreOp>(loc, offset, offsetGep);
 }
 
 Value UnrankedMemRefDescriptor::sizeBasePtr(
     OpBuilder &builder, Location loc, LLVMTypeConverter &typeConverter,
     Value memRefDescPtr, LLVM::LLVMPointerType elemPtrPtrType) {
-  LLVM::LLVMType elemPtrTy = elemPtrPtrType.getElementType();
-  LLVM::LLVMType indexTy = typeConverter.getIndexType();
-  LLVM::LLVMType structPtrTy =
+  Type elemPtrTy = elemPtrPtrType.getElementType();
+  Type indexTy = typeConverter.getIndexType();
+  Type structPtrTy =
       LLVM::LLVMPointerType::get(LLVM::LLVMStructType::getLiteral(
           indexTy.getContext(), {elemPtrTy, elemPtrTy, indexTy, indexTy}));
   Value structPtr =
       builder.create<LLVM::BitcastOp>(loc, structPtrTy, memRefDescPtr);
 
-  LLVM::LLVMType int32_type =
-      unwrap(typeConverter.convertType(builder.getI32Type()));
+  Type int32_type = unwrap(typeConverter.convertType(builder.getI32Type()));
   Value zero =
       createIndexAttrConstant(builder, loc, typeConverter.getIndexType(), 0);
   Value three = builder.create<LLVM::ConstantOp>(loc, int32_type,
                                                  builder.getI32IntegerAttr(3));
   return builder.create<LLVM::GEPOp>(loc, LLVM::LLVMPointerType::get(indexTy),
                                      structPtr, ValueRange({zero, three}));
 }
 
 Value UnrankedMemRefDescriptor::size(OpBuilder &builder, Location loc,
                                      LLVMTypeConverter typeConverter,
                                      Value sizeBasePtr, Value index) {
-  LLVM::LLVMType indexPtrTy =
-      LLVM::LLVMPointerType::get(typeConverter.getIndexType());
+  Type indexPtrTy = LLVM::LLVMPointerType::get(typeConverter.getIndexType());
   Value sizeStoreGep = builder.create<LLVM::GEPOp>(loc, indexPtrTy, sizeBasePtr,
                                                    ValueRange({index}));
   return builder.create<LLVM::LoadOp>(loc, sizeStoreGep);
 }
 
 void UnrankedMemRefDescriptor::setSize(OpBuilder &builder, Location loc,
                                        LLVMTypeConverter typeConverter,
                                        Value sizeBasePtr, Value index,
                                        Value size) {
-  LLVM::LLVMType indexPtrTy =
-      LLVM::LLVMPointerType::get(typeConverter.getIndexType());
+  Type indexPtrTy = LLVM::LLVMPointerType::get(typeConverter.getIndexType());
   Value sizeStoreGep = builder.create<LLVM::GEPOp>(loc, indexPtrTy, sizeBasePtr,
                                                    ValueRange({index}));
   builder.create<LLVM::StoreOp>(loc, size, sizeStoreGep);
 }
 
 Value UnrankedMemRefDescriptor::strideBasePtr(OpBuilder &builder, Location loc,
                                               LLVMTypeConverter &typeConverter,
                                               Value sizeBasePtr, Value rank) {
-  LLVM::LLVMType indexPtrTy =
-      LLVM::LLVMPointerType::get(typeConverter.getIndexType());
+  Type indexPtrTy = LLVM::LLVMPointerType::get(typeConverter.getIndexType());
   return builder.create<LLVM::GEPOp>(loc, indexPtrTy, sizeBasePtr,
                                      ValueRange({rank}));
 }
 
 Value UnrankedMemRefDescriptor::stride(OpBuilder &builder, Location loc,
                                        LLVMTypeConverter typeConverter,
                                        Value strideBasePtr, Value index,
                                        Value stride) {
-  LLVM::LLVMType indexPtrTy =
-      LLVM::LLVMPointerType::get(typeConverter.getIndexType());
+  Type indexPtrTy = LLVM::LLVMPointerType::get(typeConverter.getIndexType());
   Value strideStoreGep = builder.create<LLVM::GEPOp>(
       loc, indexPtrTy, strideBasePtr, ValueRange({index}));
   return builder.create<LLVM::LoadOp>(loc, strideStoreGep);
 }
 
 void UnrankedMemRefDescriptor::setStride(OpBuilder &builder, Location loc,
                                          LLVMTypeConverter typeConverter,
                                          Value strideBasePtr, Value index,
                                          Value stride) {
-  LLVM::LLVMType indexPtrTy =
-      LLVM::LLVMPointerType::get(typeConverter.getIndexType());
+  Type indexPtrTy = LLVM::LLVMPointerType::get(typeConverter.getIndexType());
   Value strideStoreGep = builder.create<LLVM::GEPOp>(
       loc, indexPtrTy, strideBasePtr, ValueRange({index}));
   builder.create<LLVM::StoreOp>(loc, stride, strideStoreGep);
 }
 
 LLVMTypeConverter *ConvertToLLVMPattern::getTypeConverter() const {
   return static_cast<LLVMTypeConverter *>(
       ConversionPattern::getTypeConverter());
 }
 
 LLVM::LLVMDialect &ConvertToLLVMPattern::getDialect() const {
   return *getTypeConverter()->getDialect();
 }
 
-LLVM::LLVMType ConvertToLLVMPattern::getIndexType() const {
+Type ConvertToLLVMPattern::getIndexType() const {
   return getTypeConverter()->getIndexType();
 }
 
-LLVM::LLVMType
-ConvertToLLVMPattern::getIntPtrType(unsigned addressSpace) const {
+Type ConvertToLLVMPattern::getIntPtrType(unsigned addressSpace) const {
   return LLVM::LLVMIntegerType::get(
       &getTypeConverter()->getContext(),
       getTypeConverter()->getPointerBitwidth(addressSpace));
 }
 
-LLVM::LLVMType ConvertToLLVMPattern::getVoidType() const {
+Type ConvertToLLVMPattern::getVoidType() const {
   return LLVM::LLVMVoidType::get(&getTypeConverter()->getContext());
 }
 
-LLVM::LLVMType ConvertToLLVMPattern::getVoidPtrType() const {
+Type ConvertToLLVMPattern::getVoidPtrType() const {
   return LLVM::LLVMPointerType::get(
       LLVM::LLVMIntegerType::get(&getTypeConverter()->getContext(), 8));
 }
 
 Value ConvertToLLVMPattern::createIndexConstant(
     ConversionPatternRewriter &builder, Location loc, uint64_t value) const {
   return createIndexAttrConstant(builder, loc, getIndexType(), value);
 }
if (strides[i] != 1) { // Skip if stride is 1.
                          ? memRefDescriptor.stride(rewriter, loc, i)
                          : createIndexConstant(rewriter, loc, strides[i]);
       increment = rewriter.create<LLVM::MulOp>(loc, increment, stride);
     }
     index =
         index ? rewriter.create<LLVM::AddOp>(loc, index, increment) : increment;
   }
 
-  LLVM::LLVMType elementPtrType = memRefDescriptor.getElementPtrType();
+  Type elementPtrType = memRefDescriptor.getElementPtrType();
   return index ? rewriter.create<LLVM::GEPOp>(loc, elementPtrType, base, index)
                : base;
 }
 
 Value ConvertToLLVMPattern::getDataPtr(
     Location loc, MemRefType type, Value memRefDesc, ValueRange indices,
     ConversionPatternRewriter &rewriter) const {
   return getStridedElementPtr(loc, type, memRefDesc, indices, rewriter);

 
 Value ConvertToLLVMPattern::getSizeInBytes(
     Location loc, Type type, ConversionPatternRewriter &rewriter) const {
   // Compute the size of an individual element. This emits the MLIR equivalent
   // of the following sizeof(...) implementation in LLVM IR:
   //   %0 = getelementptr %elementType* null, %indexType 1
   //   %1 = ptrtoint %elementType* %0 to %indexType
   // which is a common pattern of getting the size of a type in bytes.
-  auto convertedPtrType = LLVM::LLVMPointerType::get(
-      typeConverter->convertType(type).cast<LLVM::LLVMType>());
+  auto convertedPtrType =
+      LLVM::LLVMPointerType::get(typeConverter->convertType(type));
   auto nullPtr = rewriter.create<LLVM::NullOp>(loc, convertedPtrType);
   auto gep = rewriter.create<LLVM::GEPOp>(
       loc, convertedPtrType,
       ArrayRef<Value>{nullPtr, createIndexConstant(rewriter, loc, 1)});
   return rewriter.create<LLVM::PtrToIntOp>(loc, getIndexType(), gep);
 }
 
 Value ConvertToLLVMPattern::getNumElements(

 /// the auxiliary function. This auxiliary external function is now compatible
 /// with functions defined in C using pointers to C structs corresponding to a
 /// memref descriptor.
 static void wrapExternalFunction(OpBuilder &builder, Location loc,
                                  LLVMTypeConverter &typeConverter,
                                  FuncOp funcOp, LLVM::LLVMFuncOp newFuncOp) {
   OpBuilder::InsertionGuard guard(builder);
 
-  LLVM::LLVMType wrapperType =
+  Type wrapperType =
       typeConverter.convertFunctionTypeCWrapper(funcOp.getType());
   // This conversion can only fail if it could not convert one of the argument
   // types. But since it has been applies to a non-wrapper function before, it
   // should have failed earlier and not reach this point at all.
   assert(wrapperType && "unexpected type conversion failure");
 
   SmallVector<NamedAttribute, 4> attributes;
   filterFuncAttributes(funcOp.getAttrs(), /*filterArgAttrs=*/false, attributes);
if (memRefType || unrankedMemRefType) {
       Value packed =
           memRefType
               ? MemRefDescriptor::pack(builder, loc, typeConverter, memRefType,
                                        wrapperArgsRange.take_front(numToDrop))
               : UnrankedMemRefDescriptor::pack(
                     builder, loc, typeConverter, unrankedMemRefType,
                     wrapperArgsRange.take_front(numToDrop));
 
-      auto ptrTy =
-          LLVM::LLVMPointerType::get(packed.getType().cast<LLVM::LLVMType>());
+      auto ptrTy = LLVM::LLVMPointerType::get(packed.getType());
       Value one = builder.create<LLVM::ConstantOp>(
           loc, typeConverter.convertType(builder.getIndexType()),
           builder.getIntegerAttr(builder.getIndexType(), 1));
       Value allocated =
           builder.create<LLVM::AllocaOp>(loc, ptrTy, one, /*alignment=*/0);
       builder.create<LLVM::StoreOp>(loc, packed, allocated);
       arg = allocated;
     } else {
struct BarePtrFuncOpConversion : public FuncOpConversionBase {
   }
 };
 
 //////////////// Support for Lowering operations on n-D vectors ////////////////
 // Helper struct to "unroll" operations on n-D vectors in terms of operations on
 // 1-D LLVM vectors.
 struct NDVectorTypeInfo {
   // LLVM array struct which encodes n-D vectors.
-  LLVM::LLVMType llvmArrayTy;
+  Type llvmArrayTy;
   // LLVM vector type which encodes the inner 1-D vector type.
-  LLVM::LLVMType llvmVectorTy;
+  Type llvmVectorTy;
   // Multiplicity of llvmArrayTy to llvmVectorTy.
   SmallVector<int64_t, 4> arraySizes;
 };
 } // namespace
 
 // For >1-D vector types, extracts the necessary information to iterate over all
 // 1-D subvectors in the underlying llrepresentation of the n-D vector
 // Iterates on the llvm array type until we hit a non-array type (which is
 // asserted to be an llvm vector type).
 static NDVectorTypeInfo extractNDVectorTypeInfo(VectorType vectorType,
                                                 LLVMTypeConverter &converter) {
   assert(vectorType.getRank() > 1 && "expected >1D vector type");
   NDVectorTypeInfo info;
-  info.llvmArrayTy =
-      converter.convertType(vectorType).dyn_cast<LLVM::LLVMType>();
-  if (!info.llvmArrayTy)
+  info.llvmArrayTy = converter.convertType(vectorType);
+  if (!info.llvmArrayTy || !LLVM::isCompatibleType(info.llvmArrayTy)) {
+    info.llvmArrayTy = nullptr;
     return info;
+  }
   info.arraySizes.reserve(vectorType.getRank() - 1);
   auto llvmTy = info.llvmArrayTy;
   while (llvmTy.isa<LLVM::LLVMArrayType>()) {
     info.arraySizes.push_back(
         llvmTy.cast<LLVM::LLVMArrayType>().getNumElements());
     llvmTy = llvmTy.cast<LLVM::LLVMArrayType>().getElementType();
   }
   if (!llvmTy.isa<LLVM::LLVMVectorType>())
results.push_back(rewriter.create<LLVM::ExtractValueOp>(
         op->getLoc(), type, newOp->getResult(0), rewriter.getI64ArrayAttr(i)));
   }
   rewriter.replaceOp(op, results);
   return success();
 }
 
 static LogicalResult handleMultidimensionalVectors(
     Operation *op, ValueRange operands, LLVMTypeConverter &typeConverter,
-    std::function<Value(LLVM::LLVMType, ValueRange)> createOperand,
+    std::function<Value(Type, ValueRange)> createOperand,
     ConversionPatternRewriter &rewriter) {
   auto vectorType = op->getResult(0).getType().dyn_cast<VectorType>();
   if (!vectorType)
     return failure();
   auto vectorTypeInfo = extractNDVectorTypeInfo(vectorType, typeConverter);
   auto llvmVectorTy = vectorTypeInfo.llvmVectorTy;
-  auto llvmArrayTy = operands[0].getType().cast<LLVM::LLVMType>();
+  auto llvmArrayTy = operands[0].getType();
   if (!llvmVectorTy || llvmArrayTy != vectorTypeInfo.llvmArrayTy)
     return failure();
 
   auto loc = op->getLoc();
   Value desc = rewriter.create<LLVM::UndefOp>(loc, llvmArrayTy);
   nDVectorIterate(vectorTypeInfo, rewriter, [&](ArrayAttr position) {
     // For this unrolled `position` corresponding to the `linearIndex`^th
     // element, extract operand vectors

 
 LogicalResult LLVM::detail::vectorOneToOneRewrite(
     Operation *op, StringRef targetOp, ValueRange operands,
     LLVMTypeConverter &typeConverter, ConversionPatternRewriter &rewriter) {
   assert(!operands.empty());
 
   // Cannot convert ops if their operands are not of LLVM type.
   if (!llvm::all_of(operands.getTypes(),
-                    [](Type t) { return t.isa<LLVM::LLVMType>(); }))
+                    [](Type t) { return isCompatibleType(t); }))
     return failure();
 
-  auto llvmArrayTy = operands[0].getType().cast<LLVM::LLVMType>();
+  auto llvmArrayTy = operands[0].getType();
   if (!llvmArrayTy.isa<LLVM::LLVMArrayType>())
     return oneToOneRewrite(op, targetOp, operands, typeConverter, rewriter);
 
-  auto callback = [op, targetOp, &rewriter](LLVM::LLVMType llvmVectorTy,
+  auto callback = [op, targetOp, &rewriter](Type llvmVectorTy,
                                             ValueRange operands) {
     OperationState state(op->getLoc(), targetOp);
     state.addTypes(llvmVectorTy);
     state.addOperands(operands);
     state.addAttributes(op->getAttrs());
     return rewriter.createOperation(state)->getResult(0);
   };
 

 struct ConstantOpLowering : public ConvertOpToLLVMPattern<ConstantOp> {
   using ConvertOpToLLVMPattern<ConstantOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(ConstantOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     // If constant refers to a function, convert it to "addressof".
     if (auto symbolRef = op.getValue().dyn_cast<FlatSymbolRefAttr>()) {
-      auto type = typeConverter->convertType(op.getResult().getType())
-                      .dyn_cast_or_null<LLVM::LLVMType>();
-      if (!type)
+      auto type = typeConverter->convertType(op.getResult().getType());
+      if (!type || !LLVM::isCompatibleType(type))
         return rewriter.notifyMatchFailure(op, "failed to convert result type");
 
       MutableDictionaryAttr attrs(op.getAttrs());
       attrs.remove(rewriter.getIdentifier("value"));
-      rewriter.replaceOpWithNewOp<LLVM::AddressOfOp>(
-          op, type.cast<LLVM::LLVMType>(), symbolRef.getValue(),
-          attrs.getAttrs());
+      attrs.remove(rewriter.getIdentifier("global_name"));
+      auto newOp = rewriter.create<LLVM::AddressOfOp>(op.getLoc(), type,
+                                                      symbolRef.getValue());
+      for (const NamedAttribute &attr : attrs.getAttrs())
+        newOp->setAttr(attr.first, attr.second);
+      rewriter.replaceOp(op, newOp->getResults());
       return success();
     }
 
     // Calling into other scopes (non-flat reference) is not supported in LLVM.
     if (op.getValue().isa<SymbolRefAttr>())
       return rewriter.notifyMatchFailure(
           op, "referring to a symbol outside of the current module");
 
static Value createAligned(ConversionPatternRewriter &rewriter, Location loc,
     return rewriter.create<LLVM::SubOp>(loc, bumped, mod);
   }
 
   // Creates a call to an allocation function with params and casts the
   // resulting void pointer to ptrType.
   Value createAllocCall(Location loc, StringRef name, Type ptrType,
                         ArrayRef<Value> params, ModuleOp module,
                         ConversionPatternRewriter &rewriter) const {
-    SmallVector<LLVM::LLVMType, 2> paramTypes;
+    SmallVector<Type, 2> paramTypes;
     auto allocFuncOp = module.lookupSymbol<LLVM::LLVMFuncOp>(name);
     if (!allocFuncOp) {
       for (Value param : params)
-        paramTypes.push_back(param.getType().cast<LLVM::LLVMType>());
+        paramTypes.push_back(param.getType());
       auto allocFuncType =
           LLVM::LLVMFunctionType::get(getVoidPtrType(), paramTypes);
       OpBuilder::InsertionGuard guard(rewriter);
       rewriter.setInsertionPointToStart(module.getBody());
       allocFuncOp = rewriter.create<LLVM::LLVMFuncOp>(rewriter.getUnknownLoc(),
                                                       name, allocFuncType);
     }
     auto allocFuncSymbol = rewriter.getSymbolRefAttr(allocFuncOp);
static LogicalResult copyUnrankedDescriptors(OpBuilder &builder, Location loc,
   // Compute allocation sizes.
   SmallVector<Value, 4> sizes;
   UnrankedMemRefDescriptor::computeSizes(builder, loc, typeConverter,
                                          unrankedMemrefs, sizes);
 
   // Get frequently used types.
   MLIRContext *context = builder.getContext();
   auto voidType = LLVM::LLVMVoidType::get(context);
-  LLVM::LLVMType voidPtrType =
+  Type voidPtrType =
       LLVM::LLVMPointerType::get(LLVM::LLVMIntegerType::get(context, 8));
   auto i1Type = LLVM::LLVMIntegerType::get(context, 1);
-  LLVM::LLVMType indexType = typeConverter.getIndexType();
+  Type indexType = typeConverter.getIndexType();
 
   // Find the malloc and free, or declare them if necessary.
   auto module = builder.getInsertionPoint()->getParentOfType<ModuleOp>();
   auto mallocFunc = module.lookupSymbol<LLVM::LLVMFuncOp>("malloc");
   if (!mallocFunc && toDynamic) {
     OpBuilder::InsertionGuard guard(builder);
     builder.setInsertionPointToStart(module.getBody());
     mallocFunc = builder.create<LLVM::LLVMFuncOp>(
Value casted = rewriter.create<LLVM::BitcastOp>(
         memref.allocatedPtr(rewriter, op.getLoc()));
     rewriter.replaceOpWithNewOp<LLVM::CallOp>(
         op, TypeRange(), rewriter.getSymbolRefAttr(freeFunc), casted);
     return success();
   }
 };
 
 /// Returns the LLVM type of the global variable given the memref type `type`.
-static LLVM::LLVMType
-convertGlobalMemrefTypeToLLVM(MemRefType type,
+static Type convertGlobalMemrefTypeToLLVM(MemRefType type,
                                           LLVMTypeConverter &typeConverter) {
   // LLVM type for a global memref will be a multi-dimension array. For
   // declarations or uninitialized global memrefs, we can potentially flatten
   // this to a 1D array. However, for global_memref's with an initial value,
   // we do not intend to flatten the ElementsAttribute when going from std ->
   // LLVM dialect, so the LLVM type needs to me a multi-dimension array.
-  LLVM::LLVMType elementType =
-      unwrap(typeConverter.convertType(type.getElementType()));
-  LLVM::LLVMType arrayTy = elementType;
+  Type elementType = unwrap(typeConverter.convertType(type.getElementType()));
+  Type arrayTy = elementType;
   // Shape has the outermost dim at index 0, so need to walk it backwards
   for (int64_t dim : llvm::reverse(type.getShape()))
     arrayTy = LLVM::LLVMArrayType::get(arrayTy, dim);
   return arrayTy;
 }
 
 /// GlobalMemrefOp is lowered to a LLVM Global Variable.
 struct GlobalMemrefOpLowering : public ConvertOpToLLVMPattern<GlobalMemrefOp> {
   using ConvertOpToLLVMPattern<GlobalMemrefOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(GlobalMemrefOp global, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     MemRefType type = global.type().cast<MemRefType>();
     if (!isSupportedMemRefType(type))
       return failure();
 
-    LLVM::LLVMType arrayTy =
-        convertGlobalMemrefTypeToLLVM(type, *getTypeConverter());
+    Type arrayTy = convertGlobalMemrefTypeToLLVM(type, *getTypeConverter());
 
     LLVM::Linkage linkage =
         global.isPublic() ? LLVM::Linkage::External : LLVM::Linkage::Private;
 
     Attribute initialValue = nullptr;
     if (!global.isExternal() && !global.isUninitialized()) {
       auto elementsAttr = global.initial_value()->cast<ElementsAttr>();
       initialValue = elementsAttr;
struct GetGlobalMemrefOpLowering : public AllocLikeOpLowering {
   /// the global variable referenced.
   std::tuple<Value, Value> allocateBuffer(ConversionPatternRewriter &rewriter,
                                           Location loc, Value sizeBytes,
                                           Operation *op) const override {
     auto getGlobalOp = cast<GetGlobalMemrefOp>(op);
     MemRefType type = getGlobalOp.result().getType().cast<MemRefType>();
     unsigned memSpace = type.getMemorySpace();
 
-    LLVM::LLVMType arrayTy =
-        convertGlobalMemrefTypeToLLVM(type, *getTypeConverter());
+    Type arrayTy = convertGlobalMemrefTypeToLLVM(type, *getTypeConverter());
     auto addressOf = rewriter.create<LLVM::AddressOfOp>(
         loc, LLVM::LLVMPointerType::get(arrayTy, memSpace), getGlobalOp.name());
 
     // Get the address of the first element in the array by creating a GEP with
     // the address of the GV as the base, and (rank + 1) number of 0 indices.
-    LLVM::LLVMType elementType =
+    Type elementType =
         unwrap(typeConverter->convertType(type.getElementType()));
-    LLVM::LLVMType elementPtrType =
-        LLVM::LLVMPointerType::get(elementType, memSpace);
+    Type elementPtrType = LLVM::LLVMPointerType::get(elementType, memSpace);
 
     SmallVector<Value, 4> operands = {addressOf};
     operands.insert(operands.end(), type.getRank() + 1,
                     createIndexConstant(rewriter, loc, 0));
     auto gep = rewriter.create<LLVM::GEPOp>(loc, elementPtrType, operands);
 
     // We do not expect the memref obtained using `get_global_memref` to be
     // ever deallocated. Set the allocated pointer to be known bad value to

 // A `rsqrt` is converted into `1 / sqrt`.
 struct RsqrtOpLowering : public ConvertOpToLLVMPattern<RsqrtOp> {
   using ConvertOpToLLVMPattern<RsqrtOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(RsqrtOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     RsqrtOp::Adaptor transformed(operands);
-    auto operandType =
-        transformed.operand().getType().dyn_cast<LLVM::LLVMType>();
+    auto operandType = transformed.operand().getType();
 
-    if (!operandType)
+    if (!operandType || !LLVM::isCompatibleType(operandType))
       return failure();
 
     auto loc = op.getLoc();
     auto resultType = op.getResult().getType();
     auto floatType = getElementTypeOrSelf(resultType).cast<FloatType>();
     auto floatOne = rewriter.getFloatAttr(floatType, 1.0);
 
     if (!operandType.isa<LLVM::LLVMArrayType>()) {
matchAndRewrite(RsqrtOp op, ArrayRef<Value> operands,
     }
 
     auto vectorType = resultType.dyn_cast<VectorType>();
     if (!vectorType)
       return failure();
 
     return handleMultidimensionalVectors(
         op.getOperation(), operands, *getTypeConverter(),
-        [&](LLVM::LLVMType llvmVectorTy, ValueRange operands) {
+        [&](Type llvmVectorTy, ValueRange operands) {
           auto splatAttr = SplatElementsAttr::get(
               mlir::VectorType::get(
                   {llvmVectorTy.cast<LLVM::LLVMFixedVectorType>()
                        .getNumElements()},
                   floatType),
               floatOne);
           auto one =
               rewriter.create<LLVM::ConstantOp>(loc, llvmVectorTy, splatAttr);
void rewrite(MemRefCastOp memRefCastOp, ArrayRef<Value> operands,
     } else if (srcType.isa<UnrankedMemRefType>() && dstType.isa<MemRefType>()) {
       // Casting from unranked type to ranked.
       // The operation is assumed to be doing a correct cast. If the destination
       // type mismatches the unranked the type, it is undefined behavior.
       UnrankedMemRefDescriptor memRefDesc(transformed.source());
       // ptr = ExtractValueOp src, 1
       auto ptr = memRefDesc.memRefDescPtr(rewriter, loc);
       // castPtr = BitCastOp i8* to structTy*
-      auto castPtr = rewriter
-                         .create<LLVM::BitcastOp>(
-                             loc,
-                             LLVM::LLVMPointerType::get(
-                                 targetStructType.cast<LLVM::LLVMType>()),
-                             ptr)
-                         .getResult();
+      auto castPtr =
+          rewriter
+                  loc, LLVM::LLVMPointerType::get(targetStructType), ptr)
       // struct = LoadOp castPtr
       auto loadOp = rewriter.create<LLVM::LoadOp>(loc, castPtr);
       rewriter.replaceOp(memRefCastOp, loadOp.getResult());
     } else {
       llvm_unreachable("Unsupported unranked memref to unranked memref cast");
     }
   }
 };
if (operandType.isa<MemRefType>()) {
     if (offset != nullptr)
       *offset = desc.offset(rewriter, loc);
     return;
   }
 
   unsigned memorySpace =
       operandType.cast<UnrankedMemRefType>().getMemorySpace();
   Type elementType = operandType.cast<UnrankedMemRefType>().getElementType();
-  LLVM::LLVMType llvmElementType =
-      unwrap(typeConverter.convertType(elementType));
-  LLVM::LLVMType elementPtrPtrType = LLVM::LLVMPointerType::get(
+  Type llvmElementType = unwrap(typeConverter.convertType(elementType));
+  Type elementPtrPtrType = LLVM::LLVMPointerType::get(
       LLVM::LLVMPointerType::get(llvmElementType, memorySpace));
 
   // Extract pointer to the underlying ranked memref descriptor and cast it to
   // ElemType**.
   UnrankedMemRefDescriptor unrankedDesc(convertedOperand);
   Value underlyingDescPtr = unrankedDesc.memRefDescPtr(rewriter, loc);
 
   *allocatedPtr = UnrankedMemRefDescriptor::allocatedPtr(
convertSourceMemRefToDescriptor(ConversionPatternRewriter &rewriter,
 
     // Extract pointers and offset from the source memref.
     Value allocatedPtr, alignedPtr, offset;
     extractPointersAndOffset(loc, rewriter, *getTypeConverter(),
                              reshapeOp.source(), adaptor.source(),
                              &allocatedPtr, &alignedPtr, &offset);
 
     // Set pointers and offset.
-    LLVM::LLVMType llvmElementType =
-        unwrap(typeConverter->convertType(elementType));
+    Type llvmElementType = unwrap(typeConverter->convertType(elementType));
     auto elementPtrPtrType = LLVM::LLVMPointerType::get(
         LLVM::LLVMPointerType::get(llvmElementType, addressSpace));
     UnrankedMemRefDescriptor::setAllocatedPtr(rewriter, loc, underlyingDescPtr,
                                               elementPtrPtrType, allocatedPtr);
     UnrankedMemRefDescriptor::setAlignedPtr(rewriter, loc, *getTypeConverter(),
                                             underlyingDescPtr,
                                             elementPtrPtrType, alignedPtr);
     UnrankedMemRefDescriptor::setOffset(rewriter, loc, *getTypeConverter(),
                                         underlyingDescPtr, elementPtrPtrType,
                                         offset);
 
     // Use the offset pointer as base for further addressing. Copy over the new
     // shape and compute strides. For this, we create a loop from rank-1 to 0.
     Value targetSizesBase = UnrankedMemRefDescriptor::sizeBasePtr(
         rewriter, loc, *getTypeConverter(), underlyingDescPtr,
         elementPtrPtrType);
     Value targetStridesBase = UnrankedMemRefDescriptor::strideBasePtr(
         rewriter, loc, *getTypeConverter(), targetSizesBase, resultRank);
     Value shapeOperandPtr = shapeDesc.alignedPtr(rewriter, loc);
     Value oneIndex = createIndexConstant(rewriter, loc, 1);
     Value resultRankMinusOne =
         rewriter.create<LLVM::SubOp>(loc, resultRank, oneIndex);
 
     Block *initBlock = rewriter.getInsertionBlock();
-    LLVM::LLVMType indexType = getTypeConverter()->getIndexType();
+    Type indexType = getTypeConverter()->getIndexType();
     Block::iterator remainingOpsIt = std::next(rewriter.getInsertionPoint());
 
     Block *condBlock = rewriter.createBlock(initBlock->getParent(), {},
                                             {indexType, indexType});
 
     // Iterate over the remaining ops in initBlock and move them to condBlock.
     BlockAndValueMapping map;
     for (auto it = remainingOpsIt, e = initBlock->end(); it != e; ++it) {
Value pred = rewriter.create<LLVM::ICmpOp>(
         loc, LLVM::LLVMIntegerType::get(rewriter.getContext(), 1),
         LLVM::ICmpPredicate::sge, indexArg, zeroIndex);
 
     Block *bodyBlock =
         rewriter.splitBlock(condBlock, rewriter.getInsertionPoint());
     rewriter.setInsertionPointToStart(bodyBlock);
 
     // Copy size from shape to descriptor.
-    LLVM::LLVMType llvmIndexPtrType = LLVM::LLVMPointerType::get(indexType);
+    Type llvmIndexPtrType = LLVM::LLVMPointerType::get(indexType);
     Value sizeLoadGep = rewriter.create<LLVM::GEPOp>(
         loc, llvmIndexPtrType, shapeOperandPtr, ValueRange{indexArg});
     Value size = rewriter.create<LLVM::LoadOp>(loc, sizeLoadGep);
     UnrankedMemRefDescriptor::setSize(rewriter, loc, *getTypeConverter(),
                                       targetSizesBase, indexArg, size);
 
     // Write stride value and compute next one.
     UnrankedMemRefDescriptor::setStride(rewriter, loc, *getTypeConverter(),
Value extractSizeOfUnrankedMemRef(Type operandType, DimOp dimOp,
 
     // Extract pointer to the underlying ranked descriptor and bitcast it to a
     // memref<element_type> descriptor pointer to minimize the number of GEP
     // operations.
     UnrankedMemRefDescriptor unrankedDesc(transformed.memrefOrTensor());
     Value underlyingRankedDesc = unrankedDesc.memRefDescPtr(rewriter, loc);
     Value scalarMemRefDescPtr = rewriter.create<LLVM::BitcastOp>(
         loc,
-        LLVM::LLVMPointerType::get(
-            typeConverter->convertType(scalarMemRefType).cast<LLVM::LLVMType>(),
+        LLVM::LLVMPointerType::get(typeConverter->convertType(scalarMemRefType),
                                    addressSpace),
         underlyingRankedDesc);
 
     // Get pointer to offset field of memref<element_type> descriptor.
     Type indexPtrTy = LLVM::LLVMPointerType::get(
         getTypeConverter()->getIndexType(), addressSpace);
     Value two = rewriter.create<LLVM::ConstantOp>(
         loc, typeConverter->convertType(rewriter.getI32Type()),
         rewriter.getI32IntegerAttr(2));
struct SubViewOpLowering : public ConvertOpToLLVMPattern<SubViewOp> {
 
   LogicalResult
   matchAndRewrite(SubViewOp subViewOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     auto loc = subViewOp.getLoc();
 
     auto sourceMemRefType = subViewOp.source().getType().cast<MemRefType>();
     auto sourceElementTy =
-        typeConverter->convertType(sourceMemRefType.getElementType())
-            .dyn_cast_or_null<LLVM::LLVMType>();
+        typeConverter->convertType(sourceMemRefType.getElementType());
 
     auto viewMemRefType = subViewOp.getType();
     auto inferredType = SubViewOp::inferResultType(
                             subViewOp.getSourceType(),
                             extractFromI64ArrayAttr(subViewOp.static_offsets()),
                             extractFromI64ArrayAttr(subViewOp.static_sizes()),
                             extractFromI64ArrayAttr(subViewOp.static_strides()))
                             .cast<MemRefType>();
     auto targetElementTy =
-        typeConverter->convertType(viewMemRefType.getElementType())
-            .dyn_cast<LLVM::LLVMType>();
-    auto targetDescTy = typeConverter->convertType(viewMemRefType)
-                            .dyn_cast_or_null<LLVM::LLVMType>();
-    if (!sourceElementTy || !targetDescTy)
+        typeConverter->convertType(viewMemRefType.getElementType());
+    auto targetDescTy = typeConverter->convertType(viewMemRefType);
+    if (!sourceElementTy || !targetDescTy || !targetElementTy ||
+        !LLVM::isCompatibleType(sourceElementTy) ||
+        !LLVM::isCompatibleType(targetElementTy) ||
+        !LLVM::isCompatibleType(targetDescTy))
       return failure();
 
     // Extract the offset and strides from the type.
     int64_t offset;
     SmallVector<int64_t, 4> strides;
     auto successStrides = getStridesAndOffset(inferredType, strides, offset);
     if (failed(successStrides))
       return failure();
 
     // Create the descriptor.
-    if (!operands.front().getType().isa<LLVM::LLVMType>())
+    if (!LLVM::isCompatibleType(operands.front().getType()))
       return failure();
     MemRefDescriptor sourceMemRef(operands.front());
     auto targetMemRef = MemRefDescriptor::undef(rewriter, loc, targetDescTy);
 
     // Copy the buffer pointer from the old descriptor to the new one.
     Value extracted = sourceMemRef.allocatedPtr(rewriter, loc);
     Value bitcastPtr = rewriter.create<LLVM::BitcastOp>(
         loc,
struct ViewOpLowering : public ConvertOpToLLVMPattern<ViewOp> {
   LogicalResult
   matchAndRewrite(ViewOp viewOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     auto loc = viewOp.getLoc();
     ViewOpAdaptor adaptor(operands);
 
     auto viewMemRefType = viewOp.getType();
     auto targetElementTy =
-        typeConverter->convertType(viewMemRefType.getElementType())
-            .dyn_cast<LLVM::LLVMType>();
-    auto targetDescTy =
-        typeConverter->convertType(viewMemRefType).dyn_cast<LLVM::LLVMType>();
-    if (!targetDescTy)
+        typeConverter->convertType(viewMemRefType.getElementType());
+    auto targetDescTy = typeConverter->convertType(viewMemRefType);
+    if (!targetDescTy || !targetElementTy ||
+        !LLVM::isCompatibleType(targetElementTy) ||
+        !LLVM::isCompatibleType(targetDescTy))
       return viewOp.emitWarning("Target descriptor type not converted to LLVM"),
              failure();
 
     int64_t offset;
     SmallVector<int64_t, 4> strides;
     auto successStrides = getStridesAndOffset(viewMemRefType, strides, offset);
     if (failed(successStrides))
       return viewOp.emitWarning("cannot cast to non-strided shape"), failure();
struct GenericAtomicRMWOpLowering
   using Base::Base;
 
   LogicalResult
   matchAndRewrite(GenericAtomicRMWOp atomicOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
 
     auto loc = atomicOp.getLoc();
     GenericAtomicRMWOp::Adaptor adaptor(operands);
-    LLVM::LLVMType valueType =
-        typeConverter->convertType(atomicOp.getResult().getType())
-            .cast<LLVM::LLVMType>();
+    Type valueType = typeConverter->convertType(atomicOp.getResult().getType());
 
     // Split the block into initial, loop, and ending parts.
     auto *initBlock = rewriter.getInsertionBlock();
     auto *loopBlock =
         rewriter.createBlock(initBlock->getParent(),
                              std::next(Region::iterator(initBlock)), valueType);
     auto *endBlock = rewriter.createBlock(
         loopBlock->getParent(), std::next(Region::iterator(loopBlock)));

 /// create an LLVM IR structure type with elements that correspond to each of
 /// the MLIR types converted with `convertType`.
 Type LLVMTypeConverter::packFunctionResults(ArrayRef<Type> types) {
   assert(!types.empty() && "expected non-empty list of type");
 
   if (types.size() == 1)
     return convertCallingConventionType(types.front());
 
-  SmallVector<LLVM::LLVMType, 8> resultTypes;
+  SmallVector<Type, 8> resultTypes;
   resultTypes.reserve(types.size());
   for (auto t : types) {
-    auto converted =
-        convertCallingConventionType(t).dyn_cast_or_null<LLVM::LLVMType>();
-    if (!converted)
+    auto converted = convertCallingConventionType(t);
+    if (!converted || !LLVM::isCompatibleType(converted))
       return {};
     resultTypes.push_back(converted);
   }
 
   return LLVM::LLVMStructType::getLiteral(&getContext(), resultTypes);
 }
 
 Value LLVMTypeConverter::promoteOneMemRefDescriptor(Location loc, Value operand,
                                                     OpBuilder &builder) {
   auto *context = builder.getContext();
   auto int64Ty = LLVM::LLVMIntegerType::get(builder.getContext(), 64);
   auto indexType = IndexType::get(context);
   // Alloca with proper alignment. We do not expect optimizations of this
   // alloca op and so we omit allocating at the entry block.
-  auto ptrType =
-      LLVM::LLVMPointerType::get(operand.getType().cast<LLVM::LLVMType>());
+  auto ptrType = LLVM::LLVMPointerType::get(operand.getType());
   Value one = builder.create<LLVM::ConstantOp>(loc, int64Ty,
                                                IntegerAttr::get(indexType, 1));
   Value allocated =
       builder.create<LLVM::AllocaOp>(loc, ptrType, one, /*alignment=*/0);
   // Store into the alloca'ed descriptor.
   builder.create<LLVM::StoreOp>(loc, operand, allocated);
   return allocated;
 }

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

Type elementTy =
       typeConverter.convertType(op.getMemRefType().getElementType());
   if (!elementTy)
     return failure();
 
   // TODO: this should use the MLIR data layout when it becomes available and
   // stop depending on translation.
   llvm::LLVMContext llvmContext;
   align = LLVM::TypeToLLVMIRTranslator(llvmContext)
-              .getPreferredAlignment(elementTy.cast<LLVM::LLVMType>(),
-                                     typeConverter.getDataLayout());
+              .getPreferredAlignment(elementTy, typeConverter.getDataLayout());
   return success();
 }
 
 // Helper that returns the base address of a memref.
 static LogicalResult getBase(ConversionPatternRewriter &rewriter, Location loc,
                              Value memref, MemRefType memRefType, Value &base) {
   // Inspect stride and offset structure.
   //

 
 // Helper that returns a bit-casted pointer given a memref base.
 static LogicalResult getBasePtr(ConversionPatternRewriter &rewriter,
                                 Location loc, Value memref,
                                 MemRefType memRefType, Type type, Value &ptr) {
   Value base;
   if (failed(getBase(rewriter, loc, memref, memRefType, base)))
     return failure();
-  auto pType = LLVM::LLVMPointerType::get(type.template cast<LLVM::LLVMType>());
+  auto pType = LLVM::LLVMPointerType::get(type);
   base = rewriter.create<LLVM::BitcastOp>(loc, pType, base);
   ptr = rewriter.create<LLVM::GEPOp>(loc, pType, base);
   return success();
 }
 
 // Helper that returns vector of pointers given a memref base and an index
 // vector.
 static LogicalResult getIndexedPtrs(ConversionPatternRewriter &rewriter,
private:
   static void emitCall(ConversionPatternRewriter &rewriter, Location loc,
                        Operation *ref, ValueRange params = ValueRange()) {
     rewriter.create<LLVM::CallOp>(loc, TypeRange(),
                                   rewriter.getSymbolRefAttr(ref), params);
   }
 
   // Helper for printer method declaration (first hit) and lookup.
   static Operation *getPrint(Operation *op, StringRef name,
-                             ArrayRef<LLVM::LLVMType> params) {
+                             ArrayRef<Type> params) {
     auto module = op->getParentOfType<ModuleOp>();
     auto func = module.lookupSymbol<LLVM::LLVMFuncOp>(name);
     if (func)
       return func;
     OpBuilder moduleBuilder(module.getBodyRegion());
     return moduleBuilder.create<LLVM::LLVMFuncOp>(
         op->getLoc(), name,
         LLVM::LLVMFunctionType::get(LLVM::LLVMVoidType::get(op->getContext()),

mlir/lib/Conversion/VectorToROCDL/VectorToROCDL.cpp

 #include "mlir/Transforms/DialectConversion.h"
 
 using namespace mlir;
 using namespace mlir::vector;
 
 static LogicalResult replaceTransferOpWithMubuf(
     ConversionPatternRewriter &rewriter, ArrayRef<Value> operands,
     LLVMTypeConverter &typeConverter, Location loc, TransferReadOp xferOp,
-    LLVM::LLVMType &vecTy, Value &dwordConfig, Value &vindex,
-    Value &offsetSizeInBytes, Value &glc, Value &slc) {
+    Type &vecTy, Value &dwordConfig, Value &vindex, Value &offsetSizeInBytes,
+    Value &glc, Value &slc) {
   rewriter.replaceOpWithNewOp<ROCDL::MubufLoadOp>(
       xferOp, vecTy, dwordConfig, vindex, offsetSizeInBytes, glc, slc);
   return success();
 }
 
 static LogicalResult replaceTransferOpWithMubuf(
     ConversionPatternRewriter &rewriter, ArrayRef<Value> operands,
     LLVMTypeConverter &typeConverter, Location loc, TransferWriteOp xferOp,
-    LLVM::LLVMType &vecTy, Value &dwordConfig, Value &vindex,
-    Value &offsetSizeInBytes, Value &glc, Value &slc) {
+    Type &vecTy, Value &dwordConfig, Value &vindex, Value &offsetSizeInBytes,
+    Value &glc, Value &slc) {
   auto adaptor = TransferWriteOpAdaptor(operands);
   rewriter.replaceOpWithNewOp<ROCDL::MubufStoreOp>(xferOp, adaptor.vector(),
                                                    dwordConfig, vindex,
                                                    offsetSizeInBytes, glc, slc);
   return success();
 }
 
 namespace {
Value constConfig = rewriter.create<LLVM::ConstantOp>(
         loc, toLLVMTy(i32Vecx4),
         DenseElementsAttr::get(i32Vecx4, ArrayRef<int32_t>(constConfigAttr)));
 
     // Treat first two element of <4 x i32> as i64, and save the dataPtr
     // to it.
     Type i64Ty = rewriter.getIntegerType(64);
     Value i64x2Ty = rewriter.create<LLVM::BitcastOp>(
         loc,
-        LLVM::LLVMFixedVectorType::get(
-            toLLVMTy(i64Ty).template cast<LLVM::LLVMType>(), 2),
+        LLVM::LLVMFixedVectorType::get(toLLVMTy(i64Ty).template cast<Type>(),
+                                       2),
         constConfig);
     Value dataPtrAsI64 = rewriter.create<LLVM::PtrToIntOp>(
-        loc, toLLVMTy(i64Ty).template cast<LLVM::LLVMType>(), dataPtr);
+        loc, toLLVMTy(i64Ty).template cast<Type>(), dataPtr);
     Value zero = this->createIndexConstant(rewriter, loc, 0);
     Value dwordConfig = rewriter.create<LLVM::InsertElementOp>(
         loc,
-        LLVM::LLVMFixedVectorType::get(
-            toLLVMTy(i64Ty).template cast<LLVM::LLVMType>(), 2),
+        LLVM::LLVMFixedVectorType::get(toLLVMTy(i64Ty).template cast<Type>(),
+                                       2),
         i64x2Ty, dataPtrAsI64, zero);
     dwordConfig =
         rewriter.create<LLVM::BitcastOp>(loc, toLLVMTy(i32Vecx4), dwordConfig);
 
     // 2. Rewrite op as a buffer read or write.
     Value int1False = rewriter.create<LLVM::ConstantOp>(
         loc, toLLVMTy(rewriter.getIntegerType(1)),
         rewriter.getIntegerAttr(rewriter.getIntegerType(1), 0));

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

if (std::is_same<CmpPredicateType, ICmpPredicate>()) {
     predicateValue = static_cast<int64_t>(predicate.getValue());
   }
 
   result.attributes.set("predicate",
                         parser.getBuilder().getI64IntegerAttr(predicateValue));
 
   // The result type is either i1 or a vector type <? x i1> if the inputs are
   // vectors.
-  LLVMType resultType = LLVMIntegerType::get(builder.getContext(), 1);
-  auto argType = type.dyn_cast<LLVM::LLVMType>();
-  if (!argType)
-    return parser.emitError(trailingTypeLoc, "expected LLVM IR dialect type");
-  if (auto vecArgType = argType.dyn_cast<LLVM::LLVMFixedVectorType>())
+  Type resultType = LLVMIntegerType::get(builder.getContext(), 1);
+  if (!isCompatibleType(type))
+    return parser.emitError(trailingTypeLoc,
+                            "expected LLVM dialect-compatible type");
+  if (auto vecArgType = type.dyn_cast<LLVM::LLVMFixedVectorType>())
     resultType =
         LLVMFixedVectorType::get(resultType, vecArgType.getNumElements());
-  assert(!argType.isa<LLVM::LLVMScalableVectorType>() &&
+  assert(!type.isa<LLVM::LLVMScalableVectorType>() &&
          "unhandled scalable vector");
 
   result.addTypes({resultType});
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Printing/parsing for LLVM::AllocaOp.
if (isDirect) {
     result.addTypes(funcType.getResults());
   } else {
     // Construct the LLVM IR Dialect function type that the first operand
     // should match.
     if (funcType.getNumResults() > 1)
       return parser.emitError(trailingTypeLoc,
                               "expected function with 0 or 1 result");
 
-    LLVM::LLVMType llvmResultType;
+    Type llvmResultType;
     if (funcType.getNumResults() == 0) {
       llvmResultType = LLVM::LLVMVoidType::get(builder.getContext());
     } else {
-      llvmResultType = funcType.getResult(0).dyn_cast<LLVM::LLVMType>();
-      if (!llvmResultType)
+      llvmResultType = funcType.getResult(0);
+      if (!isCompatibleType(llvmResultType))
         return parser.emitError(trailingTypeLoc,
                                 "expected result to have LLVM type");
     }
 
-    SmallVector<LLVM::LLVMType, 8> argTypes;
+    SmallVector<Type, 8> argTypes;
     argTypes.reserve(funcType.getNumInputs());
     for (Type ty : funcType.getInputs()) {
-      if (auto argType = ty.dyn_cast<LLVM::LLVMType>())
-        argTypes.push_back(argType);
+      if (isCompatibleType(ty))
+        argTypes.push_back(ty);
       else
         return parser.emitError(trailingTypeLoc,
                                 "expected LLVM types as inputs");
     }
 
     auto llvmFuncType = LLVM::LLVMFunctionType::get(llvmResultType, argTypes);
     auto wrappedFuncType = LLVM::LLVMPointerType::get(llvmFuncType);
 

 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(CallOp &op) {
   if (op.getNumResults() > 1)
     return op.emitOpError("must have 0 or 1 result");
 
   // Type for the callee, we'll get it differently depending if it is a direct
   // or indirect call.
-  LLVMType fnType;
+  Type fnType;
 
   bool isIndirect = false;
 
   // If this is an indirect call, the callee attribute is missing.
   Optional<StringRef> calleeName = op.callee();
   if (!calleeName) {
     isIndirect = true;
     if (!op.getNumOperands())
       return op.emitOpError(
           "must have either a `callee` attribute or at least an operand");
-    fnType = op.getOperand(0).getType().dyn_cast<LLVMType>();
-    if (!fnType)
-      return op.emitOpError("indirect call to a non-llvm type: ")
-             << op.getOperand(0).getType();
-    auto ptrType = fnType.dyn_cast<LLVMPointerType>();
+    auto ptrType = op.getOperand(0).getType().dyn_cast<LLVMPointerType>();
     if (!ptrType)
       return op.emitOpError("indirect call expects a pointer as callee: ")
-             << fnType;
+             << ptrType;
     fnType = ptrType.getElementType();
   } else {
     Operation *callee = SymbolTable::lookupNearestSymbolFrom(op, *calleeName);
     if (!callee)
       return op.emitOpError()
              << "'" << *calleeName
              << "' does not reference a symbol in the current scope";
     auto fn = dyn_cast<LLVMFuncOp>(callee);
static ParseResult parseCallOp(OpAsmParser &parser, OperationState &result) {
   } else {
     // Construct the LLVM IR Dialect function type that the first operand
     // should match.
     if (funcType.getNumResults() > 1)
       return parser.emitError(trailingTypeLoc,
                               "expected function with 0 or 1 result");
 
     Builder &builder = parser.getBuilder();
-    LLVM::LLVMType llvmResultType;
+    Type llvmResultType;
     if (funcType.getNumResults() == 0) {
       llvmResultType = LLVM::LLVMVoidType::get(builder.getContext());
     } else {
-      llvmResultType = funcType.getResult(0).dyn_cast<LLVM::LLVMType>();
-      if (!llvmResultType)
+      llvmResultType = funcType.getResult(0);
+      if (!isCompatibleType(llvmResultType))
         return parser.emitError(trailingTypeLoc,
                                 "expected result to have LLVM type");
     }
 
-    SmallVector<LLVM::LLVMType, 8> argTypes;
+    SmallVector<Type, 8> argTypes;
     argTypes.reserve(funcType.getNumInputs());
     for (int i = 0, e = funcType.getNumInputs(); i < e; ++i) {
-      auto argType = funcType.getInput(i).dyn_cast<LLVM::LLVMType>();
-      if (!argType)
+      auto argType = funcType.getInput(i);
+      if (!isCompatibleType(argType))
         return parser.emitError(trailingTypeLoc,
                                 "expected LLVM types as inputs");
       argTypes.push_back(argType);
     }
     auto llvmFuncType = LLVM::LLVMFunctionType::get(llvmResultType, argTypes);
     auto wrappedFuncType = LLVM::LLVMPointerType::get(llvmFuncType);
 
     auto funcArguments =
static void printExtractValueOp(OpAsmPrinter &p, ExtractValueOp &op) {
   p.printOptionalAttrDict(op.getAttrs(), {"position"});
   p << " : " << op.container().getType();
 }
 
 // Extract the type at `position` in the wrapped LLVM IR aggregate type
 // `containerType`.  Position is an integer array attribute where each value
 // is a zero-based position of the element in the aggregate type.  Return the
 // resulting type wrapped in MLIR, or nullptr on error.
-static LLVM::LLVMType getInsertExtractValueElementType(OpAsmParser &parser,
-                                                       Type containerType,
-                                                       ArrayAttr positionAttr,
-                                                       llvm::SMLoc attributeLoc,
-                                                       llvm::SMLoc typeLoc) {
-  auto llvmType = containerType.dyn_cast<LLVM::LLVMType>();
-  if (!llvmType)
+static Type getInsertExtractValueElementType(OpAsmParser &parser,
+  Type llvmType = containerType;
+  if (!isCompatibleType(containerType))
     return parser.emitError(typeLoc, "expected LLVM IR Dialect type"), nullptr;
 
   // Infer the element type from the structure type: iteratively step inside the
   // type by taking the element type, indexed by the position attribute for
   // structures.  Check the position index before accessing, it is supposed to
   // be in bounds.
   for (Attribute subAttr : positionAttr) {
     auto positionElementAttr = subAttr.dyn_cast<IntegerAttr>();

 //===----------------------------------------------------------------------===//
 // Builder, printer and verifier for LLVM::GlobalOp.
 //===----------------------------------------------------------------------===//
 
 /// Returns the name used for the linkage attribute. This *must* correspond to
 /// the name of the attribute in ODS.
 static StringRef getLinkageAttrName() { return "linkage"; }
 
-void GlobalOp::build(OpBuilder &builder, OperationState &result, LLVMType type,
+void GlobalOp::build(OpBuilder &builder, OperationState &result, Type type,
                      bool isConstant, Linkage linkage, StringRef name,
                      Attribute value, unsigned addrSpace,
                      ArrayRef<NamedAttribute> attrs) {
   result.addAttribute(SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
   result.addAttribute("type", TypeAttr::get(type));
   if (isConstant)
     result.addAttribute("constant", builder.getUnitAttr());

 //===----------------------------------------------------------------------===//
 // Verifier for LLVM::DialectCastOp.
 //===----------------------------------------------------------------------===//
 
 /// Checks if `llvmType` is dialect cast-compatible with `index` type. Does not
 /// report the error, the user is expected to produce an appropriate message.
 // TODO: make the size depend on data layout rather than on the conversion
 // pass option, and pull that information here.
-static LogicalResult verifyCastWithIndex(LLVMType llvmType) {
+static LogicalResult verifyCastWithIndex(Type llvmType) {
   return success(llvmType.isa<LLVMIntegerType>());
 }
 
 /// Checks if `llvmType` is dialect cast-compatible with built-in `type` and
 /// reports errors to the location of `op`.
-static LogicalResult verifyCast(DialectCastOp op, LLVMType llvmType,
-                                Type type) {
+static LogicalResult verifyCast(DialectCastOp op, Type llvmType, Type type) {
   // Index is compatible with any integer.
   if (type.isIndex()) {
     if (succeeded(verifyCastWithIndex(llvmType)))
       return success();
 
     return op.emitOpError("invalid cast between index and non-integer type");
   }
 
if (auto unrankedMemrefType = type.dyn_cast<UnrankedMemRefType>()) {
     return success();
   }
 
   // Everything else is not supported.
   return op->emitError("unsupported cast");
 }
 
 static LogicalResult verify(DialectCastOp op) {
-  if (auto llvmType = op.getType().dyn_cast<LLVMType>())
-    return verifyCast(op, llvmType, op.in().getType());
+  if (isCompatibleType(op.getType()))
+    return verifyCast(op, op.getType(), op.in().getType());
 
-  auto llvmType = op.in().getType().dyn_cast<LLVMType>();
-  if (!llvmType)
+  if (!isCompatibleType(op.in().getType()))
     return op->emitOpError("expected one LLVM type and one built-in type");
 
-  return verifyCast(op, llvmType, op.getType());
+  return verifyCast(op, op.in().getType(), op.getType());
 }
 
 // Parses one of the keywords provided in the list `keywords` and returns the
 // position of the parsed keyword in the list. If none of the keywords from the
 // list is parsed, returns -1.
 static int parseOptionalKeywordAlternative(OpAsmParser &parser,
                                            ArrayRef<StringRef> keywords) {
   for (auto en : llvm::enumerate(keywords)) {
Block *LLVMFuncOp::addEntryBlock() {
 
   LLVMFunctionType type = getType();
   for (unsigned i = 0, e = type.getNumParams(); i < e; ++i)
     entry->addArgument(type.getParamType(i));
   return entry;
 }
 
 void LLVMFuncOp::build(OpBuilder &builder, OperationState &result,
-                       StringRef name, LLVMType type, LLVM::Linkage linkage,
+                       StringRef name, Type type, LLVM::Linkage linkage,
                        ArrayRef<NamedAttribute> attrs,
                        ArrayRef<MutableDictionaryAttr> argAttrs) {
   result.addRegion();
   result.addAttribute(SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
   result.addAttribute("type", TypeAttr::get(type));
   result.addAttribute(getLinkageAttrName(),
                       builder.getI64IntegerAttr(static_cast<int64_t>(linkage)));
static Type buildLLVMFunctionType(OpAsmParser &parser, llvm::SMLoc loc,
   Builder &b = parser.getBuilder();
   if (outputs.size() > 1) {
     parser.emitError(loc, "failed to construct function type: expected zero or "
                           "one function result");
     return {};
   }
 
   // Convert inputs to LLVM types, exit early on error.
-  SmallVector<LLVMType, 4> llvmInputs;
+  SmallVector<Type, 4> llvmInputs;
   for (auto t : inputs) {
-    auto llvmTy = t.dyn_cast<LLVMType>();
-    if (!llvmTy) {
+    if (!isCompatibleType(t)) {
       parser.emitError(loc, "failed to construct function type: expected LLVM "
                             "type for function arguments");
       return {};
     }
-    llvmInputs.push_back(llvmTy);
+    llvmInputs.push_back(t);
   }
 
   // No output is denoted as "void" in LLVM type system.
-  LLVMType llvmOutput = outputs.empty() ? LLVMVoidType::get(b.getContext())
-                                        : outputs.front().dyn_cast<LLVMType>();
-  if (!llvmOutput) {
+  Type llvmOutput =
+      outputs.empty() ? LLVMVoidType::get(b.getContext()) : outputs.front();
+  if (!isCompatibleType(llvmOutput)) {
     parser.emitError(loc, "failed to construct function type: expected LLVM "
-                          "type for function results");
+                          "type for function results")
+        << llvmOutput;
     return {};
   }
   return LLVMFunctionType::get(llvmOutput, llvmInputs,
                                variadicFlag.isVariadic());
 }
 
 // Parses an LLVM function.
 //
static void printLLVMFuncOp(OpAsmPrinter &p, LLVMFuncOp op) {
 
   LLVMFunctionType fnType = op.getType();
   SmallVector<Type, 8> argTypes;
   SmallVector<Type, 1> resTypes;
   argTypes.reserve(fnType.getNumParams());
   for (unsigned i = 0, e = fnType.getNumParams(); i < e; ++i)
     argTypes.push_back(fnType.getParamType(i));
 
-  LLVMType returnType = fnType.getReturnType();
+  Type returnType = fnType.getReturnType();
   if (!returnType.isa<LLVMVoidType>())
     resTypes.push_back(returnType);
 
   impl::printFunctionSignature(p, op, argTypes, op.isVarArg(), resTypes);
   impl::printFunctionAttributes(p, op, argTypes.size(), resTypes.size(),
                                 {getLinkageAttrName()});
 
   // Print the body if this is not an external function.
static LogicalResult verify(LLVMFuncOp op) {
 
   if (op.isVarArg())
     return op.emitOpError("only external functions can be variadic");
 
   unsigned numArguments = op.getType().getNumParams();
   Block &entryBlock = op.front();
   for (unsigned i = 0; i < numArguments; ++i) {
     Type argType = entryBlock.getArgument(i).getType();
-    auto argLLVMType = argType.dyn_cast<LLVMType>();
-    if (!argLLVMType)
+    if (!isCompatibleType(argType))
       return op.emitOpError("entry block argument #")
              << i << " is not of LLVM type";
-    if (op.getType().getParamType(i) != argLLVMType)
+    if (op.getType().getParamType(i) != argType)
       return op.emitOpError("the type of entry block argument #")
              << i << " does not match the function signature";
   }
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
static void printAtomicRMWOp(OpAsmPrinter &p, AtomicRMWOp &op) {
   p.printOptionalAttrDict(op.getAttrs(), {"bin_op", "ordering"});
   p << " : " << op.res().getType();
 }
 
 // <operation> ::= `llvm.atomicrmw` keyword ssa-use `,` ssa-use keyword
 //                 attribute-dict? `:` type
 static ParseResult parseAtomicRMWOp(OpAsmParser &parser,
                                     OperationState &result) {
-  LLVMType type;
+  Type type;
   OpAsmParser::OperandType ptr, val;
   if (parseAtomicBinOp(parser, result, "bin_op") || parser.parseOperand(ptr) ||
       parser.parseComma() || parser.parseOperand(val) ||
       parseAtomicOrdering(parser, result, "ordering") ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(type) ||
       parser.resolveOperand(ptr, LLVM::LLVMPointerType::get(type),
                             result.operands) ||
       parser.resolveOperand(val, type, result.operands))
     return failure();
 
   result.addTypes(type);
   return success();
 }
 
 static LogicalResult verify(AtomicRMWOp op) {
   auto ptrType = op.ptr().getType().cast<LLVM::LLVMPointerType>();
-  auto valType = op.val().getType().cast<LLVM::LLVMType>();
+  auto valType = op.val().getType();
   if (valType != ptrType.getElementType())
     return op.emitOpError("expected LLVM IR element type for operand #0 to "
                           "match type for operand #1");
-  auto resType = op.res().getType().cast<LLVM::LLVMType>();
+  auto resType = op.res().getType();
   if (resType != valType)
     return op.emitOpError(
         "expected LLVM IR result type to match type for operand #1");
   if (op.bin_op() == AtomicBinOp::fadd || op.bin_op() == AtomicBinOp::fsub) {
     if (!mlir::LLVM::isCompatibleFloatingPointType(valType))
       return op.emitOpError("expected LLVM IR floating point type");
   } else if (op.bin_op() == AtomicBinOp::xchg) {
     auto intType = valType.dyn_cast<LLVMIntegerType>();
static void printAtomicCmpXchgOp(OpAsmPrinter &p, AtomicCmpXchgOp &op) {
   p << " : " << op.val().getType();
 }
 
 // <operation> ::= `llvm.cmpxchg` ssa-use `,` ssa-use `,` ssa-use
 //                 keyword keyword attribute-dict? `:` type
 static ParseResult parseAtomicCmpXchgOp(OpAsmParser &parser,
                                         OperationState &result) {
   auto &builder = parser.getBuilder();
-  LLVMType type;
+  Type type;
   OpAsmParser::OperandType ptr, cmp, val;
   if (parser.parseOperand(ptr) || parser.parseComma() ||
       parser.parseOperand(cmp) || parser.parseComma() ||
       parser.parseOperand(val) ||
       parseAtomicOrdering(parser, result, "success_ordering") ||
       parseAtomicOrdering(parser, result, "failure_ordering") ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(type) ||
static ParseResult parseAtomicCmpXchgOp(OpAsmParser &parser,
 
   return success();
 }
 
 static LogicalResult verify(AtomicCmpXchgOp op) {
   auto ptrType = op.ptr().getType().cast<LLVM::LLVMPointerType>();
   if (!ptrType)
     return op.emitOpError("expected LLVM IR pointer type for operand #0");
-  auto cmpType = op.cmp().getType().cast<LLVM::LLVMType>();
-  auto valType = op.val().getType().cast<LLVM::LLVMType>();
+  auto cmpType = op.cmp().getType();
+  auto valType = op.val().getType();
   if (cmpType != ptrType.getElementType() || cmpType != valType)
     return op.emitOpError("expected LLVM IR element type for operand #0 to "
                           "match type for all other operands");
   auto intType = valType.dyn_cast<LLVMIntegerType>();
   unsigned intBitWidth = intType ? intType.getBitWidth() : 0;
   if (!valType.isa<LLVMPointerType>() && intBitWidth != 8 &&
       intBitWidth != 16 && intBitWidth != 32 && intBitWidth != 64 &&
       !valType.isa<LLVMBFloatType>() && !valType.isa<LLVMHalfType>() &&

 
 /// 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.cast<LLVMType>(), os);
+  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();

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

 
 using namespace mlir;
 using namespace mlir::LLVM;
 
 //===----------------------------------------------------------------------===//
 // Printing.
 //===----------------------------------------------------------------------===//
 
-static void printTypeImpl(llvm::raw_ostream &os, LLVMType type,
+static void printTypeImpl(llvm::raw_ostream &os, Type type,
                           llvm::SetVector<StringRef> &stack);
 
 /// Returns the keyword to use for the given type.
-static StringRef getTypeKeyword(LLVMType type) {
+static StringRef getTypeKeyword(Type type) {
   return TypeSwitch<Type, StringRef>(type)
       .Case<LLVMVoidType>([&](Type) { return "void"; })
       .Case<LLVMHalfType>([&](Type) { return "half"; })
       .Case<LLVMBFloatType>([&](Type) { return "bfloat"; })
       .Case<LLVMFloatType>([&](Type) { return "float"; })
       .Case<LLVMDoubleType>([&](Type) { return "double"; })
       .Case<LLVMFP128Type>([&](Type) { return "fp128"; })
       .Case<LLVMX86FP80Type>([&](Type) { return "x86_fp80"; })
static void printStructTypeBody(llvm::raw_ostream &os, LLVMStructType type,
 
   if (type.isPacked())
     os << "packed ";
 
   // Put the current type on stack to avoid infinite recursion.
   os << '(';
   if (type.isIdentified())
     stack.insert(type.getName());
-  llvm::interleaveComma(type.getBody(), os, [&](LLVMType subtype) {
+  llvm::interleaveComma(type.getBody(), os, [&](Type subtype) {
     printTypeImpl(os, subtype, stack);
   });
   if (type.isIdentified())
     stack.pop_back();
   os << ')';
 }
 
 /// Prints a structure type. Uses `stack` to keep track of the identifiers of

 }
 
 /// Prints a function type.
 static void printFunctionType(llvm::raw_ostream &os, LLVMFunctionType funcType,
                               llvm::SetVector<StringRef> &stack) {
   os << '<';
   printTypeImpl(os, funcType.getReturnType(), stack);
   os << " (";
-  llvm::interleaveComma(
-      funcType.getParams(), os,
-      [&os, &stack](LLVMType subtype) { printTypeImpl(os, subtype, stack); });
+  llvm::interleaveComma(funcType.getParams(), os, [&os, &stack](Type subtype) {
+    printTypeImpl(os, subtype, stack);
+  });
   if (funcType.isVarArg()) {
     if (funcType.getNumParams() != 0)
       os << ", ";
     os << "...";
   }
   os << ")>";
 }
 
 /// 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.
-static void printTypeImpl(llvm::raw_ostream &os, LLVMType type,
+static void printTypeImpl(llvm::raw_ostream &os, Type type,
                           llvm::SetVector<StringRef> &stack) {
   if (!type) {
     os << "<<NULL-TYPE>>";
     return;
   }
 
   os << getTypeKeyword(type);
 
static void printTypeImpl(llvm::raw_ostream &os, Type type,
 
   if (auto structType = type.dyn_cast<LLVMStructType>())
     return printStructType(os, structType, stack);
 
   if (auto funcType = type.dyn_cast<LLVMFunctionType>())
     return printFunctionType(os, funcType, stack);
 }
 
-void mlir::LLVM::detail::printType(LLVMType type, DialectAsmPrinter &printer) {
+void mlir::LLVM::detail::printType(Type type, DialectAsmPrinter &printer) {
   llvm::SetVector<StringRef> stack;
   return printTypeImpl(printer.getStream(), type, stack);
 }
 
 //===----------------------------------------------------------------------===//
 // Parsing.
 //===----------------------------------------------------------------------===//
 
-static LLVMType parseTypeImpl(DialectAsmParser &parser,
-                              llvm::SetVector<StringRef> &stack);
+static Type parseTypeImpl(DialectAsmParser &parser,
 
 /// Helper to be chained with other parsing functions.
 static ParseResult parseTypeImpl(DialectAsmParser &parser,
                                  llvm::SetVector<StringRef> &stack,
-                                 LLVMType &result) {
+                                 Type &result) {
   result = parseTypeImpl(parser, stack);
   return success(result != nullptr);
 }
 
 /// Parses an LLVM dialect function type.
 ///   llvm-type :: = `func<` llvm-type `(` llvm-type-list `...`? `)>`
 static LLVMFunctionType parseFunctionType(DialectAsmParser &parser,
                                           llvm::SetVector<StringRef> &stack) {
   Location loc = parser.getEncodedSourceLoc(parser.getCurrentLocation());
-  LLVMType returnType;
+  Type returnType;
   if (parser.parseLess() || parseTypeImpl(parser, stack, returnType) ||
       parser.parseLParen())
     return LLVMFunctionType();
 
   // Function type without arguments.
   if (succeeded(parser.parseOptionalRParen())) {
     if (succeeded(parser.parseGreater()))
       return LLVMFunctionType::getChecked(loc, returnType, {},
                                           /*isVarArg=*/false);
     return LLVMFunctionType();
   }
 
   // Parse arguments.
-  SmallVector<LLVMType, 8> argTypes;
+  SmallVector<Type, 8> argTypes;
   do {
     if (succeeded(parser.parseOptionalEllipsis())) {
       if (parser.parseOptionalRParen() || parser.parseOptionalGreater())
         return LLVMFunctionType();
       return LLVMFunctionType::getChecked(loc, returnType, argTypes,
                                           /*isVarArg=*/true);
     }
 
     argTypes.push_back(parseTypeImpl(parser, stack));
     if (!argTypes.back())
       return LLVMFunctionType();
   } while (succeeded(parser.parseOptionalComma()));
 
   if (parser.parseOptionalRParen() || parser.parseOptionalGreater())
     return LLVMFunctionType();
   return LLVMFunctionType::getChecked(loc, returnType, argTypes,
                                       /*isVarArg=*/false);
 }
 
 /// Parses an LLVM dialect pointer type.
 ///   llvm-type ::= `ptr<` llvm-type (`,` integer)? `>`
 static LLVMPointerType parsePointerType(DialectAsmParser &parser,
                                         llvm::SetVector<StringRef> &stack) {
   Location loc = parser.getEncodedSourceLoc(parser.getCurrentLocation());
-  LLVMType elementType;
+  Type elementType;
   if (parser.parseLess() || parseTypeImpl(parser, stack, elementType))
     return LLVMPointerType();
 
   unsigned addressSpace = 0;
   if (succeeded(parser.parseOptionalComma()) &&
       failed(parser.parseInteger(addressSpace)))
     return LLVMPointerType();
   if (failed(parser.parseGreater()))
     return LLVMPointerType();
   return LLVMPointerType::getChecked(loc, elementType, addressSpace);
 }
 
 /// Parses an LLVM dialect vector type.
 ///   llvm-type ::= `vec<` `? x`? integer `x` llvm-type `>`
 /// Supports both fixed and scalable vectors.
 static LLVMVectorType parseVectorType(DialectAsmParser &parser,
                                       llvm::SetVector<StringRef> &stack) {
   SmallVector<int64_t, 2> dims;
   llvm::SMLoc dimPos;
-  LLVMType elementType;
+  Type elementType;
   Location loc = parser.getEncodedSourceLoc(parser.getCurrentLocation());
   if (parser.parseLess() || parser.getCurrentLocation(&dimPos) ||
       parser.parseDimensionList(dims, /*allowDynamic=*/true) ||
       parseTypeImpl(parser, stack, elementType) || parser.parseGreater())
     return LLVMVectorType();
 
   // We parsed a generic dimension list, but vectors only support two forms:
   //  - single non-dynamic entry in the list (fixed vector);

 }
 
 /// Parses an LLVM dialect array type.
 ///   llvm-type ::= `array<` integer `x` llvm-type `>`
 static LLVMArrayType parseArrayType(DialectAsmParser &parser,
                                     llvm::SetVector<StringRef> &stack) {
   SmallVector<int64_t, 1> dims;
   llvm::SMLoc sizePos;
-  LLVMType elementType;
+  Type elementType;
   Location loc = parser.getEncodedSourceLoc(parser.getCurrentLocation());
   if (parser.parseLess() || parser.getCurrentLocation(&sizePos) ||
       parser.parseDimensionList(dims, /*allowDynamic=*/false) ||
       parseTypeImpl(parser, stack, elementType) || parser.parseGreater())
     return LLVMArrayType();
 
   if (dims.size() != 1) {
     parser.emitError(sizePos) << "expected ? x <type>";
     return LLVMArrayType();
   }
 
   return LLVMArrayType::getChecked(loc, elementType, dims[0]);
 }
 
 /// Attempts to set the body of an identified structure type. Reports a parsing
 /// error at `subtypesLoc` in case of failure, uses `stack` to make sure the
 /// types printed in the error message look like they did when parsed.
 static LLVMStructType trySetStructBody(LLVMStructType type,
-                                       ArrayRef<LLVMType> subtypes,
-                                       bool isPacked, DialectAsmParser &parser,
+                                       ArrayRef<Type> subtypes, bool isPacked,
+                                       DialectAsmParser &parser,
                                        llvm::SMLoc subtypesLoc,
                                        llvm::SetVector<StringRef> &stack) {
-  for (LLVMType t : subtypes) {
+  for (Type t : subtypes) {
     if (!LLVMStructType::isValidElementType(t)) {
       parser.emitError(subtypesLoc)
           << "invalid LLVM structure element type: " << t;
       return LLVMStructType();
     }
   }
 
   if (succeeded(type.setBody(subtypes, isPacked)))
if (succeeded(parser.parseOptionalRParen())) {
     if (!isIdentified)
       return LLVMStructType::getLiteralChecked(loc, {}, isPacked);
     auto type = LLVMStructType::getIdentifiedChecked(loc, name);
     return trySetStructBody(type, {}, isPacked, parser, kwLoc, stack);
   }
 
   // Parse subtypes. For identified structs, put the identifier of the struct on
   // the stack to support self-references in the recursive calls.
-  SmallVector<LLVMType, 4> subtypes;
+  SmallVector<Type, 4> subtypes;
   llvm::SMLoc subtypesLoc = parser.getCurrentLocation();
   do {
     if (isIdentified)
       stack.insert(name);
-    LLVMType type = parseTypeImpl(parser, stack);
+    Type type = parseTypeImpl(parser, stack);
     if (!type)
       return LLVMStructType();
     subtypes.push_back(type);
     if (isIdentified)
       stack.pop_back();
   } while (succeeded(parser.parseOptionalComma()));
 
   if (parser.parseRParen() || parser.parseGreater())
     return LLVMStructType();
 
   // Construct the struct with body.
   if (!isIdentified)
     return LLVMStructType::getLiteralChecked(loc, subtypes, isPacked);
   auto type = LLVMStructType::getIdentifiedChecked(loc, name);
   return trySetStructBody(type, subtypes, isPacked, parser, subtypesLoc, stack);
 }
 
 /// Parses one of the LLVM dialect types.
-static LLVMType parseTypeImpl(DialectAsmParser &parser,
-                              llvm::SetVector<StringRef> &stack) {
+static Type parseTypeImpl(DialectAsmParser &parser,
   // Special case for integers (i[1-9][0-9]*) that are literals rather than
   // keywords for the parser, so they are not caught by the main dispatch below.
   // Try parsing it a built-in integer type instead.
   Type maybeIntegerType;
   MLIRContext *ctx = parser.getBuilder().getContext();
   llvm::SMLoc keyLoc = parser.getCurrentLocation();
   Location loc = parser.getEncodedSourceLoc(keyLoc);
   OptionalParseResult result = parser.parseOptionalType(maybeIntegerType);
   if (result.hasValue()) {
     if (failed(*result))
-      return LLVMType();
+      return Type();
 
     if (!maybeIntegerType.isSignlessInteger()) {
       parser.emitError(keyLoc) << "unexpected type, expected i* or keyword";
-      return LLVMType();
+      return Type();
     }
     return LLVMIntegerType::getChecked(
         loc, maybeIntegerType.getIntOrFloatBitWidth());
   }
 
   // Dispatch to concrete functions.
   StringRef key;
   if (failed(parser.parseKeyword(&key)))
-    return LLVMType();
+    return Type();
 
-  return StringSwitch<function_ref<LLVMType()>>(key)
+  return StringSwitch<function_ref<Type()>>(key)
       .Case("void", [&] { return LLVMVoidType::get(ctx); })
       .Case("half", [&] { return LLVMHalfType::get(ctx); })
       .Case("bfloat", [&] { return LLVMBFloatType::get(ctx); })
       .Case("float", [&] { return LLVMFloatType::get(ctx); })
       .Case("double", [&] { return LLVMDoubleType::get(ctx); })
       .Case("fp128", [&] { return LLVMFP128Type::get(ctx); })
       .Case("x86_fp80", [&] { return LLVMX86FP80Type::get(ctx); })
       .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, stack); })
       .Case("ptr", [&] { return parsePointerType(parser, stack); })
       .Case("vec", [&] { return parseVectorType(parser, stack); })
       .Case("array", [&] { return parseArrayType(parser, stack); })
       .Case("struct", [&] { return parseStructType(parser, stack); })
       .Default([&] {
         parser.emitError(keyLoc) << "unknown LLVM type: " << key;
-        return LLVMType();
+        return Type();
       })();
 }
 
-LLVMType mlir::LLVM::detail::parseType(DialectAsmParser &parser) {
+Type mlir::LLVM::detail::parseType(DialectAsmParser &parser) {
   llvm::SetVector<StringRef> stack;
   return parseTypeImpl(parser, stack);
 }

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

 
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/TypeSize.h"
 
 using namespace mlir;
 using namespace mlir::LLVM;
 
 //===----------------------------------------------------------------------===//
-// LLVMType.
-//===----------------------------------------------------------------------===//
-
-bool LLVMType::classof(Type type) {
-  return llvm::isa<LLVMDialect>(type.getDialect());
-}
-
-LLVMDialect &LLVMType::getDialect() {
-  return static_cast<LLVMDialect &>(Type::getDialect());
-}
-
-//===----------------------------------------------------------------------===//
 // Array type.
 //===----------------------------------------------------------------------===//
 
-bool LLVMArrayType::isValidElementType(LLVMType type) {
+bool LLVMArrayType::isValidElementType(Type type) {
   return !type.isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
                    LLVMFunctionType, LLVMTokenType, LLVMScalableVectorType>();
 }
 
-LLVMArrayType LLVMArrayType::get(LLVMType elementType, unsigned numElements) {
+LLVMArrayType LLVMArrayType::get(Type elementType, unsigned numElements) {
   assert(elementType && "expected non-null subtype");
   return Base::get(elementType.getContext(), elementType, numElements);
 }
 
-LLVMArrayType LLVMArrayType::getChecked(Location loc, LLVMType elementType,
+LLVMArrayType LLVMArrayType::getChecked(Location loc, Type elementType,
                                         unsigned numElements) {
   assert(elementType && "expected non-null subtype");
   return Base::getChecked(loc, elementType, numElements);
 }
 
-LLVMType LLVMArrayType::getElementType() { return getImpl()->elementType; }
+Type LLVMArrayType::getElementType() { return getImpl()->elementType; }
 
 unsigned LLVMArrayType::getNumElements() { return getImpl()->numElements; }
 
 LogicalResult
-LLVMArrayType::verifyConstructionInvariants(Location loc, LLVMType elementType,
+LLVMArrayType::verifyConstructionInvariants(Location loc, Type elementType,
                                             unsigned numElements) {
   if (!isValidElementType(elementType))
     return emitError(loc, "invalid array element type: ") << elementType;
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Function type.
 //===----------------------------------------------------------------------===//
 
-bool LLVMFunctionType::isValidArgumentType(LLVMType type) {
+bool LLVMFunctionType::isValidArgumentType(Type type) {
   return !type.isa<LLVMVoidType, LLVMFunctionType>();
 }
 
-bool LLVMFunctionType::isValidResultType(LLVMType type) {
+bool LLVMFunctionType::isValidResultType(Type type) {
   return !type.isa<LLVMFunctionType, LLVMMetadataType, LLVMLabelType>();
 }
 
-LLVMFunctionType LLVMFunctionType::get(LLVMType result,
-                                       ArrayRef<LLVMType> arguments,
+LLVMFunctionType LLVMFunctionType::get(Type result, ArrayRef<Type> arguments,
                                        bool isVarArg) {
   assert(result && "expected non-null result");
   return Base::get(result.getContext(), result, arguments, isVarArg);
 }
 
-LLVMFunctionType LLVMFunctionType::getChecked(Location loc, LLVMType result,
-                                              ArrayRef<LLVMType> arguments,
+LLVMFunctionType LLVMFunctionType::getChecked(Location loc, Type result,
+                                              ArrayRef<Type> arguments,
                                               bool isVarArg) {
   assert(result && "expected non-null result");
   return Base::getChecked(loc, result, arguments, isVarArg);
 }
 
-LLVMType LLVMFunctionType::getReturnType() {
-  return getImpl()->getReturnType();
-}
+Type LLVMFunctionType::getReturnType() { return getImpl()->getReturnType(); }
 
 unsigned LLVMFunctionType::getNumParams() {
   return getImpl()->getArgumentTypes().size();
 }
 
-LLVMType LLVMFunctionType::getParamType(unsigned i) {
+Type LLVMFunctionType::getParamType(unsigned i) {
   return getImpl()->getArgumentTypes()[i];
 }
 
 bool LLVMFunctionType::isVarArg() { return getImpl()->isVariadic(); }
 
-ArrayRef<LLVMType> LLVMFunctionType::getParams() {
+ArrayRef<Type> LLVMFunctionType::getParams() {
   return getImpl()->getArgumentTypes();
 }
 
-LogicalResult LLVMFunctionType::verifyConstructionInvariants(
-    Location loc, LLVMType result, ArrayRef<LLVMType> arguments, bool) {
+LogicalResult
+LLVMFunctionType::verifyConstructionInvariants(Location loc, Type result,
+                                               ArrayRef<Type> arguments, bool) {
   if (!isValidResultType(result))
     return emitError(loc, "invalid function result type: ") << result;
 
-  for (LLVMType arg : arguments)
+  for (Type arg : arguments)
     if (!isValidArgumentType(arg))
       return emitError(loc, "invalid function argument type: ") << arg;
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Integer type.
if (bitwidth >= maxSupportedBitwidth)
     return emitError(loc, "integer type too wide");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Pointer type.
 //===----------------------------------------------------------------------===//
 
-bool LLVMPointerType::isValidElementType(LLVMType type) {
+bool LLVMPointerType::isValidElementType(Type type) {
   return !type.isa<LLVMVoidType, LLVMTokenType, LLVMMetadataType,
                    LLVMLabelType>();
 }
 
-LLVMPointerType LLVMPointerType::get(LLVMType pointee, unsigned addressSpace) {
+LLVMPointerType LLVMPointerType::get(Type pointee, unsigned addressSpace) {
   assert(pointee && "expected non-null subtype");
   return Base::get(pointee.getContext(), pointee, addressSpace);
 }
 
-LLVMPointerType LLVMPointerType::getChecked(Location loc, LLVMType pointee,
+LLVMPointerType LLVMPointerType::getChecked(Location loc, Type pointee,
                                             unsigned addressSpace) {
   return Base::getChecked(loc, pointee, addressSpace);
 }
 
-LLVMType LLVMPointerType::getElementType() { return getImpl()->pointeeType; }
+Type LLVMPointerType::getElementType() { return getImpl()->pointeeType; }
 
 unsigned LLVMPointerType::getAddressSpace() { return getImpl()->addressSpace; }
 
 LogicalResult LLVMPointerType::verifyConstructionInvariants(Location loc,
-                                                            LLVMType pointee,
+                                                            Type pointee,
                                                             unsigned) {
   if (!isValidElementType(pointee))
     return emitError(loc, "invalid pointer element type: ") << pointee;
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Struct type.
 //===----------------------------------------------------------------------===//
 
-bool LLVMStructType::isValidElementType(LLVMType type) {
+bool LLVMStructType::isValidElementType(Type type) {
   return !type.isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
                    LLVMFunctionType, LLVMTokenType, LLVMScalableVectorType>();
 }
 
 LLVMStructType LLVMStructType::getIdentified(MLIRContext *context,
                                              StringRef name) {
   return Base::get(context, name, /*opaque=*/false);
 }
 
 LLVMStructType LLVMStructType::getIdentifiedChecked(Location loc,
                                                     StringRef name) {
   return Base::getChecked(loc, name, /*opaque=*/false);
 }
 
 LLVMStructType LLVMStructType::getNewIdentified(MLIRContext *context,
                                                 StringRef name,
-                                                ArrayRef<LLVMType> elements,
+                                                ArrayRef<Type> elements,
                                                 bool isPacked) {
   std::string stringName = name.str();
   unsigned counter = 0;
   do {
     auto type = LLVMStructType::getIdentified(context, stringName);
     if (type.isInitialized() || failed(type.setBody(elements, isPacked))) {
       counter += 1;
       stringName = (Twine(name) + "." + std::to_string(counter)).str();
       continue;
     }
     return type;
   } while (true);
 }
 
 LLVMStructType LLVMStructType::getLiteral(MLIRContext *context,
-                                          ArrayRef<LLVMType> types,
-                                          bool isPacked) {
+                                          ArrayRef<Type> types, bool isPacked) {
   return Base::get(context, types, isPacked);
 }
 
 LLVMStructType LLVMStructType::getLiteralChecked(Location loc,
-                                                 ArrayRef<LLVMType> types,
+                                                 ArrayRef<Type> types,
                                                  bool isPacked) {
   return Base::getChecked(loc, types, isPacked);
 }
 
 LLVMStructType LLVMStructType::getOpaque(StringRef name, MLIRContext *context) {
   return Base::get(context, name, /*opaque=*/true);
 }
 
 LLVMStructType LLVMStructType::getOpaqueChecked(Location loc, StringRef name) {
   return Base::getChecked(loc, name, /*opaque=*/true);
 }
 
-LogicalResult LLVMStructType::setBody(ArrayRef<LLVMType> types, bool isPacked) {
+LogicalResult LLVMStructType::setBody(ArrayRef<Type> types, bool isPacked) {
   assert(isIdentified() && "can only set bodies of identified structs");
   assert(llvm::all_of(types, LLVMStructType::isValidElementType) &&
          "expected valid body types");
   return Base::mutate(types, isPacked);
 }
 
 bool LLVMStructType::isPacked() { return getImpl()->isPacked(); }
 bool LLVMStructType::isIdentified() { return getImpl()->isIdentified(); }
 bool LLVMStructType::isOpaque() {
   return getImpl()->isIdentified() &&
          (getImpl()->isOpaque() || !getImpl()->isInitialized());
 }
 bool LLVMStructType::isInitialized() { return getImpl()->isInitialized(); }
 StringRef LLVMStructType::getName() { return getImpl()->getIdentifier(); }
-ArrayRef<LLVMType> LLVMStructType::getBody() {
+ArrayRef<Type> LLVMStructType::getBody() {
   return isIdentified() ? getImpl()->getIdentifiedStructBody()
                         : getImpl()->getTypeList();
 }
 
 LogicalResult LLVMStructType::verifyConstructionInvariants(Location, StringRef,
                                                            bool) {
   return success();
 }
 
-LogicalResult
-LLVMStructType::verifyConstructionInvariants(Location loc,
-                                             ArrayRef<LLVMType> types, bool) {
-  for (LLVMType t : types)
+LogicalResult LLVMStructType::verifyConstructionInvariants(Location loc,
+                                                           ArrayRef<Type> types,
+                                                           bool) {
+  for (Type t : types)
     if (!isValidElementType(t))
       return emitError(loc, "invalid LLVM structure element type: ") << t;
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Vector types.
 //===----------------------------------------------------------------------===//
 
-bool LLVMVectorType::isValidElementType(LLVMType type) {
+bool LLVMVectorType::isValidElementType(Type type) {
   return type.isa<LLVMIntegerType, LLVMPointerType>() ||
          mlir::LLVM::isCompatibleFloatingPointType(type);
 }
 
 /// Support type casting functionality.
 bool LLVMVectorType::classof(Type type) {
   return type.isa<LLVMFixedVectorType, LLVMScalableVectorType>();
 }
 
-LLVMType LLVMVectorType::getElementType() {
+Type LLVMVectorType::getElementType() {
   // Both derived classes share the implementation type.
   return static_cast<detail::LLVMTypeAndSizeStorage *>(impl)->elementType;
 }
 
 llvm::ElementCount LLVMVectorType::getElementCount() {
   // Both derived classes share the implementation type.
   return llvm::ElementCount::get(
       static_cast<detail::LLVMTypeAndSizeStorage *>(impl)->numElements,
       isa<LLVMScalableVectorType>());
 }
 
 /// Verifies that the type about to be constructed is well-formed.
 LogicalResult
-LLVMVectorType::verifyConstructionInvariants(Location loc, LLVMType elementType,
+LLVMVectorType::verifyConstructionInvariants(Location loc, Type elementType,
                                              unsigned numElements) {
   if (numElements == 0)
     return emitError(loc, "the number of vector elements must be positive");
 
   if (!isValidElementType(elementType))
     return emitError(loc, "invalid vector element type");
 
   return success();
 }
 
-LLVMFixedVectorType LLVMFixedVectorType::get(LLVMType elementType,
+LLVMFixedVectorType LLVMFixedVectorType::get(Type elementType,
                                              unsigned numElements) {
   assert(elementType && "expected non-null subtype");
   return Base::get(elementType.getContext(), elementType, numElements);
 }
 
 LLVMFixedVectorType LLVMFixedVectorType::getChecked(Location loc,
-                                                    LLVMType elementType,
+                                                    Type elementType,
                                                     unsigned numElements) {
   assert(elementType && "expected non-null subtype");
   return Base::getChecked(loc, elementType, numElements);
 }
 
 unsigned LLVMFixedVectorType::getNumElements() {
   return getImpl()->numElements;
 }
 
-LLVMScalableVectorType LLVMScalableVectorType::get(LLVMType elementType,
+LLVMScalableVectorType LLVMScalableVectorType::get(Type elementType,
                                                    unsigned minNumElements) {
   assert(elementType && "expected non-null subtype");
   return Base::get(elementType.getContext(), elementType, minNumElements);
 }
 
 LLVMScalableVectorType
-LLVMScalableVectorType::getChecked(Location loc, LLVMType elementType,
+LLVMScalableVectorType::getChecked(Location loc, Type elementType,
                                    unsigned minNumElements) {
   assert(elementType && "expected non-null subtype");
   return Base::getChecked(loc, elementType, minNumElements);
 }
 
 unsigned LLVMScalableVectorType::getMinNumElements() {
   return getImpl()->numElements;
 }
 
 //===----------------------------------------------------------------------===//
 // Utility functions.
 //===----------------------------------------------------------------------===//
 
 llvm::TypeSize mlir::LLVM::getPrimitiveTypeSizeInBits(Type type) {
   assert(isCompatibleType(type) &&
          "expected a type compatible with the LLVM dialect");
 
   return llvm::TypeSwitch<Type, llvm::TypeSize>(type)
       .Case<LLVMHalfType, LLVMBFloatType>(
-          [](LLVMType) { return llvm::TypeSize::Fixed(16); })
-      .Case<LLVMFloatType>([](LLVMType) { return llvm::TypeSize::Fixed(32); })
+          [](Type) { return llvm::TypeSize::Fixed(16); })
+      .Case<LLVMFloatType>([](Type) { return llvm::TypeSize::Fixed(32); })
       .Case<LLVMDoubleType, LLVMX86MMXType>(
-          [](LLVMType) { return llvm::TypeSize::Fixed(64); })
+          [](Type) { return llvm::TypeSize::Fixed(64); })
       .Case<LLVMIntegerType>([](LLVMIntegerType intTy) {
         return llvm::TypeSize::Fixed(intTy.getBitWidth());
       })
-      .Case<LLVMX86FP80Type>([](LLVMType) { return llvm::TypeSize::Fixed(80); })
+      .Case<LLVMX86FP80Type>([](Type) { return llvm::TypeSize::Fixed(80); })
       .Case<LLVMPPCFP128Type, LLVMFP128Type>(
-          [](LLVMType) { return llvm::TypeSize::Fixed(128); })
+          [](Type) { return llvm::TypeSize::Fixed(128); })
       .Case<LLVMVectorType>([](LLVMVectorType t) {
         llvm::TypeSize elementSize =
             getPrimitiveTypeSizeInBits(t.getElementType());
         llvm::ElementCount elementCount = t.getElementCount();
         assert(!elementSize.isScalable() &&
                "vector type should have fixed-width elements");
         return llvm::TypeSize(elementSize.getFixedSize() *
                                   elementCount.getKnownMinValue(),

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

static ParseResult parseNVVMShflSyncBflyOp(OpAsmParser &parser,
   SmallVector<OpAsmParser::OperandType, 8> ops;
   Type resultType;
   if (parser.parseOperandList(ops) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(resultType) ||
       parser.addTypeToList(resultType, result.types))
     return failure();
 
-  auto type = resultType.cast<LLVM::LLVMType>();
   for (auto &attr : result.attributes) {
     if (attr.first != "return_value_and_is_valid")
       continue;
-    auto structType = type.dyn_cast<LLVM::LLVMStructType>();
+    auto structType = resultType.dyn_cast<LLVM::LLVMStructType>();
     if (structType && !structType.getBody().empty())
-      type = structType.getBody()[0];
+      resultType = structType.getBody()[0];
     break;
   }
 
   auto int32Ty =
       LLVM::LLVMIntegerType::get(parser.getBuilder().getContext(), 32);
-  return parser.resolveOperands(ops, {int32Ty, type, int32Ty, int32Ty},
+  return parser.resolveOperands(ops, {int32Ty, resultType, int32Ty, int32Ty},
                                 parser.getNameLoc(), result.operands);
 }
 
 // <operation> ::= `llvm.nvvm.vote.ballot.sync %mask, %pred` : result_type
 static ParseResult parseNVVMVoteBallotOp(OpAsmParser &parser,
                                          OperationState &result) {
   MLIRContext *context = parser.getBuilder().getContext();
   auto int32Ty = LLVM::LLVMIntegerType::get(context, 32);

mlir/lib/Dialect/LLVMIR/IR/TypeDetail.h

public:
   /// the key participate in uniquing, but all elements participate in
   /// construction.
   class Key {
   public:
     /// Constructs a key for an identified struct.
     Key(StringRef name, bool opaque)
         : name(name), identified(true), packed(false), opaque(opaque) {}
     /// Constructs a key for a literal struct.
-    Key(ArrayRef<LLVMType> types, bool packed)
+    Key(ArrayRef<Type> types, bool packed)
         : types(types), identified(false), packed(packed), opaque(false) {}
 
     /// Checks a specific property of the struct.
     bool isIdentified() const { return identified; }
     bool isPacked() const {
       assert(!isIdentified() &&
              "'packed' bit is not part of the key for identified structs");
       return packed;
     }
     bool isOpaque() const {
       assert(isIdentified() &&
              "'opaque' bit is meaningless on literal structs");
       return opaque;
     }
 
     /// Returns the identifier of a key for identified structs.
     StringRef getIdentifier() const {
       assert(isIdentified() &&
              "non-identified struct key canont have an identifier");
       return name;
     }
 
     /// Returns the list of type contained in the key of a literal struct.
-    ArrayRef<LLVMType> getTypeList() const {
+    ArrayRef<Type> getTypeList() const {
       assert(!isIdentified() &&
              "identified struct key cannot have a type list");
       return types;
     }
 
     /// Returns the hash value of the key. This combines various flags into a
     /// single value: the identified flag sets the first bit, and the packedness
     /// flag sets the second bit. Opacity bit is only used for construction and
public:
     /// Copies dynamically-sized components of the key into the given allocator.
     Key copyIntoAllocator(TypeStorageAllocator &allocator) const {
       if (isIdentified())
         return Key(allocator.copyInto(name), opaque);
       return Key(allocator.copyInto(types), packed);
     }
 
   private:
-    ArrayRef<LLVMType> types;
+    ArrayRef<Type> types;
     StringRef name;
     bool identified;
     bool packed;
     bool opaque;
   };
   using KeyTy = Key;
 
   /// Returns the string identifier of an identified struct.
   StringRef getIdentifier() const {
     assert(isIdentified() && "requested identifier on a non-identified struct");
     return StringRef(static_cast<const char *>(keyPtr), keySize());
   }
 
   /// Returns the list of types (partially) identifying a literal struct.
-  ArrayRef<LLVMType> getTypeList() const {
+  ArrayRef<Type> getTypeList() const {
     // If this triggers, use getIdentifiedStructBody() instead.
     assert(!isIdentified() && "requested typelist on an identified struct");
-    return ArrayRef<LLVMType>(static_cast<const LLVMType *>(keyPtr), keySize());
+    return ArrayRef<Type>(static_cast<const Type *>(keyPtr), keySize());
   }
 
   /// Returns the list of types contained in an identified struct.
-  ArrayRef<LLVMType> getIdentifiedStructBody() const {
+  ArrayRef<Type> getIdentifiedStructBody() const {
     // If this triggers, use getTypeList() instead.
     assert(isIdentified() &&
            "requested struct body on a non-identified struct");
-    return ArrayRef<LLVMType>(identifiedBodyArray, identifiedBodySize());
+    return ArrayRef<Type>(identifiedBodyArray, identifiedBodySize());
   }
 
   /// Checks whether the struct is identified.
   bool isIdentified() const {
     return llvm::Bitfield::get<KeyFlagIdentified>(keySizeAndFlags);
   }
 
   /// Checks whether the struct is packed (both literal and identified structs).
public:
   }
 
   /// Constructs the storage from the given key. This sets up the uniquing key
   /// components and optionally the mutable component if they construction key
   /// has the relevant information. In the latter case, the struct is considered
   /// as initialized and can no longer be mutated.
   LLVMStructTypeStorage(const KeyTy &key) {
     if (!key.isIdentified()) {
-      ArrayRef<LLVMType> types = key.getTypeList();
+      ArrayRef<Type> types = key.getTypeList();
       keyPtr = static_cast<const void *>(types.data());
       setKeySize(types.size());
       llvm::Bitfield::set<KeyFlagPacked>(keySizeAndFlags, key.isPacked());
       return;
     }
 
     StringRef name = key.getIdentifier();
     keyPtr = static_cast<const void *>(name.data());
static LLVMStructTypeStorage *construct(TypeStorageAllocator &allocator,
     return new (allocator.allocate<LLVMStructTypeStorage>())
         LLVMStructTypeStorage(key.copyIntoAllocator(allocator));
   }
 
   /// Sets the body of an identified struct. If the struct is already
   /// initialized, succeeds only if the body is equal to the current body. Fails
   /// if the struct is marked as intentionally opaque. The struct will be marked
   /// as initialized as a result of this operation and can no longer be changed.
-  LogicalResult mutate(TypeStorageAllocator &allocator, ArrayRef<LLVMType> body,
+  LogicalResult mutate(TypeStorageAllocator &allocator, ArrayRef<Type> body,
                        bool packed) {
     if (!isIdentified())
       return failure();
     if (isInitialized())
       return success(!isOpaque() && body == getIdentifiedStructBody() &&
                      packed == isPacked());
 
     llvm::Bitfield::set<MutableFlagInitialized>(identifiedBodySizeAndFlags,
                                                 true);
     llvm::Bitfield::set<MutableFlagPacked>(identifiedBodySizeAndFlags, packed);
 
-    ArrayRef<LLVMType> typesInAllocator = allocator.copyInto(body);
+    ArrayRef<Type> typesInAllocator = allocator.copyInto(body);
     identifiedBodyArray = typesInAllocator.data();
     setIdentifiedBodySize(typesInAllocator.size());
 
     return success();
   }
 
 private:
   /// Returns the number of elements in the key.
using MutableSize =
                               std::numeric_limits<unsigned>::digits - 3>;
 
   /// Pointer to the first element of the uniquing key.
   // Note: cannot use PointerUnion because bump-ptr allocator does not guarantee
   // address alignment.
   const void *keyPtr = nullptr;
 
   /// Pointer to the first type contained in an identified struct.
-  const LLVMType *identifiedBodyArray = nullptr;
+  const Type *identifiedBodyArray = nullptr;
 
   /// Size of the uniquing key combined with identified/literal and
   /// packedness bits. Must only be used through the Key* bitfields.
   unsigned keySizeAndFlags = 0;
 
   /// Number of the types contained in an identified struct combined with
   /// mutable flags. Must only be used through the Mutable* bitfields.
   unsigned identifiedBodySizeAndFlags = 0;
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMFunctionTypeStorage.
 //===----------------------------------------------------------------------===//
 
 /// Type storage for LLVM dialect function types. These are uniqued using the
 /// list of types they contain and the vararg bit.
 struct LLVMFunctionTypeStorage : public TypeStorage {
-  using KeyTy = std::tuple<LLVMType, ArrayRef<LLVMType>, bool>;
+  using KeyTy = std::tuple<Type, ArrayRef<Type>, bool>;
 
   /// Construct a storage from the given components. The list is expected to be
   /// allocated in the context.
-  LLVMFunctionTypeStorage(LLVMType result, ArrayRef<LLVMType> arguments,
-                          bool variadic)
+  LLVMFunctionTypeStorage(Type result, ArrayRef<Type> arguments, bool variadic)
       : argumentTypes(arguments) {
     returnTypeAndVariadic.setPointerAndInt(result, variadic);
   }
 
   /// Hook into the type uniquing infrastructure.
   static LLVMFunctionTypeStorage *construct(TypeStorageAllocator &allocator,
                                             const KeyTy &key) {
     return new (allocator.allocate<LLVMFunctionTypeStorage>())
struct LLVMFunctionTypeStorage : public TypeStorage {
   }
 
   bool operator==(const KeyTy &key) const {
     return std::make_tuple(getReturnType(), getArgumentTypes(), isVariadic()) ==
            key;
   }
 
   /// Returns the list of function argument types.
-  ArrayRef<LLVMType> getArgumentTypes() const { return argumentTypes; }
+  ArrayRef<Type> getArgumentTypes() const { return argumentTypes; }
 
   /// Checks whether the function type is variadic.
   bool isVariadic() const { return returnTypeAndVariadic.getInt(); }
 
   /// Returns the function result type.
-  LLVMType getReturnType() const { return returnTypeAndVariadic.getPointer(); }
+  Type getReturnType() const { return returnTypeAndVariadic.getPointer(); }
 
 private:
   /// Function result type packed with the variadic bit.
-  llvm::PointerIntPair<LLVMType, 1, bool> returnTypeAndVariadic;
+  llvm::PointerIntPair<Type, 1, bool> returnTypeAndVariadic;
   /// Argument types.
-  ArrayRef<LLVMType> argumentTypes;
+  ArrayRef<Type> argumentTypes;
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMIntegerTypeStorage.
 //===----------------------------------------------------------------------===//
 
 /// Storage type for LLVM dialect integer types. These are uniqued by bitwidth.
 struct LLVMIntegerTypeStorage : public TypeStorage {

 
 //===----------------------------------------------------------------------===//
 // LLVMPointerTypeStorage.
 //===----------------------------------------------------------------------===//
 
 /// Storage type for LLVM dialect pointer types. These are uniqued by a pair of
 /// element type and address space.
 struct LLVMPointerTypeStorage : public TypeStorage {
-  using KeyTy = std::tuple<LLVMType, unsigned>;
+  using KeyTy = std::tuple<Type, unsigned>;
 
   LLVMPointerTypeStorage(const KeyTy &key)
       : pointeeType(std::get<0>(key)), addressSpace(std::get<1>(key)) {}
 
   static LLVMPointerTypeStorage *construct(TypeStorageAllocator &allocator,
                                            const KeyTy &key) {
     return new (allocator.allocate<LLVMPointerTypeStorage>())
         LLVMPointerTypeStorage(key);
   }
 
   bool operator==(const KeyTy &key) const {
     return std::make_tuple(pointeeType, addressSpace) == key;
   }
 
-  LLVMType pointeeType;
+  Type pointeeType;
   unsigned addressSpace;
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMTypeAndSizeStorage.
 //===----------------------------------------------------------------------===//
 
 /// Common storage used for LLVM dialect types that need an element type and a
 /// number: arrays, fixed and scalable vectors. The actual semantics of the
 /// type is defined by its kind.
 struct LLVMTypeAndSizeStorage : public TypeStorage {
-  using KeyTy = std::tuple<LLVMType, unsigned>;
+  using KeyTy = std::tuple<Type, unsigned>;
 
   LLVMTypeAndSizeStorage(const KeyTy &key)
       : elementType(std::get<0>(key)), numElements(std::get<1>(key)) {}
 
   static LLVMTypeAndSizeStorage *construct(TypeStorageAllocator &allocator,
                                            const KeyTy &key) {
     return new (allocator.allocate<LLVMTypeAndSizeStorage>())
         LLVMTypeAndSizeStorage(key);
   }
 
   bool operator==(const KeyTy &key) const {
     return std::make_tuple(elementType, numElements) == key;
   }
 
-  LLVMType elementType;
+  Type elementType;
   unsigned numElements;
 };
 
 } // end namespace detail
 } // end namespace LLVM
 } // end namespace mlir
 
 #endif // DIALECT_LLVMIR_IR_TYPEDETAIL_H

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

 
 private:
   /// Returns personality of `f` as a FlatSymbolRefAttr.
   FlatSymbolRefAttr getPersonalityAsAttr(llvm::Function *f);
   /// Imports `bb` into `block`, which must be initially empty.
   LogicalResult processBasicBlock(llvm::BasicBlock *bb, Block *block);
   /// Imports `inst` and populates instMap[inst] with the imported Value.
   LogicalResult processInstruction(llvm::Instruction *inst);
-  /// Creates an LLVMType for `type`.
-  LLVMType processType(llvm::Type *type);
+  /// Creates an LLVM-compatible MLIR type for `type`.
+  Type processType(llvm::Type *type);
   /// `value` is an SSA-use. Return the remapped version of `value` or a
   /// placeholder that will be remapped later if this is an instruction that
   /// has not yet been visited.
   Value processValue(llvm::Value *value);
   /// Create the most accurate Location possible using a llvm::DebugLoc and
   /// possibly an llvm::Instruction to narrow the Location if debug information
   /// is unavailable.
   Location processDebugLoc(const llvm::DebugLoc &loc,
                            llvm::Instruction *inst = nullptr);
   /// `br` branches to `target`. Append the block arguments to attach to the
   /// generated branch op to `blockArguments`. These should be in the same order
   /// as the PHIs in `target`.
   LogicalResult processBranchArgs(llvm::Instruction *br,
                                   llvm::BasicBlock *target,
                                   SmallVectorImpl<Value> &blockArguments);
   /// Returns the builtin type equivalent to be used in attributes for the given
   /// LLVM IR dialect type.
-  Type getStdTypeForAttr(LLVMType type);
+  Type getStdTypeForAttr(Type type);
   /// Return `value` as an attribute to attach to a GlobalOp.
   Attribute getConstantAsAttr(llvm::Constant *value);
   /// Return `c` as an MLIR Value. This could either be a ConstantOp, or
   /// an expanded sequence of ops in the current function's entry block (for
   /// ConstantExprs or ConstantGEPs).
   Value processConstant(llvm::Constant *c);
 
   /// The current builder, pointing at where the next Instruction should be
Location Importer::processDebugLoc(const llvm::DebugLoc &loc,
   } else if (!loc) {
     return unknownLoc;
   }
   // FIXME: Obtain the filename from DILocationInfo.
   return FileLineColLoc::get("imported-bitcode", loc.getLine(), loc.getCol(),
                              context);
 }
 
-LLVMType Importer::processType(llvm::Type *type) {
-  if (LLVMType result = typeTranslator.translateType(type))
+Type Importer::processType(llvm::Type *type) {
+  if (Type result = typeTranslator.translateType(type))
     return result;
 
   // FIXME: Diagnostic should be able to natively handle types that have
   // operator<<(raw_ostream&) defined.
   std::string s;
   llvm::raw_string_ostream os(s);
   os << *type;
   emitError(unknownLoc) << "unhandled type: " << os.str();
   return nullptr;
 }
 
 // We only need integers, floats, doubles, and vectors and tensors thereof for
 // attributes. Scalar and vector types are converted to the standard
 // equivalents. Array types are converted to ranked tensors; nested array types
 // are converted to multi-dimensional tensors or vectors, depending on the
 // innermost type being a scalar or a vector.
-Type Importer::getStdTypeForAttr(LLVMType type) {
+Type Importer::getStdTypeForAttr(Type type) {
   if (!type)
     return nullptr;
 
   if (auto intType = type.dyn_cast<LLVMIntegerType>())
     return b.getIntegerType(intType.getBitWidth());
 
   if (type.isa<LLVMFloatType>())
     return b.getF32Type();
if (auto *c = dyn_cast<llvm::ConstantFP>(value)) {
     else if (c->getType()->isFloatingPointTy())
       return b.getFloatAttr(FloatType::getF32(context), c->getValueAPF());
   }
   if (auto *f = dyn_cast<llvm::Function>(value))
     return b.getSymbolRefAttr(f->getName());
 
   // Convert constant data to a dense elements attribute.
   if (auto *cd = dyn_cast<llvm::ConstantDataSequential>(value)) {
-    LLVMType type = processType(cd->getElementType());
+    Type type = processType(cd->getElementType());
     if (!type)
       return nullptr;
 
     auto attrType = getStdTypeForAttr(processType(cd->getType()))
                         .dyn_cast_or_null<ShapedType>();
     if (!attrType)
       return nullptr;
 
GlobalOp Importer::processGlobal(llvm::GlobalVariable *GV) {
   auto it = globals.find(GV);
   if (it != globals.end())
     return it->second;
 
   OpBuilder b(module.getBody(), getGlobalInsertPt());
   Attribute valueAttr;
   if (GV->hasInitializer())
     valueAttr = getConstantAsAttr(GV->getInitializer());
-  LLVMType type = processType(GV->getValueType());
+  Type type = processType(GV->getValueType());
   if (!type)
     return nullptr;
   GlobalOp op = b.create<GlobalOp>(
       UnknownLoc::get(context), type, GV->isConstant(),
       convertLinkageFromLLVM(GV->getLinkage()), GV->getName(), valueAttr);
   if (GV->hasInitializer() && !valueAttr) {
     Region &r = op.getInitializerRegion();
     currentEntryBlock = b.createBlock(&r);
     b.setInsertionPoint(currentEntryBlock, currentEntryBlock->begin());
     Value v = processConstant(GV->getInitializer());
     if (!v)
       return nullptr;
     b.create<ReturnOp>(op.getLoc(), ArrayRef<Value>({v}));
   }
   return globals[GV] = op;
 }
 
 Value Importer::processConstant(llvm::Constant *c) {
   OpBuilder bEntry(currentEntryBlock, currentEntryBlock->begin());
   if (Attribute attr = getConstantAsAttr(c)) {
     // These constants can be represented as attributes.
     OpBuilder b(currentEntryBlock, currentEntryBlock->begin());
-    LLVMType type = processType(c->getType());
+    Type type = processType(c->getType());
     if (!type)
       return nullptr;
     if (auto symbolRef = attr.dyn_cast<FlatSymbolRefAttr>())
       return instMap[c] = bEntry.create<AddressOfOp>(unknownLoc, type,
                                                      symbolRef.getValue());
     return instMap[c] = bEntry.create<ConstantOp>(unknownLoc, type, attr);
   }
   if (auto *cn = dyn_cast<llvm::ConstantPointerNull>(c)) {
-    LLVMType type = processType(cn->getType());
+    Type type = processType(cn->getType());
     if (!type)
       return nullptr;
     return instMap[c] = bEntry.create<NullOp>(unknownLoc, type);
   }
   if (auto *GV = dyn_cast<llvm::GlobalVariable>(c))
     return bEntry.create<AddressOfOp>(UnknownLoc::get(context),
                                       processGlobal(GV));
 
   if (auto *ce = dyn_cast<llvm::ConstantExpr>(c)) {
     llvm::Instruction *i = ce->getAsInstruction();
     OpBuilder::InsertionGuard guard(b);
     b.setInsertionPoint(currentEntryBlock, currentEntryBlock->begin());
     if (failed(processInstruction(i)))
       return nullptr;
     assert(instMap.count(i));
 
     // Remove this zombie LLVM instruction now, leaving us only with the MLIR
     // op.
     i->deleteValue();
     return instMap[c] = instMap[i];
   }
   if (auto *ue = dyn_cast<llvm::UndefValue>(c)) {
-    LLVMType type = processType(ue->getType());
+    Type type = processType(ue->getType());
     if (!type)
       return nullptr;
     return instMap[c] = bEntry.create<UndefOp>(UnknownLoc::get(context), type);
   }
   emitError(unknownLoc) << "unhandled constant: " << diag(*c);
   return nullptr;
 }
 
 Value Importer::processValue(llvm::Value *value) {
   auto it = instMap.find(value);
   if (it != instMap.end())
     return it->second;
 
   // We don't expect to see instructions in dominator order. If we haven't seen
   // this instruction yet, create an unknown op and remap it later.
   if (isa<llvm::Instruction>(value)) {
     OperationState state(UnknownLoc::get(context), "llvm.unknown");
-    LLVMType type = processType(value->getType());
+    Type type = processType(value->getType());
     if (!type)
       return nullptr;
     state.addTypes(type);
     unknownInstMap[value] = b.createOperation(state);
     return unknownInstMap[value]->getResult(0);
   }
 
   if (auto *c = dyn_cast<llvm::Constant>(value))
case llvm::Instruction::BitCast: {
     for (auto *op : inst->operand_values()) {
       Value value = processValue(op);
       if (!value)
         return failure();
       ops.push_back(value);
     }
     state.addOperands(ops);
     if (!inst->getType()->isVoidTy()) {
-      LLVMType type = processType(inst->getType());
+      Type type = processType(inst->getType());
       if (!type)
         return failure();
       state.addTypes(type);
     }
     Operation *op = b.createOperation(state);
     if (!inst->getType()->isVoidTy())
       v = op->getResult(0);
     return success();
if (brInst->isConditional()) {
       state.addAttribute(LLVM::CondBrOp::getOperandSegmentSizeAttr(),
                          b.getI32VectorAttr(operandSegmentSizes));
     }
 
     b.createOperation(state);
     return success();
   }
   case llvm::Instruction::PHI: {
-    LLVMType type = processType(inst->getType());
+    Type type = processType(inst->getType());
     if (!type)
       return failure();
     v = b.getInsertionBlock()->addArgument(type);
     return success();
   }
   case llvm::Instruction::Call: {
     llvm::CallInst *ci = cast<llvm::CallInst>(inst);
     SmallVector<Value, 4> ops;
     ops.reserve(inst->getNumOperands());
     for (auto &op : ci->arg_operands()) {
       Value arg = processValue(op.get());
       if (!arg)
         return failure();
       ops.push_back(arg);
     }
 
     SmallVector<Type, 2> tys;
     if (!ci->getType()->isVoidTy()) {
-      LLVMType type = processType(inst->getType());
+      Type type = processType(inst->getType());
       if (!type)
         return failure();
       tys.push_back(type);
     }
     Operation *op;
     if (llvm::Function *callee = ci->getCalledFunction()) {
       op = b.create<CallOp>(loc, tys, b.getSymbolRefAttr(callee->getName()),
                             ops);

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

if (isa<LLVM::CallOp>(opInst)) {
     }
     // Check that LLVM call returns void for 0-result functions.
     return success(result->getType()->isVoidTy());
   }
 
   if (auto inlineAsmOp = dyn_cast<LLVM::InlineAsmOp>(opInst)) {
     // TODO: refactor function type creation which usually occurs in std-LLVM
     // conversion.
-    SmallVector<LLVM::LLVMType, 8> operandTypes;
+    SmallVector<Type, 8> operandTypes;
     operandTypes.reserve(inlineAsmOp.operands().size());
     for (auto t : inlineAsmOp.operands().getTypes())
-      operandTypes.push_back(t.cast<LLVM::LLVMType>());
+      operandTypes.push_back(t);
 
-    LLVM::LLVMType resultType;
+    Type resultType;
     if (inlineAsmOp.getNumResults() == 0) {
       resultType = LLVM::LLVMVoidType::get(mlirModule->getContext());
     } else {
       assert(inlineAsmOp.getNumResults() == 1);
-      resultType = inlineAsmOp.getResultTypes()[0].cast<LLVM::LLVMType>();
+      resultType = inlineAsmOp.getResultTypes()[0];
     }
     auto ft = LLVM::LLVMFunctionType::get(resultType, operandTypes);
     llvm::InlineAsm *inlineAsmInst =
         inlineAsmOp.asm_dialect().hasValue()
             ? llvm::InlineAsm::get(
                   static_cast<llvm::FunctionType *>(convertType(ft)),
                   inlineAsmOp.asm_string(), inlineAsmOp.constraints(),
                   inlineAsmOp.has_side_effects(), inlineAsmOp.is_align_stack(),
if (auto attr = opInst.getAttrOfType<FlatSymbolRefAttr>("callee")) {
       builder.CreateInvoke(
           calleeType, operandsRef.front(), blockMapping[invOp.getSuccessor(0)],
           blockMapping[invOp.getSuccessor(1)], operandsRef.drop_front());
     }
     return success();
   }
 
   if (auto lpOp = dyn_cast<LLVM::LandingpadOp>(opInst)) {
-    llvm::Type *ty = convertType(lpOp.getType().cast<LLVMType>());
+    llvm::Type *ty = convertType(lpOp.getType());
     llvm::LandingPadInst *lpi =
         builder.CreateLandingPad(ty, lpOp.getNumOperands());
 
     // Add clauses
     for (auto operand : lookupValues(lpOp.getOperands())) {
       // All operands should be constant - checked by verifier
       if (auto constOperand = dyn_cast<llvm::Constant>(operand))
         lpi->addClause(constOperand);
if (auto weights = switchOp.branch_weights()) {
                           .createBranchWeights(weightValues);
     }
 
     llvm::SwitchInst *switchInst =
         builder.CreateSwitch(valueMapping[switchOp.value()],
                              blockMapping[switchOp.defaultDestination()],
                              switchOp.caseDestinations().size(), branchWeights);
 
-    auto *ty = llvm::cast<llvm::IntegerType>(
-        convertType(switchOp.value().getType().cast<LLVMType>()));
+    auto *ty =
+        llvm::cast<llvm::IntegerType>(convertType(switchOp.value().getType()));
     for (auto i :
          llvm::zip(switchOp.case_values()->cast<DenseIntElementsAttr>(),
                    switchOp.caseDestinations()))
       switchInst->addCase(
           llvm::ConstantInt::get(ty, std::get<0>(i).getLimitedValue()),
           blockMapping[std::get<1>(i)]);
 
     branchMapping.try_emplace(&opInst, switchInst);
LogicalResult ModuleTranslation::convertBlock(Block &bb, bool ignoreArguments) {
   // This step is omitted if "ignoreArguments" is set.  The arguments of the
   // first block have been already made available through the remapping of
   // LLVM function arguments.
   if (!ignoreArguments) {
     auto predecessors = bb.getPredecessors();
     unsigned numPredecessors =
         std::distance(predecessors.begin(), predecessors.end());
     for (auto arg : bb.getArguments()) {
-      auto wrappedType = arg.getType().dyn_cast<LLVM::LLVMType>();
-      if (!wrappedType)
+      auto wrappedType = arg.getType();
+      if (!isCompatibleType(wrappedType))
         return emitError(bb.front().getLoc(),
                          "block argument does not have an LLVM type");
       llvm::Type *type = convertType(wrappedType);
       llvm::PHINode *phi = builder.CreatePHI(type, numPredecessors);
       valueMapping[arg] = phi;
     }
   }
 
LogicalResult ModuleTranslation::convertOneFunction(LLVMFuncOp func) {
   for (auto kvp : llvm::zip(func.getArguments(), llvmFunc->args())) {
     llvm::Argument &llvmArg = std::get<1>(kvp);
     BlockArgument mlirArg = std::get<0>(kvp);
 
     if (auto attr = func.getArgAttrOfType<BoolAttr>(
             argIdx, LLVMDialect::getNoAliasAttrName())) {
       // NB: Attribute already verified to be boolean, so check if we can indeed
       // attach the attribute to this argument, based on its type.
-      auto argTy = mlirArg.getType().dyn_cast<LLVM::LLVMType>();
+      auto argTy = mlirArg.getType();
       if (!argTy.isa<LLVM::LLVMPointerType>())
         return func.emitError(
             "llvm.noalias attribute attached to LLVM non-pointer argument");
       if (attr.getValue())
         llvmArg.addAttr(llvm::Attribute::AttrKind::NoAlias);
     }
 
     if (auto attr = func.getArgAttrOfType<IntegerAttr>(
             argIdx, LLVMDialect::getAlignAttrName())) {
       // NB: Attribute already verified to be int, so check if we can indeed
       // attach the attribute to this argument, based on its type.
-      auto argTy = mlirArg.getType().dyn_cast<LLVM::LLVMType>();
+      auto argTy = mlirArg.getType();
       if (!argTy.isa<LLVM::LLVMPointerType>())
         return func.emitError(
             "llvm.align attribute attached to LLVM non-pointer argument");
       llvmArg.addAttrs(
           llvm::AttrBuilder().addAlignmentAttr(llvm::Align(attr.getInt())));
     }
 
     valueMapping[mlirArg] = &llvmArg;
for (auto function : getModuleBody(mlirModule).getOps<LLVMFuncOp>()) {
 
     if (failed(convertOneFunction(function)))
       return failure();
   }
 
   return success();
 }
 
-llvm::Type *ModuleTranslation::convertType(LLVMType type) {
+llvm::Type *ModuleTranslation::convertType(Type type) {
   return typeTranslator.translateType(type);
 }
 
 /// A helper to look up remapped operands in the value remapping table.`
 SmallVector<llvm::Value *, 8>
 ModuleTranslation::lookupValues(ValueRange values) {
   SmallVector<llvm::Value *, 8> remapped;
   remapped.reserve(values.size());

mlir/lib/Target/LLVMIR/TypeTranslation.cpp

 namespace detail {
 /// Support for translating MLIR LLVM dialect types to LLVM IR.
 class TypeToLLVMIRTranslatorImpl {
 public:
   /// Constructs a class creating types in the given LLVM context.
   TypeToLLVMIRTranslatorImpl(llvm::LLVMContext &context) : context(context) {}
 
   /// Translates a single type.
-  llvm::Type *translateType(LLVM::LLVMType type) {
+  llvm::Type *translateType(Type type) {
     // If the conversion is already known, just return it.
     if (knownTranslations.count(type))
       return knownTranslations.lookup(type);
 
     // Dispatch to an appropriate function.
     llvm::Type *translated =
-        llvm::TypeSwitch<LLVM::LLVMType, llvm::Type *>(type)
+        llvm::TypeSwitch<Type, llvm::Type *>(type)
             .Case([this](LLVM::LLVMVoidType) {
               return llvm::Type::getVoidTy(context);
             })
             .Case([this](LLVM::LLVMHalfType) {
               return llvm::Type::getHalfTy(context);
             })
             .Case([this](LLVM::LLVMBFloatType) {
               return llvm::Type::getBFloatTy(context);
llvm::Type *translated =
             .Case([this](LLVM::LLVMMetadataType) {
               return llvm::Type::getMetadataTy(context);
             })
             .Case<LLVM::LLVMArrayType, LLVM::LLVMIntegerType,
                   LLVM::LLVMFunctionType, LLVM::LLVMPointerType,
                   LLVM::LLVMStructType, LLVM::LLVMFixedVectorType,
                   LLVM::LLVMScalableVectorType>(
                 [this](auto type) { return this->translate(type); })
-            .Default([](LLVM::LLVMType t) -> llvm::Type * {
+            .Default([](Type t) -> llvm::Type * {
               llvm_unreachable("unknown LLVM dialect type");
             });
 
     // Cache the result of the conversion and return.
     knownTranslations.try_emplace(type, translated);
     return translated;
   }
 
private:
 
   /// Translates the given scalable-vector type.
   llvm::Type *translate(LLVM::LLVMScalableVectorType type) {
     return llvm::ScalableVectorType::get(translateType(type.getElementType()),
                                          type.getMinNumElements());
   }
 
   /// Translates a list of types.
-  void translateTypes(ArrayRef<LLVM::LLVMType> types,
+  void translateTypes(ArrayRef<Type> types,
                       SmallVectorImpl<llvm::Type *> &result) {
     result.reserve(result.size() + types.size());
     for (auto type : types)
       result.push_back(translateType(type));
   }
 
   /// Reference to the context in which the LLVM IR types are created.
   llvm::LLVMContext &context;
 
   /// Map of known translation. This serves a double purpose: caches translation
   /// results to avoid repeated recursive calls and makes sure identified
   /// structs with the same name (that is, equal) are resolved to an existing
   /// type instead of creating a new type.
-  llvm::DenseMap<LLVM::LLVMType, llvm::Type *> knownTranslations;
+  llvm::DenseMap<Type, llvm::Type *> knownTranslations;
 };
 } // end namespace detail
 } // end namespace LLVM
 } // end namespace mlir
 
 LLVM::TypeToLLVMIRTranslator::TypeToLLVMIRTranslator(llvm::LLVMContext &context)
     : impl(new detail::TypeToLLVMIRTranslatorImpl(context)) {}
 
 LLVM::TypeToLLVMIRTranslator::~TypeToLLVMIRTranslator() {}
 
-llvm::Type *LLVM::TypeToLLVMIRTranslator::translateType(LLVM::LLVMType type) {
+llvm::Type *LLVM::TypeToLLVMIRTranslator::translateType(Type type) {
   return impl->translateType(type);
 }
 
 unsigned LLVM::TypeToLLVMIRTranslator::getPreferredAlignment(
-    LLVM::LLVMType type, const llvm::DataLayout &layout) {
+    Type type, const llvm::DataLayout &layout) {
   return layout.getPrefTypeAlignment(translateType(type));
 }
 
 namespace mlir {
 namespace LLVM {
 namespace detail {
 /// Support for translating LLVM IR types to MLIR LLVM dialect types.
 class TypeFromLLVMIRTranslatorImpl {
 public:
   /// Constructs a class creating types in the given MLIR context.
   TypeFromLLVMIRTranslatorImpl(MLIRContext &context) : context(context) {}
 
   /// Translates the given type.
-  LLVM::LLVMType translateType(llvm::Type *type) {
+  Type translateType(llvm::Type *type) {
     if (knownTranslations.count(type))
       return knownTranslations.lookup(type);
 
-    LLVM::LLVMType translated =
-        llvm::TypeSwitch<llvm::Type *, LLVM::LLVMType>(type)
+    Type translated =
+        llvm::TypeSwitch<llvm::Type *, Type>(type)
             .Case<llvm::ArrayType, llvm::FunctionType, llvm::IntegerType,
                   llvm::PointerType, llvm::StructType, llvm::FixedVectorType,
                   llvm::ScalableVectorType>(
                 [this](auto *type) { return this->translate(type); })
             .Default([this](llvm::Type *type) {
               return translatePrimitiveType(type);
             });
     knownTranslations.try_emplace(type, translated);
     return translated;
   }
 
 private:
   /// Translates the given primitive, i.e. non-parametric in MLIR nomenclature,
   /// type.
-  LLVM::LLVMType translatePrimitiveType(llvm::Type *type) {
+  Type translatePrimitiveType(llvm::Type *type) {
     if (type->isVoidTy())
       return LLVM::LLVMVoidType::get(&context);
     if (type->isHalfTy())
       return LLVM::LLVMHalfType::get(&context);
     if (type->isBFloatTy())
       return LLVM::LLVMBFloatType::get(&context);
     if (type->isFloatTy())
       return LLVM::LLVMFloatType::get(&context);
Type translatePrimitiveType(llvm::Type *type) {
     if (type->isLabelTy())
       return LLVM::LLVMLabelType::get(&context);
     if (type->isMetadataTy())
       return LLVM::LLVMMetadataType::get(&context);
     llvm_unreachable("not a primitive type");
   }
 
   /// Translates the given array type.
-  LLVM::LLVMType translate(llvm::ArrayType *type) {
+  Type translate(llvm::ArrayType *type) {
     return LLVM::LLVMArrayType::get(translateType(type->getElementType()),
                                     type->getNumElements());
   }
 
   /// Translates the given function type.
-  LLVM::LLVMType translate(llvm::FunctionType *type) {
-    SmallVector<LLVM::LLVMType, 8> paramTypes;
+  Type translate(llvm::FunctionType *type) {
+    SmallVector<Type, 8> paramTypes;
     translateTypes(type->params(), paramTypes);
     return LLVM::LLVMFunctionType::get(translateType(type->getReturnType()),
                                        paramTypes, type->isVarArg());
   }
 
   /// Translates the given integer type.
-  LLVM::LLVMType translate(llvm::IntegerType *type) {
+  Type translate(llvm::IntegerType *type) {
     return LLVM::LLVMIntegerType::get(&context, type->getBitWidth());
   }
 
   /// Translates the given pointer type.
-  LLVM::LLVMType translate(llvm::PointerType *type) {
+  Type translate(llvm::PointerType *type) {
     return LLVM::LLVMPointerType::get(translateType(type->getElementType()),
                                       type->getAddressSpace());
   }
 
   /// Translates the given structure type.
-  LLVM::LLVMType translate(llvm::StructType *type) {
-    SmallVector<LLVM::LLVMType, 8> subtypes;
+  Type translate(llvm::StructType *type) {
+    SmallVector<Type, 8> subtypes;
     if (type->isLiteral()) {
       translateTypes(type->subtypes(), subtypes);
       return LLVM::LLVMStructType::getLiteral(&context, subtypes,
                                               type->isPacked());
     }
 
     if (type->isOpaque())
       return LLVM::LLVMStructType::getOpaque(type->getName(), &context);
 
     LLVM::LLVMStructType translated =
         LLVM::LLVMStructType::getIdentified(&context, type->getName());
     knownTranslations.try_emplace(type, translated);
     translateTypes(type->subtypes(), subtypes);
     LogicalResult bodySet = translated.setBody(subtypes, type->isPacked());
     assert(succeeded(bodySet) &&
            "could not set the body of an identified struct");
     (void)bodySet;
     return translated;
   }
 
   /// Translates the given fixed-vector type.
-  LLVM::LLVMType translate(llvm::FixedVectorType *type) {
+  Type translate(llvm::FixedVectorType *type) {
     return LLVM::LLVMFixedVectorType::get(translateType(type->getElementType()),
                                           type->getNumElements());
   }
 
   /// Translates the given scalable-vector type.
-  LLVM::LLVMType translate(llvm::ScalableVectorType *type) {
+  Type translate(llvm::ScalableVectorType *type) {
     return LLVM::LLVMScalableVectorType::get(
         translateType(type->getElementType()), type->getMinNumElements());
   }
 
   /// Translates a list of types.
   void translateTypes(ArrayRef<llvm::Type *> types,
-                      SmallVectorImpl<LLVM::LLVMType> &result) {
+                      SmallVectorImpl<Type> &result) {
     result.reserve(result.size() + types.size());
     for (llvm::Type *type : types)
       result.push_back(translateType(type));
   }
 
   /// Map of known translations. Serves as a cache and as recursion stopper for
   /// translating recursive structs.
-  llvm::DenseMap<llvm::Type *, LLVM::LLVMType> knownTranslations;
+  llvm::DenseMap<llvm::Type *, Type> knownTranslations;
 
   /// The context in which MLIR types are created.
   MLIRContext &context;
 };
 } // end namespace detail
 } // end namespace LLVM
 } // end namespace mlir
 
 LLVM::TypeFromLLVMIRTranslator::TypeFromLLVMIRTranslator(MLIRContext &context)
     : impl(new detail::TypeFromLLVMIRTranslatorImpl(context)) {}
 
 LLVM::TypeFromLLVMIRTranslator::~TypeFromLLVMIRTranslator() {}
 
-LLVM::LLVMType LLVM::TypeFromLLVMIRTranslator::translateType(llvm::Type *type) {
+Type LLVM::TypeFromLLVMIRTranslator::translateType(llvm::Type *type) {
   return impl->translateType(type);
 }

mlir/test/Dialect/LLVMIR/invalid.mlir

 func @call_non_llvm() {
   // expected-error@+1 {{'llvm.call' op 'standard_func_callee' does not reference a valid LLVM function}}
   llvm.call @standard_func_callee() : () -> ()
 }
 
 // -----
 
 func @call_non_llvm_indirect(%arg0 : i32) {
-  // expected-error@+1 {{'llvm.call' op operand #0 must be LLVM dialect type, but got 'i32'}}
+  // expected-error@+1 {{'llvm.call' op operand #0 must be LLVM dialect-compatible type, but got 'i32'}}
   "llvm.call"(%arg0) : (i32) -> ()
 }
 
 // -----
 
 llvm.func @callee_func(!llvm.i8) -> ()
 
 func @callee_arg_mismatch(%arg0 : !llvm.i32) {

mlir/tools/mlir-tblgen/LLVMIRConversionGen.cpp

if (isOperandName(op, name)) {
                         ? formatv("lookupValues(op.{0}())", name)
                         : formatv("valueMapping.lookup(op.{0}())", name);
       bs << result;
     } else if (isAttributeName(op, name)) {
       bs << formatv("op.{0}()", name);
     } else if (isResultName(op, name)) {
       bs << formatv("valueMapping[op.{0}()]", name);
     } else if (name == "_resultType") {
-      bs << "convertType(op.getResult().getType().cast<LLVM::LLVMType>())";
+      bs << "convertType(op.getResult().getType())";
     } else if (name == "_hasResult") {
       bs << "opInst.getNumResults() == 1";
     } else if (name == "_location") {
       bs << "opInst.getLoc()";
     } else if (name == "_numOperands") {
       bs << "opInst.getNumOperands()";
     } else if (name == "$") {
       bs << '$';