[mlir] Add verification to LLVM dialect types

[ftynse]

Summary

Now that LLVM dialect types are implemented directly in the dialect, we can use
MLIR hooks for verifying type construction invariants. Implement the verifiers
and use them in the parser.

[rriddle]

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

357

nit: Add a variable name for the bool parameter.

415

nit: Missing a variable name here.

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

300

nit: Can you just use an if here instead?

if (isScalable)
  ...
...

335

nit: Add braces here, the body is non-trivial.

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

226

nit: Use one isa here:

!type.isa<LLVMVoidType, LLVMLabelType, ...>()

259

Same here and below.

328

Can you use a constexpr for this magic number?

432

nit: Can you include the fact that this is an LLVM structure?

[ftynse]

Address review

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

357

It is not used by the body of the function. If I add a name here, the linter will complain about mismatching names. If I add a name in both, it will complain about an unused variable.

415

Same as above.

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

public:
   LLVMType getFunctionResultType();
   bool isFunctionTy();
   bool isFunctionVarArg();
 
   /// Pointer type utilities.
   LLVMType getPointerTo(unsigned addrSpace = 0);
   LLVMType getPointerElementTy();
   bool isPointerTy();
-  static bool isValidPointerElementType(LLVMType type);
 
   /// Struct type utilities.
   LLVMType getStructElementType(unsigned i);
   unsigned getStructNumElements();
   bool isStructTy();
 
   /// Utilities used to generate floating point types.
   static LLVMType getDoubleTy(MLIRContext *context);

 /// elements in memory, parameterized by the number of elements and the element
 /// type.
 class LLVMArrayType : public Type::TypeBase<LLVMArrayType, LLVMType,
                                             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);
+
   /// 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,
+                                  unsigned numElements);
 
   /// Returns the element type of the array.
   LLVMType 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,
+                                                    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,
                             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);
+
+  /// Checks if the given type can be used as a result in a function type.
+  static bool isValidResultType(LLVMType 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,
                               bool isVarArg = false);
+  static LLVMFunctionType getChecked(Location loc, LLVMType result,
+                                     ArrayRef<LLVMType> arguments,
+                                     bool isVarArg = false);
 
   /// Returns the result type of the function.
   LLVMType 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);
 
-  /// Returns whether the function is variadic.
-  bool isVarArg();
-
   /// Returns a list of argument types of the function.
   ArrayRef<LLVMType> getParams();
   ArrayRef<LLVMType> 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);
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMIntegerType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect signless integer type parameterized by bitwidth.
 class LLVMIntegerType : public Type::TypeBase<LLVMIntegerType, LLVMType,
                                               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);
+  static LLVMIntegerType getChecked(Location loc, unsigned bitwidth);
 
   /// Returns the bitwidth of this integer type.
   unsigned getBitWidth();
+
+  /// Verifies that the type about to be constructed is well-formed.
+  static LogicalResult verifyConstructionInvariants(Location loc,
+                                                    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,
                                               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);
+
   /// 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,
+                                    unsigned addressSpace = 0);
 
   /// Returns the pointed-to type.
   LLVMType 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);
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMStructType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect structure type representing a collection of different-typed
 /// elements manipulated together. Structured can optionally be packed, meaning

 /// 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,
                                              detail::LLVMStructTypeStorage> {
 public:
   /// Inherit base construtors.
   using Base::Base;
 
+  /// Checks if the given type can be contained in a structure type.
+  static bool isValidElementType(LLVMType 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 or creates a literal struct with the given body in the provided
   /// context.
   static LLVMStructType getLiteral(MLIRContext *context,
                                    ArrayRef<LLVMType> types,
                                    bool isPacked = false);
+  static LLVMStructType getLiteralChecked(Location loc,
+                                          ArrayRef<LLVMType> 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);
public:
   /// 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();
+
+  /// 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);
 };
 
 //===----------------------------------------------------------------------===//
 // 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 {
 public:
   /// Inherit base constructor.
   using LLVMType::LLVMType;
 
   /// 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);
+
   /// Returns the element type of the vector.
   LLVMType 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,
+                                                    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,
+                                        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,
+                                           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();
 };
 
 //===----------------------------------------------------------------------===//

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

if (types.empty()) {
     return failure();
   }
 
   result.addAttribute("type", TypeAttr::get(types[0]));
   return success();
 }
 
 static LogicalResult verify(GlobalOp op) {
-  if (!LLVMType::isValidPointerElementType(op.getType()))
+  if (!LLVMPointerType::isValidElementType(op.getType()))
     return op.emitOpError(
         "expects type to be a valid element type for an LLVM pointer");
   if (op.getParentOp() && !satisfiesLLVMModule(op.getParentOp()))
     return op.emitOpError("must appear at the module level");
 
   if (auto strAttr = op.getValueOrNull().dyn_cast_or_null<StringAttr>()) {
     auto type = op.getType();
     if (!type.isArrayTy() || !type.getArrayElementType().isIntegerTy(8) ||

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

static ParseResult parseTypeImpl(DialectAsmParser &parser,
   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;
   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::get(returnType, {}, /*isVarArg=*/false);
+      return LLVMFunctionType::getChecked(loc, returnType, {},
+                                          /*isVarArg=*/false);
     return LLVMFunctionType();
   }
 
   // Parse arguments.
   SmallVector<LLVMType, 8> argTypes;
   do {
     if (succeeded(parser.parseOptionalEllipsis())) {
       if (parser.parseOptionalRParen() || parser.parseOptionalGreater())
         return LLVMFunctionType();
-      return LLVMFunctionType::get(returnType, argTypes, /*isVarArg=*/true);
+      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::get(returnType, argTypes, /*isVarArg=*/false);
+  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;
   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::get(elementType, addressSpace);
+  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;
+  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);
   //  - two elements, the first dynamic (indicated by -1) and the second
   //    non-dynamic (scalable vector).
   if (dims.empty() || dims.size() > 2 ||
       ((dims.size() == 2) ^ (dims[0] == -1)) ||
       (dims.size() == 2 && dims[1] == -1)) {
     parser.emitError(dimPos)
         << "expected '? x <integer> x <type>' or '<integer> x <type>'";
     return LLVMVectorType();
   }
 
   bool isScalable = dims.size() == 2;
-  return isScalable ? static_cast<LLVMVectorType>(
-                          LLVMScalableVectorType::get(elementType, dims[1]))
-                    : LLVMFixedVectorType::get(elementType, dims[0]);
+  return isScalable
+             ? static_cast<LLVMVectorType>(LLVMScalableVectorType::getChecked(
+                   loc, elementType, dims[1]))
+             : LLVMFixedVectorType::getChecked(loc, elementType, dims[0]);
 }
 
 /// 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;
+  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::get(elementType, dims[0]);
+  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,
                                        llvm::SMLoc subtypesLoc,
                                        llvm::SetVector<StringRef> &stack) {
+  for (LLVMType t : subtypes)
+    if (!LLVMStructType::isValidElementType(t)) {
+      parser.emitError(subtypesLoc) << "invalid structure element type: " << t;
+      return LLVMStructType();
+    }
+
   if (succeeded(type.setBody(subtypes, isPacked)))
     return type;
 
   std::string currentBody;
   llvm::raw_string_ostream currentBodyStream(currentBody);
   printStructTypeBody(currentBodyStream, type, stack);
   auto diag = parser.emitError(subtypesLoc)
               << "identified type already used with a different body";
   diag.attachNote() << "existing body: " << currentBodyStream.str();
   return LLVMStructType();
 }
 
 /// Parses an LLVM dialect structure type.
 ///   llvm-type ::= `struct<` (string-literal `,`)? `packed`?
 ///                 `(` llvm-type-list `)` `>`
 ///               | `struct<` string-literal `>`
 ///               | `struct<` string-literal `, opaque>`
 static LLVMStructType parseStructType(DialectAsmParser &parser,
                                       llvm::SetVector<StringRef> &stack) {
-  MLIRContext *ctx = parser.getBuilder().getContext();
+  Location loc = parser.getEncodedSourceLoc(parser.getCurrentLocation());
 
   if (failed(parser.parseLess()))
     return LLVMStructType();
 
   // If we are parsing a self-reference to a recursive struct, i.e. the parsing
   // stack already contains a struct with the same identifier, bail out after
   // the name.
   StringRef name;
   bool isIdentified = succeeded(parser.parseOptionalString(&name));
   if (isIdentified) {
     if (stack.count(name)) {
       if (failed(parser.parseGreater()))
         return LLVMStructType();
-      return LLVMStructType::getIdentified(ctx, name);
+      return LLVMStructType::getIdentifiedChecked(loc, name);
     }
     if (failed(parser.parseComma()))
       return LLVMStructType();
   }
 
   // Handle intentionally opaque structs.
   llvm::SMLoc kwLoc = parser.getCurrentLocation();
   if (succeeded(parser.parseOptionalKeyword("opaque"))) {
     if (!isIdentified)
       return parser.emitError(kwLoc, "only identified structs can be opaque"),
              LLVMStructType();
     if (failed(parser.parseGreater()))
       return LLVMStructType();
-    auto type = LLVMStructType::getOpaque(name, ctx);
+    auto type = LLVMStructType::getOpaqueChecked(loc, name);
     if (!type.isOpaque()) {
       parser.emitError(kwLoc, "redeclaring defined struct as opaque");
       return LLVMStructType();
     }
     return type;
   }
 
   // Check for packedness.
   bool isPacked = succeeded(parser.parseOptionalKeyword("packed"));
   if (failed(parser.parseLParen()))
     return LLVMStructType();
 
   // Fast pass for structs with zero subtypes.
   if (succeeded(parser.parseOptionalRParen())) {
     if (failed(parser.parseGreater()))
       return LLVMStructType();
     if (!isIdentified)
-      return LLVMStructType::getLiteral(ctx, {}, isPacked);
-    auto type = LLVMStructType::getIdentified(ctx, name);
+      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;
   llvm::SMLoc subtypesLoc = parser.getCurrentLocation();
   do {
     if (isIdentified)
       stack.insert(name);
     LLVMType 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::getLiteral(ctx, subtypes, isPacked);
-  auto type = LLVMStructType::getIdentified(ctx, name);
+    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) {
   // 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();
 
     if (!maybeIntegerType.isSignlessInteger()) {
       parser.emitError(keyLoc) << "unexpected type, expected i* or keyword";
       return LLVMType();
     }
-    return LLVMIntegerType::get(ctx, maybeIntegerType.getIntOrFloatBitWidth());
+    return LLVMIntegerType::getChecked(
+        loc, maybeIntegerType.getIntOrFloatBitWidth());
   }
 
   // Dispatch to concrete functions.
   StringRef key;
   if (failed(parser.parseKeyword(&key)))
     return LLVMType();
 
   return llvm::StringSwitch<function_ref<LLVMType()>>(key)

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

 }
 
 LLVMType LLVMType::getPointerElementTy() {
   return cast<LLVMPointerType>().getElementType();
 }
 
 bool LLVMType::isPointerTy() { return isa<LLVMPointerType>(); }
 
-bool LLVMType::isValidPointerElementType(LLVMType type) {
-  return !type.isa<LLVMVoidType>() && !type.isa<LLVMTokenType>() &&
-         !type.isa<LLVMMetadataType>() && !type.isa<LLVMLabelType>();
-}
-
 //----------------------------------------------------------------------------//
 // Struct type utilities.
 
 LLVMType LLVMType::getStructElementType(unsigned i) {
   return cast<LLVMStructType>().getBody()[i];
 }
 
 unsigned LLVMType::getStructNumElements() {
LLVMType LLVMType::setStructTyBody(LLVMType structType,
   assert(succeeded(couldSet) && "failed to set the body");
   (void)couldSet;
   return structType;
 }
 
 //===----------------------------------------------------------------------===//
 // Array type.
 
+bool LLVMArrayType::isValidElementType(LLVMType type) {
+  return !type.isa<LLVMVoidType>() && !type.isa<LLVMLabelType>() &&
+         !type.isa<LLVMMetadataType>() && !type.isa<LLVMFunctionType>() &&
+         !type.isa<LLVMTokenType>() && !type.isa<LLVMScalableVectorType>();
+}
+
 LLVMArrayType LLVMArrayType::get(LLVMType elementType, unsigned numElements) {
   assert(elementType && "expected non-null subtype");
   return Base::get(elementType.getContext(), LLVMType::ArrayType, elementType,
                    numElements);
 }
 
+LLVMArrayType LLVMArrayType::getChecked(Location loc, LLVMType elementType,
+                                        unsigned numElements) {
+  assert(elementType && "expected non-null subtype");
+  return Base::getChecked(loc, LLVMType::ArrayType, elementType, numElements);
+}
+
 LLVMType LLVMArrayType::getElementType() { return getImpl()->elementType; }
 
 unsigned LLVMArrayType::getNumElements() { return getImpl()->numElements; }
 
+LogicalResult
+LLVMArrayType::verifyConstructionInvariants(Location loc, LLVMType elementType,
+                                            unsigned numElements) {
+  if (!isValidElementType(elementType))
+    return emitError(loc, "invalid array element type: ") << elementType;
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // Function type.
 
+bool LLVMFunctionType::isValidArgumentType(LLVMType type) {
+  return !type.isa<LLVMVoidType>() && !type.isa<LLVMFunctionType>();
+}
+
+bool LLVMFunctionType::isValidResultType(LLVMType type) {
+  return !type.isa<LLVMFunctionType>() && !type.isa<LLVMMetadataType>() &&
+         !type.isa<LLVMLabelType>();
+}
+
 LLVMFunctionType LLVMFunctionType::get(LLVMType result,
                                        ArrayRef<LLVMType> arguments,
                                        bool isVarArg) {
   assert(result && "expected non-null result");
   return Base::get(result.getContext(), LLVMType::FunctionType, result,
                    arguments, isVarArg);
 }
 
+LLVMFunctionType LLVMFunctionType::getChecked(Location loc, LLVMType result,
+                                              ArrayRef<LLVMType> arguments,
+                                              bool isVarArg) {
+  assert(result && "expected non-null result");
+  return Base::getChecked(loc, LLVMType::FunctionType, result, arguments,
+                          isVarArg);
+}
+
 LLVMType LLVMFunctionType::getReturnType() {
   return getImpl()->getReturnType();
 }
 
 unsigned LLVMFunctionType::getNumParams() {
   return getImpl()->getArgumentTypes().size();
 }
 
 LLVMType LLVMFunctionType::getParamType(unsigned i) {
   return getImpl()->getArgumentTypes()[i];
 }
 
 bool LLVMFunctionType::isVarArg() { return getImpl()->isVariadic(); }
 
 ArrayRef<LLVMType> LLVMFunctionType::getParams() {
   return getImpl()->getArgumentTypes();
 }
 
+LogicalResult LLVMFunctionType::verifyConstructionInvariants(
+    Location loc, LLVMType result, ArrayRef<LLVMType> arguments, bool) {
+  if (!isValidResultType(result))
+    return emitError(loc, "invalid function result type: ") << result;
+
+  for (LLVMType arg : arguments)
+    if (!isValidArgumentType(arg))
+      return emitError(loc, "invalid function argument type: ") << arg;
+
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // Integer type.
 
 LLVMIntegerType LLVMIntegerType::get(MLIRContext *ctx, unsigned bitwidth) {
   return Base::get(ctx, LLVMType::IntegerType, bitwidth);
 }
 
+LLVMIntegerType LLVMIntegerType::getChecked(Location loc, unsigned bitwidth) {
+  return Base::getChecked(loc, LLVMType::IntegerType, bitwidth);
+}
+
 unsigned LLVMIntegerType::getBitWidth() { return getImpl()->bitwidth; }
 
+LogicalResult LLVMIntegerType::verifyConstructionInvariants(Location loc,
+                                                            unsigned bitwidth) {
+  if (bitwidth >= (1 << 24))
+    return emitError(loc, "integer type too wide");
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // Pointer type.
 
+bool LLVMPointerType::isValidElementType(LLVMType type) {
+  return !type.isa<LLVMVoidType>() && !type.isa<LLVMTokenType>() &&
+         !type.isa<LLVMMetadataType>() && !type.isa<LLVMLabelType>();
+}
+
 LLVMPointerType LLVMPointerType::get(LLVMType pointee, unsigned addressSpace) {
   assert(pointee && "expected non-null subtype");
   return Base::get(pointee.getContext(), LLVMType::PointerType, pointee,
                    addressSpace);
 }
 
+LLVMPointerType LLVMPointerType::getChecked(Location loc, LLVMType pointee,
+                                            unsigned addressSpace) {
+  return Base::getChecked(loc, LLVMType::PointerType, pointee, addressSpace);
+}
+
 LLVMType LLVMPointerType::getElementType() { return getImpl()->pointeeType; }
 
 unsigned LLVMPointerType::getAddressSpace() { return getImpl()->addressSpace; }
 
+LogicalResult LLVMPointerType::verifyConstructionInvariants(Location loc,
+                                                            LLVMType pointee,
+                                                            unsigned) {
+  if (!isValidElementType(pointee))
+    return emitError(loc, "invalid pointer element type: ") << pointee;
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // Struct type.
 
+bool LLVMStructType::isValidElementType(LLVMType type) {
+  return !type.isa<LLVMVoidType>() && !type.isa<LLVMLabelType>() &&
+         !type.isa<LLVMMetadataType>() && !type.isa<LLVMFunctionType>() &&
+         !type.isa<LLVMTokenType>() && !type.isa<LLVMScalableVectorType>();
+}
+
 LLVMStructType LLVMStructType::getIdentified(MLIRContext *context,
                                              StringRef name) {
   return Base::get(context, LLVMType::StructType, name, /*opaque=*/false);
 }
 
+LLVMStructType LLVMStructType::getIdentifiedChecked(Location loc,
+                                                    StringRef name) {
+  return Base::getChecked(loc, LLVMType::StructType, name, /*opaque=*/false);
+}
+
 LLVMStructType LLVMStructType::getLiteral(MLIRContext *context,
                                           ArrayRef<LLVMType> types,
                                           bool isPacked) {
   return Base::get(context, LLVMType::StructType, types, isPacked);
 }
 
+LLVMStructType LLVMStructType::getLiteralChecked(Location loc,
+                                                 ArrayRef<LLVMType> types,
+                                                 bool isPacked) {
+  return Base::getChecked(loc, LLVMType::StructType, types, isPacked);
+}
+
 LLVMStructType LLVMStructType::getOpaque(StringRef name, MLIRContext *context) {
   return Base::get(context, LLVMType::StructType, name, /*opaque=*/true);
 }
 
+LLVMStructType LLVMStructType::getOpaqueChecked(Location loc, StringRef name) {
+  return Base::getChecked(loc, LLVMType::StructType, name, /*opaque=*/true);
+}
+
 LogicalResult LLVMStructType::setBody(ArrayRef<LLVMType> 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()->isOpaque() || !getImpl()->isInitialized();
 }
 bool LLVMStructType::isInitialized() { return getImpl()->isInitialized(); }
 StringRef LLVMStructType::getName() { return getImpl()->getIdentifier(); }
 ArrayRef<LLVMType> 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)
+    if (!isValidElementType(t))
+      return emitError(loc, "invalid structure element type: ") << t;
+
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // Vector types.
 
+bool LLVMVectorType::isValidElementType(LLVMType type) {
+  return type.isa<LLVMIntegerType>() || type.isFloatingPointTy() ||
+         type.isa<LLVMPointerType>();
+}
+
 /// Support type casting functionality.
 bool LLVMVectorType::classof(Type type) {
   return type.isa<LLVMFixedVectorType, LLVMScalableVectorType>();
 }
 
 LLVMType 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(
       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,
+                                             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,
                                              unsigned numElements) {
   assert(elementType && "expected non-null subtype");
   return Base::get(elementType.getContext(), LLVMType::FixedVectorType,
-                   elementType, numElements)
-      .cast<LLVMFixedVectorType>();
+                   elementType, numElements);
+}
+
+LLVMFixedVectorType LLVMFixedVectorType::getChecked(Location loc,
+                                                    LLVMType elementType,
+                                                    unsigned numElements) {
+  assert(elementType && "expected non-null subtype");
+  return Base::getChecked(loc, LLVMType::FixedVectorType, elementType,
+                          numElements);
 }
 
 unsigned LLVMFixedVectorType::getNumElements() {
   return getImpl()->numElements;
 }
 
 LLVMScalableVectorType LLVMScalableVectorType::get(LLVMType elementType,
                                                    unsigned minNumElements) {
   assert(elementType && "expected non-null subtype");
   return Base::get(elementType.getContext(), LLVMType::ScalableVectorType,
-                   elementType, minNumElements)
-      .cast<LLVMScalableVectorType>();
+                   elementType, minNumElements);
+}
+
+LLVMScalableVectorType
+LLVMScalableVectorType::getChecked(Location loc, LLVMType elementType,
+                                   unsigned minNumElements) {
+  assert(elementType && "expected non-null subtype");
+  return Base::getChecked(loc, LLVMType::ScalableVectorType, elementType,
+                          minNumElements);
 }
 
 unsigned LLVMScalableVectorType::getMinNumElements() {
   return getImpl()->numElements;
 }

mlir/test/Dialect/LLVMIR/types-invalid.mlir

 // RUN: mlir-opt --allow-unregistered-dialect -split-input-file -verify-diagnostics %s
 
+func @array_of_void() {
+  // expected-error @+1 {{invalid array element type}}
+  "some.op"() : () -> !llvm.array<4 x void>
+}
+
+// -----
+
+func @function_returning_function() {
+  // expected-error @+1 {{invalid function result type}}
+  "some.op"() : () -> !llvm.func<func<void ()> ()>
+}
+
+// -----
+
+func @function_taking_function() {
+  // expected-error @+1 {{invalid function argument type}}
+  "some.op"() : () -> !llvm.func<void (func<void ()>)>
+}
+
+// -----
+
+func @void_pointer() {
+  // expected-error @+1 {{invalid pointer element type}}
+  "some.op"() : () -> !llvm.ptr<void>
+}
+
+// -----
+
 func @repeated_struct_name() {
   "some.op"() : () -> !llvm.struct<"a", (ptr<struct<"a">>)>
   // expected-error @+2 {{identified type already used with a different body}}
   // expected-note @+1 {{existing body: (ptr<struct<"a">>)}}
   "some.op"() : () -> !llvm.struct<"a", (i32)>
 }
 
 // -----
func @explicitly_opaque_struct() {
   "some.op"() : () -> !llvm.struct<"a", opaque>
   // expected-error @+2 {{identified type already used with a different body}}
   // expected-note @+1 {{existing body: opaque}}
   "some.op"() : () -> !llvm.struct<"a", ()>
 }
 
 // -----
 
+func @literal_struct_with_void() {
+  // expected-error @+1 {{invalid structure element type}}
+  "some.op"() : () -> !llvm.struct<(void)>
+}
+
+// -----
+
+func @identified_struct_with_void() {
+  // expected-error @+1 {{invalid structure element type}}
+  "some.op"() : () -> !llvm.struct<"a", (void)>
+}
+
+// -----
+
 func @dynamic_vector() {
   // expected-error @+1 {{expected '? x <integer> x <type>' or '<integer> x <type>'}}
   "some.op"() : () -> !llvm.vec<? x float>
 }
 
 // -----
 
 func @dynamic_scalable_vector() {
   // expected-error @+1 {{expected '? x <integer> x <type>' or '<integer> x <type>'}}
   "some.op"() : () -> !llvm.vec<? x ? x float>
 }
 
 // -----
 
 func @unscalable_vector() {
   // expected-error @+1 {{expected '? x <integer> x <type>' or '<integer> x <type>'}}
   "some.op"() : () -> !llvm.vec<4 x 4 x i32>
 }
 
+// -----
+
+func @zero_vector() {
+  // expected-error @+1 {{the number of vector elements must be positive}}
+  "some.op"() : () -> !llvm.vec<0 x i32>
+}
+
+// -----
+
+func @nested_vector() {
+  // expected-error @+1 {{invalid vector element type}}
+  "some.op"() : () -> !llvm.vec<2 x vec<2 x i32>>
+}
+
+// -----
+
+func @scalable_void_vector() {
+  // expected-error @+1 {{invalid vector element type}}
+  "some.op"() : () -> !llvm.vec<? x 4 x void>
+}