[mlir][ods] Add codegen support for custom verifiers (for attributes and types)

[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 the capability to specify a
verify() function directly in the mlir-tblgen input (ODS) file.

This is accomplished by duplicating the existing mlir-tblgen logic for code
generation of get() methods via the builders field, and modifying it
slightly to generate verify() methods. As such:

• the TablgGen Builder class was renamed to MethodSpec (for "method specification") to reflect a more general usage
• a verifiers field was added to the AttrOrTypeDef base class
• the EnumAttr class was modified to provide a custom verify() implementation for integer and bit enum attributes
• tests were added 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 verifiers field is 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.

[rriddle]

Did you consider adding verification support to AttrOrTypeParameter instead? That would be more inline with how verification is done for operations.

[jfurtek]

In D126108#3533577, @rriddle wrote:

Did you consider adding verification support to AttrOrTypeParameter instead? That would be more inline with how verification is done for operations.

I had not considered that.

So this scheme would allow each AttrOrTypeParameter in ODS to provide verifier code, and then tblgen can generate a verify() function for the attribute/type that verifies each AttrOrTypeParameter, returning success() only if all succeed? IIUC, this differs slightly from operations in that MyOp::verifyInvariants() is run on an operation that already exists, whereas for attributes MyAttr::verify() is called before creation.

I think that your approach makes more sense - I just want to make sure I understand before implementing...

[rriddle]

In D126108#3534508, @jfurtek wrote:

In D126108#3533577, @rriddle wrote:

Did you consider adding verification support to AttrOrTypeParameter instead? That would be more inline with how verification is done for operations.

I had not considered that.

So this scheme would allow each AttrOrTypeParameter in ODS to provide verifier code, and then tblgen can generate a verify() function for the attribute/type that verifies each AttrOrTypeParameter, returning success() only if all succeed?

I think that your approach makes more sense - I just want to make sure I understand before implementing...

Yeah, what you describe there is what I had in mind.

IIUC, this differs slightly from operations in that MyOp::verifyInvariants() is run on an operation that already exists, whereas for attributes MyAttr::verify() is called before creation.

Indeed, given that Attributes/Types are immortal/unique'd, verification happens prior to creation.

[jfurtek]

OK - I think I understand. Let me take another pass at this. Thanks for the help.

mlir/include/mlir/IR/AttrTypeBase.td

class ParamNativeTypeTrait<string prop, string params>
     : ParamNativeTrait<prop, params, "Type">;
 class GenInternalTypeTrait<string prop> : GenInternalTrait<prop, "Type">;
 class PredTypeTrait<string descr, Pred pred> : PredTrait<descr, pred>;
 
 //===----------------------------------------------------------------------===//
 // Builders
 //===----------------------------------------------------------------------===//
 
-// Class for defining a custom getter.
+// Class for defining a custom getters and verifiers (MethodSpec)
+//
+// The MethodSpec (method specification) class can be used to provide function
+// signatures (and optionally implementations) in a tablegen record.
+//
+// Custom getters:
 //
 // TableGen generates several generic getter methods for each attribute and type
 // by default, corresponding to the specified dag parameters. If the default
 // generated ones cannot cover some use case, custom getters can be defined
 // using instances of this class.
 //
 // The signature of the `get` is always either:
 //

 // AttrOrTypeBuilder<(ins "int":$integerArg, CArg<"float", "3.0f">:$floatArg), [{
 //   return $_get($_ctxt, integerArg, floatArg);
 // }]>
 // ```
 //
 // This is necessary because the `body` is also used to generate `getChecked`
 // methods, which have a different underlying `Base::get*` call.
 //
-class AttrOrTypeBuilder<dag parameters, code bodyCode = ""> {
+// Custom verifiers:
+//
+// A `verify()` function is necessary when an attribute or type implements the
+// `getChecked()` static method. The `getChecked()` arguments are forwarded to
+// the `verify()` method, and if that method returns `failure()`, a null
+// attribute will be returned to the `getChecked()` caller.
+//
+// If `genVerifyDecl=1` and no custom verifiers are provided, the `verify()`
+// function will be declared in the class header, and the user must provide an
+// implementation of the function in a separate source file. (The `getChecked()`
+// function will be generated automatically when `genVerifyDecl=1`.)
+//
+// If one or more custom verifiers are provided in the `verifiers` field, the
+// associated declarations will be generated in the header file. Providing a
+// body for the verifier is optional - if no body/implementation is provided,
+// the user must provide one in a separate source file. (The `getChecked()`
+// implementation will be generated automatically when `verifiers` is nonempty.)
+class MethodSpec<dag parameters, code bodyCode = ""> {
   dag dagParams = parameters;
   code body = bodyCode;
+}
 
+class AttrOrTypeBuilder<dag parameters, code bodyCode = "">  :
+  MethodSpec<parameters, bodyCode> {
   // The context parameter can be inferred from one of the other parameters and
   // is not implicitly added to the parameter list.
   bit hasInferredContextParam = 0;
 }
 class AttrBuilder<dag parameters, code bodyCode = "">
   : AttrOrTypeBuilder<parameters, bodyCode>;
 class TypeBuilder<dag parameters, code bodyCode = "">
   : AttrOrTypeBuilder<parameters, bodyCode>;
 
 // A class of AttrOrTypeBuilder that is able to infer the MLIRContext parameter
 // from one of the other builder parameters. Instances of this builder do not
 // have `MLIRContext *` implicitly added to the parameter list.
 class AttrOrTypeBuilderWithInferredContext<dag parameters, code bodyCode = "">
   : TypeBuilder<parameters, bodyCode> {
   let hasInferredContextParam = 1;
 }
 class AttrBuilderWithInferredContext<dag parameters, code bodyCode = "">
   : AttrOrTypeBuilderWithInferredContext<parameters, bodyCode>;
 class TypeBuilderWithInferredContext<dag parameters, code bodyCode = "">
   : AttrOrTypeBuilderWithInferredContext<parameters, bodyCode>;
 
+class AttrOrTypeVerifier<dag parameters, code bodyCode = "">  :
+  MethodSpec<parameters, bodyCode> {
+}
+
 //===----------------------------------------------------------------------===//
 // Definitions
 //===----------------------------------------------------------------------===//
 
 // Define a new attribute or type, named `name`, that inherits from the given
 // C++ base class.
 class AttrOrTypeDef<string valueType, string name, list<Trait> defTraits,
                     string baseCppClass> {
class AttrOrTypeDef<string valueType, string name, list<Trait> defTraits,
   //
   // ```c++
   // static <ClassName> get(MLIRContext *, <parameters>);
   // ```
   //
   // Note that builders should only be provided when a def has parameters.
   list<AttrOrTypeBuilder> builders = ?;
 
+  // Note that verifiers should only be provided when a def has parameters.
+  list<AttrOrTypeVerifier> verifiers = ?;
+
   // The list of traits attached to this def.
   list<Trait> traits = defTraits;
 
   // Use the lowercased name as the keyword for parsing/printing. Specify only
   // if you want tblgen to generate declarations and/or definitions of
   // the printer/parser. If specified and the Attribute or Type contains
   // parameters, `assemblyFormat` or `hasCustomAssemblyFormat` must also be
   // specified.

mlir/include/mlir/IR/EnumAttr.td

class EnumAttr<Dialect dialect, EnumAttrInfo enumInfo, string name = "",
   let parameters = (ins EnumParameter<enumInfo>:$value);
 
   // If a mnemonic was provided, use it to generate a custom assembly format.
   let mnemonic = name;
 
   // The default assembly format for enum attributes. Selected to best work with
   // operation assembly formats.
   let assemblyFormat = "$value";
+
+  // Provide a verifier for enums so that getChecked() will return a null
+  // attribute when the argument is not a valid enum value.
+  let verifiers = [
+    AttrOrTypeVerifier<(ins returnType:$value), [{
+      auto uval = static_cast<}] # enumInfo.underlyingType # [{>(value);
+      return }] # enumInfo.underlyingToSymbolFnName # [{(uval) ? ::mlir::success() : ::mlir::failure();
+    }]>
+  ];
 }
 
 #endif // ENUMATTR_TD

mlir/include/mlir/TableGen/AttrOrTypeDef.h

 // Record defining a MLIR attributes and types.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TABLEGEN_ATTRORTYPEDEF_H
 #define MLIR_TABLEGEN_ATTRORTYPEDEF_H
 
 #include "mlir/Support/LLVM.h"
-#include "mlir/TableGen/Builder.h"
+#include "mlir/TableGen/MethodSpec.h"
 #include "mlir/TableGen/Trait.h"
 
 namespace llvm {
 class DagInit;
 class Record;
 class SMLoc;
 } // namespace llvm
 
 namespace mlir {
 namespace tblgen {
 class Dialect;
 
 //===----------------------------------------------------------------------===//
 // AttrOrTypeBuilder
 //===----------------------------------------------------------------------===//
 
 /// Wrapper class that represents a Tablegen AttrOrTypeBuilder.
-class AttrOrTypeBuilder : public Builder {
+class AttrOrTypeBuilder : public MethodSpec {
 public:
-  using Builder::Builder;
+  using MethodSpec::MethodSpec;
 
   /// Returns true if this builder is able to infer the MLIRContext parameter.
   bool hasInferredContextParameter() const;
 };
 
 //===----------------------------------------------------------------------===//
 // AttrOrTypeParameter
 //===----------------------------------------------------------------------===//
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 verifier methods were provided in the record, or if
+  /// automatic verify() declaration was requested (genVerifyDecl=1).
+  bool usesCheckedBuilder() 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.
   bool skipDefaultBuilders() const;
 
   /// Returns the builders of this def.
   ArrayRef<AttrOrTypeBuilder> getBuilders() const { return builders; }
 
+  /// Returns the verifiers of this def.
+  ArrayRef<MethodSpec> getVerifiers() const { return verifiers; }
+
   /// Returns the traits of this def.
   ArrayRef<Trait> getTraits() const { return traits; }
 
   /// Returns whether two AttrOrTypeDefs are equal by checking the equality of
   /// the underlying record.
   bool operator==(const AttrOrTypeDef &other) const;
 
   /// Compares two AttrOrTypeDefs by comparing the names of the dialects.
   bool operator<(const AttrOrTypeDef &other) const;
 
   /// Returns whether the AttrOrTypeDef is defined.
   operator bool() const { return def != nullptr; }
 
   /// Return the underlying def.
   const llvm::Record *getDef() const { return def; }
 
 protected:
   const llvm::Record *def;
 
   /// The builders of this definition.
   SmallVector<AttrOrTypeBuilder> builders;
 
+  /// The verifiers of this definition.
+  SmallVector<MethodSpec> verifiers;
+
   /// The traits of this definition.
   SmallVector<Trait> traits;
 
   /// The parameters of this attribute or type.
   SmallVector<AttrOrTypeParameter> parameters;
 };
 
 //===----------------------------------------------------------------------===//

mlir/include/mlir/TableGen/MethodSpec.h

-//===- Builder.h - Builder classes ------------------------------*- C++ -*-===//
+//===- MethodSpec.h - MethodSpec classes ------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
-// Builder wrapper to simplify using TableGen Record for building
-// operations/types/etc.
+// Method specification wrapper to simplify using TableGen records for building
+// operations/attributes/types/etc.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_TABLEGEN_BUILDER_H_
-#define MLIR_TABLEGEN_BUILDER_H_
+#ifndef MLIR_TABLEGEN_METHODSPEC_H_
+#define MLIR_TABLEGEN_METHODSPEC_H_
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 class Init;
 class Record;
 class SMLoc;
 } // namespace llvm
 
 namespace mlir {
 namespace tblgen {
 
-/// Wrapper class with helper methods for accessing Builders defined in
-/// TableGen.
-class Builder {
+/// Wrapper class with helper methods for accessing MethodSpecs defined in
+/// TableGen. A MethodSpec (method specification) provides a function
+/// signature (declaration), and (optionally) a function body
+/// (implementation).
+class MethodSpec {
 public:
-  /// This class represents a single parameter to a builder method.
+  /// This class represents a single parameter to a method specification.
   class Parameter {
   public:
     /// Return a string containing the C++ type of this parameter.
     StringRef getCppType() const;
 
     /// Return an optional string containing the name of this parameter. If
     /// None, no name was specified for this parameter by the user.
     Optional<StringRef> getName() const { return name; }
private:
     /// The optional name of the parameter.
     Optional<StringRef> name;
 
     /// The tablegen definition of the parameter. This is either a StringInit,
     /// or a CArg DefInit.
     const llvm::Init *def;
 
     // Allow access to the constructor.
-    friend Builder;
+    friend MethodSpec;
   };
 
-  /// Construct a builder from the given Record instance.
-  Builder(const llvm::Record *record, ArrayRef<SMLoc> loc);
+  /// Construct a MethodSpec from the given Record instance.
+  MethodSpec(const llvm::Record *record, ArrayRef<SMLoc> loc);
 
-  /// Return a list of parameters used in this build method.
+  /// Return a list of parameters used in this method.
   ArrayRef<Parameter> getParameters() const { return parameters; }
 
-  /// Return an optional string containing the body of the builder.
+  /// Return an optional string containing the body of the method spec.
   Optional<StringRef> getBody() const;
 
 protected:
-  /// The TableGen definition of this builder.
+  /// The TableGen definition of this method specification.
   const llvm::Record *def;
 
 private:
-  /// A collection of parameters to the builder.
+  /// A collection of parameters to the method specification.
   SmallVector<Parameter> parameters;
 };
 
 } // namespace tblgen
 } // namespace mlir
 
-#endif // MLIR_TABLEGEN_BUILDER_H_
+#endif // MLIR_TABLEGEN_METHODSPEC_H_

mlir/include/mlir/TableGen/Operator.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TABLEGEN_OPERATOR_H_
 #define MLIR_TABLEGEN_OPERATOR_H_
 
 #include "mlir/Support/LLVM.h"
 #include "mlir/TableGen/Argument.h"
 #include "mlir/TableGen/Attribute.h"
-#include "mlir/TableGen/Builder.h"
 #include "mlir/TableGen/Dialect.h"
+#include "mlir/TableGen/MethodSpec.h"
 #include "mlir/TableGen/Region.h"
 #include "mlir/TableGen/Successor.h"
 #include "mlir/TableGen/Trait.h"
 #include "mlir/TableGen/Type.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
public:
   private:
     int packed;
   };
 
   // Returns the OperandOrAttribute corresponding to the index.
   OperandOrAttribute getArgToOperandOrAttribute(int index) const;
 
   // Returns the builders of this operation.
-  ArrayRef<Builder> getBuilders() const { return builders; }
+  ArrayRef<MethodSpec> getBuilders() const { return builders; }
 
   // Returns the preferred getter name for the accessor.
   std::string getGetterName(StringRef name) const {
     return getGetterNames(name).front();
   }
 
   // Returns the getter names for the accessor.
   SmallVector<std::string, 2> getGetterNames(StringRef name) const;
private:
 
   // The argument with the same type as the result.
   SmallVector<SmallVector<ArgOrType, 2>, 4> resultTypeMapping;
 
   // Map from argument to attribute or operand number.
   SmallVector<OperandOrAttribute, 4> attrOrOperandMapping;
 
   // The builders of this operator.
-  SmallVector<Builder> builders;
+  SmallVector<MethodSpec> builders;
 
   // The number of native attributes stored in the leading positions of
   // `attributes`.
   int numNativeAttributes;
 
   // The TableGen definition of this op.
   const llvm::Record &def;
 
   // Whether the type of all results are known.
   bool allResultsHaveKnownTypes;
 };
 
 } // namespace tblgen
 } // namespace mlir
 
 #endif // MLIR_TABLEGEN_OPERATOR_H_

mlir/lib/TableGen/AttrOrTypeDef.cpp

 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace mlir;
 using namespace mlir::tblgen;
 
+template <class T>
+void populateMethodSpecList(SmallVector<T> &v, const llvm::Record *def,
+                            const char *name) {
+  auto *methodList = dyn_cast_or_null<llvm::ListInit>(def->getValueInit(name));
+  if (methodList && !methodList->empty()) {
+    for (llvm::Init *init : methodList->getValues()) {
+      T method(cast<llvm::DefInit>(init)->getDef(), def->getLoc());
+
+      // Ensure that all parameters have names.
+      for (const typename T::Parameter &param : method.getParameters()) {
+        if (!param.getName())
+          PrintFatalError(def->getLoc(), "method parameters must have a name");
+      }
+      v.emplace_back(method);
+    }
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // AttrOrTypeBuilder
 //===----------------------------------------------------------------------===//
 
 /// Returns true if this builder is able to infer the MLIRContext parameter.
 bool AttrOrTypeBuilder::hasInferredContextParameter() const {
   return def->getValueAsBit("hasInferredContextParam");
 }
 
 //===----------------------------------------------------------------------===//
 // AttrOrTypeDef
 //===----------------------------------------------------------------------===//
 
 AttrOrTypeDef::AttrOrTypeDef(const llvm::Record *def) : def(def) {
-  // Populate the builders.
-  auto *builderList =
-      dyn_cast_or_null<llvm::ListInit>(def->getValueInit("builders"));
-  if (builderList && !builderList->empty()) {
-    for (llvm::Init *init : builderList->getValues()) {
-      AttrOrTypeBuilder builder(cast<llvm::DefInit>(init)->getDef(),
-                                def->getLoc());
-
-      // Ensure that all parameters have names.
-      for (const AttrOrTypeBuilder::Parameter &param :
-           builder.getParameters()) {
-        if (!param.getName())
-          PrintFatalError(def->getLoc(), "builder parameters must have a name");
-      }
-      builders.emplace_back(builder);
-    }
-  }
+  // Populate the builders and verifiers.
+  populateMethodSpecList(builders, def, "builders");
+  populateMethodSpecList(verifiers, def, "verifiers");
 
   // Populate the traits.
   if (auto *traitList = def->getValueAsListInit("traits")) {
     SmallPtrSet<const llvm::Init *, 32> traitSet;
     traits.reserve(traitSet.size());
     for (auto *traitInit : *traitList)
       if (traitSet.insert(traitInit).second)
         traits.push_back(Trait::create(traitInit));

 bool AttrOrTypeDef::genAccessors() const {
   return def->getValueAsBit("genAccessors");
 }
 
 bool AttrOrTypeDef::genVerifyDecl() const {
   return def->getValueAsBit("genVerifyDecl");
 }
 
+bool AttrOrTypeDef::usesCheckedBuilder() const {
+  return !verifiers.empty() || def->getValueAsBit("genVerifyDecl");
+}
+
 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 {

mlir/lib/TableGen/CMakeLists.txt

 # This library is unusual, since mlir-tblgen depends on it, which is
 # built with DISABLE_LLVM_LINK_LLVM_DYLIB, this must also be built
 # with that option.  Otherwise builds with LLVM_BUILD_LLVM_DYLIB and
 # LLVM_LINK_LLVM_DYLIB fail.  (Note that even if this has no llvm
 # component dependencies, LLVM_LINK_LLVM_DYLIB tends to introduce a
 # dependence on libLLVM.so)  However, it must also be linkable against
 # libMLIR.so in some contexts (see unittests/Tablegen, for instance, which
 # has a dependence on MLIRIR, which must depend on libLLVM.so).  This works
 # in this special case because this library is static.
 
 llvm_add_library(MLIRTableGen STATIC
   Argument.cpp
   Attribute.cpp
   AttrOrTypeDef.cpp
-  Builder.cpp
   Class.cpp
   Constraint.cpp
   Dialect.cpp
   Format.cpp
   Interfaces.cpp
+  MethodSpec.cpp
   Operator.cpp
   Pass.cpp
   Pattern.cpp
   Predicate.cpp
   Region.cpp
   SideEffects.cpp
   Successor.cpp
   Trait.cpp

mlir/lib/TableGen/MethodSpec.cpp

-//===- Builder.cpp - Builder definitions ----------------------------------===//
+//===- MethodSpec.cpp - MethodSpec definitions ----------------------------===//
 //
 // 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/TableGen/Builder.h"
+#include "mlir/TableGen/MethodSpec.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace mlir;
 using namespace mlir::tblgen;
 
 //===----------------------------------------------------------------------===//
-// Builder::Parameter
+// MethodSpec::Parameter
 //===----------------------------------------------------------------------===//
 
 /// Return a string containing the C++ type of this parameter.
-StringRef Builder::Parameter::getCppType() const {
+StringRef MethodSpec::Parameter::getCppType() const {
   if (const auto *stringInit = dyn_cast<llvm::StringInit>(def))
     return stringInit->getValue();
   const llvm::Record *record = cast<llvm::DefInit>(def)->getDef();
   return record->getValueAsString("type");
 }
 
 /// Return an optional string containing the default value to use for this
 /// parameter.
-Optional<StringRef> Builder::Parameter::getDefaultValue() const {
+Optional<StringRef> MethodSpec::Parameter::getDefaultValue() const {
   if (isa<llvm::StringInit>(def))
     return llvm::None;
   const llvm::Record *record = cast<llvm::DefInit>(def)->getDef();
   Optional<StringRef> value = record->getValueAsOptionalString("defaultValue");
   return value && !value->empty() ? value : llvm::None;
 }
 
 //===----------------------------------------------------------------------===//
-// Builder
+// MethodSpec
 //===----------------------------------------------------------------------===//
 
-Builder::Builder(const llvm::Record *record, ArrayRef<SMLoc> loc)
+MethodSpec::MethodSpec(const llvm::Record *record, ArrayRef<SMLoc> loc)
     : def(record) {
-  // Initialize the parameters of the builder.
+  // Initialize the parameters of the method specification.
   const llvm::DagInit *dag = def->getValueAsDag("dagParams");
   auto *defInit = dyn_cast<llvm::DefInit>(dag->getOperator());
   if (!defInit || !defInit->getDef()->getName().equals("ins"))
-    PrintFatalError(def->getLoc(), "expected 'ins' in builders");
+    PrintFatalError(def->getLoc(), "expected 'ins' in methodspec");
 
   bool seenDefaultValue = false;
   for (unsigned i = 0, e = dag->getNumArgs(); i < e; ++i) {
     const llvm::StringInit *paramName = dag->getArgName(i);
     const llvm::Init *paramValue = dag->getArg(i);
     Parameter param(paramName ? paramName->getValue() : Optional<StringRef>(),
                     paramValue);
 
     // Similarly to C++, once an argument with a default value is detected, the
     // following arguments must have default values as well.
     if (param.getDefaultValue()) {
       seenDefaultValue = true;
     } else if (seenDefaultValue) {
       PrintFatalError(loc,
                       "expected an argument with default value after other "
                       "arguments with default values");
     }
     parameters.emplace_back(param);
   }
 }
 
-/// Return an optional string containing the body of the builder.
-Optional<StringRef> Builder::getBody() const {
+/// Return an optional string containing the body of the method spec.
+Optional<StringRef> MethodSpec::getBody() const {
   Optional<StringRef> body = def->getValueAsOptionalString("body");
   return body && !body->empty() ? body : llvm::None;
 }

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

if (selectedDialect.empty()) {
     // Otherwise, generate the defs that belong to the selected dialect.
     auto dialectDefs = llvm::make_filter_range(defs, [&](const auto &def) {
       return def.getDialect().getName().equals(selectedDialect);
     });
     resultDefs.assign(dialectDefs.begin(), dialectDefs.end());
   }
 }
 
+static SmallVector<MethodParameter>
+getCustomVerifierParams(std::initializer_list<MethodParameter> prefix,
+                        const MethodSpec &verifier) {
+  auto params = verifier.getParameters();
+  SmallVector<MethodParameter> verifierParams;
+  verifierParams.append(prefix.begin(), prefix.end());
+  for (auto &param : params) {
+    verifierParams.emplace_back(param.getCppType(), *param.getName(),
+                                param.getDefaultValue());
+  }
+  return verifierParams;
+}
+
 //===----------------------------------------------------------------------===//
 // DefGen
 //===----------------------------------------------------------------------===//
 
 namespace {
 class DefGen {
 public:
   /// Create the attribute or type class.
private:
   /// Emit parsers and printers.
   void emitParserPrinter();
   /// Emit parameter accessors, if required.
   void emitAccessors();
   /// Emit interface methods.
   void emitInterfaceMethods();
 
   //===--------------------------------------------------------------------===//
-  // Builder Emission
+  // Builder/Verifier Emission
 
   /// Emit the default builder `Attribute::get`
   void emitDefaultBuilder();
   /// Emit the checked builder `Attribute::getChecked`
   void emitCheckedBuilder();
   /// Emit a custom builder.
   void emitCustomBuilder(const AttrOrTypeBuilder &builder);
   /// Emit a checked custom builder.
   void emitCheckedCustomBuilder(const AttrOrTypeBuilder &builder);
+  /// Emit a custom verifier.
+  void emitCustomVerifier(const MethodSpec &verifier);
 
   //===--------------------------------------------------------------------===//
   // Interface Method Emission
 
   /// Emit methods for a trait.
   void emitTraitMethods(const InterfaceTrait &trait);
   /// Emit a trait method.
   void emitTraitMethod(const InterfaceMethod &method);
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())
+  if (storageCls && def.usesCheckedBuilder())
     emitVerifier();
   // 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
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() {
+  assert(def.usesCheckedBuilder() && "verify() emitted without getChecked()");
   defCls.declare<UsingDeclaration>("Base::getChecked");
+  if (!def.getVerifiers().empty()) {
+    // The record has one or more verifiers.
+    for (auto &verifier : def.getVerifiers())
+      emitCustomVerifier(verifier);
+  } else {
+    // The record has genVerifyDecl=1, and no tblgen verifiers were provided.
+    // Generate a verify() declaration corresponding to the default builder,
+    // and the user must provide a definition.
     defCls.declareStaticMethod(
         "::mlir::LogicalResult", "verify",
         getBuilderParams({{"::llvm::function_ref<::mlir::InFlightDiagnostic()>",
                            "emitError"}}));
   }
+}
 
 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.
   bool hasAssemblyFormat = def.getAssemblyFormat().hasValue();
void DefGen::emitCheckedCustomBuilder(const AttrOrTypeBuilder &builder) {
   if (!builder.hasInferredContextParameter())
     ctx.addSubst("_ctxt", "context");
   std::string bodyStr = replaceInStr(builder.getBody()->str(), "$_get(",
                                      "Base::getChecked(emitError, ");
   bodyStr = tgfmt(bodyStr, &ctx);
   m->body().indent().getStream().printReindented(bodyStr);
 }
 
+void DefGen::emitCustomVerifier(const MethodSpec &verifier) {
+  // Don't emit a body if there isn't one.
+  auto props = verifier.getBody() ? Method::Static : Method::StaticDeclaration;
+  Method *m = defCls.addMethod(
+      "::mlir::LogicalResult", "verify", props,
+      getCustomVerifierParams(
+          {{"::llvm::function_ref<::mlir::InFlightDiagnostic()>", "emitError"}},
+          verifier));
+  if (!verifier.getBody())
+    return;
+  m->body().indent().getStream().printReindented(*verifier.getBody());
+}
+
 //===----------------------------------------------------------------------===//
 // Interface Method Emission
 
 void DefGen::emitTraitMethods(const InterfaceTrait &trait) {
   // Get the set of methods that should always be declared.
   auto alwaysDeclaredMethods = trait.getAlwaysDeclaredMethods();
   StringSet<> alwaysDeclared;
   alwaysDeclared.insert(alwaysDeclaredMethods.begin(),

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/tools/mlir-tblgen/OpDefinitionsGen.cpp

void OpEmitter::genUseAttrAsResultTypeBuilder() {
   body << "    " << builderOpState << ".addTypes({"
        << llvm::join(resultTypes, ", ") << "});\n";
   body << "  }\n";
 }
 
 /// Returns a signature of the builder. Updates the context `fctx` to enable
 /// replacement of $_builder and $_state in the body.
 static SmallVector<MethodParameter>
-getBuilderSignature(const Builder &builder) {
-  ArrayRef<Builder::Parameter> params(builder.getParameters());
+getBuilderSignature(const MethodSpec &builder) {
+  ArrayRef<MethodSpec::Parameter> params(builder.getParameters());
 
   // Inject builder and state arguments.
   SmallVector<MethodParameter> arguments;
   arguments.reserve(params.size() + 2);
   arguments.emplace_back("::mlir::OpBuilder &", odsBuilder);
   arguments.emplace_back("::mlir::OperationState &", builderOpState);
 
   for (unsigned i = 0, e = params.size(); i < e; ++i) {
arguments.emplace_back(params[i].getCppType(), std::move(name),
                            defaultValue);
   }
 
   return arguments;
 }
 
 void OpEmitter::genBuilder() {
   // Handle custom builders if provided.
-  for (const Builder &builder : op.getBuilders()) {
+  for (const MethodSpec &builder : op.getBuilders()) {
     SmallVector<MethodParameter> arguments = getBuilderSignature(builder);
 
     Optional<StringRef> body = builder.getBody();
     auto properties = body ? Method::Static : Method::StaticDeclaration;
     auto *method =
         opClass.addMethod("void", "build", properties, std::move(arguments));
     if (body)
       ERROR_IF_PRUNED(method, "build", op);

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);
+}
+
 } // namespace