[mlir][ods] Add codegen support for AttrOrTypeParameter verifiers

[jfurtek]

Summary

mlir-tblgen has enough information to automatically generate the verify()
function for some attributes and types. (The canonical example might be checking
whether or not an integer value is one of the specified enum values for enum
attributes.)

Previously, the genVerifyDecl field was used to instruct mlir-tblgen to
generate a declaration for the verify() function, and users would be required
to provide the implementation. This diff adds support for a verifyInvariants()
function that will

• verify any individual parameters with custom verification code, and
• call the custom verify() function (if directed via genVerifyDecl=1)

This is accomplished by:

• Adding a verifier field to the AttrOrTypeParameter base class
• Modifying tblgen to generate a verifier function composed of parameter and custom verification
• Modifying the get() and getChecked() implementations in StorageUserBase to call verifyInvariants()
• Adding custom verification for integer and bit enum attributes
• Adding tests for integer and bit enums to verify that getChecked() will return a null attribute for invalid enum values

The existing genVerifyDecl behavior is maintained, and attributes/types will
only behave differently if a non-empty parameter verifier fields are present.

This functionality is expected to be used by a subsequent diff that adds Python
bindings for enums, and will also be used for fastmath support in the
Arithmetic dialect.

Example verifyInvariants() implementation for an enum attribute in the linalg dialect:

::mlir::LogicalResult TypeFnAttr::verifyInvariants(
        ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError,
        ::mlir::linalg::TypeFn value) {
  // Verify parameter 'value':
  if (failed(
          [&emitError](::mlir::linalg::TypeFn value) -> ::mlir::LogicalResult {
            return symbolizeTypeFn(static_cast<uint32_t>(value)).hasValue()
                       ? ::mlir::success()
                       : (emitError() << "invalid enum value");
          }(value)))
    return ::mlir::failure();
  // If genVerifyDecl were equal to 1, the line below would look like this:
  // return verify(emitError, value);
  // Instead, in this case we just return success();
  return ::mlir::success();
}

[rriddle]

mlir/include/mlir/IR/AttrTypeBase.td

213–215

We should eventually move to a model that allows both parameter verification and user verification (similar to operations), but I'm fine with punting that.

330–331

Can we have a return type of LogicalResult instead? That would align with verifiers everywhere else.

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

258–259

nit: Can you add an early return in the if branch and drop this else?

272

I would have the verification code block handle error emission, otherwise you'll end up with a worse error message here and potential for double error messages.

278

nit: I'd just drop this comment.

mlir/unittests/IR/AttributeTest.cpp

257

This couldn't be triggered from a .mlir file?

[jfurtek]

• Modify AttrOrTypeParameter verifier codegen to return LogicalResult

[jfurtek]

• Use early return as per review

[jfurtek]

mlir/include/mlir/IR/AttrTypeBase.td

213–215

I agree - I think that there is more to be done here.

At the moment, the parameter verification code from the .td file is emitted as a local (anonymous) lambda. It seems like, in the general case, it might be desirable for the AttrOrType verification function to be able to use the verification functions for each parameter (or maybe some of them). So maybe the parameter verification functions become class members, with a fixed naming convention that can be used by ODS verification code?

If you would like to sketch out or describe how it should work I can take a crack at it.

mlir/unittests/IR/AttributeTest.cpp

257

It could, but that exercises a different code path: the parameter parser (i.e. creating the enum from an IR string). Enum parameter parsers don't currently accept raw integers - they require one (or more) of the string value identifiers.

The Python bindings will (in subsequent commits) pass enum values through the C interface, using the underlying integer type. (The enum generated by mlir-tblgen uses a C++ enum class, which is not compatible with a C interface.) The Python binding code would call getChecked(), much like the test code here, and raise a Python exception if the attribute can't be created.

[rriddle]

mlir/include/mlir/IR/AttrTypeBase.td

213–215

I think we should do something like what we do for operations, i.e. we change the verify method called by get/getChecked to be a method called verifyInvariants, which is the thing that we auto-generate. Users that want additional verification can define a verify method as they do today.

The places we'd need to update to call the new method should be near: https://github.com/llvm/llvm-project/blob/db15e31212436ae51c04e8b5fcc2f140db4d6626/mlir/include/mlir/IR/StorageUniquerSupport.h#L140

For the method itself, I think it would look something like:

// This method is what we auto-generate.
static LogicalResult verifyInvariants(...) {
  // Auto-generated verification for parameters goes here.
  ...

  // Invoke the user defined verifier or a empty one here:
  return verify(...);
}

The idea there is that the user never really interacts with verifyInvariants directly, they just implement the verify method.

327

Can you document this field in the AttributesAndTypes.md doc as well? Should likely be added to the parameters section IIRC.

[jfurtek]

This still needs work - I am just changing the state to "requesting review" to continue the discussion.

mlir/include/mlir/IR/AttrTypeBase.td

213–215

I've modified the get() and getChecked() methods (locally) to call a tblgen-erated verifyInvariants() method.

/// Get or create a new ConcreteT instance within the ctx. If the arguments
/// provided are invalid, errors are emitted using the provided `emitError`
/// and a null object is returned.
template <typename... Args>
static ConcreteT getChecked(function_ref<InFlightDiagnostic()> emitErrorFn,
                            MLIRContext *ctx, Args... args) {
  // If the construction invariants fail then we return a null attribute.
  if (failed(ConcreteT::verifyInvariants(emitErrorFn, args...)))
    return ConcreteT();
  return UniquerT::template get<ConcreteT>(ctx, args...);
}

Where it gets tricky (and currently fails to compile) is for attributes/types that define custom builders.

For operations, there can be a single post-construction verify() method that checks the operation state. But it seems like for attributes/types, we would need a verifyInvariants() function for each builder (default and custom). This seems doable - I just want to see if you agree.

For the attribute/type default builder case, the getChecked() (and verifyInvariants()) signature is derived from the attribute/type parameters, and mlir-tblgen can use the verifier field of the parameter for the generated verification code. (No problems here.)

However, attribute/type custom builder arguments can be different than the attribute/type parameter types. For example, the builtin Tuple type has this:

let parameters = (ins "ArrayRef<Type>":$types);
let builders = [
  TypeBuilder<(ins "TypeRange":$elementTypes), [{
    return $_get($_ctxt, elementTypes);
  }]>,
  TypeBuilder<(ins), [{
    return $_get($_ctxt, TypeRange());
  }]>
];

In the general case, there is no way to associate custom builder arguments to a specific parameter that has verification code. (For example, consider a custom builder with arguments that are in a different order than the parameter list.) And even if a mapping were known, the parameter type may not be unambigously constructible from the custom builder argument. So it seems that the responsibility for verification needs to be entirely on user-provided code when custom builders are used.

So I would think that it would work like this:

• mlir-tblgen will generate a verifyInvariants() implementation that matches the signature of default builder (unless skipDefaultBuilders=1). This default verifyInvariants() implementation will invoke the verifier code for attribute/type parameters that have that field. In addition, if genVerfifyDecl=1, a declaration for a custom verify() method will be provided, and the user-provided verify() implementation will be called from the default automatically generated verifyInvariants() function.
• For attributes/types with custom builders and parameters that DO NOT contain verification code, mlir-tblgen will generate a default trivial implementation of verifyInvariants() that always returns success(). (However, if genVerifyDecl=1, then a verify() method will be declared, and the user-provided implementation will be called by the automatically generated verifyInvariants() function.)
• For attributes/types with customer builders and parameters that DO contain verification code, the tblgen record must have genVerifyDecl=1. (mlir-tblgen will return an error if genVerifyDecl is not equal to 1.) In this case, mlir-tblgen will generate verify() method prototypes to match each custom builder. User-provided verify() implementations will be called from automatically generated verifyInvariants() functions, and the user-provided verify() shall be responsible for verification of ALL custom builder arguments.

Is this how you envisioned the feature working?

[jfurtek]

• Modify AttrOrTypeParameter verifier codegen to return LogicalResult
• Use early return as per review
• Add mlir-tblgen-eration of verifyInvariants
• Generate multiple verifyInvariants() functions - one per builder
• Fix some build errors
• Add using declaration for verifyInvariants() and a default variadic template implementation
• Add generation of multiple verify() functions
• Update AttrOrTypeDef to use optional verifyParameters field. Add documentation and an additional unit test.
• Revert FloatAttr::verify() type change. Fix formatting.
• Fix formatting

[jfurtek]

• Modify AttrOrTypeParameter verifier codegen to return LogicalResult
• Use early return as per review
• Add mlir-tblgen-eration of verifyInvariants
• Generate multiple verifyInvariants() functions - one per builder
• Fix some build errors
• Add using declaration for verifyInvariants() and a default variadic template implementation
• Add generation of multiple verify() functions
• Update AttrOrTypeDef to use optional verifyParameters field. Add documentation and an additional unit test.
• Revert FloatAttr::verify() type change. Fix formatting.
• Fix formatting
• Remove unnecessary use of verifyParameters tblgen field

[jfurtek]

• Fix clang formatting

[rriddle]

Looks really great! Thanks for tackling this. (Sorry for the delay, coming back from two week OOO)

mlir/docs/AttributesAndTypes.md

871–874

This could just link to the AttrParameter, TypeParameter, and AttrOrTypeParameter section above, which should likely also get a little blurb about the verifier field (which could just be the next paragraph + example you have here..

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

245

You could cache the result of def.genVerifyDecl() given that you invoke it again immediately after, otherwise you could shift the control flow to something like:

if (def.genVerifyDecl()) {
    // Declare the verify() method, to be implemented by the user.
    ...

} else if (!def.anyParamHasVerifier()) {
  return;
}

284

This doesn't work?

[jfurtek]

• Modify AttrOrTypeParameter verifier codegen to return LogicalResult
• Use early return as per review
• Add mlir-tblgen-eration of verifyInvariants
• Generate multiple verifyInvariants() functions - one per builder
• Fix some build errors
• Add using declaration for verifyInvariants() and a default variadic template implementation
• Add generation of multiple verify() functions
• Update AttrOrTypeDef to use optional verifyParameters field. Add documentation and an additional unit test.
• Revert FloatAttr::verify() type change. Fix formatting.
• Fix formatting
• Remove unnecessary use of verifyParameters tblgen field
• Fix clang formatting
• Revert unintended function changes
• Update documentation and clean up control flow based on review feedback

[jfurtek]

• Rebase

[jfurtek]

I don't have commit privileges - can someone land this when convenient? Thanks!

mlir/docs/AttributesAndTypes.md

 additional functionality. This is generally useful for complex parameters, or those
 with additional invariants that prevent using the raw C++ class. Examples
 include documentation (e.g. the `summary` and `syntax` field), the C++ type, a
 custom allocator to use in the storage constructor method, a custom comparator
 to decide if two instances of the parameter type are equal, etc. As the names
 may suggest, `AttrParameter` is intended for parameters on Attributes,
 `TypeParameter` for Type parameters, and `AttrOrTypeParameters` for either.
 
+#### Parameter Pitfalls
+
 Below is an easy parameter pitfall, and highlights when to use these parameter
 classes.
 
 ```tablegen
 let parameters = (ins "ArrayRef<int>":$dims);
 ```
 
 The above seems innocuous, but it is often a bug! The default storage

 }
 
 The parameter can then be used as so:
 
 ...
 let parameters = (ins ArrayRefIntParam:$dims);
 ```
 
+#### Other Parameter Fields
+
 Below contains descriptions for other various available fields:
 
 The `allocator` code block has the following substitutions:
 
 - `$_allocator` is the TypeStorageAllocator in which to allocate objects.
 - `$_dst` is the variable in which to place the allocated data.
 
 The `comparator` code block has the following substitutions:
 
 - `$_lhs` is an instance of the parameter type.
 - `$_rhs` is an instance of the parameter type.
 
+##### Parameter Verification
+
+Parameters can optionally provide custom verification code that will be used
+for validation when creating attributes or types. This verification code is
+invoked when the "checked" builders are used. (See the section on
+[Builders](#Builders) below.) If verification fails, the attribute or type
+will not be created.
+
+Parameter verification code is specified via the `verifier` field of the
+`tblgen` record for the parameter class. An example of using parameter
+verification using the `verifier` field is shown below. In this case, the
+`NonNegativeFloatAttr` will be successfully created only if the float value is
+non-negative.
+
+```tablegen
+def NonNegativeAPFloatParam : APFloatParameter<"positive float"> {
+  let verifier = [{ return ::mlir::success(!value.isNegative()); }];
+}
+
+def NonNegativeFloatAttr : Test_Attr<"NonNegativeFloat"> {
+  let parameters = (ins NonNegativeAPFloatParam:$nnfloat);
+}
+```
+
+For more information on attribute/type verification, see the
+[Verification](#Verification) section below.
+
+#### Specialized Parameter Classes
+
 MLIR includes several specialized classes for common situations:
 
 - `APFloatParameter` for APFloats.
 
 - `StringRefParameter<descriptionOfParam>` for StringRefs.
 
 - `ArrayRefParameter<arrayOf, descriptionOfParam>` for ArrayRefs of value types.
 

 void printStringParam(AsmPrinter &printer, StringRef value);
 ```
 
 The custom parser is considered to have failed if it returns failure or if any
 bound parameters have failure values afterwards.
 
 ### Verification
 
-If the `genVerifyDecl` field is set, additional verification methods are
-generated on the class.
+Attribute and type classes provide verification of inputs using the
+`verifyInvariants()` method. For cases when no verification is necessary,
+storage base classes provide a default implementation.
+
+There are two phases of verification of inputs when creating instances of
+attributes and types:
+
+- parameter verification
+- custom verification
+
+Parameter verification operates on a single parameter (or argument) to the
+attribute/type creation function, and can be specified via the `verifier`
+record. See the [Parameter Verification](#Parameter Verification) section above
+for an example.
+
+Custom (user-provided) verification occurs in the static `verify()` method of
+the class, and can perform arbitrary checks. The signature for the `verify()`
+method is generated in the header for the attribute/type C++ class when the
+`genVerifyDecl` field (of type `bit`) is set.
 
 - `static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError, parameters...)`
 
+Since parameter verification is applied to a single parameter only, custom
+verification is necessary when success or failure depends on more than one
+attribute/type parameter. Users may also wish to use the custom `verify()`
+method to avoid defining complex code in `tablegen` input files.
+
 These methods are used to verify the parameters provided to the attribute or
 type class on construction, and emit any necessary diagnostics. This method is
 automatically invoked from the builders of the attribute or type class.
 
 - `AttrOrType getChecked(function_ref<InFlightDiagnostic()> emitError, parameters...)`
 
 As noted in the [Builders](#Builders) section, these methods are companions to
 `get` builders that are failable. If the `verify` invocation fails when these

mlir/include/mlir/IR/AttrTypeBase.td

class AttrOrTypeDef<string valueType, string name, list<Trait> defTraits,
 
   // If set, generate accessors for each parameter.
   bit genAccessors = 1;
 
   // Avoid generating default get/getChecked functions. Custom get methods must
   // be provided.
   bit skipDefaultBuilders = 0;
 
-  // Generate the verify and getChecked methods.
+  // Generate the verify and getChecked methods. (Note that these methods will
+  // also be generated automatically if any AttrOrTypeParameters have custom
+  // verifier code.)
   bit genVerifyDecl = 0;
 
   // Extra code to include in the class declaration.
   code extraClassDeclaration = [{}];
 }
 
 // Define a new attribute, named `name`, belonging to `dialect` that inherits
 // from the given C++ base class.
class AttrOrTypeParameter<string type, string desc, string accessorType = ""> {
   // Provide a default value for the parameter. Parameters with default values
   // are considered optional. If a value was not parsed for the parameter, it
   // will be set to the default value. Parameters equal to their default values
   // are elided when printing. Equality is checked using the `comparator` field,
   // which by default is the C++ equality operator. The current MLIR context is
   // made available through `$_ctxt`, e.g., for constructing default values for
   // attributes and types.
   string defaultValue = ?;
+  // Custom code to verify parameters used to create an attribute or type. The
+  // code string should represent the body of a function that takes two
+  // arguments:
+  // - a functionref 'emitError' that returns an InFlightDiagnostic
+  // - a parameter value argument with a name and type that match the name and
+  //   C++ type of the parameter.
+  // The return type is ::mlir::LogicalResult, where failure() indicates that
+  // verification failed.
+  code verifier = ?;
 }
 class AttrParameter<string type, string desc, string accessorType = "">
  : AttrOrTypeParameter<type, desc, accessorType>;
 class TypeParameter<string type, string desc, string accessorType = "">
  : AttrOrTypeParameter<type, desc, accessorType>;
 
 // For StringRefs, which require allocation.
 class StringRefParameter<string desc = ""> :

mlir/include/mlir/IR/BuiltinAttributes.td

let description = [{
     42.0 : f32   // float attribute of f32 type
     0x7C00 : f16 // positive infinity
     0x7CFF : f16 // NaN (one of possible values)
     42 : f32     // Error: expected integer type
     ```
   }];
   let parameters = (ins AttributeSelfTypeParameter<"">:$type,
                         APFloatParameter<"">:$value);
+
   let builders = [
     AttrBuilderWithInferredContext<(ins "Type":$type,
                                         "const APFloat &":$value), [{
       return $_get(type.getContext(), type, value);
     }]>,
     AttrBuilderWithInferredContext<(ins "Type":$type, "double":$value), [{
       if (type.isF64() || !type.isa<FloatType>())
         return $_get(type.getContext(), type, APFloat(value));
let description = [{
     ```
   }];
 
   let parameters = (ins AttributeSelfTypeParameter<"", "ShapedType">:$type,
                         "DenseIntElementsAttr":$indices,
                         "DenseElementsAttr":$values);
   let builders = [
     AttrBuilderWithInferredContext<(ins "ShapedType":$type,
-                                        "DenseElementsAttr":$indices,
+                                        "DenseIntElementsAttr":$indices,
                                         "DenseElementsAttr":$values), [{
       assert(indices.getType().getElementType().isInteger(64) &&
              "expected sparse indices to be 64-bit integer values");
       assert((type.isa<RankedTensorType, VectorType>()) &&
              "type must be ranked tensor or vector");
       assert(type.hasStaticShape() && "type must have static shape");
-      return $_get(type.getContext(), type,
-                   indices.cast<DenseIntElementsAttr>(), values);
+      return $_get(type.getContext(), type, indices, values);
     }]>,
   ];
   let extraClassDeclaration = [{
     /// The set of data types that can be iterated by this attribute.
     // FIXME: Realistically, SparseElementsAttr could use ElementsAttr for the
     // value storage. This would mean dispatching to `values` when accessing
     // values. For now, we just add the types that can be iterated by
     // DenseElementsAttr.

mlir/include/mlir/IR/EnumAttr.td

 // A C++ enum as an attribute parameter. The parameter implements a parser and
 // printer for the enum by dispatching calls to `stringToSymbol` and
 // `symbolToString`.
 class EnumParameter<EnumAttrInfo enumInfo>
     : AttrParameter<enumInfo.cppNamespace # "::" # enumInfo.className,
                     "an enum of type " # enumInfo.className> {
   let parser = enumInfo.parameterParser;
   let printer = enumInfo.parameterPrinter;
+  let verifier = [{return }] # enumInfo.underlyingToSymbolFnName #
+    [{(static_cast<}] # enumInfo.underlyingType # [{>(value)).hasValue()
+                       ? ::mlir::success()
+                       : (emitError() << "invalid enum value");}];
 }
 
 // An attribute backed by a C++ enum. The attribute contains a single
 // parameter `value` whose type is the C++ enum class.
 //
 // Example:
 //
 // ```

mlir/include/mlir/IR/StorageUniquerSupport.h

public:
   }
 
   /// Get or create a new ConcreteT instance within the ctx. This
   /// function is guaranteed to return a non null object and will assert if
   /// the arguments provided are invalid.
   template <typename... Args>
   static ConcreteT get(MLIRContext *ctx, Args... args) {
     // Ensure that the invariants are correct for construction.
-    assert(
-        succeeded(ConcreteT::verify(getDefaultDiagnosticEmitFn(ctx), args...)));
+    assert(succeeded(
+        ConcreteT::verifyInvariants(getDefaultDiagnosticEmitFn(ctx), args...)));
     return UniquerT::template get<ConcreteT>(ctx, args...);
   }
 
   /// Get or create a new ConcreteT instance within the ctx, defined at
   /// the given, potentially unknown, location. If the arguments provided are
   /// invalid, errors are emitted using the provided location and a null object
   /// is returned.
   template <typename... Args>
   static ConcreteT getChecked(const Location &loc, Args... args) {
     return ConcreteT::getChecked(getDefaultDiagnosticEmitFn(loc), args...);
   }
 
   /// Get or create a new ConcreteT instance within the ctx. If the arguments
   /// provided are invalid, errors are emitted using the provided `emitError`
   /// and a null object is returned.
   template <typename... Args>
   static ConcreteT getChecked(function_ref<InFlightDiagnostic()> emitErrorFn,
                               MLIRContext *ctx, Args... args) {
     // If the construction invariants fail then we return a null attribute.
-    if (failed(ConcreteT::verify(emitErrorFn, args...)))
+    if (failed(ConcreteT::verifyInvariants(emitErrorFn, args...)))
       return ConcreteT();
     return UniquerT::template get<ConcreteT>(ctx, args...);
   }
 
   /// Get an instance of the concrete type from a void pointer.
   static ConcreteT getFromOpaquePointer(const void *ptr) {
     return ConcreteT((const typename BaseT::ImplType *)ptr);
   }
return UniquerT::template mutate<ConcreteT>(this->getContext(), getImpl(),
                                                 std::forward<Args>(args)...);
   }
 
   /// Default implementation that just returns success.
   template <typename... Args> static LogicalResult verify(Args... args) {
     return success();
   }
 
+  /// Default implementation that just calls the verify() function
+  template <typename... Args>
+  static LogicalResult
+  verifyInvariants(function_ref<InFlightDiagnostic()> emitErrorFn,
+                   Args... args) {
+    return ConcreteT::verify(emitErrorFn, args...);
+  }
+
   /// Utility for easy access to the storage instance.
   ImplType *getImpl() const { return static_cast<ImplType *>(this->impl); }
 
 private:
   /// Trait to check if T provides a 'ConcreteEntity' type alias.
   template <typename T>
   using has_concrete_entity_t = typename T::ConcreteEntity;
 

mlir/include/mlir/TableGen/AttrOrTypeDef.h

public:
   StringRef getSyntax() const;
 
   /// Returns true if the parameter is optional.
   bool isOptional() const;
 
   /// Get the default value of the parameter if it has one.
   Optional<StringRef> getDefaultValue() const;
 
+  /// If specified, get the custom verifier code for this parameter.
+  Optional<StringRef> getVerifier() const;
+
   /// Return the underlying def of this parameter.
   llvm::Init *getDef() const;
 
   /// The parameter is pointer-comparable.
   bool operator==(const AttrOrTypeParameter &other) const {
     return def == other.def && index == other.index;
   }
   bool operator!=(const AttrOrTypeParameter &other) const {
public:
 
   /// Returns true if the accessors based on the parameters should be generated.
   bool genAccessors() const;
 
   /// Return true if we need to generate the verify declaration and getChecked
   /// method.
   bool genVerifyDecl() const;
 
+  /// Returns true if automatic verify() declaration was requested
+  /// (genVerifyDecl=1), or if any AttrOrTypeParameters have custom verifier
+  /// code.
+  bool usesCheckedBuilder() const;
+
+  /// Returns true if any parameter has a non-empty verifier code string
+  bool anyParamHasVerifier() const;
+
   /// Returns the def's extra class declaration code.
   Optional<StringRef> getExtraDecls() const;
 
   /// Get the code location (for error printing).
   ArrayRef<SMLoc> getLoc() const;
 
   /// Returns true if the default get/getChecked methods should be skipped
   /// during generation.

mlir/lib/CAPI/IR/BuiltinAttributes.cpp

bool mlirAttributeIsASparseElements(MlirAttribute attr) {
   return unwrap(attr).isa<SparseElementsAttr>();
 }
 
 MlirAttribute mlirSparseElementsAttribute(MlirType shapedType,
                                           MlirAttribute denseIndices,
                                           MlirAttribute denseValues) {
   return wrap(
       SparseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
-                              unwrap(denseIndices).cast<DenseElementsAttr>(),
+                              unwrap(denseIndices).cast<DenseIntElementsAttr>(),
                               unwrap(denseValues).cast<DenseElementsAttr>()));
 }
 
 MlirAttribute mlirSparseElementsAttrGetIndices(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<SparseElementsAttr>().getIndices());
 }
 
 MlirAttribute mlirSparseElementsAttrGetValues(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<SparseElementsAttr>().getValues());
 }

mlir/lib/IR/Location.cpp

 //===- Location.cpp - MLIR Location Classes -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/Location.h"
 #include "mlir/IR/BuiltinDialect.h"
+#include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Visitors.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 using namespace mlir;
 using namespace mlir::detail;
 
 //===----------------------------------------------------------------------===//

mlir/lib/Parser/AttributeParser.cpp

if (!type)
       return nullptr;
 
     // Construct the sparse elements attr using zero element indice/value
     // attributes.
     ShapedType indicesType =
         RankedTensorType::get({0, type.getRank()}, indiceEltType);
     ShapedType valuesType = RankedTensorType::get({0}, type.getElementType());
     return getChecked<SparseElementsAttr>(
-        loc, type, DenseElementsAttr::get(indicesType, ArrayRef<Attribute>()),
+        loc, type,
+        DenseIntElementsAttr::get(indicesType, ArrayRef<Attribute>()),
         DenseElementsAttr::get(valuesType, ArrayRef<Attribute>()));
   }
 
   /// Parse the indices. We don't allow hex values here as we may need to use
   /// the inferred shape.
   auto indicesLoc = getToken().getLoc();
   TensorLiteralParser indiceParser(*this);
   if (indiceParser.parse(/*allowHex=*/false))
Attribute Parser::parseSparseElementsAttr(Type attrType) {
   // indice and thus one for the first dimension.
   ShapedType indicesType;
   if (indiceParser.getShape().empty()) {
     indicesType = RankedTensorType::get({1, type.getRank()}, indiceEltType);
   } else {
     // Otherwise, set the shape to the one parsed by the literal parser.
     indicesType = RankedTensorType::get(indiceParser.getShape(), indiceEltType);
   }
-  auto indices = indiceParser.getAttr(indicesLoc, indicesType);
+  auto indices = indiceParser.getAttr(indicesLoc, indicesType)
+                     .cast<DenseIntElementsAttr>();
 
   // If the values are a splat, set the shape explicitly based on the number of
   // indices. The number of indices is encoded in the first dimension of the
   // indice shape type.
   auto valuesEltType = type.getElementType();
   ShapedType valuesType =
       valuesParser.getShape().empty()
           ? RankedTensorType::get({indicesType.getDimSize(0)}, valuesEltType)
           : RankedTensorType::get(valuesParser.getShape(), valuesEltType);
   auto values = valuesParser.getAttr(valuesLoc, valuesType);
 
   // Build the sparse elements attribute by the indices and values.
   return getChecked<SparseElementsAttr>(loc, type, indices, values);
 }

mlir/lib/TableGen/AttrOrTypeDef.cpp

 bool AttrOrTypeDef::genAccessors() const {
   return def->getValueAsBit("genAccessors");
 }
 
 bool AttrOrTypeDef::genVerifyDecl() const {
   return def->getValueAsBit("genVerifyDecl");
 }
 
+bool AttrOrTypeDef::usesCheckedBuilder() const {
+  return genVerifyDecl() || anyParamHasVerifier();
+}
+
+bool AttrOrTypeDef::anyParamHasVerifier() const {
+  return llvm::any_of(getParameters(), [](const AttrOrTypeParameter &p) {
+    return p.getVerifier();
+  });
+}
+
 Optional<StringRef> AttrOrTypeDef::getExtraDecls() const {
   auto value = def->getValueAsString("extraClassDeclaration");
   return value.empty() ? Optional<StringRef>() : value;
 }
 
 ArrayRef<SMLoc> AttrOrTypeDef::getLoc() const { return def->getLoc(); }
 
 bool AttrOrTypeDef::skipDefaultBuilders() const {
bool AttrOrTypeParameter::isOptional() const {
   return getDefValue<llvm::BitInit>("isOptional").value_or(false) ||
          getDefaultValue();
 }
 
 Optional<StringRef> AttrOrTypeParameter::getDefaultValue() const {
   return getDefValue<llvm::StringInit>("defaultValue");
 }
 
+Optional<StringRef> AttrOrTypeParameter::getVerifier() const {
+  return getDefValue<llvm::StringInit>("verifier");
+}
+
 llvm::Init *AttrOrTypeParameter::getDef() const { return def->getArg(index); }
 
 //===----------------------------------------------------------------------===//
 // AttributeSelfTypeParameter
 //===----------------------------------------------------------------------===//
 
 bool AttributeSelfTypeParameter::classof(const AttrOrTypeParameter *param) {
   llvm::Init *paramDef = param->getDef();
   if (auto *paramDefInit = dyn_cast<llvm::DefInit>(paramDef))
     return paramDefInit->getDef()->isSubClassOf("AttributeSelfTypeParameter");
   return false;
 }

mlir/test/lib/Dialect/Test/TestAttrDefs.td

 def TestAttrSelfTypeParameterFormat
     : Test_Attr<"TestAttrSelfTypeParameterFormat"> {
   let parameters = (ins "int":$a, AttributeSelfTypeParameter<"">:$type);
 
   let mnemonic = "attr_self_type_format";
   let assemblyFormat = "`<` $a `>`";
 }
 
+
 // Test simple extern 1D vector using ElementsAttrInterface.
 def TestExtern1DI64ElementsAttr : Test_Attr<"TestExtern1DI64Elements", [
     ElementsAttrInterface
   ]> {
   let mnemonic = "e1di64_elements";
   let parameters = (ins
     AttributeSelfTypeParameter<"", "::mlir::ShapedType">:$type,
     ResourceHandleParameter<"TestExternalElementsDataHandle">:$handle
let extraClassDeclaration = [{
     // * uint64_t
     auto value_begin_impl(OverloadToken<uint64_t>) const {
       return getElements().begin();
     }
   }];
   let assemblyFormat = "`<` $handle `>`";
 }
 
+def NonNegativeAPFloatParam : APFloatParameter<"positive float"> {
+  let verifier = [{ return ::mlir::success(!value.isNegative()); }];
+}
+
+def NonNegativeFloatAttr : Test_Attr<"NonNegativeFloat"> {
+  let parameters = (ins NonNegativeAPFloatParam:$nnfloat);
+}
+
 #endif // TEST_ATTRDEFS

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

 private:
   /// Add traits from the TableGen definition to the class.
   void createParentWithTraits();
   /// Emit top-level declarations: using declarations and any extra class
   /// declarations.
   void emitTopLevelDeclarations();
   /// Emit attribute or type builders.
   void emitBuilders();
-  /// Emit a verifier for the def.
-  void emitVerifier();
+  /// Emit verifiers for the def.
+  void emitVerifiers();
   /// Emit parsers and printers.
   void emitParserPrinter();
   /// Emit parameter accessors, if required.
   void emitAccessors();
   /// Emit interface methods.
   void emitInterfaceMethods();
 
   //===--------------------------------------------------------------------===//
DefGen::DefGen(const AttrOrTypeDef &def)
   // Create the parent class with any indicated traits.
   createParentWithTraits();
   // Emit top-level declarations.
   emitTopLevelDeclarations();
   // Emit builders for defs with parameters
   if (storageCls)
     emitBuilders();
   // Emit the verifier.
-  if (storageCls && def.genVerifyDecl())
-    emitVerifier();
+  if (storageCls)
+    emitVerifiers();
   // Emit the mnemonic, if there is one, and any associated parser and printer.
   if (def.getMnemonic())
     emitParserPrinter();
   // Emit accessors
   if (def.genAccessors())
     emitAccessors();
   // Emit trait interface methods
   emitInterfaceMethods();
void DefGen::emitTopLevelDeclarations() {
   // Emit the extra declarations first in case there's a definition in there.
   if (Optional<StringRef> extraDecl = def.getExtraDecls())
     defCls.declare<ExtraClassDeclaration>(*extraDecl);
 }
 
 void DefGen::emitBuilders() {
   if (!def.skipDefaultBuilders()) {
     emitDefaultBuilder();
-    if (def.genVerifyDecl())
+    if (def.usesCheckedBuilder())
       emitCheckedBuilder();
   }
   for (auto &builder : def.getBuilders()) {
     emitCustomBuilder(builder);
-    if (def.genVerifyDecl())
+    if (def.usesCheckedBuilder())
       emitCheckedCustomBuilder(builder);
   }
 }
 
-void DefGen::emitVerifier() {
+void DefGen::emitVerifiers() {
   defCls.declare<UsingDeclaration>("Base::getChecked");
+
+  // When no custom verifier code is present, defer to the default
+  // implementations of verifyInvariants() and verify() in the base class.
+  if (!def.genVerifyDecl() && !def.anyParamHasVerifier())
+    return;
+
+  // Define the verifyInvariants() method, which verifies parameters and then
+  // invokes the user-provided verify() method (if genVerifyDecl=1) or returns
+  // success (if genVerifyDecl=0).
+  Method *viMethod = defCls.addMethod(
+      "::mlir::LogicalResult", "verifyInvariants", Method::Static,
+      getBuilderParams({{"::llvm::function_ref<::mlir::InFlightDiagnostic()>",
+                         "emitError"}}));
+
+  // Generate a check for each attribute/type parameter with verifier code.
+  const char *verifyFormat = R"(
+  // Verify parameter '{0}':
+  if (failed(
+          [&emitError]({1} value) -> ::mlir::LogicalResult {{
+            {2}
+          }({0})))
+    return ::mlir::failure();
+  )";
+  viMethod->body().indent();
+  for (auto &param : def.getParameters()) {
+    if (param.getVerifier()) {
+      std::string bodyStr(llvm::formatv(verifyFormat, param.getName(),
+                                        param.getCppType(),
+                                        param.getVerifier()));
+      viMethod->body().getStream().printReindented(bodyStr);
+    }
+  }
+
+  if (def.genVerifyDecl()) {
+    // Declare the verify() method, which is implemented by the user.
     defCls.declareStaticMethod(
         "::mlir::LogicalResult", "verify",
         getBuilderParams({{"::llvm::function_ref<::mlir::InFlightDiagnostic()>",
                            "emitError"}}));
+
+    // Call the user verify() function from verifyInvariants()
+    MethodBody &body = viMethod->body().indent();
+    SmallVector<StringRef> argNames;
+    argNames.push_back("emitError");
+    for (auto &param : params)
+      argNames.push_back(param.getName());
+
+    body << "return verify(";
+    llvm::interleaveComma(argNames, body);
+    body << ");\n";
+  } else {
+    // No user verify() function
+    viMethod->body() << "return ::mlir::success();\n";
+  }
 }
 
 void DefGen::emitParserPrinter() {
   auto *mnemonic = defCls.addStaticMethod<Method::Constexpr>(
       "::llvm::StringLiteral", "getMnemonic");
   mnemonic->body().indent() << strfmt("return {\"{0}\"};", *def.getMnemonic());
 
   // Declare the parser and printer, if needed.

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

void DefFormat::genParser(MethodBody &os) {
   for (const AttrOrTypeParameter &param : params) {
     if (param.isOptional() || isa<AttributeSelfTypeParameter>(param))
       continue;
     os << formatv("assert(::mlir::succeeded(_result_{0}));\n", param.getName());
   }
 
   // Generate call to the attribute or type builder. Use the checked getter
   // if one was generated.
-  if (def.genVerifyDecl()) {
+  if (def.usesCheckedBuilder()) {
     os << tgfmt("return $_parser.getChecked<$0>($_loc, $_parser.getContext()",
                 &ctx, def.getCppClassName());
   } else {
     os << tgfmt("return $0::get($_parser.getContext()", &ctx,
                 def.getCppClassName());
   }
   for (const AttrOrTypeParameter &param : params) {
     os << ",\n    ";

mlir/unittests/IR/AttributeTest.cpp

 //===- AttributeTest.cpp - Attribute unit tests ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "gtest/gtest.h"
 
+#include "../../test/lib/Dialect/Test/TestAttributes.h"
+#include "../../test/lib/Dialect/Test/TestDialect.h"
+
 using namespace mlir;
 using namespace mlir::detail;
+using namespace test;
 
 template <typename EltTy>
 static void testSplat(Type eltType, const EltTy &splatElt) {
   RankedTensorType shape = RankedTensorType::get({2, 1}, eltType);
 
   // Check that the generated splat is the same for 1 element and N elements.
   DenseElementsAttr splat = DenseElementsAttr::get(shape, splatElt);
   EXPECT_TRUE(splat.isSplat());
TEST(SparseElementsAttrTest, GetZero) {
   EXPECT_EQ(zeroFloatValue.cast<FloatAttr>().getValueAsDouble(), 0.0f);
   EXPECT_TRUE(zeroFloatValue.getType() == floatTy);
 
   auto zeroStringValue = sparseString.getValues<Attribute>()[{1, 1}];
   EXPECT_TRUE(zeroStringValue.cast<StringAttr>().getValue().empty());
   EXPECT_TRUE(zeroStringValue.getType() == stringTy);
 }
 
+TEST(EnumAttrTest, GetChecked) {
+  DialectRegistry registry;
+  registry.insert<test::TestDialect>();
+  MLIRContext context(registry);
+  context.loadDialect<test::TestDialect>();
+
+  Location loc(UnknownLoc::get(&context));
+  auto emitErrorFn = [&]() { return emitError(loc); };
+
+  // Check that getChecked() returns a non-nullptr attribute  when a valid enum
+  // value is provided (int enum).
+  auto enumAttr =
+      TestEnumAttr::getChecked(emitErrorFn, &context, TestEnum::Third);
+  EXPECT_NE(enumAttr, nullptr);
+
+  // Check that getChecked() returns a nullptr attribute when an invalid enum
+  // value is provided (int enum).
+  auto enumAttrInvalid = TestEnumAttr::getChecked(emitErrorFn, &context,
+                                                  static_cast<TestEnum>(-1));
+  EXPECT_EQ(enumAttrInvalid, nullptr);
+
+  // Check that getChecked() returns a non-nullptr attribute  when a valid enum
+  // value is provided (bit enum).
+  auto bitEnumAttr = TestBitEnumAttr::getChecked(
+      emitErrorFn, &context, TestBitEnum::Read | TestBitEnum::Write);
+  EXPECT_NE(bitEnumAttr, nullptr);
+
+  // Check that getChecked() returns a nullptr attribute when an invalid enum
+  // value is provided (bit enum).
+  auto bitEnumAttrInvalid = TestBitEnumAttr::getChecked(
+      emitErrorFn, &context, static_cast<TestBitEnum>(0xFFFFFFFF));
+  EXPECT_EQ(bitEnumAttrInvalid, nullptr);
+
+  // Check that getChecked() returns a non-nullptr attribute  when a non-
+  // negative value is provided.
+  auto nonNegAttr =
+      NonNegativeFloatAttr::getChecked(emitErrorFn, &context, APFloat(1.0));
+  EXPECT_NE(nonNegAttr, nullptr);
+
+  // Check that getChecked() returns a non-nullptr attribute  when a non-
+  // negative value is provided.
+  auto nonNegAttrInvalid =
+      NonNegativeFloatAttr::getChecked(emitErrorFn, &context, APFloat(-1.0f));
+  EXPECT_EQ(nonNegAttrInvalid, nullptr);
+}
+
 } // namespace