Static verifier for type/attribute in DRR

[Chia-hungDuan]

Summary

Generate static function for matching the type/attribute to reduce the
memory footprint.

[Chia-hungDuan]

mlir/tools/mlir-tblgen/RewriterGen.cpp

743

I'm considering if we should have static function for attribute in DRR. The point is in the DRR code, we generate

"auto tblgen_attr = {0}->getAttrOfType<{1}>(\"{2}\");"

tblgen_attr will get the derived type rather than the base class mlir::Attribute and many attribute constraint function are having argument with derived type. For example,

in tensorflow/compiler/mlir/hlo/lib/utils/hlo_utils.{td|cc}

// Constraint that Attr has values [0, 1, ...].
def IdentityBroadcastDims : AttrConstraint<
    CPred<"hlo::IsSequenceStartingWith0($_self)">>;

bool IsSequenceStartingWith0(DenseIntElementsAttr attr)

Of course we can do the cast in the utility function, just not sure which way is better. In perspective of supporting Commutative, focusing on type may be enough at beginning.

BTW, in ODS, type is always mlir::Attribute.

[jpienaar]

mlir/tools/mlir-tblgen/RewriterGen.cpp

743

In the first part you say both get derived attribute type, that sounds good then.

For types, it is a TypeAttr storage wise I'm assuming, but else I'm missing how type and derived attribute interplay here. And also how that affects commutative.

Are you saying ODS and DRR casts differently and so reusing between them is difficult at the moment?

[Chia-hungDuan]

mlir/tools/mlir-tblgen/RewriterGen.cpp

743

It's not difficult and I'm just thinking if we can use Attribute it'll be easier and it'll align the predicate format with the cases in ODS.

PS. As mentioned here, https://llvm.discourse.group/t/self-will-be-the-base-type-of-the-entity-that-attaches-to-a-predicate/4367/3. we can use template to solve this issue.

[Chia-hungDuan]

Rebased

[Mogball]

Looks fine overall.

mlir/include/mlir/TableGen/CodeGenHelpers.h

137

I wouldn't make these functions inline. Also document these.

147–148

Document this

mlir/include/mlir/TableGen/Pattern.h

117

This could probably be public.

mlir/tools/mlir-tblgen/CodeGenHelpers.cpp

51

OpDef constraints are collected inside here, but pattern ones are collected outside this class and then passing in through emitConstraintMethods which seems inconsistent

82–83

Don't mark ArrayRef as const, and drop llvm::

84

name the raw_ostream as something else (maybe raw_os) and then name this one os

mlir/tools/mlir-tblgen/RewriterGen.cpp

679

Isn't operandIndex passed into the function?

1645

Since you've added DenseMapInfo for the other classes, why not add one for Constraint as well so that you don't have to use opaque pointers?

[Chia-hungDuan]

mlir/include/mlir/TableGen/Pattern.h

117

This is private in DagNode, do you think we need to change both of them to public?

mlir/tools/mlir-tblgen/CodeGenHelpers.cpp

51

That's true. I moved out this collection process. I think maybe we can have further refactoring on this architecture.

mlir/tools/mlir-tblgen/RewriterGen.cpp

679

Nice catch!

[Chia-hungDuan]

Address review comments

[Chia-hungDuan]

mlir/tools/mlir-tblgen/RewriterGen.cpp

1645

Sorry, missed this comment.

I think I was thinking this before but I forgot the exact reason now... Maybe it's just trying to align the style in StaticMatcherHelper. I think this can be refactored along with your change, what do you think?

[Chia-hungDuan]

fixed minor format

[Mogball]

mlir/tools/mlir-tblgen/RewriterGen.cpp

1645

Oh, it's because Constraint doesn't provide a default constructor.

[quinnp]

Hi @Chia-hungDuan, while doing PowerPC Linux release testing for LLVM 14.0.0-rc1 I encountered some differing object files between Phase2 and Phase3 of the bootstrap build:

# Comparing Phase 2 and Phase 3 files
file ArithmeticOps.cpp.o differs between phase 2 and phase 3
file TestPatterns.cpp.o differs between phase 2 and phase 3

I used git bisect to find that this patch was the first instance of the differing files. We are hoping to fix this for the LLVM 14.0.0 release. I've created this issue in the llvm project. It would be great if you could take a look at it. Thanks!

[Chia-hungDuan]

In D110199#3341510, @quinnp wrote:

Hi @Chia-hungDuan, while doing PowerPC Linux release testing for LLVM 14.0.0-rc1 I encountered some differing object files between Phase2 and Phase3 of the bootstrap build:

# Comparing Phase 2 and Phase 3 files
file ArithmeticOps.cpp.o differs between phase 2 and phase 3
file TestPatterns.cpp.o differs between phase 2 and phase 3

I used git bisect to find that this patch was the first instance of the differing files. We are hoping to fix this for the LLVM 14.0.0 release. I've created this issue in the llvm project. It would be great if you could take a look at it. Thanks!

Hi Quinn, thanks for letting me know. I'm checking it

[mehdi_amini]

I commented on the issue on GitHub : I don’t quite get how a change in MLIR can have any impact here: I suspect it is just triggering something else or it is non deterministic

[Chia-hungDuan]

Thanks, just saw it. I don't quite understand either. Let's move the discussion there

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 "mlir/TableGen/Format.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 class RecordKeeper;
 } // namespace llvm
 

 /// LogicalResult OpB::verify(...) {
 ///  if (failed(localVerify(...)))
 ///    return failure();
 ///  ...
 /// }
 ///
 class StaticVerifierFunctionEmitter {
 public:
-  StaticVerifierFunctionEmitter(const llvm::RecordKeeper &records,
-                                raw_ostream &os);
+  StaticVerifierFunctionEmitter(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.
-  void emitFunctionsFor(StringRef signatureFormat, StringRef errorHandlerFormat,
-                        StringRef typeArgName, ArrayRef<llvm::Record *> opDefs,
-                        bool emitDecl);
+
+  /// 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);
 
   /// 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);
-  StringRef getTypeConstraintFn(const Constraint &constraint) const;
+  StringRef getConstraintFn(const Constraint &constraint) const;
+
+  /// The setter to set `self` in format context.
+  StaticVerifierFunctionEmitter &setSelf(StringRef str);
+
+  /// The setter to set `builder` in format context.
+  StaticVerifierFunctionEmitter &setBuilder(StringRef str);
 
 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);
-
-  raw_indented_ostream os;
+  /// The format context used for building the verifier function.
+  FmtContext fctx;
 
   /// 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;

mlir/include/mlir/TableGen/Pattern.h

public:
 
   // Returns the string associated with the leaf.
   // Precondition: isStringAttr()
   std::string getStringAttr() const;
 
   void print(raw_ostream &os) const;
 
 private:
+  friend llvm::DenseMapInfo<DagLeaf>;
+  const void *getAsOpaquePointer() const { return def; }
+
   // Returns true if the TableGen Init `def` in this DagLeaf is a DefInit and
   // also a subclass of the given `superclass`.
   bool isSubClassOf(StringRef superclass) const;
 
   const llvm::Init *def;
 };
 
 // Wrapper class providing helper methods for accessing TableGen DAG constructs
struct DenseMapInfo<mlir::tblgen::DagNode> {
   }
   static unsigned getHashValue(mlir::tblgen::DagNode node) {
     return llvm::hash_value(node.getAsOpaquePointer());
   }
   static bool isEqual(mlir::tblgen::DagNode lhs, mlir::tblgen::DagNode rhs) {
     return lhs.node == rhs.node;
   }
 };
+
+template <>
+struct DenseMapInfo<mlir::tblgen::DagLeaf> {
+  static mlir::tblgen::DagLeaf getEmptyKey() {
+    return mlir::tblgen::DagLeaf(
+        llvm::DenseMapInfo<llvm::Init *>::getEmptyKey());
+  }
+  static mlir::tblgen::DagLeaf getTombstoneKey() {
+    return mlir::tblgen::DagLeaf(
+        llvm::DenseMapInfo<llvm::Init *>::getTombstoneKey());
+  }
+  static unsigned getHashValue(mlir::tblgen::DagLeaf leaf) {
+    return llvm::hash_value(leaf.getAsOpaquePointer());
+  }
+  static bool isEqual(mlir::tblgen::DagLeaf lhs, mlir::tblgen::DagLeaf rhs) {
+    return lhs.def == rhs.def;
+  }
+};
 } // end namespace llvm
 
 #endif // MLIR_TABLEGEN_PATTERN_H_

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: static ::mlir::LogicalResult static_dag_matcher_0
+// 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: if(failed([[$ATTR_CONSTRAINT]]
 
-// CHECK: if(failed(static_dag_matcher_0(rewriter, op1, tblgen_ops
+// CHECK: if(failed([[$DAG_MATCHER]](rewriter, op1, tblgen_ops
 def : Pat<(AOp (BOp I32Attr:$attr, I32:$int)),
           (AOp $int)>;
 
-// CHECK: if(failed(static_dag_matcher_0(rewriter, op1, tblgen_ops
+// 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/Format.h"
 #include "mlir/TableGen/Operator.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, raw_ostream &os)
-    : os(os), uniqueOutputLabel(getUniqueName(records)) {}
+    const llvm::RecordKeeper &records)
+    : uniqueOutputLabel(getUniqueName(records)) {}
 
-void StaticVerifierFunctionEmitter::emitFunctionsFor(
+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 typeArgName, ArrayRef<llvm::Record *> opDefs, bool emitDecl) {
+    StringRef cppNamespace, ArrayRef<const void *> constraints, raw_ostream &os,
+    bool emitDecl) {
   llvm::Optional<NamespaceEmitter> namespaceEmitter;
   if (!emitDecl)
-    namespaceEmitter.emplace(os, Operator(*opDefs[0]).getCppNamespace());
+    namespaceEmitter.emplace(os, cppNamespace);
 
-  emitTypeConstraintMethods(signatureFormat, errorHandlerFormat, typeArgName,
-                            opDefs, emitDecl);
+  emitConstraintMethods(signatureFormat, errorHandlerFormat, constraints, os,
+                        emitDecl);
 }
 
-StringRef StaticVerifierFunctionEmitter::getTypeConstraintFn(
+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) {
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(
+void StaticVerifierFunctionEmitter::emitConstraintMethods(
     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());
-  }
+    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;
-  FmtContext fctx;
-  for (auto it : llvm::enumerate(typeConstraints)) {
+  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 = getTypeConstraintFn(built).str();
+          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);
 
     // Only generate the methods if we are generating definitions.
     if (emitDecl)
       continue;
 
     os << formatv(signatureFormat.data(), name) << " {\n";
-    os.indent() << "if (!("
-                << tgfmt(constraint.getConditionTemplate(),
-                         &fctx.withSelf(typeArgName))
+    os.indent() << "if (!(" << tgfmt(constraint.getConditionTemplate(), &fctx)
                 << ")) {\n";
     os.indent() << "return "
-                << formatv(errorHandlerFormat.data(), constraint.getSummary())
+                << formatv(errorHandlerFormat.data(),
+                           escapeString(constraint.getSummary()))
                 << ";\n";
     os.unindent() << "}\nreturn ::mlir::success();\n";
     os.unindent() << "}\n\n";
   }
 }
 
 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

if (isOptional) {
           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);
+        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";
   }
if (emitDecl) {
     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, os);
+  StaticVerifierFunctionEmitter staticVerifierEmitter(recordKeeper);
   os << formatv(opCommentHeader, "Local Utility Method", "Definitions");
-  staticVerifierEmitter.emitFunctionsFor(
-      typeVerifierSignature, typeVerifierErrorHandler, /*typeArgName=*/"type",
-      defs, emitDecl);
+  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);
 
   for (auto *def : defs) {
     Operator op(*def);
     if (emitDecl) {
       {
         NamespaceEmitter emitter(os, op.getCppNamespace());
         os << formatv(opCommentHeader, op.getQualCppClassName(),
                       "declarations");

mlir/tools/mlir-tblgen/RewriterGen.cpp

 #include "mlir/TableGen/CodeGenHelpers.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/Operator.h"
 #include "mlir/TableGen/Pattern.h"
 #include "mlir/TableGen/Predicate.h"
 #include "mlir/TableGen/Type.h"
 #include "llvm/ADT/FunctionExtras.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormatAdapters.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Main.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 
 using namespace mlir;
 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:
   //===--------------------------------------------------------------------===//
 
   // Emits C++ statements for matching the DAG structure.
   void emitMatch(DagNode tree, StringRef name, int depth);
 
   // Emit C++ function call to static DAG matcher.
   void emitStaticMatchCall(DagNode tree, StringRef name);
 
+  // Emit C++ function call to static type/attribute constraint function.
+  void emitStaticVerifierCall(StringRef funcName, StringRef opName,
+                              StringRef arg, StringRef failureStr);
+
   // Emits C++ statements for matching using a native code call.
   void emitNativeCodeMatch(DagNode tree, StringRef name, int depth);
 
   // Emits C++ statements for matching the op constrained by the given DAG
   // `tree` returning the op's variable name.
   void emitOpMatch(DagNode tree, StringRef opName, int depth);
 
   // Emits C++ statements for matching the `argIndex`-th argument of the given
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(RecordOperatorMap &mapper);
+  StaticMatcherHelper(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);
+
   // 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);
 
+  // Emit all static functions for Constraints.
+  void populateStaticConstraintFunctions(raw_ostream &os);
+
 private:
   static constexpr unsigned kStaticMatcherThreshold = 1;
 
   // Consider two patterns as down below,
   //   DagNode_Root_A    DagNode_Root_B
   //       \                 \
   //     DagNode_C         DagNode_C
   //         \                 \
private:
   // After collecting all the DagNode in each pattern, `refStats` records the
   // number of users for each DagNode. We will generate the static matcher for a
   // DagNode while the number of users exceeds a certain threshold.
   DenseMap<DagNode, unsigned> refStats;
 
   // Number of static matcher generated. This is used to generate a unique name
   // for each DagNode.
   int staticMatcherCounter = 0;
+
+  // The DagLeaf which contains type or attr constraint.
+  DenseSet<DagLeaf> constraints;
+
+  // Static type/attribute verification function emitter.
+  StaticVerifierFunctionEmitter staticVerifierEmitter;
 };
 
 } // end anonymous namespace
 
 PatternEmitter::PatternEmitter(Record *pat, RecordOperatorMap *mapper,
                                raw_ostream &os, StaticMatcherHelper &helper)
     : loc(pat->getLoc()), opMap(mapper), pattern(pat, mapper),
       symbolInfoMap(pat->getLoc()), staticMatcherHelper(helper), nextValueId(0),
for (const auto &info : localSymbolMap) {
     os << formatv(", {0}", ret->second.getVarName(name));
   }
 
   os << "))) {\n";
   os.scope().os << "return ::mlir::failure();\n";
   os << "}\n";
 }
 
+void PatternEmitter::emitStaticVerifierCall(StringRef funcName,
+                                            StringRef opName, StringRef arg,
+                                            StringRef failureStr) {
+  os << formatv("if(failed({0}(rewriter, {1}, {2}, {3}))) {{\n", funcName,
+                opName, arg, failureStr);
+  os.scope().os << "return ::mlir::failure();\n";
+  os << "}\n";
+}
+
 // Helper function to match patterns.
 void PatternEmitter::emitNativeCodeMatch(DagNode tree, StringRef opName,
                                          int depth) {
   LLVM_DEBUG(llvm::dbgs() << "handle NativeCodeCall matcher pattern: ");
   LLVM_DEBUG(tree.print(llvm::dbgs()));
   LLVM_DEBUG(llvm::dbgs() << '\n');
 
   // The order of generating static matcher follows the topological order so
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);
-    emitMatchCheck(
-        opName,
-        tgfmt(constraint.getConditionTemplate(), &fmtCtx.withSelf(self)),
+    StringRef verifier = staticMatcherHelper.getVerifierName(constraint);
+    emitStaticVerifierCall(
+        verifier, opName, self,
         formatv("\"operand {0} of native code call '{1}' failed to satisfy "
                 "constraint: "
                 "'{2}'\"",
                 i, tree.getNativeCodeTemplate(),
-                escapeString(constraint.getSummary())));
+                escapeString(constraint.getSummary()))
+            .str());
   }
 
   LLVM_DEBUG(llvm::dbgs() << "done emitting match for native code call\n");
 }
 
 // Helper function to match patterns.
 void PatternEmitter::emitOpMatch(DagNode tree, StringRef opName, int depth) {
   Operator &op = tree.getDialectOp(opMap);
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}.getODSOperands({1}).begin()).getType()",
                           opName, operandIndex);
-      emitMatchCheck(
-          opName,
-          tgfmt(constraint.getConditionTemplate(), &fmtCtx.withSelf(self)),
-          formatv("\"operand {0} of op '{1}' failed to satisfy constraint: "
-                  "'{2}'\"",
-                  operand - op.operand_begin(), op.getOperationName(),
-                  escapeString(constraint.getSummary())));
+      StringRef verifier = staticMatcherHelper.getVerifierName(constraint);
+      emitStaticVerifierCall(
+          verifier, opName, self.str(),
+          formatv(
+              "\"operand {0} of op '{1}' failed to satisfy constraint: '{2}'\"",
+              operandIndex, op.getOperationName(),
+              escapeString(constraint.getSummary()))
+              .str());
     }
   }
 
   // Capture the value
   auto name = tree.getArgName(argIndex);
   // `$_` is a special symbol to ignore op argument matching.
   if (!name.empty() && name != "_") {
     // We need to subtract the number of attributes before this operand to get
void PatternEmitter::emitAttributeMatch(DagNode tree, StringRef opName,
   auto matcher = tree.getArgAsLeaf(argIndex);
   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 C++ statements to
-    // check the constraint.
-    emitMatchCheck(
-        opName,
-        tgfmt(matcher.getConditionTemplate(), &fmtCtx.withSelf("tblgen_attr")),
+    // If a constraint is specified, we need to generate function call to its
+    // static verifier.
+    StringRef verifier =
+        staticMatcherHelper.getVerifierName(matcher.getAsConstraint());
+    emitStaticVerifierCall(
+        verifier, opName, "tblgen_attr",
         formatv("\"op '{0}' attribute '{1}' failed to satisfy constraint: "
                 "'{2}'\"",
                 op.getOperationName(), namedAttr->name,
-                escapeString(matcher.getAsConstraint().getSummary())));
+                escapeString(matcher.getAsConstraint().getSummary()))
+            .str());
   }
 
   // Capture the value
   auto name = tree.getArgName(argIndex);
   // `$_` is a special symbol to ignore op argument matching.
   if (!name.empty() && name != "_") {
     os << formatv("{0} = tblgen_attr;\n", name);
   }
if (operand->isVariadic()) {
           os << symbol;
         }
       }
       os << ");\n";
     }
   }
 }
 
-StaticMatcherHelper::StaticMatcherHelper(RecordOperatorMap &mapper)
-    : opMap(mapper) {}
+StaticMatcherHelper::StaticMatcherHelper(const RecordKeeper &recordKeeper,
+                                         RecordOperatorMap &mapper)
+    : opMap(mapper), staticVerifierEmitter(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);
+}
+
 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
   // order.
   llvm::unique_function<void(DagNode)> dfs = [&](DagNode node) {
     ++refStats[node];
 
     if (refStats[node] != 1)
       return;
 
     for (unsigned i = 0, e = node.getNumArgs(); i < e; ++i)
       if (DagNode sibling = node.getArgAsNestedDag(i))
         dfs(sibling);
+      else {
+        DagLeaf leaf = node.getArgAsLeaf(i);
+        if (!leaf.isUnspecified())
+          constraints.insert(leaf);
+      }
 
     topologicalOrder.push_back(std::make_pair(node, record));
   };
 
   dfs(pat.getSourcePattern());
 }
 
+StringRef StaticMatcherHelper::getVerifierName(Constraint constraint) {
+  return staticVerifierEmitter.getConstraintFn(constraint);
+}
+
 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(recordOpMap);
+  StaticMatcherHelper staticMatcher(recordKeeper, recordOpMap);
   for (Record *p : patterns)
     staticMatcher.addPattern(p);
+  staticMatcher.populateStaticConstraintFunctions(os);
   staticMatcher.populateStaticMatchers(os);
 
   std::vector<std::string> rewriterNames;
   rewriterNames.reserve(patterns.size());
 
   std::string baseRewriterName = "GeneratedConvert";
   int rewriterIndex = 0;