[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

108–109

Heh.

[Mogball]

Fixing some comments and cleaning up code

[Mogball]

Actually updated the patch this time

[jpienaar]

mlir/include/mlir/TableGen/Predicate.h

66

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

66

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

[Mogball]

Rebase and review comments

[rriddle]

mlir/tools/mlir-tblgen/CodeGenHelpers.cpp

211–216

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

221–226

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

2338

Why?

[Mogball]

mlir/tools/mlir-tblgen/CodeGenHelpers.cpp

221–226

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

104

Why do we need the "Local" here?

159–160

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

205

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

mlir/tools/mlir-tblgen/CodeGenHelpers.cpp

193–194

Can we concatenate them?

234–240

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

104

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

159–160

Oh, yeah probably. I totally missed this.

205

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

234–240

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

234–240

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

256–257

One space between functions

311–314

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/Attribute.h

 namespace tblgen {
 class Dialect;
 class Type;
 
 // Wrapper class with helper methods for accessing attribute constraints defined
 // in TableGen.
 class AttrConstraint : public Constraint {
 public:
-  explicit AttrConstraint(const llvm::Record *record);
+  using Constraint::Constraint;
 
   static bool classof(const Constraint *c) { return c->getKind() == CK_Attr; }
 
   // Returns true if this constraint is a subclass of the given `className`
   // class defined in TableGen.
   bool isSubClassOf(StringRef className) const;
 };
 

mlir/include/mlir/TableGen/CodeGenHelpers.h

 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines common utilities for generating C++ from tablegen
 // structures.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TABLEGEN_CODEGENHELPERS_H
 #define MLIR_TABLEGEN_CODEGENHELPERS_H
 
-#include "mlir/Support/IndentedOstream.h"
 #include "mlir/TableGen/Dialect.h"
 #include "mlir/TableGen/Format.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 {
 namespace tblgen {
-
 class Constraint;
+class DagLeaf;
 
 // Simple RAII helper for defining ifdef-undef-endif scopes.
 class IfDefScope {
 public:
   IfDefScope(llvm::StringRef name, llvm::raw_ostream &os)
       : name(name.str()), os(os) {
     os << "#ifdef " << name << "\n"
        << "#undef " << name << "\n\n";

 /// LogicalResult OpB::verify(...) {
 ///  if (failed(localVerify(...)))
 ///    return failure();
 ///  ...
 /// }
 ///
 class StaticVerifierFunctionEmitter {
 public:
-  StaticVerifierFunctionEmitter(const llvm::RecordKeeper &records);
+  StaticVerifierFunctionEmitter(raw_ostream &os,
+                                const llvm::RecordKeeper &records);
 
-  /// 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.
-
-  /// This is the helper to generate the constraint functions from op
-  /// definitions.
-  void emitConstraintMethodsInNamespace(StringRef signatureFormat,
-                                        StringRef errorHandlerFormat,
-                                        StringRef cppNamespace,
-                                        ArrayRef<const void *> constraints,
-                                        raw_ostream &rawOs, bool emitDecl);
-
-  /// Emit the static functions for the giving type constraints.
-  void emitConstraintMethods(StringRef signatureFormat,
-                             StringRef errorHandlerFormat,
-                             ArrayRef<const void *> constraints,
-                             raw_ostream &rawOs, bool emitDecl);
+  /// Collect and unique all compatible type, attribute, successor, and region
+  /// constraints from the operations 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 emitOpConstraints(ArrayRef<llvm::Record *> opDefs, bool emitDecl);
 
-  /// Get the name of the local function used for the given type constraint.
+  /// Unique all compatible type and attribute constraints from a pattern file
+  /// and emit them at the top of the generated file.
+  ///
+  /// Constraints that do not meet the restriction that they can only reference
+  /// `$_self`, `$_op`, and `$_builder` are not uniqued.
+  void emitPatternConstraints(const DenseSet<DagLeaf> &constraints);
+
+  /// Get the name of the static 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);
-  StringRef getConstraintFn(const Constraint &constraint) const;
+  ///                 unsigned valueIndex);
+  ///
+  /// Pattern constraints have the form:
+  ///
+  ///   LogicalResult(PatternRewriter &rewriter, Operation *op, Type type,
+  ///                 StringRef failureStr);
+  ///
+  StringRef getTypeConstraintFn(const Constraint &constraint) const;
+
+  /// Get the name of the static 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.
+  ///
+  /// Pattern constraints have the form:
+  ///
+  ///   LogicalResult(PatternRewriter &rewriter, Operation *op, Attribute attr,
+  ///                 StringRef failureStr);
+  ///
+  Optional<StringRef> getAttrConstraintFn(const Constraint &constraint) const;
 
-  /// The setter to set `self` in format context.
-  StaticVerifierFunctionEmitter &setSelf(StringRef str);
+  /// Get the name of the static 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;
 
-  /// The setter to set `builder` in format context.
-  StaticVerifierFunctionEmitter &setBuilder(StringRef str);
+  /// Get the name of the static 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 static type constraint functions.
+  void emitTypeConstraints();
+  /// Emit static attribute constraint functions.
+  void emitAttrConstraints();
+  /// Emit static successor constraint functions.
+  void emitSuccessorConstraints();
+  /// Emit static region constraint functions.
+  void emitRegionConstraints();
+
+  /// Emit pattern constraints.
+  void emitPatternConstraints();
+
+  /// Collect and unique all the constraints used by operations.
+  void collectOpConstraints(ArrayRef<llvm::Record *> opDefs);
+  /// Collect and unique all pattern constraints.
+  void collectPatternConstraints(const DenseSet<DagLeaf> &constraints);
 
-  /// The format context used for building the verifier function.
-  FmtContext fctx;
+  /// The output stream.
+  raw_ostream &os;
 
   /// A unique label for the file currently being generated. This is used to
-  /// ensure that the local functions have a unique name.
+  /// ensure that the static 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);
+
+  /// Assign a unique name to a unique constraint.
+  std::string getUniqueName(StringRef kind, unsigned index);
+  /// Unique a constraint in the map.
+  void collectConstraint(ConstraintMap &map, StringRef kind,
+                         Constraint constraint);
+
+  /// The set of type constraints used for operand and result verification in
+  /// the current file.
+  ConstraintMap typeConstraints;
+  /// The set of attribute constraints used in the current file.
+  ConstraintMap attrConstraints;
+  /// The set of successor constraints used in the current file.
+  ConstraintMap successorConstraints;
+  /// The set of region constraints used in the current file.
+  ConstraintMap regionConstraints;
 };
 
 // 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 kind
+  enum Kind { CK_Attr, CK_Region, CK_Successor, CK_Type, CK_Uncategorized };
+
+  // Create a constraint with a TableGen definition and a kind.
+  Constraint(const llvm::Record *record, Kind kind) : def(record), kind(kind) {}
+  // Create a constraint with a TableGen definition, and infer the kind.
   Constraint(const llvm::Record *record);
 
+  /// Constraints are pointer-comparable.
   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;
 
 private:
   // What kind of constraint this is.
   Kind kind;
 };
 

mlir/include/mlir/TableGen/Predicate.h

public:
   // Get the predicate condition.  This may dispatch to getConditionImpl() of
   // the underlying predicate type.
   std::string getCondition() const;
 
   // Whether the predicate is a combination of other predicates, i.e. an
   // record of type CombinedPred.
   bool isCombined() const;
 
+  // Get the location of the predicate.
+  ArrayRef<llvm::SMLoc> getLoc() 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;
+  // Return true if the predicate is not null.
+  operator bool() const { return def; }
 
-protected:
-  friend llvm::DenseMapInfo<Pred>;
+  // Hash a predicate by its pointer value.
+  friend llvm::hash_code hash_value(Pred pred) {
+    return llvm::hash_value(pred.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/include/mlir/TableGen/Type.h

 
 namespace mlir {
 namespace tblgen {
 
 // Wrapper class with helper methods for accessing Type constraints defined in
 // TableGen.
 class TypeConstraint : public Constraint {
 public:
-  explicit TypeConstraint(const llvm::Record *record);
-  explicit TypeConstraint(const llvm::DefInit *init);
+  using Constraint::Constraint;
+
+  TypeConstraint(const llvm::DefInit *record);
 
   static bool classof(const Constraint *c) { return c->getKind() == CK_Type; }
 
   // Returns true if this is an optional type constraint.
   bool isOptional() const;
 
   // Returns true if this is a variadic type constraint.
   bool isVariadic() const;

mlir/lib/TableGen/Attribute.cpp

 // Returns the initializer's value as string if the given TableGen initializer
 // is a code or string initializer. Returns the empty StringRef otherwise.
 static StringRef getValueAsString(const Init *init) {
   if (const auto *str = dyn_cast<StringInit>(init))
     return str->getValue().trim();
   return {};
 }
 
-AttrConstraint::AttrConstraint(const Record *record)
-    : Constraint(Constraint::CK_Attr, record) {
-  assert(isSubClassOf("AttrConstraint") &&
-         "must be subclass of TableGen 'AttrConstraint' class");
-}
-
 bool AttrConstraint::isSubClassOf(StringRef className) const {
   return def->isSubClassOf(className);
 }
 
 Attribute::Attribute(const Record *record) : AttrConstraint(record) {
   assert(record->isSubClassOf("Attr") &&
          "must be subclass of TableGen 'Attr' class");
 }

mlir/lib/TableGen/Constraint.cpp

 
 #include "mlir/TableGen/Constraint.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace mlir;
 using namespace mlir::tblgen;
 
 Constraint::Constraint(const llvm::Record *record)
-    : def(record), kind(CK_Uncategorized) {
+    : Constraint(record, CK_Uncategorized) {
   // Look through OpVariable's to their constraint.
   if (def->isSubClassOf("OpVariable"))
     def = def->getValueAsDef("constraint");
+
   if (def->isSubClassOf("TypeConstraint")) {
     kind = CK_Type;
   } else if (def->isSubClassOf("AttrConstraint")) {
     kind = CK_Attr;
   } else if (def->isSubClassOf("RegionConstraint")) {
     kind = CK_Region;
   } else if (def->isSubClassOf("SuccessorConstraint")) {
     kind = CK_Successor;
   } else {
     assert(def->isSubClassOf("Constraint"));
   }
 }
 
-Constraint::Constraint(Kind kind, const llvm::Record *record)
-    : def(record), kind(kind) {
-  // Look through OpVariable's to their constraint.
-  if (def->isSubClassOf("OpVariable"))
-    def = def->getValueAsDef("constraint");
-}
-
 Pred Constraint::getPredicate() const {
   auto *val = def->getValue("predicate");
 
   // If no predicate is specified, then return the null predicate (which
   // corresponds to true).
   if (!val)
     return Pred();
 

mlir/lib/TableGen/Type.cpp

 #include "mlir/TableGen/Dialect.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace mlir;
 using namespace mlir::tblgen;
 
-TypeConstraint::TypeConstraint(const llvm::Record *record)
-    : Constraint(Constraint::CK_Type, record) {
-  assert(def->isSubClassOf("TypeConstraint") &&
-         "must be subclass of TableGen 'TypeConstraint' class");
-}
-
 TypeConstraint::TypeConstraint(const llvm::DefInit *init)
     : TypeConstraint(init->getDef()) {}
 
 bool TypeConstraint::isOptional() const {
   return def->isSubClassOf("Optional");
 }
 
 bool TypeConstraint::isVariadic() const {

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>())) && ([](::mlir::Type elementType) { return (true); }(type.cast<::mlir::ShapedType>().getElementType())))) {
-// CHECK-NEXT:    return op->emitOpError(valueKind) << " #" << valueGroupStartIndex << " must be tensor of any type values, but got " << type;
+// CHECK:       if (!(((type.isa<::mlir::TensorType>())) && ([](::mlir::Type elementType) { return (true); }(type.cast<::mlir::ShapedType>().getElementType())))) {
+// 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>())) && ([](::mlir::Type elementType) { return ((elementType.isF32())) || ((elementType.isSignlessInteger(32))); }(type.cast<::mlir::ShapedType>().getElementType())))) {
-// 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>())) && ([](::mlir::Type elementType) { return ((elementType.isF32())) || ((elementType.isSignlessInteger(32))); }(type.cast<::mlir::ShapedType>().getElementType())))) {
+// 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/test/mlir-tblgen/rewriter-static-matcher.td

def COp : NS_Op<"c_op", []> {
   );
 
   let results = (outs AnyInteger);
 }
 
 // Test static matcher for duplicate DagNode
 // ---
 
-// CHECK-DAG: static ::mlir::LogicalResult [[$TYPE_CONSTRAINT:__mlir_ods_local_type_constraint.*]]({{.*::mlir::Type typeOrAttr}}
-// CHECK-DAG: static ::mlir::LogicalResult [[$ATTR_CONSTRAINT:__mlir_ods_local_type_constraint.*]]({{.*::mlir::Attribute}}
-// CHECK-DAG: static ::mlir::LogicalResult [[$DAG_MATCHER:static_dag_matcher.*]](
-// CHECK: if(failed([[$TYPE_CONSTRAINT]]
+// CHECK: static ::mlir::LogicalResult [[$TYPE_CONSTRAINT:__mlir_ods_local_type_constraint.*]](
+// CHECK-NEXT: {{.*::mlir::Type type}}
+// CHECK: static ::mlir::LogicalResult [[$ATTR_CONSTRAINT:__mlir_ods_local_attr_constraint.*]](
+// CHECK-NEXT: {{.*::mlir::Attribute attr}}
+// CHECK: static ::mlir::LogicalResult [[$DAG_MATCHER:static_dag_matcher.*]](
 // CHECK: if(failed([[$ATTR_CONSTRAINT]]
+// CHECK: if(failed([[$TYPE_CONSTRAINT]]
 
 // CHECK: if(failed([[$DAG_MATCHER]](rewriter, op1, tblgen_ops
 def : Pat<(AOp (BOp I32Attr:$attr, I32:$int)),
           (AOp $int)>;
 
 // CHECK: if(failed([[$DAG_MATCHER]](rewriter, op1, tblgen_ops
 def : Pat<(COp $_, (BOp I32Attr:$attr, I32:$int)),
           (COp $attr, $int)>;

mlir/tools/mlir-tblgen/CodeGenHelpers.cpp

 //===- CodeGenHelpers.cpp - MLIR op definitions generator ---------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // OpDefinitionsGen uses the description of operations to generate C++
 // definitions for ops.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/TableGen/CodeGenHelpers.h"
 #include "mlir/TableGen/Operator.h"
+#include "mlir/TableGen/Pattern.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace llvm;
 using namespace mlir;
 using namespace mlir::tblgen;
 
-StaticVerifierFunctionEmitter::StaticVerifierFunctionEmitter(
-    const llvm::RecordKeeper &records)
-    : uniqueOutputLabel(getUniqueName(records)) {}
-
-StaticVerifierFunctionEmitter &
-StaticVerifierFunctionEmitter::setSelf(StringRef str) {
-  fctx.withSelf(str);
-  return *this;
-}
-
-StaticVerifierFunctionEmitter &
-StaticVerifierFunctionEmitter::setBuilder(StringRef str) {
-  fctx.withBuilder(str);
-  return *this;
-}
-
-void StaticVerifierFunctionEmitter::emitConstraintMethodsInNamespace(
-    StringRef signatureFormat, StringRef errorHandlerFormat,
-    StringRef cppNamespace, ArrayRef<const void *> constraints, raw_ostream &os,
-    bool emitDecl) {
-  llvm::Optional<NamespaceEmitter> namespaceEmitter;
-  if (!emitDecl)
-    namespaceEmitter.emplace(os, cppNamespace);
-
-  emitConstraintMethods(signatureFormat, errorHandlerFormat, constraints, os,
-                        emitDecl);
-}
-
-StringRef StaticVerifierFunctionEmitter::getConstraintFn(
-    const Constraint &constraint) const {
-  auto it = localTypeConstraints.find(constraint.getAsOpaquePointer());
-  assert(it != localTypeConstraints.end() && "expected valid constraint fn");
-  return it->second;
-}
-
-std::string StaticVerifierFunctionEmitter::getUniqueName(
-    const llvm::RecordKeeper &records) {
+/// Generate a unique label based on the current file name to prevent name
+/// collisions if multiple generated files are included at once.
+static std::string getUniqueOutputLabel(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::emitConstraintMethods(
-    StringRef signatureFormat, StringRef errorHandlerFormat,
-    ArrayRef<const void *> constraints, raw_ostream &rawOs, bool emitDecl) {
-  raw_indented_ostream os(rawOs);
-
-  // 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;
-  for (auto it : llvm::enumerate(constraints)) {
-    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 = getConstraintFn(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);
+StaticVerifierFunctionEmitter::StaticVerifierFunctionEmitter(
+    raw_ostream &os, const llvm::RecordKeeper &records)
+    : os(os), uniqueOutputLabel(getUniqueOutputLabel(records)) {}
 
-    // Only generate the methods if we are generating definitions.
-    if (emitDecl)
-      continue;
+void StaticVerifierFunctionEmitter::emitOpConstraints(
+    ArrayRef<llvm::Record *> opDefs, bool emitDecl) {
+  collectOpConstraints(opDefs);
+    return;
+
+  NamespaceEmitter namespaceEmitter(os, Operator(*opDefs[0]).getCppNamespace());
+  emitTypeConstraints();
+  emitAttrConstraints();
+  emitSuccessorConstraints();
+  emitRegionConstraints();
+}
+
+void StaticVerifierFunctionEmitter::emitPatternConstraints(
+    const DenseSet<DagLeaf> &constraints) {
+  collectPatternConstraints(constraints);
+  emitPatternConstraints();
+}
+
+//===----------------------------------------------------------------------===//
+// Constraint Getters
+
+StringRef StaticVerifierFunctionEmitter::getTypeConstraintFn(
+    const Constraint &constraint) const {
+  auto it = typeConstraints.find(constraint);
+  assert(it != typeConstraints.end() && "expected to find a type constraint");
+  return it->second;
+}
+
+// Find a uniqued attribute constraint. Since not all attribute constraints can
+// be uniqued, return None if one was not found.
+Optional<StringRef> StaticVerifierFunctionEmitter::getAttrConstraintFn(
+    const Constraint &constraint) const {
+  auto it = attrConstraints.find(constraint);
+  return it == attrConstraints.end() ? Optional<StringRef>()
+                                     : StringRef(it->second);
+}
 
-    os << formatv(signatureFormat.data(), name) << " {\n";
-    os.indent() << "if (!(" << tgfmt(constraint.getConditionTemplate(), &fctx)
-                << ")) {\n";
-    os.indent() << "return "
-                << formatv(errorHandlerFormat.data(),
-                           escapeString(constraint.getSummary()))
-                << ";\n";
-    os.unindent() << "}\nreturn ::mlir::success();\n";
-    os.unindent() << "}\n\n";
+StringRef StaticVerifierFunctionEmitter::getSuccessorConstraintFn(
+    const Constraint &constraint) const {
+  auto it = successorConstraints.find(constraint);
+  assert(it != successorConstraints.end() &&
+         "expected to find a sucessor constraint");
+  return it->second;
+}
+
+StringRef StaticVerifierFunctionEmitter::getRegionConstraintFn(
+    const Constraint &constraint) const {
+  auto it = regionConstraints.find(constraint);
+  assert(it != regionConstraints.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();
+}
+)";
+
+/// Code for a pattern type or attribute constraint.
+///
+/// {3}: "Type type" or "Attribute attr".
+static const char *const patternAttrOrTypeConstraintCode = R"(
+static ::mlir::LogicalResult {0}(
+    ::mlir::PatternRewriter &rewriter, ::mlir::Operation *op, ::mlir::{3},
+    ::llvm::StringRef failureStr) {
+  if (!({1})) {
+    return rewriter.notifyMatchFailure(op, [&](::mlir::Diagnostic &diag) {
+      diag << failureStr << ": {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(typeConstraints, "type", typeConstraintCode);
+}
+
+void StaticVerifierFunctionEmitter::emitAttrConstraints() {
+  emitConstraints(attrConstraints, "attr", attrConstraintCode);
+}
+
+void StaticVerifierFunctionEmitter::emitSuccessorConstraints() {
+  emitConstraints(successorConstraints, "successor", successorConstraintCode);
+}
+
+void StaticVerifierFunctionEmitter::emitRegionConstraints() {
+  emitConstraints(regionConstraints, "region", regionConstraintCode);
+}
+
+void StaticVerifierFunctionEmitter::emitPatternConstraints() {
+  FmtContext ctx;
+  ctx.withOp("*op").withBuilder("rewriter").withSelf("type");
+  for (auto &it : typeConstraints) {
+    os << formatv(patternAttrOrTypeConstraintCode, it.second,
+                  tgfmt(it.first.getConditionTemplate(), &ctx),
+                  it.first.getSummary(), "Type type");
+  }
+  ctx.withSelf("attr");
+  for (auto &it : attrConstraints) {
+    os << formatv(patternAttrOrTypeConstraintCode, it.second,
+                  tgfmt(it.first.getConditionTemplate(), &ctx),
+                  it.first.getSummary(), "Attribute attr");
+  }
+}
+
+//===----------------------------------------------------------------------===//
+// Constraint Uniquing
+
+using RecordDenseMapInfo = llvm::DenseMapInfo<const llvm::Record *>;
+
+Constraint StaticVerifierFunctionEmitter::ConstraintUniquer::getEmptyKey() {
+  return Constraint(RecordDenseMapInfo::getEmptyKey(),
+                    Constraint::CK_Uncategorized);
+}
+
+Constraint StaticVerifierFunctionEmitter::ConstraintUniquer::getTombstoneKey() {
+  return Constraint(RecordDenseMapInfo::getTombstoneKey(),
+                    Constraint::CK_Uncategorized);
+}
+
+unsigned StaticVerifierFunctionEmitter::ConstraintUniquer::getHashValue(
+    Constraint constraint) {
+  if (constraint == getEmptyKey())
+    return RecordDenseMapInfo::getHashValue(RecordDenseMapInfo::getEmptyKey());
+  if (constraint == getTombstoneKey()) {
+    return RecordDenseMapInfo::getHashValue(
+        RecordDenseMapInfo::getTombstoneKey());
+  }
+  return llvm::hash_combine(constraint.getPredicate(), constraint.getSummary());
+}
+
+bool StaticVerifierFunctionEmitter::ConstraintUniquer::isEqual(Constraint lhs,
+                                                               Constraint rhs) {
+  if (lhs == rhs)
+    return true;
+  if (lhs == getEmptyKey() || lhs == getTombstoneKey())
+    return false;
+  if (rhs == getEmptyKey() || rhs == getTombstoneKey())
+    return false;
+  return 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>");
+}
+
+std::string StaticVerifierFunctionEmitter::getUniqueName(StringRef kind,
+                                                         unsigned index) {
+  return ("__mlir_ods_local_" + kind + "_constraint_" + uniqueOutputLabel +
+          Twine(index))
+      .str();
+}
+
+void StaticVerifierFunctionEmitter::collectConstraint(ConstraintMap &map,
+                                                      StringRef kind,
+                                                      Constraint constraint) {
+  auto it = map.find(constraint);
+  if (it == map.end())
+    map.insert({constraint, getUniqueName(kind, map.size())});
+}
+
+void StaticVerifierFunctionEmitter::collectOpConstraints(
+    ArrayRef<Record *> opDefs) {
+  const auto collectTypeConstraints = [&](Operator::value_range values) {
+    for (const NamedTypeConstraint &value : values)
+      if (value.hasPredicate())
+        collectConstraint(typeConstraints, "type", value.constraint);
+  };
+
+  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(attrConstraints, "attr", namedAttr.attr);
+    }
+    /// Collect successor constraints.
+    for (const NamedSuccessor &successor : op.getSuccessors()) {
+      if (!successor.constraint.getPredicate().isNull()) {
+        collectConstraint(successorConstraints, "successor",
+                          successor.constraint);
+      }
+    }
+    /// Collect region constraints.
+    for (const NamedRegion &region : op.getRegions())
+      if (!region.constraint.getPredicate().isNull())
+        collectConstraint(regionConstraints, "region", region.constraint);
+  }
+}
+
+void StaticVerifierFunctionEmitter::collectPatternConstraints(
+    const DenseSet<DagLeaf> &constraints) {
+  for (auto &leaf : constraints) {
+    assert(leaf.isOperandMatcher() || leaf.isAttrMatcher());
+    collectConstraint(
+        leaf.isOperandMatcher() ? typeConstraints : attrConstraints,
+        leaf.isOperandMatcher() ? "type" : "attr", leaf.getAsConstraint());
   }
 }
 
+//===----------------------------------------------------------------------===//
+// 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, emitHelper.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 &emitHelper,
-                                 FmtContext &ctx, OpMethodBody &body) {
+static void genAttributeVerifier(
+    const OpOrAdaptorHelper &emitHelper, 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 : emitHelper.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") || emitHelper.isEmittingForOp();
+        !condition.empty() && (!StringRef(condition).contains("$_op") ||
+                               emitHelper.isEmittingForOp());
 
     // 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,
                     emitHelper.getAttr(attrName));
 
     if (!allowMissingAttr) {
-      body << formatv(checkRequiredAttr, varName, emitHelper.emitErrorPrefix(),
+      body << formatv(verifyRequiredAttr, varName, emitHelper.emitErrorPrefix(),
                       attrName);
     }
     if (canEmitCondition) {
-      body << formatv(checkAttrCondition, varName,
+      Optional<StringRef> constraintFn;
+      if (emitHelper.isEmittingForOp() &&
+          (constraintFn = staticVerifierEmitter.getAttrConstraintFn(attr))) {
+        body << formatv(verifyAttrUnique, *constraintFn, varName, attrName);
+      } else {
+        body << formatv(verifyAttrInline, varName,
                         tgfmt(condition, &ctx.withSelf(varName)),
                         emitHelper.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 emitHelper(op, /*isOp=*/true);
   genNativeTraitAttrVerifier(body, emitHelper);
 
   auto *valueInit = def.getValueInit("verifier");
   StringInit *stringInit = dyn_cast<StringInit>(valueInit);
   bool hasCustomVerify = stringInit && !stringInit->getValue().empty();
   populateSubstitutions(emitHelper, verifyCtx);
 
-  genAttributeVerifier(emitHelper, verifyCtx, body);
+  genAttributeVerifier(emitHelper, 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.getConstraintFn(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";
+        staticVerifierEmitter.getTypeConstraintFn(value.constraint);
+    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}: The region's index.
+  const char *const getSingleRegion =
+      "::llvm::makeMutableArrayRef((*this)->getRegion({0}))";
+
   // 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 = region.isVariadic()
+                         ? formatv("{0}()", op.getGetterName(region.name)).str()
+                         : formatv(getSingleRegion, it.index()).str();
+    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 emitHelper(op, /*isOp=*/false);
   genNativeTraitAttrVerifier(body, emitHelper);
   FmtContext verifyCtx;
   populateSubstitutions(emitHelper, verifyCtx);
 
-  genAttributeVerifier(emitHelper, verifyCtx, body);
+  genAttributeVerifier(emitHelper, 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.
   if (emitDecl) {
     os << "#if defined(GET_OP_CLASSES) || defined(GET_OP_FWD_DEFINES)\n";
     os << "#undef GET_OP_FWD_DEFINES\n";
     for (auto *def : defs) {
       Operator op(*def);
       NamespaceEmitter emitter(os, op.getCppNamespace());
       os << "class " << op.getCppClassName() << ";\n";
     }
     os << "#endif\n\n";
   }
 
   IfDefScope scope("GET_OP_CLASSES", os);
   if (defs.empty())
     return;
 
   // Generate all of the locally instantiated methods first.
-  StaticVerifierFunctionEmitter staticVerifierEmitter(recordKeeper);
+  StaticVerifierFunctionEmitter staticVerifierEmitter(os, recordKeeper);
   os << formatv(opCommentHeader, "Local Utility Method", "Definitions");
-  staticVerifierEmitter.setSelf("type");
-
-  // Collect a set of all of the used type constraints within the operation
-  // definitions.
-  llvm::SetVector<const void *> typeConstraints;
-  for (Record *def : defs) {
-    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());
-  }
-
-  staticVerifierEmitter.emitConstraintMethodsInNamespace(
-      typeVerifierSignature, typeVerifierErrorHandler,
-      Operator(*defs[0]).getCppNamespace(), typeConstraints.getArrayRef(), os,
-      emitDecl);
+  staticVerifierEmitter.emitOpConstraints(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";
     }
   }

mlir/tools/mlir-tblgen/RewriterGen.cpp

 using namespace mlir::tblgen;
 
 using llvm::formatv;
 using llvm::Record;
 using llvm::RecordKeeper;
 
 #define DEBUG_TYPE "mlir-tblgen-rewritergen"
 
-// The signature of static type verification function
-static const char *typeVerifierSignature =
-    "static ::mlir::LogicalResult {0}(::mlir::PatternRewriter &rewriter, "
-    "::mlir::Operation *op, ::mlir::Type typeOrAttr, "
-    "::llvm::StringRef failureStr)";
-
-// The signature of static attribute verification function
-static const char *attrVerifierSignature =
-    "static ::mlir::LogicalResult {0}(::mlir::PatternRewriter &rewriter, "
-    "::mlir::Operation *op, ::mlir::Attribute typeOrAttr, "
-    "::llvm::StringRef failureStr)";
-
-// The template of error handler in static type/attribute verification function
-static const char *verifierErrorHandler =
-    "rewriter.notifyMatchFailure(op, [&](::mlir::Diagnostic &diag) {\n  diag "
-    "<< failureStr <<  \": {0}\";\n});";
-
 namespace llvm {
 template <>
 struct format_provider<mlir::tblgen::Pattern::IdentifierLine> {
   static void format(const mlir::tblgen::Pattern::IdentifierLine &v,
                      raw_ostream &os, StringRef style) {
     os << v.first << ":" << v.second;
   }
 };
private:
   FmtContext fmtCtx;
 };
 
 // Tracks DagNode's reference multiple times across patterns. Enables generating
 // static matcher functions for DagNode's referenced multiple times rather than
 // inlining them.
 class StaticMatcherHelper {
 public:
-  StaticMatcherHelper(const RecordKeeper &recordKeeper,
+  StaticMatcherHelper(raw_ostream &os, const RecordKeeper &recordKeeper,
                       RecordOperatorMap &mapper);
 
   // Determine if we should inline the match logic or delegate to a static
   // function.
   bool useStaticMatcher(DagNode node) {
     return refStats[node] > kStaticMatcherThreshold;
   }
 
   // Get the name of the static DAG matcher function corresponding to the node.
   std::string getMatcherName(DagNode node) {
     assert(useStaticMatcher(node));
     return matcherNames[node];
   }
 
   // Get the name of static type/attribute verification function.
-  StringRef getVerifierName(Constraint constraint);
+  StringRef getVerifierName(DagLeaf leaf);
 
   // Collect the `Record`s, i.e., the DRR, so that we can get the information of
   // the duplicated DAGs.
   void addPattern(Record *record);
 
   // Emit all static functions of DAG Matcher.
   void populateStaticMatchers(raw_ostream &os);
 
for (int i = 0, e = tree.getNumArgs() - tail.numDirectives; i != e; ++i) {
 
     auto constraint = leaf.getAsConstraint();
 
     std::string self;
     if (leaf.isAttrMatcher() || leaf.isConstantAttr())
       self = argName;
     else
       self = formatv("{0}.getType()", argName);
-    StringRef verifier = staticMatcherHelper.getVerifierName(constraint);
+    StringRef verifier = staticMatcherHelper.getVerifierName(leaf);
     emitStaticVerifierCall(
         verifier, opName, self,
         formatv("\"operand {0} of native code call '{1}' failed to satisfy "
                 "constraint: "
                 "'{2}'\"",
                 i, tree.getNativeCodeTemplate(),
                 escapeString(constraint.getSummary()))
             .str());
if (!operandMatcher.isUnspecified()) {
     if (operand->constraint != constraint) {
       if (operand->isVariableLength()) {
         auto error = formatv(
             "further constrain op {0}'s variadic operand #{1} unsupported now",
             op.getOperationName(), argIndex);
         PrintFatalError(loc, error);
       }
       auto self = formatv("(*{0}.begin()).getType()", operandName);
-      StringRef verifier = staticMatcherHelper.getVerifierName(constraint);
+      StringRef verifier = staticMatcherHelper.getVerifierName(operandMatcher);
       emitStaticVerifierCall(
           verifier, opName, self.str(),
           formatv(
               "\"operand {0} of op '{1}' failed to satisfy constraint: '{2}'\"",
               operand - op.operand_begin(), op.getOperationName(),
               escapeString(constraint.getSummary()))
               .str());
     }
if (!matcher.isUnspecified()) {
     if (!matcher.isAttrMatcher()) {
       PrintFatalError(
           loc, formatv("the {1}-th argument of op '{0}' should be an attribute",
                        op.getOperationName(), argIndex + 1));
     }
 
     // If a constraint is specified, we need to generate function call to its
     // static verifier.
-    StringRef verifier =
-        staticMatcherHelper.getVerifierName(matcher.getAsConstraint());
+    StringRef verifier = staticMatcherHelper.getVerifierName(matcher);
     emitStaticVerifierCall(
         verifier, opName, "tblgen_attr",
         formatv("\"op '{0}' attribute '{1}' failed to satisfy constraint: "
                 "'{2}'\"",
                 op.getOperationName(), namedAttr->name,
                 escapeString(matcher.getAsConstraint().getSummary()))
             .str());
   }
if (operand->isVariadic()) {
           os << symbol;
         }
       }
       os << ");\n";
     }
   }
 }
 
-StaticMatcherHelper::StaticMatcherHelper(const RecordKeeper &recordKeeper,
+StaticMatcherHelper::StaticMatcherHelper(raw_ostream &os,
+                                         const RecordKeeper &recordKeeper,
                                          RecordOperatorMap &mapper)
-    : opMap(mapper), staticVerifierEmitter(recordKeeper) {}
+    : opMap(mapper), staticVerifierEmitter(os, recordKeeper) {}
 
 void StaticMatcherHelper::populateStaticMatchers(raw_ostream &os) {
   // PatternEmitter will use the static matcher if there's one generated. To
   // ensure that all the dependent static matchers are generated before emitting
   // the matching logic of the DagNode, we use topological order to achieve it.
   for (auto &dagInfo : topologicalOrder) {
     DagNode node = dagInfo.first;
     if (!useStaticMatcher(node))
       continue;
 
     std::string funcName =
         formatv("static_dag_matcher_{0}", staticMatcherCounter++);
     assert(matcherNames.find(node) == matcherNames.end());
     PatternEmitter(dagInfo.second, &opMap, os, *this)
         .emitStaticMatcher(node, funcName);
     matcherNames[node] = funcName;
   }
 }
 
 void StaticMatcherHelper::populateStaticConstraintFunctions(raw_ostream &os) {
-  llvm::SetVector<const void *> typeConstraints;
-  llvm::SetVector<const void *> attrConstraints;
-  for (DagLeaf leaf : constraints) {
-    if (leaf.isOperandMatcher()) {
-      typeConstraints.insert(leaf.getAsConstraint().getAsOpaquePointer());
-    } else {
-      assert(leaf.isAttrMatcher());
-      attrConstraints.insert(leaf.getAsConstraint().getAsOpaquePointer());
-    }
-  }
-
-  staticVerifierEmitter.setBuilder("rewriter").setSelf("typeOrAttr");
-
-  staticVerifierEmitter.emitConstraintMethods(typeVerifierSignature,
-                                              verifierErrorHandler,
-                                              typeConstraints.getArrayRef(), os,
-                                              /*emitDecl=*/false);
-
-  staticVerifierEmitter.emitConstraintMethods(attrVerifierSignature,
-                                              verifierErrorHandler,
-                                              attrConstraints.getArrayRef(), os,
-                                              /*emitDecl=*/false);
+  staticVerifierEmitter.emitPatternConstraints(constraints);
 }
 
 void StaticMatcherHelper::addPattern(Record *record) {
   Pattern pat(record, &opMap);
 
   // While generating the function body of the DAG matcher, it may depends on
   // other DAG matchers. To ensure the dependent matchers are ready, we compute
   // the topological order for all the DAGs and emit the DAG matchers in this
for (unsigned i = 0, e = node.getNumArgs(); i < e; ++i)
       }
 
     topologicalOrder.push_back(std::make_pair(node, record));
   };
 
   dfs(pat.getSourcePattern());
 }
 
-StringRef StaticMatcherHelper::getVerifierName(Constraint constraint) {
-  return staticVerifierEmitter.getConstraintFn(constraint);
+StringRef StaticMatcherHelper::getVerifierName(DagLeaf leaf) {
+  if (leaf.isAttrMatcher()) {
+    Optional<StringRef> constraint =
+        staticVerifierEmitter.getAttrConstraintFn(leaf.getAsConstraint());
+    assert(constraint.hasValue() && "attribute constraint was not uniqued");
+    return *constraint;
+  }
+  assert(leaf.isOperandMatcher());
+  return staticVerifierEmitter.getTypeConstraintFn(leaf.getAsConstraint());
 }
 
 static void emitRewriters(const RecordKeeper &recordKeeper, raw_ostream &os) {
   emitSourceFileHeader("Rewriters", os);
 
   const auto &patterns = recordKeeper.getAllDerivedDefinitions("Pattern");
 
   // We put the map here because it can be shared among multiple patterns.
   RecordOperatorMap recordOpMap;
 
   // Exam all the patterns and generate static matcher for the duplicated
   // DagNode.
-  StaticMatcherHelper staticMatcher(recordKeeper, recordOpMap);
+  StaticMatcherHelper staticMatcher(os, recordKeeper, recordOpMap);
   for (Record *p : patterns)
     staticMatcher.addPattern(p);
   staticMatcher.populateStaticConstraintFunctions(os);
   staticMatcher.populateStaticMatchers(os);
 
   std::vector<std::string> rewriterNames;
   rewriterNames.reserve(patterns.size());