[mlir][ods] Unique attribute, successor, region constraints

[Mogball]

Summary

With -Os turned on, results in 2-5% binary size reduction
(depends on the original binary). Without it, the binary size
is essentially unchanged.

Depends on D113128

[Mogball]

mlir/include/mlir/TableGen/CodeGenHelpers.h

101–103

Heh.

[Mogball]

Fixing some comments and cleaning up code

[Mogball]

Actually updated the patch this time

[jpienaar]

mlir/include/mlir/TableGen/Predicate.h

63

We mostly try to not expose the underlying Tablegen types directly here, why is this needed? (And could it be avoided)

[Mogball]

mlir/include/mlir/TableGen/Predicate.h

63

Needed for ConstraintMap. I think I can get rid of this.

[Mogball]

Rebase and review comments

[rriddle]

mlir/tools/mlir-tblgen/CodeGenHelpers.cpp

202–207

The tombstone shouldn't be the same as the empty key.

212–217

Is this providing additional uniquing power over the def pointer? This is now doing string comparison. I would rather expose the raw pointer than do this.

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

2335

Why?

[Mogball]

mlir/tools/mlir-tblgen/CodeGenHelpers.cpp

212–217

Yes it is. Constraints are being uniqued by their predicate (pointer value) and description (string value). I'm using this ConstraintUniquer to do it all at once, instead of whatever's going on in StaticVerifierFunctionEmitter::emitConstraintMethods

[Chia-hungDuan]

mlir/include/mlir/TableGen/CodeGenHelpers.h

102

Why do we need the "Local" here?

142

Do we need to change the name for this? It seems a little bit confusing with the other one.

183

How about let's have an enum class for this?

mlir/tools/mlir-tblgen/CodeGenHelpers.cpp

184–185

Can we concatenate them?

225–231

Sorry, I'm not following. Can you give me an example that we can't turn attribute verifier into a function? We fill the placehold $_self and $_op. The remaining case is $_builder, can we just find if we see that?

[Mogball]

mlir/include/mlir/TableGen/CodeGenHelpers.h

102

The constraint maps were called localType/AttrConstraints so I stuck the name in here too. I can probably drop that qualifier.

142

Oh, yeah probably. I totally missed this.

183

kind is just a string to be printed as part of the name. "attr", "type", "successor", or "region". An enum would only be used inside this class and it would needlessly complicate calling this function.

mlir/tools/mlir-tblgen/CodeGenHelpers.cpp

225–231

Under OpDefinitionsGen.cpp, the function populateSubstitutions replaces variables that reference operands, results, or attributes with calls to get them, e.g. $myAttr becomes (*this)->getAttr(myAttrAttrName()) which is not possible to do generically inside a static function. I.e., op attribute, successor, and region constraints can reference other operands, results, or attributes of the op.

I checked for usages of this for successor and region constraints and found none (because most people use SizedRegion or AnySuccessor). But I can't be sure that not a single attribute constraint uses this feature.

[Chia-hungDuan]

mlir/tools/mlir-tblgen/CodeGenHelpers.cpp

225–231

Got it. I would suggest that adding comments at "Constraint Getters". Because only attribute has Optional return value.

[Mogball]

Review comments, and changing Constraint constructors to allow usage with
DenseMapInfo

[Chia-hungDuan]

mlir/tools/mlir-tblgen/CodeGenHelpers.cpp

247–248

One space between functions

302–305

Not sure if the coding style say it but I think may the braces at loop level may look better

[Mogball]

Review comments

mlir/include/mlir/TableGen/CodeGenHelpers.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TABLEGEN_CODEGENHELPERS_H
 #define MLIR_TABLEGEN_CODEGENHELPERS_H
 
 #include "mlir/Support/IndentedOstream.h"
 #include "mlir/TableGen/Dialect.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 class RecordKeeper;
 } // namespace llvm
 
 namespace mlir {

 ///  ...
 /// }
 ///
 class StaticVerifierFunctionEmitter {
 public:
   StaticVerifierFunctionEmitter(const llvm::RecordKeeper &records,
                                 raw_ostream &os);
 
-  /// Emit the static verifier functions for `llvm::Record`s. The
-  /// `signatureFormat` describes the required arguments and it must have a
-  /// placeholder for function name.
-  /// Example,
-  ///   const char *typeVerifierSignature =
-  ///     "static ::mlir::LogicalResult {0}(::mlir::Operation *op, ::mlir::Type"
-  ///     " type, ::llvm::StringRef valueKind, unsigned valueGroupStartIndex)";
-  ///
-  /// `errorHandlerFormat` describes the error message to return. It may have a
-  /// placeholder for the summary of Constraint and bring more information for
-  /// the error message.
-  /// Example,
-  ///   const char *typeVerifierErrorHandler =
-  ///       " op->emitOpError(valueKind) << \" #\" << valueGroupStartIndex << "
-  ///       "\" must be {0}, but got \" << type";
-  ///
-  /// `typeArgName` is used to identify the argument that needs to check its
-  /// type. The constraint template will replace `$_self` with it.
-  void emitFunctionsFor(StringRef signatureFormat, StringRef errorHandlerFormat,
-                        StringRef typeArgName, ArrayRef<llvm::Record *> opDefs,
-                        bool emitDecl);
+  /// Collect and unique all compatible type, attribute, successor, and region
+  /// constraints in the file and emit them at the top of the generated file.
+  ///
+  /// Constraints that do not meet the restriction that they can only reference
+  /// `$_self` and `$_op` are not uniqued.
+  void emitLocalFunctions(ArrayRef<llvm::Record *> opDefs, bool emitDecl);
 
   /// Get the name of the local function used for the given type constraint.
   /// These functions are used for operand and result constraints and have the
   /// form:
+  ///
   ///   LogicalResult(Operation *op, Type type, StringRef valueKind,
-  ///                 unsigned valueGroupStartIndex);
+  ///                 unsigned valueIndex);
+  ///
   StringRef getTypeConstraintFn(const Constraint &constraint) const;
 
+  /// Get the name of the local function used for the given attribute
+  /// constraint. These functions are in the form:
+  ///
+  ///   LogicalResult(Operation *op, Attribute attr, StringRef attrName);
+  ///
+  /// If a uniqued constraint was not found, this function returns None. The
+  /// uniqued constraints cannot be used in the context of an OpAdaptor.
+  Optional<StringRef> getAttrConstraintFn(const Constraint &constraint) const;
+
+  /// Get the name of the local function used for the given successor
+  /// constraint. These functions are in the form:
+  ///
+  ///   LogicalResult(Operation *op, Block *successor, StringRef successorName,
+  ///                 unsigned successorIndex);
+  ///
+  StringRef getSuccessorConstraintFn(const Constraint &constraint) const;
+
+  /// Get the name of the local function used for the given region constraint.
+  /// These functions are in the form:
+  ///
+  ///   LogicalResult(Operation *op, Region &region, StringRef regionName,
+  ///                 unsigned regionIndex);
+  ///
+  /// The region name may be empty.
+  StringRef getRegionConstraintFn(const Constraint &constraint) const;
+
 private:
   /// Returns a unique name to use when generating local methods.
   static std::string getUniqueName(const llvm::RecordKeeper &records);
 
-  /// Emit local methods for the type constraints used within the provided op
-  /// definitions.
-  void emitTypeConstraintMethods(StringRef signatureFormat,
-                                 StringRef errorHandlerFormat,
-                                 StringRef typeArgName,
-                                 ArrayRef<llvm::Record *> opDefs,
-                                 bool emitDecl);
+  /// Emit local type constraint functions.
+  void emitTypeConstraints();
+  /// Emit local attribute constraint functions.
+  void emitAttrConstraints();
+  /// Emit local successor constraint functions.
+  void emitSuccessorConstraints();
+  /// Emit local region constraint functions.
+  void emitRegionConstraints();
+
+  /// Collect and unique all the constraints used by operations.
+  void collectAllConstraints(ArrayRef<llvm::Record *> opDefs);
 
   raw_indented_ostream os;
 
   /// A unique label for the file currently being generated. This is used to
   /// ensure that the local functions have a unique name.
   std::string uniqueOutputLabel;
 
-  /// A set of functions implementing type constraints, used for operand and
-  /// result verification.
-  llvm::DenseMap<const void *, std::string> localTypeConstraints;
+  /// Unique constraints by their predicate and summary. Constraints that share
+  /// the same predicate may have different descriptions; ensure that the
+  /// correct error message is reported when verification fails.
+  struct ConstraintUniquer {
+    static Constraint getEmptyKey();
+    static Constraint getTombstoneKey();
+    static unsigned getHashValue(Constraint constraint);
+    static bool isEqual(Constraint lhs, Constraint rhs);
+  };
+  /// Use a MapVector to ensure that functions are generated deterministically.
+  using ConstraintMap =
+      llvm::MapVector<Constraint, std::string,
+                      llvm::DenseMap<Constraint, unsigned, ConstraintUniquer>>;
+
+  /// A generic function to emit constraints.
+  void emitConstraints(const ConstraintMap &constraints, StringRef selfName,
+                       const char *const codeTemplate);
+
+  /// The set of type constraints used for operand and result verification in
+  /// the current file.
+  ConstraintMap localTypeConstraints;
+  /// The set of attribute constraints used in the current file.
+  ConstraintMap localAttrConstraints;
+  /// The set of successor constraints used in the current file.
+  ConstraintMap localSuccessorConstraints;
+  /// The set of region constraints used in the current file.
+  ConstraintMap localRegionConstraints;
 };
 
 // Escape a string using C++ encoding. E.g. foo"bar -> foo\x22bar.
 std::string escapeString(StringRef value);
 
 } // namespace tblgen
 } // namespace mlir
 
 #endif // MLIR_TABLEGEN_CODEGENHELPERS_H

mlir/include/mlir/TableGen/Constraint.h

 
 namespace mlir {
 namespace tblgen {
 
 // Wrapper class with helper methods for accessing Constraint defined in
 // TableGen.
 class Constraint {
 public:
+  Constraint() : def(nullptr) {}
   Constraint(const llvm::Record *record);
 
   bool operator==(const Constraint &that) { return def == that.def; }
   bool operator!=(const Constraint &that) { return def != that.def; }
 
   // Returns the predicate for this constraint.
   Pred getPredicate() const;
 
   // Returns the condition template that can be used to check if a type or
   // attribute satisfies this constraint.  The template may contain "{0}" that
   // must be substituted with an expression returning an mlir::Type or
   // mlir::Attribute.
   std::string getConditionTemplate() const;
 
   // Returns the user-readable description of this constraint. If the
   // description is not provided, returns the TableGen def name.
   StringRef getSummary() const;
 
   // Constraint kind
   enum Kind { CK_Attr, CK_Region, CK_Successor, CK_Type, CK_Uncategorized };
 
   Kind getKind() const { return kind; }
 
-  /// Get an opaque pointer to the constraint.
-  const void *getAsOpaquePointer() const { return def; }
-  /// Construct a constraint from the opaque pointer representation.
-  static Constraint getFromOpaquePointer(const void *ptr) {
-    return Constraint(reinterpret_cast<const llvm::Record *>(ptr));
-  }
-
   // Return the underlying def.
   const llvm::Record *getDef() const { return def; }
 
 protected:
   Constraint(Kind kind, const llvm::Record *record);
 
   // The TableGen definition of this constraint.
   const llvm::Record *def;

mlir/include/mlir/TableGen/Predicate.h

public:
   bool isCombined() const;
 
   // Records are pointer-comparable.
   bool operator==(const Pred &other) const { return def == other.def; }
 
   // Get the location of the predicate.
   ArrayRef<llvm::SMLoc> getLoc() const;
 
-protected:
-  friend llvm::DenseMapInfo<Pred>;
+  // Get the TableGen definition.
+  const llvm::Record *getDef() const { return def; }
 
+protected:
   // The TableGen definition of this predicate.
   const llvm::Record *def;
 };
 
 // A logical predicate wrapping a C expression.  This class must closely follow
 // the definition of TableGen class 'CPred'.
 class CPred : public Pred {
 public:

 public:
   StringRef getPrefix() const;
   StringRef getSuffix() const;
 };
 
 } // end namespace tblgen
 } // end namespace mlir
 
-namespace llvm {
-template <>
-struct DenseMapInfo<mlir::tblgen::Pred> {
-  static mlir::tblgen::Pred getEmptyKey() { return mlir::tblgen::Pred(); }
-  static mlir::tblgen::Pred getTombstoneKey() { return mlir::tblgen::Pred(); }
-  static unsigned getHashValue(mlir::tblgen::Pred pred) {
-    return llvm::hash_value(pred.def);
-  }
-  static bool isEqual(mlir::tblgen::Pred lhs, mlir::tblgen::Pred rhs) {
-    return lhs == rhs;
-  }
-};
-} // end namespace llvm
-
 #endif // MLIR_TABLEGEN_PREDICATE_H_

mlir/test/mlir-tblgen/constraint-unique.td

+// RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
+
+include "mlir/IR/OpBase.td"
+
+def Test_Dialect : Dialect {
+  let name = "test";
+}
+
+class NS_Op<string mnemonic, list<OpTrait> traits = []> :
+    Op<Test_Dialect, mnemonic, traits>;
+
+/// Test unique'ing of type, attribute, successor, and region constraints.
+
+def ATypePred : CPred<"typePred($_self, $_op)">;
+def AType : Type<ATypePred, "a type">;
+def OtherType : Type<ATypePred, "another type">;
+
+def AnAttrPred : CPred<"attrPred($_self, $_op)">;
+def AnAttr : Attr<AnAttrPred, "an attribute">;
+def OtherAttr : Attr<AnAttrPred, "another attribute">;
+
+def ASuccessorPred : CPred<"successorPred($_self, $_op)">;
+def ASuccessor : Successor<ASuccessorPred, "a successor">;
+def OtherSuccessor : Successor<ASuccessorPred, "another successor">;
+
+def ARegionPred : CPred<"regionPred($_self, $_op)">;
+def ARegion : Region<ARegionPred, "a region">;
+def OtherRegion : Region<ARegionPred, "another region">;
+
+// OpA and OpB have the same type, attribute, successor, and region constraints.
+
+def OpA : NS_Op<"op_a"> {
+  let arguments = (ins AType:$a, AnAttr:$b);
+  let results = (outs AType:$ret);
+  let successors = (successor ASuccessor:$c);
+  let regions = (region ARegion:$d);
+}
+
+def OpB : NS_Op<"op_b"> {
+  let arguments = (ins AType:$a, AnAttr:$b);
+  let successors = (successor ASuccessor:$c);
+  let regions = (region ARegion:$d);
+}
+
+// OpC has the same type, attribute, successor, and region predicates but has
+// difference descriptions for them.
+
+def OpC : NS_Op<"op_c"> {
+  let arguments = (ins OtherType:$a, OtherAttr:$b);
+  let results = (outs OtherType:$ret);
+  let successors = (successor OtherSuccessor:$c);
+  let regions = (region OtherRegion:$d);
+}
+
+/// Test that a type contraint was generated.
+// CHECK:    static ::mlir::LogicalResult [[$A_TYPE_CONSTRAINT:__mlir_ods_local_type_constraint.*]](
+// CHECK:      if (!((typePred(type, *op)))) {
+// CHECK-NEXT:   return op->emitOpError(valueKind) << " #" << valueIndex
+// CHECK-NEXT:       << " must be a type, but got " << type;
+
+/// Test that duplicate type constraint was not generated.
+// CHECK-NOT:        << " must be a type, but got " << type;
+
+/// Test that a type constraint with a different description was generated.
+// CHECK:    static ::mlir::LogicalResult [[$O_TYPE_CONSTRAINT:__mlir_ods_local_type_constraint.*]](
+// CHECK:      if (!((typePred(type, *op)))) {
+// CHECK-NEXT:   return op->emitOpError(valueKind) << " #" << valueIndex
+// CHECK-NEXT:       << " must be another type, but got " << type;
+
+/// Test that an attribute contraint was generated.
+// CHECK:    static ::mlir::LogicalResult [[$A_ATTR_CONSTRAINT:__mlir_ods_local_attr_constraint.*]](
+// CHECK:      if (attr && !((attrPred(attr, *op)))) {
+// CHECK-NEXT:   return op->emitOpError("attribute '") << attrName
+// CHECK-NEXT:       << "' failed to satisfy constraint: an attribute";
+
+/// Test that duplicate attribute constraint was not generated.
+// CHECK-NOT:        << "' failed to satisfy constraint: an attribute";
+
+/// Test that a attribute constraint with a different description was generated.
+// CHECK:    static ::mlir::LogicalResult [[$O_ATTR_CONSTRAINT:__mlir_ods_local_attr_constraint.*]](
+// CHECK:      if (attr && !((attrPred(attr, *op)))) {
+// CHECK-NEXT:   return op->emitOpError("attribute '") << attrName
+// CHECK-NEXT:       << "' failed to satisfy constraint: another attribute";
+
+/// Test that a successor contraint was generated.
+// CHECK:    static ::mlir::LogicalResult [[$A_SUCCESSOR_CONSTRAINT:__mlir_ods_local_successor_constraint.*]](
+// CHECK:      if (!((successorPred(successor, *op)))) {
+// CHECK-NEXT:   return op->emitOpError("successor #") << successorIndex << " ('"
+// CHECK-NEXT:       << successorName << ")' failed to verify constraint: a successor";
+
+/// Test that duplicate successor constraint was not generated.
+// CHECK-NOT:        << successorName << ")' failed to verify constraint: a successor";
+
+/// Test that a successor constraint with a different description was generated.
+// CHECK:    static ::mlir::LogicalResult [[$O_SUCCESSOR_CONSTRAINT:__mlir_ods_local_successor_constraint.*]](
+// CHECK:      if (!((successorPred(successor, *op)))) {
+// CHECK-NEXT:   return op->emitOpError("successor #") << successorIndex << " ('"
+// CHECK-NEXT:       << successorName << ")' failed to verify constraint: another successor";
+
+/// Test that a region contraint was generated.
+// CHECK:    static ::mlir::LogicalResult [[$A_REGION_CONSTRAINT:__mlir_ods_local_region_constraint.*]](
+// CHECK:      if (!((regionPred(region, *op)))) {
+// CHECK-NEXT:   return op->emitOpError("region #") << regionIndex
+// CHECK-NEXT:       << (regionName.empty() ? " " : " ('" + regionName + "') ")
+// CHECK-NEXT:       << "failed to verify constraint: a region";
+
+/// Test that duplicate region constraint was not generated.
+// CHECK-NOT:        << "failed to verify constraint: a region";
+
+/// Test that a region constraint with a different description was generated.
+// CHECK:    static ::mlir::LogicalResult [[$O_REGION_CONSTRAINT:__mlir_ods_local_region_constraint.*]](
+// CHECK:      if (!((regionPred(region, *op)))) {
+// CHECK-NEXT:   return op->emitOpError("region #") << regionIndex
+// CHECK-NEXT:       << (regionName.empty() ? " " : " ('" + regionName + "') ")
+// CHECK-NEXT:       << "failed to verify constraint: another region";
+
+/// Test that the uniqued constraints are being used.
+// CHECK-LABEL: OpA::verify
+// CHECK:         auto [[$B_ATTR:.*b]] = (*this)->getAttr(bAttrName());
+// CHECK:         if (::mlir::failed([[$A_ATTR_CONSTRAINT]](*this, [[$B_ATTR]], "b")))
+// CHECK-NEXT:      return ::mlir::failure();
+// CHECK:         auto [[$A_VALUE_GROUP:.*]] = getODSOperands(0);
+// CHECK:         for (auto [[$A_VALUE:.*]] : [[$A_VALUE_GROUP]])
+// CHECK-NEXT:      if (::mlir::failed([[$A_TYPE_CONSTRAINT]](*this, [[$A_VALUE]].getType(), "operand", index++)))
+// CHECK-NEXT:        return ::mlir::failure();
+// CHECK:         auto [[$RET_VALUE_GROUP:.*]] = getODSResults(0);
+// CHECK:         for (auto [[$RET_VALUE:.*]] : [[$RET_VALUE_GROUP]])
+// CHECK-NEXT:      if (::mlir::failed([[$A_TYPE_CONSTRAINT]](*this, [[$RET_VALUE]].getType(), "result", index++)))
+// CHECK-NEXT:        return ::mlir::failure();
+// CHECK:         for (auto &region : ::llvm::makeMutableArrayRef((*this)->getRegion(0)))
+// CHECK-NEXT:      if (::mlir::failed([[$A_REGION_CONSTRAINT]](*this, region, "d", index++)))
+// CHECK-NEXT:        return ::mlir::failure();
+// CHECK:         for (auto *successor : ::llvm::makeMutableArrayRef(c()))
+// CHECK-NEXT:      if (::mlir::failed([[$A_SUCCESSOR_CONSTRAINT]](*this, successor, "c", index++)))
+// CHECK-NEXT:        return ::mlir::failure();
+
+/// Test that the op with the same predicates but different with descriptions
+/// uses the different constraints.
+// CHECK-LABEL: OpC::verify
+// CHECK:         auto [[$B_ATTR:.*b]] = (*this)->getAttr(bAttrName());
+// CHECK:         if (::mlir::failed([[$O_ATTR_CONSTRAINT]](*this, [[$B_ATTR]], "b")))
+// CHECK-NEXT:      return ::mlir::failure();
+// CHECK:         auto [[$A_VALUE_GROUP:.*]] = getODSOperands(0);
+// CHECK:         for (auto [[$A_VALUE:.*]] : [[$A_VALUE_GROUP]])
+// CHECK-NEXT:      if (::mlir::failed([[$O_TYPE_CONSTRAINT]](*this, [[$A_VALUE]].getType(), "operand", index++)))
+// CHECK-NEXT:        return ::mlir::failure();
+// CHECK:         auto [[$RET_VALUE_GROUP:.*]] = getODSResults(0);
+// CHECK:         for (auto [[$RET_VALUE:.*]] : [[$RET_VALUE_GROUP]])
+// CHECK-NEXT:      if (::mlir::failed([[$O_TYPE_CONSTRAINT]](*this, [[$RET_VALUE]].getType(), "result", index++)))
+// CHECK-NEXT:        return ::mlir::failure();
+// CHECK:         for (auto &region : ::llvm::makeMutableArrayRef((*this)->getRegion(0)))
+// CHECK-NEXT:      if (::mlir::failed([[$O_REGION_CONSTRAINT]](*this, region, "d", index++)))
+// CHECK-NEXT:        return ::mlir::failure();
+// CHECK:         for (auto *successor : ::llvm::makeMutableArrayRef(c()))
+// CHECK-NEXT:      if (::mlir::failed([[$O_SUCCESSOR_CONSTRAINT]](*this, successor, "c", index++)))
+// CHECK-NEXT:        return ::mlir::failure();

mlir/test/mlir-tblgen/predicate.td

def I32OrF32 : Type<CPred<"$_self.isInteger(32) || $_self.isF32()">,
                     "32-bit integer or floating-point type">;
 
 def OpA : NS_Op<"op_for_CPred_containing_multiple_same_placeholder", []> {
   let arguments = (ins I32OrF32:$x);
   let results = (outs Variadic<I32OrF32>:$y);
 }
 
 // CHECK: static ::mlir::LogicalResult [[$INTEGER_FLOAT_CONSTRAINT:__mlir_ods_local_type_constraint.*]](
-// CHECK-NEXT:  if (!((type.isInteger(32) || type.isF32()))) {
-// CHECK-NEXT:    return op->emitOpError(valueKind) << " #" << valueGroupStartIndex << " must be 32-bit integer or floating-point type, but got " << type;
+// CHECK:      if (!((type.isInteger(32) || type.isF32()))) {
+// CHECK-NEXT:   return op->emitOpError(valueKind) << " #" << valueIndex
+// CHECK-NEXT:       << " must be 32-bit integer or floating-point type, but got " << type;
 
 // Check there is no verifier with same predicate generated.
 // CHECK-NOT:  if (!((type.isInteger(32) || type.isF32()))) {
-// CHECK-NOT:    return op->emitOpError(valueKind) << " #" << valueGroupStartIndex << " must be 32-bit integer or floating-point type, but got " << type;
+// CHECK-NOT:    return op->emitOpError(valueKind) << " #" << valueIndex
+// CHECK-NOT.        << " must be 32-bit integer or floating-point type, but got " << type;
 
 // CHECK: static ::mlir::LogicalResult [[$TENSOR_CONSTRAINT:__mlir_ods_local_type_constraint.*]](
-// CHECK-NEXT:  if (!(((type.isa<::mlir::TensorType>())) && ((true)))) {
-// CHECK-NEXT:    return op->emitOpError(valueKind) << " #" << valueGroupStartIndex << " must be tensor of any type values, but got " << type;
+// CHECK:       if (!(((type.isa<::mlir::TensorType>())) && ((true)))) {
+// CHECK-NEXT:    return op->emitOpError(valueKind) << " #" << valueIndex
+// CHECK-NEXT:       << " must be tensor of any type values, but got " << type;
 
 // CHECK: static ::mlir::LogicalResult [[$TENSOR_INTEGER_FLOAT_CONSTRAINT:__mlir_ods_local_type_constraint.*]](
-// CHECK-NEXT:  if (!(((type.isa<::mlir::TensorType>())) && (((type.cast<::mlir::ShapedType>().getElementType().isF32())) || ((type.cast<::mlir::ShapedType>().getElementType().isSignlessInteger(32)))))) {
-// CHECK-NEXT:    return op->emitOpError(valueKind) << " #" << valueGroupStartIndex << " must be tensor of 32-bit float or 32-bit signless integer values, but got " << type;
+// CHECK:       if (!(((type.isa<::mlir::TensorType>())) && (((type.cast<::mlir::ShapedType>().getElementType().isF32())) || ((type.cast<::mlir::ShapedType>().getElementType().isSignlessInteger(32)))))) {
+// CHECK-NEXT:    return op->emitOpError(valueKind) << " #" << valueIndex
+// CHECK-NEXT:       << " must be tensor of 32-bit float or 32-bit signless integer values, but got " << type;
 
 // CHECK-LABEL: OpA::verify
 // CHECK: auto valueGroup0 = getODSOperands(0);
-// CHECK: for (::mlir::Value v : valueGroup0) {
+// CHECK: for (auto v : valueGroup0) {
 // CHECK:   if (::mlir::failed([[$INTEGER_FLOAT_CONSTRAINT]]
 
 def OpB : NS_Op<"op_for_And_PredOpTrait", [
     PredOpTrait<"both first and second holds",
                 And<[CPred<"first">, CPred<"second">]>>]> {
 }
 
 // CHECK-LABEL: OpB::verify

 // CHECK: "failed to verify that operands indexed at 0, 2, 3 should all have the same type"
 
 def OpK : NS_Op<"op_for_AnyTensorOf", []> {
   let arguments = (ins TensorOf<[F32, I32]>:$x);
 }
 
 // CHECK-LABEL: OpK::verify
 // CHECK: auto valueGroup0 = getODSOperands(0);
-// CHECK: for (::mlir::Value v : valueGroup0) {
+// CHECK: for (auto v : valueGroup0) {
 // CHECK: if (::mlir::failed([[$TENSOR_INTEGER_FLOAT_CONSTRAINT]]
 
 def OpL : NS_Op<"op_for_StringEscaping", []> {
   let arguments = (ins
     StringBasedAttr<CPred<"$_self.cast<StringAttr>().getValue() == \"foo\"">,
                     "only value \"foo\" is allowed">:$s
   );
 }
 
 // CHECK-LABEL: OpLAdaptor::verify
 // CHECK: getValue() == "foo"
 // CHECK-NEXT: only value \"foo\" is allowed

mlir/tools/mlir-tblgen/CodeGenHelpers.cpp

 using namespace llvm;
 using namespace mlir;
 using namespace mlir::tblgen;
 
 StaticVerifierFunctionEmitter::StaticVerifierFunctionEmitter(
     const llvm::RecordKeeper &records, raw_ostream &os)
     : os(os), uniqueOutputLabel(getUniqueName(records)) {}
 
-void StaticVerifierFunctionEmitter::emitFunctionsFor(
-    StringRef signatureFormat, StringRef errorHandlerFormat,
-    StringRef typeArgName, ArrayRef<llvm::Record *> opDefs, bool emitDecl) {
-  llvm::Optional<NamespaceEmitter> namespaceEmitter;
-  if (!emitDecl)
-    namespaceEmitter.emplace(os, Operator(*opDefs[0]).getCppNamespace());
-
-  emitTypeConstraintMethods(signatureFormat, errorHandlerFormat, typeArgName,
-                            opDefs, emitDecl);
-}
+void StaticVerifierFunctionEmitter::emitLocalFunctions(
+    ArrayRef<llvm::Record *> opDefs, bool emitDecl) {
+  collectAllConstraints(opDefs);
+  if (emitDecl)
+    return;
 
-StringRef StaticVerifierFunctionEmitter::getTypeConstraintFn(
-    const Constraint &constraint) const {
-  auto it = localTypeConstraints.find(constraint.getAsOpaquePointer());
-  assert(it != localTypeConstraints.end() && "expected valid constraint fn");
-  return it->second;
+  NamespaceEmitter namespaceEmitter(os, Operator(*opDefs[0]).getCppNamespace());
+  emitTypeConstraints();
+  emitAttrConstraints();
+  emitSuccessorConstraints();
+  emitRegionConstraints();
 }
 
 std::string StaticVerifierFunctionEmitter::getUniqueName(
     const llvm::RecordKeeper &records) {
   // Use the input file name when generating a unique name.
   std::string inputFilename = records.getInputFilename();
 
   // Drop all but the base filename.
   StringRef nameRef = llvm::sys::path::filename(inputFilename);
   nameRef.consume_back(".td");
 
   // Sanitize any invalid characters.
   std::string uniqueName;
   for (char c : nameRef) {
     if (llvm::isAlnum(c) || c == '_')
       uniqueName.push_back(c);
     else
       uniqueName.append(llvm::utohexstr((unsigned char)c));
   }
   return uniqueName;
 }
 
-void StaticVerifierFunctionEmitter::emitTypeConstraintMethods(
-    StringRef signatureFormat, StringRef errorHandlerFormat,
-    StringRef typeArgName, ArrayRef<llvm::Record *> opDefs, bool emitDecl) {
-  // Collect a set of all of the used type constraints within the operation
-  // definitions.
-  llvm::SetVector<const void *> typeConstraints;
-  for (Record *def : opDefs) {
-    Operator op(*def);
-    for (NamedTypeConstraint &operand : op.getOperands())
-      if (operand.hasPredicate())
-        typeConstraints.insert(operand.constraint.getAsOpaquePointer());
-    for (NamedTypeConstraint &result : op.getResults())
-      if (result.hasPredicate())
-        typeConstraints.insert(result.constraint.getAsOpaquePointer());
-  }
-
-  // Record the mapping from predicate to constraint. If two constraints has the
-  // same predicate and constraint summary, they can share the same verification
-  // function.
-  llvm::DenseMap<Pred, const void *> predToConstraint;
-  FmtContext fctx;
-  for (auto it : llvm::enumerate(typeConstraints)) {
-    std::string name;
-    Constraint constraint = Constraint::getFromOpaquePointer(it.value());
-    Pred pred = constraint.getPredicate();
-    auto iter = predToConstraint.find(pred);
-    if (iter != predToConstraint.end()) {
-      do {
-        Constraint built = Constraint::getFromOpaquePointer(iter->second);
-        // We may have the different constraints but have the same predicate,
-        // for example, ConstraintA and Variadic<ConstraintA>, note that
-        // Variadic<> doesn't introduce new predicate. In this case, we can
-        // share the same predicate function if they also have consistent
-        // summary, otherwise we may report the wrong message while verification
-        // fails.
-        if (constraint.getSummary() == built.getSummary()) {
-          name = getTypeConstraintFn(built).str();
-          break;
-        }
-        ++iter;
-      } while (iter != predToConstraint.end() && iter->first == pred);
-    }
-
-    if (!name.empty()) {
-      localTypeConstraints.try_emplace(it.value(), name);
-      continue;
-    }
-
-    // Generate an obscure and unique name for this type constraint.
-    name = (Twine("__mlir_ods_local_type_constraint_") + uniqueOutputLabel +
-            Twine(it.index()))
-               .str();
-    predToConstraint.insert(
-        std::make_pair(constraint.getPredicate(), it.value()));
-    localTypeConstraints.try_emplace(it.value(), name);
+//===----------------------------------------------------------------------===//
+// Constraint Getters
+
+StringRef StaticVerifierFunctionEmitter::getTypeConstraintFn(
+    const Constraint &constraint) const {
+  auto it = localTypeConstraints.find(constraint);
+  assert(it != localTypeConstraints.end() &&
+         "expected to find a type constraint");
+  return it->second;
+}
+
+Optional<StringRef> StaticVerifierFunctionEmitter::getAttrConstraintFn(
+    const Constraint &constraint) const {
+  auto it = localAttrConstraints.find(constraint);
+  return it == localAttrConstraints.end() ? Optional<StringRef>()
+                                          : StringRef(it->second);
+}
+
+StringRef StaticVerifierFunctionEmitter::getSuccessorConstraintFn(
+    const Constraint &constraint) const {
+  auto it = localSuccessorConstraints.find(constraint);
+  assert(it != localSuccessorConstraints.end() &&
+         "expected to find a sucessor constraint");
+  return it->second;
+}
+
+StringRef StaticVerifierFunctionEmitter::getRegionConstraintFn(
+    const Constraint &constraint) const {
+  auto it = localRegionConstraints.find(constraint);
+  assert(it != localRegionConstraints.end() &&
+         "expected to find a region constraint");
+  return it->second;
+}
+
+//===----------------------------------------------------------------------===//
+// Constraint Emission
+
+/// Code templates for emitting type, attribute, successor, and region
+/// constraints. Each of these templates require the following arguments:
+///
+/// {0}: The unique constraint name.
+/// {1}: The constraint code.
+/// {2}: The constraint description.
+
+/// Code for a type constraint. These may be called on the type of either
+/// operands or results.
+static const char *const typeConstraintCode = R"(
+static ::mlir::LogicalResult {0}(
+    ::mlir::Operation *op, ::mlir::Type type, ::llvm::StringRef valueKind,
+    unsigned valueIndex) {
+  if (!({1})) {
+    return op->emitOpError(valueKind) << " #" << valueIndex
+        << " must be {2}, but got " << type;
+  }
+  return ::mlir::success();
+}
+)";
+
+/// Code for an attribute constraint. These may be called from ops only.
+/// Attribute constraints cannot reference anything other than `$_self` and
+/// `$_op`.
+///
+/// TODO: Unique constraints for adaptors. However, most Adaptor::verify
+/// functions are stripped anyways.
+static const char *const attrConstraintCode = R"(
+static ::mlir::LogicalResult {0}(
+    ::mlir::Operation *op, ::mlir::Attribute attr, ::llvm::StringRef attrName) {
+  if (attr && !({1})) {
+    return op->emitOpError("attribute '") << attrName
+        << "' failed to satisfy constraint: {2}";
+  }
+  return ::mlir::success();
+}
+)";
+
+/// Code for a successor constraint.
+static const char *const successorConstraintCode = R"(
+static ::mlir::LogicalResult {0}(
+    ::mlir::Operation *op, ::mlir::Block *successor,
+    ::llvm::StringRef successorName, unsigned successorIndex) {
+  if (!({1})) {
+    return op->emitOpError("successor #") << successorIndex << " ('"
+        << successorName << ")' failed to verify constraint: {2}";
+  }
+  return ::mlir::success();
+}
+)";
+
+/// Code for a region constraint. Callers will need to pass in the region's name
+/// for emitting an error message.
+static const char *const regionConstraintCode = R"(
+static ::mlir::LogicalResult {0}(
+    ::mlir::Operation *op, ::mlir::Region &region, ::llvm::StringRef regionName,
+    unsigned regionIndex) {
+  if (!({1})) {
+    return op->emitOpError("region #") << regionIndex
+        << (regionName.empty() ? " " : " ('" + regionName + "') ")
+        << "failed to verify constraint: {2}";
+  }
+  return ::mlir::success();
+}
+)";
+
+void StaticVerifierFunctionEmitter::emitConstraints(
+    const ConstraintMap &constraints, StringRef selfName,
+    const char *const codeTemplate) {
+  FmtContext ctx;
+  ctx.withOp("*op").withSelf(selfName);
+  for (auto &it : constraints) {
+    os << formatv(codeTemplate, it.second,
+                  tgfmt(it.first.getConditionTemplate(), &ctx),
+                  it.first.getSummary());
+  }
+}
+
+void StaticVerifierFunctionEmitter::emitTypeConstraints() {
+  emitConstraints(localTypeConstraints, "type", typeConstraintCode);
+}
+
+void StaticVerifierFunctionEmitter::emitAttrConstraints() {
+  emitConstraints(localAttrConstraints, "attr", attrConstraintCode);
+}
+
+void StaticVerifierFunctionEmitter::emitSuccessorConstraints() {
+  emitConstraints(localSuccessorConstraints, "successor",
+                  successorConstraintCode);
+}
+
+void StaticVerifierFunctionEmitter::emitRegionConstraints() {
+  emitConstraints(localRegionConstraints, "region", regionConstraintCode);
+}
+
+//===----------------------------------------------------------------------===//
+// Constraint Uniquing
+
+Constraint StaticVerifierFunctionEmitter::ConstraintUniquer::getEmptyKey() {
+  return Constraint();
+}
+Constraint StaticVerifierFunctionEmitter::ConstraintUniquer::getTombstoneKey() {
+  return Constraint();
+}
+unsigned StaticVerifierFunctionEmitter::ConstraintUniquer::getHashValue(
+    Constraint constraint) {
+  if (!constraint.getDef())
+    return 0;
+  return llvm::hash_combine(constraint.getPredicate().getDef(),
+                            constraint.getSummary());
+}
+bool StaticVerifierFunctionEmitter::ConstraintUniquer::isEqual(Constraint lhs,
+                                                               Constraint rhs) {
+  if (!lhs.getDef() ^ !rhs.getDef())
+    return false;
+  return !lhs.getDef() || (lhs.getPredicate() == rhs.getPredicate() &&
+                           lhs.getSummary() == rhs.getSummary());
+}
+
+/// An attribute constraint that references anything other than itself and the
+/// current op cannot be generically extracted into a function. Most
+/// prohibitive are operands and results, which require calls to
+/// `getODSOperands` or `getODSResults`. Attribute references are tricky too
+/// because ops use cached identifiers.
+static bool canUniqueAttrConstraint(Attribute attr) {
+  FmtContext ctx;
+  auto test =
+      tgfmt(attr.getConditionTemplate(), &ctx.withSelf("attr").withOp("*op"))
+          .str();
+  return !StringRef(test).contains("<no-subst-found>");
+}
+
+void StaticVerifierFunctionEmitter::collectAllConstraints(
+    ArrayRef<Record *> opDefs) {
+  /// Function to assign a unique name to a unique constraint.
+  const auto getUniqueName = [this](StringRef kind, unsigned index) {
+    return ("__mlir_ods_local_" + kind + "_constraint_" + uniqueOutputLabel +
+            Twine(index))
+  };
 
-    // Only generate the methods if we are generating definitions.
-    if (emitDecl)
-      continue;
+  /// Function to unique a constraint.
+  const auto collectConstraint = [&](ConstraintMap &map, StringRef kind,
+                                     Constraint constraint) {
+    auto it = map.find(constraint);
+    if (it == map.end())
+      map.insert({constraint, getUniqueName(kind, map.size())});
+  };
+
+  const auto collectTypeConstraints = [&](Operator::value_range values) {
+    for (const NamedTypeConstraint &value : values)
+      if (value.hasPredicate())
+        collectConstraint(localTypeConstraints, "type", value.constraint);
+  };
 
-    os << formatv(signatureFormat.data(), name) << " {\n";
-    os.indent() << "if (!("
-                << tgfmt(constraint.getConditionTemplate(),
-                         &fctx.withSelf(typeArgName))
-                << ")) {\n";
-    os.indent() << "return "
-                << formatv(errorHandlerFormat.data(), constraint.getSummary())
-                << ";\n";
-    os.unindent() << "}\nreturn ::mlir::success();\n";
-    os.unindent() << "}\n\n";
+  for (Record *def : opDefs) {
+    Operator op(*def);
+    /// Collect type constraints.
+    collectTypeConstraints(op.getOperands());
+    collectTypeConstraints(op.getResults());
+    /// Collect attribute constraints.
+    for (const NamedAttribute &namedAttr : op.getAttributes())
+      if (!namedAttr.attr.getPredicate().isNull() &&
+          canUniqueAttrConstraint(namedAttr.attr))
+        collectConstraint(localAttrConstraints, "attr", namedAttr.attr);
+    /// Collect successor constraints.
+    for (const NamedSuccessor &successor : op.getSuccessors()) {
+      if (!successor.constraint.getPredicate().isNull()) {
+        collectConstraint(localSuccessorConstraints, "successor",
+                          successor.constraint);
+      }
+    }
+    /// Collect region constraints.
+    for (const NamedRegion &region : op.getRegions())
+      if (!region.constraint.getPredicate().isNull())
+        collectConstraint(localRegionConstraints, "region", region.constraint);
   }
 }
 
+//===----------------------------------------------------------------------===//
+// Public Utility Functions
+//===----------------------------------------------------------------------===//
+
 std::string mlir::tblgen::escapeString(StringRef value) {
   std::string ret;
   llvm::raw_string_ostream os(ret);
   os.write_escaped(value);
   return os.str();
 }

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 // {0}: The begin iterator of the actual values.
 // {1}: The call to generate the start and length of the value range.
 static const char *const valueRangeReturnCode = R"(
   auto valueRange = {1};
   return {{std::next({0}, valueRange.first),
            std::next({0}, valueRange.first + valueRange.second)};
 )";
 
-static const char *const typeVerifierSignature =
-    "static ::mlir::LogicalResult {0}(::mlir::Operation *op, ::mlir::Type "
-    "type, ::llvm::StringRef valueKind, unsigned valueGroupStartIndex)";
-
-static const char *const typeVerifierErrorHandler =
-    " op->emitOpError(valueKind) << \" #\" << valueGroupStartIndex << \" must "
-    "be {0}, but got \" << type";
-
 static const char *const opCommentHeader = R"(
 //===----------------------------------------------------------------------===//
 // {0} {1}
 //===----------------------------------------------------------------------===//
 
 )";
 
 //===----------------------------------------------------------------------===//
for (int i = 0, e = op.getNumResults(); i < e; ++i) {
     auto &value = op.getResult(i);
     if (!value.name.empty())
       ctx.addSubst(value.name, emit.getResult(i).str());
   }
 }
 
 // Generate attribute verification. If an op instance is not available, then
 // attribute checks that require one will not be emitted.
-static void genAttributeVerifier(const OpOrAdaptorHelper &emit, FmtContext &ctx,
-                                 OpMethodBody &body) {
+static void genAttributeVerifier(
+    const OpOrAdaptorHelper &emit, FmtContext &ctx, OpMethodBody &body,
+    const StaticVerifierFunctionEmitter &staticVerifierEmitter) {
   // Check that a required attribute exists.
   //
   // {0}: Attribute variable name.
   // {1}: Emit error prefix.
   // {2}: Attribute name.
-  const char *const checkRequiredAttr = R"(
+  const char *const verifyRequiredAttr = R"(
     if (!{0})
       return {1}"requires attribute '{2}'");
-  )";
-  // Check the condition on an attribute if it is required. This assumes that
-  // default values are valid.
+  // Verify the attribute if it is present. This assumes that default values
+  // are valid. This code snippet pastes the condition inline.
+  //
   // TODO: verify the default value is valid (perhaps in debug mode only).
   //
   // {0}: Attribute variable name.
   // {1}: Attribute condition code.
   // {2}: Emit error prefix.
-  // {3}: Attribute/constraint description.
-  const char *const checkAttrCondition = R"(
+  // {3}: Attribute name.
+  // {4}: Attribute/constraint description.
+  const char *const verifyAttrInline = R"(
     if ({0} && !({1}))
       return {2}"attribute '{3}' failed to satisfy constraint: {4}");
-  )";
+  // Verify the attribute using a uniqued constraint. Can only be used within
+  // the context of an op.
+  //
+  // {0}: Unique constraint name.
+  // {1}: Attribute variable name.
+  // {2}: Attribute name.
+  const char *const verifyAttrUnique = R"(
+    if (::mlir::failed({0}(*this, {1}, "{2}")))
+      return ::mlir::failure();
+)";
 
   for (const auto &namedAttr : emit.getOp().getAttributes()) {
     const auto &attr = namedAttr.attr;
     StringRef attrName = namedAttr.name;
     if (attr.isDerivedAttr())
       continue;
 
     bool allowMissingAttr = attr.hasDefaultValue() || attr.isOptional();
     auto attrPred = attr.getPredicate();
     std::string condition = attrPred.isNull() ? "" : attrPred.getCondition();
     // If the attribute's condition needs an op but none is available, then the
     // condition cannot be emitted.
     bool canEmitCondition =
-        !StringRef(condition).contains("$_op") || emit.isUsingOp();
+        !condition.empty() &&
+        (!StringRef(condition).contains("$_op") || emit.isUsingOp());
 
     // Prefix with `tblgen_` to avoid hiding the attribute accessor.
     Twine varName = tblgenNamePrefix + attrName;
 
     // If the attribute is not required and we cannot emit the condition, then
     // there is nothing to be done.
     if (allowMissingAttr && !canEmitCondition)
       continue;
 
     body << formatv("  {\n    auto {0} = {1};", varName,
                     emit.getAttr(attrName));
 
     if (!allowMissingAttr) {
-      body << formatv(checkRequiredAttr, varName, emit.emitErrorPrefix(),
+      body << formatv(verifyRequiredAttr, varName, emit.emitErrorPrefix(),
                       attrName);
     }
     if (canEmitCondition) {
+      Optional<StringRef> constraintFn;
+      if (emit.isUsingOp() &&
+          (constraintFn = staticVerifierEmitter.getAttrConstraintFn(attr))) {
+        body << formatv(verifyAttrUnique, *constraintFn, varName, attrName);
+      } else {
         body << formatv(
-          checkAttrCondition, varName, tgfmt(condition, &ctx.withSelf(varName)),
+            verifyAttrInline, varName, tgfmt(condition, &ctx.withSelf(varName)),
             emit.emitErrorPrefix(), attrName, escapeString(attr.getSummary()));
       }
-    body << "}\n";
+    }
+    body << "  }\n";
   }
 }
 
 OpEmitter::OpEmitter(const Operator &op,
                      const StaticVerifierFunctionEmitter &staticVerifierEmitter)
     : def(op.getDef()), op(op),
       opClass(op.getCppClassName(), op.getExtraClassDeclaration()),
       staticVerifierEmitter(staticVerifierEmitter) {
void OpEmitter::genVerifier() {
   OpOrAdaptorHelper emit(op, /*isOp=*/true);
   genNativeTraitAttrVerifier(body, emit);
 
   auto *valueInit = def.getValueInit("verifier");
   StringInit *stringInit = dyn_cast<StringInit>(valueInit);
   bool hasCustomVerify = stringInit && !stringInit->getValue().empty();
   populateSubstitutions(emit, verifyCtx);
 
-  genAttributeVerifier(emit, verifyCtx, body);
+  genAttributeVerifier(emit, verifyCtx, body, staticVerifierEmitter);
   genOperandResultVerifier(body, op.getOperands(), "operand");
   genOperandResultVerifier(body, op.getResults(), "result");
 
   for (auto &trait : op.getTraits()) {
     if (auto *t = dyn_cast<tblgen::PredTrait>(&trait)) {
       body << tgfmt("  if (!($0))\n    "
                     "return emitOpError(\"failed to verify that $1\");\n",
                     &verifyCtx, tgfmt(t->getPredTemplate(), &verifyCtx),
void OpEmitter::genVerifier() {
   } else {
     body << "  return ::mlir::success();\n";
   }
 }
 
 void OpEmitter::genOperandResultVerifier(OpMethodBody &body,
                                          Operator::value_range values,
                                          StringRef valueKind) {
+  // Check that an optional value is at most 1 element.
+  //
+  // {0}: Value index.
+  // {1}: "operand" or "result"
+  const char *const verifyOptional = R"(
+    if (valueGroup{0}.size() > 1) {
+      return emitOpError("{1} group starting at #") << index
+          << " requires 0 or 1 element, but found " << valueGroup{0}.size();
+    }
+)";
+  // Check the types of a range of values.
+  //
+  // {0}: Value index.
+  // {1}: Type constraint function.
+  // {2}: "operand" or "result"
+  const char *const verifyValues = R"(
+    for (auto v : valueGroup{0}) {
+      if (::mlir::failed({1}(*this, v.getType(), "{2}", index++)))
+        return ::mlir::failure();
+    }
+)";
+
+  const auto canSkip = [](const NamedTypeConstraint &value) {
+    return !value.hasPredicate() && !value.isOptional() &&
+           !value.isVariadicOfVariadic();
+  };
+  if (values.empty() || llvm::all_of(values, canSkip))
+    return;
+
   FmtContext fctx;
 
-  body << "  {\n";
-  body << "    unsigned index = 0; (void)index;\n";
+  body << "  {\n    unsigned index = 0; (void)index;\n";
 
   for (auto staticValue : llvm::enumerate(values)) {
     const NamedTypeConstraint &value = staticValue.value();
 
     bool hasPredicate = value.hasPredicate();
     bool isOptional = value.isOptional();
     bool isVariadicOfVariadic = value.isVariadicOfVariadic();
     if (!hasPredicate && !isOptional && !isVariadicOfVariadic)
       continue;
     body << formatv("    auto valueGroup{2} = getODS{0}{1}s({2});\n",
                     // Capitalize the first letter to match the function name
                     valueKind.substr(0, 1).upper(), valueKind.substr(1),
                     staticValue.index());
 
     // If the constraint is optional check that the value group has at most 1
     // value.
     if (isOptional) {
-      body << formatv("    if (valueGroup{0}.size() > 1)\n"
-                      "      return emitOpError(\"{1} group starting at #\") "
-                      "<< index << \" requires 0 or 1 element, but found \" << "
-                      "valueGroup{0}.size();\n",
-                      staticValue.index(), valueKind);
+      body << formatv(verifyOptional, staticValue.index(), valueKind);
     } else if (isVariadicOfVariadic) {
       body << formatv(
           "    if (::mlir::failed(::mlir::OpTrait::impl::verifyValueSizeAttr("
           "*this, \"{0}\", \"{1}\", valueGroup{2}.size())))\n"
           "      return ::mlir::failure();\n",
           value.constraint.getVariadicOfVariadicSegmentSizeAttr(), value.name,
           staticValue.index());
     }
 
     // Otherwise, if there is no predicate there is nothing left to do.
     if (!hasPredicate)
       continue;
     // Emit a loop to check all the dynamic values in the pack.
     StringRef constraintFn =
         staticVerifierEmitter.getTypeConstraintFn(value.constraint);
-    body << "    for (::mlir::Value v : valueGroup" << staticValue.index()
-         << ") {\n"
-         << "      if (::mlir::failed(" << constraintFn
-         << "(getOperation(), v.getType(), \"" << valueKind << "\", index)))\n"
-         << "        return ::mlir::failure();\n"
-         << "      ++index;\n"
-         << "    }\n";
+    body << formatv(verifyValues, staticValue.index(), constraintFn, valueKind);
   }
 
   body << "  }\n";
 }
 
 void OpEmitter::genRegionVerifier(OpMethodBody &body) {
+  /// Code to verify a region.
+  ///
+  /// {0}: Getter for the regions.
+  /// {1}: The region constraint.
+  /// {2}: The region's name.
+  /// {3}: The region description.
+  const char *const verifyRegion = R"(
+    for (auto &region : {0})
+      if (::mlir::failed({1}(*this, region, "{2}", index++)))
+        return ::mlir::failure();
+)";
+  /// Get a single region.
+  ///
+  /// {0}: Reserved.
+  /// {1}: The region's index.
+  const char *const getSingleRegion =
+      "::llvm::makeMutableArrayRef((*this)->getRegion({1}))";
+
   // If we have no regions, there is nothing more to do.
-  unsigned numRegions = op.getNumRegions();
-  if (numRegions == 0)
+  const auto canSkip = [](const NamedRegion &region) {
+    return region.constraint.getPredicate().isNull();
+  };
+  auto regions = op.getRegions();
+  if (regions.empty() && llvm::all_of(regions, canSkip))
     return;
 
-  body << "{\n";
-  body << "    unsigned index = 0; (void)index;\n";
-
-  for (unsigned i = 0; i < numRegions; ++i) {
-    const auto &region = op.getRegion(i);
-    if (region.constraint.getPredicate().isNull())
+  body << "  {\n    unsigned index = 0; (void)index;\n";
+  for (auto it : llvm::enumerate(regions)) {
+    const auto &region = it.value();
+    if (canSkip(region))
       continue;
 
-    body << "    for (::mlir::Region &region : ";
-    body << formatv(region.isVariadic()
-                        ? "{0}()"
-                        : "::mlir::MutableArrayRef<::mlir::Region>((*this)"
-                          "->getRegion({1}))",
-                    op.getGetterName(region.name), i);
-    body << ") {\n";
-    auto constraint = tgfmt(region.constraint.getConditionTemplate(),
-                            &verifyCtx.withSelf("region"))
-                          .str();
-
-    body << formatv("      (void)region;\n"
-                    "      if (!({0})) {\n        "
-                    "return emitOpError(\"region #\") << index << \" {1}"
-                    "failed to "
-                    "verify constraint: {2}\";\n      }\n",
-                    constraint,
-                    region.name.empty() ? "" : "('" + region.name + "') ",
-                    region.constraint.getSummary())
-         << "      ++index;\n"
-         << "    }\n";
+    auto getRegion = formatv(region.isVariadic() ? "{0}()" : getSingleRegion,
+                             op.getGetterName(region.name), it.index());
+    auto constraintFn =
+        staticVerifierEmitter.getRegionConstraintFn(region.constraint);
+    body << formatv(verifyRegion, getRegion, constraintFn, region.name);
   }
   body << "  }\n";
 }
 
 void OpEmitter::genSuccessorVerifier(OpMethodBody &body) {
+  const char *const verifySuccessor = R"(
+    for (auto *successor : {0})
+      if (::mlir::failed({1}(*this, successor, "{2}", index++)))
+        return ::mlir::failure();
+)";
+  /// Get a single successor.
+  ///
+  /// {0}: The successor's name.
+  const char *const getSingleSuccessor = "::llvm::makeMutableArrayRef({0}())";
+
   // If we have no successors, there is nothing more to do.
-  unsigned numSuccessors = op.getNumSuccessors();
-  if (numSuccessors == 0)
+  const auto canSkip = [](const NamedSuccessor &successor) {
+    return successor.constraint.getPredicate().isNull();
+  };
+  auto successors = op.getSuccessors();
+  if (successors.empty() && llvm::all_of(successors, canSkip))
     return;
 
-  body << "{\n";
-  body << "    unsigned index = 0; (void)index;\n";
+  body << "  {\n    unsigned index = 0; (void)index;\n";
 
-  for (unsigned i = 0; i < numSuccessors; ++i) {
-    const auto &successor = op.getSuccessor(i);
-    if (successor.constraint.getPredicate().isNull())
+  for (auto it : llvm::enumerate(successors)) {
+    const auto &successor = it.value();
+    if (canSkip(successor))
       continue;
 
-    if (successor.isVariadic()) {
-      body << formatv("    for (::mlir::Block *successor : {0}()) {\n",
-                      successor.name);
-    } else {
-      body << "    {\n";
-      body << formatv("      ::mlir::Block *successor = {0}();\n",
-                      successor.name);
-    }
-    auto constraint = tgfmt(successor.constraint.getConditionTemplate(),
-                            &verifyCtx.withSelf("successor"))
-                          .str();
-
-    body << formatv("      (void)successor;\n"
-                    "      if (!({0})) {\n        "
-                    "return emitOpError(\"successor #\") << index << \"('{1}') "
-                    "failed to "
-                    "verify constraint: {2}\";\n      }\n",
-                    constraint, successor.name,
-                    successor.constraint.getSummary())
-         << "      ++index;\n"
-         << "    }\n";
+    auto getSuccessor =
+        formatv(successor.isVariadic() ? "{0}()" : getSingleSuccessor,
+                successor.name, it.index())
+    auto constraintFn =
+        staticVerifierEmitter.getSuccessorConstraintFn(successor.constraint);
+    body << formatv(verifySuccessor, getSuccessor, constraintFn,
+                    successor.name);
   }
   body << "  }\n";
 }
 
 /// Add a size count trait to the given operation class.
 static void addSizeCountTrait(OpClass &opClass, StringRef traitKind,
                               int numTotal, int numVariadic) {
   if (numVariadic != 0) {

 //===----------------------------------------------------------------------===//
 
 namespace {
 // Helper class to emit Op operand adaptors to an output stream.  Operand
 // adaptors are wrappers around ArrayRef<Value> that provide named operand
 // getters identical to those defined in the Op.
 class OpOperandAdaptorEmitter {
 public:
-  static void emitDecl(const Operator &op, raw_ostream &os);
-  static void emitDef(const Operator &op, raw_ostream &os);
+  static void emitDecl(const Operator &op,
+                       StaticVerifierFunctionEmitter &staticVerifierEmitter,
+                       raw_ostream &os);
+  static void emitDef(const Operator &op,
+                      StaticVerifierFunctionEmitter &staticVerifierEmitter,
+                      raw_ostream &os);
 
 private:
-  explicit OpOperandAdaptorEmitter(const Operator &op);
+  explicit OpOperandAdaptorEmitter(
+      const Operator &op, StaticVerifierFunctionEmitter &staticVerifierEmitter);
 
   // Add verification function. This generates a verify method for the adaptor
   // which verifies all the op-independent attribute constraints.
   void addVerification();
 
   const Operator &op;
   Class adaptor;
+  StaticVerifierFunctionEmitter &staticVerifierEmitter;
 };
 } // end anonymous namespace
 
-OpOperandAdaptorEmitter::OpOperandAdaptorEmitter(const Operator &op)
-    : op(op), adaptor(op.getAdaptorName()) {
+OpOperandAdaptorEmitter::OpOperandAdaptorEmitter(
+    const Operator &op, StaticVerifierFunctionEmitter &staticVerifierEmitter)
+    : op(op), adaptor(op.getAdaptorName()),
+      staticVerifierEmitter(staticVerifierEmitter) {
   adaptor.newField("::mlir::ValueRange", "odsOperands");
   adaptor.newField("::mlir::DictionaryAttr", "odsAttrs");
   adaptor.newField("::mlir::RegionRange", "odsRegions");
   const auto *attrSizedOperands =
       op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments");
   {
     SmallVector<OpMethodParameter, 2> paramList;
     paramList.emplace_back("::mlir::ValueRange", "values");
void OpOperandAdaptorEmitter::addVerification() {
   ERROR_IF_PRUNED(method, "verify", op);
   auto &body = method->body();
 
   OpOrAdaptorHelper emit(op, /*isOp=*/false);
   genNativeTraitAttrVerifier(body, emit);
   FmtContext verifyCtx;
   populateSubstitutions(emit, verifyCtx);
 
-  genAttributeVerifier(emit, verifyCtx, body);
+  genAttributeVerifier(emit, verifyCtx, body, staticVerifierEmitter);
 
   body << "  return ::mlir::success();";
 }
 
-void OpOperandAdaptorEmitter::emitDecl(const Operator &op, raw_ostream &os) {
-  OpOperandAdaptorEmitter(op).adaptor.writeDeclTo(os);
+void OpOperandAdaptorEmitter::emitDecl(
+    const Operator &op, StaticVerifierFunctionEmitter &staticVerifierEmitter,
+    raw_ostream &os) {
+  OpOperandAdaptorEmitter(op, staticVerifierEmitter).adaptor.writeDeclTo(os);
 }
 
-void OpOperandAdaptorEmitter::emitDef(const Operator &op, raw_ostream &os) {
-  OpOperandAdaptorEmitter(op).adaptor.writeDefTo(os);
+void OpOperandAdaptorEmitter::emitDef(
+    const Operator &op, StaticVerifierFunctionEmitter &staticVerifierEmitter,
+    raw_ostream &os) {
+  OpOperandAdaptorEmitter(op, staticVerifierEmitter).adaptor.writeDefTo(os);
 }
 
 // Emits the opcode enum and op classes.
 static void emitOpClasses(const RecordKeeper &recordKeeper,
                           const std::vector<Record *> &defs, raw_ostream &os,
                           bool emitDecl) {
   // First emit forward declaration for each class, this allows them to refer
   // to each others in traits for example.
static void emitOpClasses(const RecordKeeper &recordKeeper,
 
   IfDefScope scope("GET_OP_CLASSES", os);
   if (defs.empty())
     return;
 
   // Generate all of the locally instantiated methods first.
   StaticVerifierFunctionEmitter staticVerifierEmitter(recordKeeper, os);
   os << formatv(opCommentHeader, "Local Utility Method", "Definitions");
-  staticVerifierEmitter.emitFunctionsFor(
-      typeVerifierSignature, typeVerifierErrorHandler, /*typeArgName=*/"type",
-      defs, emitDecl);
+  staticVerifierEmitter.emitLocalFunctions(defs, emitDecl);
 
   for (auto *def : defs) {
     Operator op(*def);
     if (emitDecl) {
       {
         NamespaceEmitter emitter(os, op.getCppNamespace());
         os << formatv(opCommentHeader, op.getQualCppClassName(),
                       "declarations");
-        OpOperandAdaptorEmitter::emitDecl(op, os);
+        OpOperandAdaptorEmitter::emitDecl(op, staticVerifierEmitter, os);
         OpEmitter::emitDecl(op, os, staticVerifierEmitter);
       }
       // Emit the TypeID explicit specialization to have a single definition.
       if (!op.getCppNamespace().empty())
         os << "DECLARE_EXPLICIT_TYPE_ID(" << op.getCppNamespace()
            << "::" << op.getCppClassName() << ")\n\n";
     } else {
       {
         NamespaceEmitter emitter(os, op.getCppNamespace());
         os << formatv(opCommentHeader, op.getQualCppClassName(), "definitions");
-        OpOperandAdaptorEmitter::emitDef(op, os);
+        OpOperandAdaptorEmitter::emitDef(op, staticVerifierEmitter, os);
         OpEmitter::emitDef(op, os, staticVerifierEmitter);
       }
       // Emit the TypeID explicit specialization to have a single definition.
       if (!op.getCppNamespace().empty())
         os << "DEFINE_EXPLICIT_TYPE_ID(" << op.getCppNamespace()
            << "::" << op.getCppClassName() << ")\n\n";
     }
   }