[mlir][irdl] Add IRDL registration

[math-fehr]

Summary

This patch add support for loading IRDL dialects at runtime
with mlir-opt.

Given the following dialect.irdl file:

mlir
module {
  irdl.dialect @cmath {
    irdl.type @complex {
      %0 = irdl.is f32
      %1 = irdl.is f64
      %2 = irdl.any_of(%0, %1)
      irdl.parameters(%2)
    }

    irdl.operation @norm {
      %0 = irdl.any
      %1 = irdl.parametric @complex<%0>
      irdl.operands(%1)
      irdl.results(%0)
    }
}

the IRDL file can be loaded with the mlir-opt --irdl-file=dialect.irdl
command, and the following file can then be parsed:

mlir
func.func @conorm(%p: !cmath.complex<f32>, %q: !cmath.complex<f32>) -> f32 {
  %norm_p = "cmath.norm"(%p) : (!cmath.complex<f32>) -> f32
  %norm_q = "cmath.norm"(%q) : (!cmath.complex<f32>) -> f32
  %pq = arith.mulf %norm_p, %norm_q : f32
  return %pq : f32
}

To minimize the size of this patch, the operation, attribute, and type verifier are all always returning success().

Depends on D144692

[Mogball]

mlir/lib/Tools/mlir-opt/MlirOptMain.cpp

116

please spell out this auto

118

please emit this as an error through the MLIR context, using an UnknownLoc

135

165

please use empty

[Mogball]

mlir/lib/Tools/mlir-opt/MlirOptMain.cpp

140

why is this here?

[rriddle]

This patch seems to be doing a lot of things at once. I would split out registration in mlir-opt from the various IRDL things being added, and make things a bit more incremental, given the IRDL constructs could be tested via a test-pass (for example).

[Mogball]

mlir/include/mlir/Dialect/IRDL/IRDLVerifiers.h

38

please put public first and then private class members

77

same here

mlir/lib/Dialect/IRDL/IRDLRegistration.cpp

30

please use static instead of placing file-scope functions in an anonymous namespace

36

why append instead of <<?

44

56

we typically prefer unsigned to size_t

59

please spell out this auto, auto should only be used if the type is present verbatim on the right hand side of the assignment. Please audit all your autos and apply this change

mlir/lib/Dialect/IRDL/IRDLVerifiers.cpp

28

function_ref can be null

[rriddle]

mlir/lib/Dialect/IRDL/IR/IRDLOps.cpp

26

Prefer std::optional over llvm::Optional.

39

Can you use enumerate here instead?

mlir/lib/Dialect/IRDL/IRDLRegistration.cpp

26

Use static instead of anonymous namespaces for functions.

424

Use namespace qualifiers instead of wrapping namespaces in .cpp files: https://llvm.org/docs/CodingStandards.html#use-namespace-qualifiers-to-implement-previously-declared-functions

Same throughout the patch.

[math-fehr]

In D144693#4172489, @rriddle wrote:

This patch seems to be doing a lot of things at once. I would split out registration in mlir-opt from the various IRDL things being added, and make things a bit more incremental, given the IRDL constructs could be tested via a test-pass (for example).

Do you mean removing the MLIROptMain change for another patch, and then test the rest of the patch in a test-pass (I guess I can add features one by one, like first registration of types/attributes, then of operations).

If I'm correct, you are proposing to have a pass similar to the PDL one that register rewrites that are part of the file (with the -test-pdl-bytecode-pass pass). However, I couldn't do something similar with IRDL, since we cannot parse the entire file until the attributes are registered from what I understand.

Is that what you meant? I probably misunderstood something

[Mogball]

In D144693#4172706, @math-fehr wrote:

In D144693#4172489, @rriddle wrote:

This patch seems to be doing a lot of things at once. I would split out registration in mlir-opt from the various IRDL things being added, and make things a bit more incremental, given the IRDL constructs could be tested via a test-pass (for example).

Do you mean removing the MLIROptMain change for another patch, and then test the rest of the patch in a test-pass (I guess I can add features one by one, like first registration of types/attributes, then of operations).

If I'm correct, you are proposing to have a pass similar to the PDL one that register rewrites that are part of the file (with the -test-pdl-bytecode-pass pass). However, I couldn't do something similar with IRDL, since we cannot parse the entire file until the attributes are registered from what I understand.

Is that what you meant? I probably misunderstood something

I think you should find a logical way to split this patch up in general. One way would be to do the MlirOptMain registration in a separate patch and slowly land the interfaces/verification stuff. At least, I think the op verification can be tested separately (unless the dynamic dialect has to be registered before the ops are loaded?)

[math-fehr]

I think you should find a logical way to split this patch up in general. One way would be to do the MlirOptMain registration in a separate patch and slowly land the interfaces/verification stuff. At least, I think the op verification can be tested separately (unless the dynamic dialect has to be registered before the ops are loaded?)

Is it possible to register new dialects during a pass?
Alternatively, what I can do is first add the MlirOptMain registration, which would register only the dialect, and then add type/attributes, then operations. That way, we still keep the same workflow, we just add features one by one.
Would that work for you?

Also, do you want me to split further D144692 as well?

[Mogball]

IMO that would make sense to me. Anything to land these changes incrementally.

[math-fehr]

Thanks! I'll fix these issues, and split that patch to smaller pieces, to make this more incremental. I'll do this first thing tomorrow!

[math-fehr]

Address comments, and remove AttributeWrapper

[math-fehr]

I addressed all the code style comments, and move some code away.
In order to make this increasingly incremental, I'll move out completely the any_of operation from irdl, which should remove quite a lot of code.

mlir/lib/Dialect/IRDL/IRDLRegistration.cpp

59

I should have changed all the ones in my code, besides these two exceptions:

• Lambdas, since their operands are spelled out anyway
• for (auto [i, value] : enumerate(myIterator))

Is that correct, or should these as well be spelled outs?

mlir/lib/Tools/mlir-opt/MlirOptMain.cpp

140

From my understanding, multithreading needs to be disabled when we register dialects.
I added a better comment at the location where we disable multithreading.
Otherwise, I can only inject the thread pool after the registerIRDL call, if you think this is better?

[math-fehr]

Remove any_of from irdl

[math-fehr]

I removed any_of from irdl, to simplify the registration.
I still plan on simplifying this patch further though, and split it up in more pieces.

[math-fehr]

Remove verification of constraints

This should make the patch way smaller.
Now, while operations, types, and attributes are registered, they
are unconstrained, so they will always verify.

I'll add the constraints on a separate patch.

[math-fehr]

The patch should be way smaller now, I removed the verification logic, and will add it in a subsequent patch.

[mehdi_amini]

In D144693#4174249, @math-fehr wrote:

Is it possible to register new dialects during a pass?

No it isn't. We should runtime_error on this.

[math-fehr]

In D144693#4183080, @mehdi_amini wrote:

In D144693#4174249, @math-fehr wrote:

Is it possible to register new dialects during a pass?

No it isn't. We should runtime_error on this.

Is there a way to add a check for this? Currently, I'm removing the multi-threading, but I guess that you would like a concrete check?

[mehdi_amini]

In D144693#4183083, @math-fehr wrote:

Is there a way to add a check for this?

The check exists for non IRDL cases here: https://github.com/llvm/llvm-project/blob/9e0c2626f3d4282a135da112320139d9fba32fb5/mlir/lib/IR/MLIRContext.cpp#L444-L451
(despite the name, it'll kick in even if one disables multi-threading)

but I guess that you would like a concrete check?

Yes :)

mlir/include/mlir/Dialect/IRDL/IRDLRegistration.h

24

I feel like you're using "register" when it is actually more "loading" here.
(I'm not sure IRDL has a concept equivalent to "registering" dialects?)

mlir/include/mlir/Tools/mlir-opt/MlirOptMain.h

64

This method is deprecated and will be removed, can you rebase and use the MlirOptMainConfig instead?

mlir/lib/Dialect/IRDL/IR/IRDLOps.cpp

13

All these includes don't seem to belong to this patch anymore.

[mehdi_amini]

mlir/lib/Dialect/IRDL/IRDLRegistration.cpp

56

I strictly use signed int :)

mlir/lib/Tools/mlir-opt/MlirOptMain.cpp

140

You don't need to touch multi-threading to register/load dialects. These just aren't thread-safe APIs and shouldn't be used during PassManager execution

[math-fehr]

mlir/lib/Tools/mlir-opt/MlirOptMain.cpp

140

This is done during MlirOptMain though, before the PassManager is setup (from my understanding).
I recall having some non-deterministic bugs at some points, and disabling multithreading at the registration time was the solution.

So should this pass even with multithreading? Because what this function does is both a registration and a loading.

[mehdi_amini]

mlir/lib/Tools/mlir-opt/MlirOptMain.cpp

140

Multi-threading isn't a factor here: even if the thread pool has been created, there are no active threads in the context.
So unless your process is involving thread that's just fine.

[math-fehr]

Address additional comments

[mehdi_amini]

I feel like you're using "register" when it is actually more "loading" here. (I'm not sure IRDL has a concept equivalent to "registering" dialects?)

Coming back to this: how do we differentiate registering from loading in IRDL? Do you see some difference somehow?

[math-fehr]

In D144693#4186106, @mehdi_amini wrote:

I feel like you're using "register" when it is actually more "loading" here. (I'm not sure IRDL has a concept equivalent to "registering" dialects?)

Coming back to this: how do we differentiate registering from loading in IRDL? Do you see some difference somehow?

In IRDL, there are not really any registration, since the dialects are loaded right away, without going through the `DialectRegistry.
While there may be a way to allow registering without loading, I'm not completely sure what would be the actual benefits, and I'm not sure how easy this would be.

The way we *could* make this work with an actual benefit would be to keep the IRDL program in memory for the entire compilation process,
and to register our dialects in the DialectRegistry with just a pointer to the corresponding DialectOp. Then, we would actually do the
loading and the main registration logic only if the dialect is required.
This could work, though I didn't work on it since I'm not sure what would be the advantages yet.

mlir/include/mlir/Dialect/IRDL/IRDLRegistration.h

24

True, I changed it to "load'.
However, this is something I didn't really think about when writing the dynamic dialects,
so the dynamic dialects are still using the "register" terminology.

mlir/lib/Dialect/IRDL/IRDLRegistration.cpp

56

I moved them to unsigned in the meantime, what would be the best fit then?

[mehdi_amini]

In D144693#4186322, @math-fehr wrote:

In D144693#4186106, @mehdi_amini wrote:

I feel like you're using "register" when it is actually more "loading" here. (I'm not sure IRDL has a concept equivalent to "registering" dialects?)

Coming back to this: how do we differentiate registering from loading in IRDL? Do you see some difference somehow?

In IRDL, there are not really any registration, since the dialects are loaded right away, without going through the `DialectRegistry.
While there may be a way to allow registering without loading, I'm not completely sure what would be the actual benefits, and I'm not sure how easy this would be.

The main issue I was trying to solve when designing this in MLIR was to preserve consistency of the system: we can't run a pipeline that accidentally crash because a dialect wasn't loaded in the first place for example: passes will declare dialects they need as "dependent". We also didn't want to always load all dialects preemptively if not needed, and in particular to be allow to test everything (including the "getDependentDialect" for passes) we needed mlir-opt to not load any dialect that isn't in the input IR.

Now, I don't know how IRDL plays with passes actually? What is the kind of use-cases we'll have for IRDL in mlir-opt?

mlir/lib/Dialect/IRDL/IRDLRegistration.cpp

56

This is fine, you do as you prefer.

There is no rules in LLVM, so people like me will always used signed and others will prefer unsigned. So unfortunately we're inconsistent!

FYI, see my previous attempt to define a standard: https://discourse.llvm.org/t/rfc-coding-standards-prefer-int-for-regular-arithmetic-use-unsigned-only-for-bitmask-and-when-you-intend-to-rely-on-wrapping-behavior/52191

[math-fehr]

In D144693#4186106, @mehdi_amini wrote:

I feel like you're using "register" when it is actually more "loading" here. (I'm not sure IRDL has a concept equivalent to "registering" dialects?)

Coming back to this: how do we differentiate registering from loading in IRDL? Do you see some difference somehow?

In IRDL, there are not really any registration, since the dialects are loaded right away, without going through the `DialectRegistry.
While there may be a way to allow registering without loading, I'm not completely sure what would be the actual benefits, and I'm not sure how easy this would be.

The way we *could* make this work with an actual benefit would be to keep the IRDL program in memory for the entire compilation process,
and to register our dialects in the DialectRegistry with just a pointer to the corresponding DialectOp. Then, we would actually do the
loading and the main registration logic only if the dialect is required.
This could work, though I didn't work on it since I'm not sure what would be the advantages yet.

In D144693#4186792, @mehdi_amini wrote:

In D144693#4186322, @math-fehr wrote:

In D144693#4186106, @mehdi_amini wrote:

I feel like you're using "register" when it is actually more "loading" here. (I'm not sure IRDL has a concept equivalent to "registering" dialects?)

Coming back to this: how do we differentiate registering from loading in IRDL? Do you see some difference somehow?

In IRDL, there are not really any registration, since the dialects are loaded right away, without going through the `DialectRegistry.
While there may be a way to allow registering without loading, I'm not completely sure what would be the actual benefits, and I'm not sure how easy this would be.

The main issue I was trying to solve when designing this in MLIR was to preserve consistency of the system: we can't run a pipeline that accidentally crash because a dialect wasn't loaded in the first place for example: passes will declare dialects they need as "dependent". We also didn't want to always load all dialects preemptively if not needed, and in particular to be allow to test everything (including the "getDependentDialect" for passes) we needed mlir-opt to not load any dialect that isn't in the input IR.

Now, I don't know how IRDL plays with passes actually? What is the kind of use-cases we'll have for IRDL in mlir-opt?

My feeling is that we explicitly do not want a pass to depend on a specific IRDL dialect. In fact, this is already something that we do not want to have for DynamicDialect.
Having a pass relying on a dynamic dialect would be too dangerous and error-prone, and if you are already paying the cost of recompiling to write your pass, you are willing to pay the cost of compiling your dialect to C++ (in my opinion).
Also, manipulating IRDL dialects in C++ is a bit annoying, since you need to use the generic way of accessing operands/results/attributes, meaning that you have almost no guarantee that those operands/results/attributes exist in the first place.

However, having passes that use Traits or Interfaces to manipulate these dialects is something that is useful, though we would need to first add Traits and Interfaces to IRDL, which may be complex in some cases (since some heavily rely on C++ templates).

That being said, our objective with having IRDL in mlir-opt is to then be able to load PDL rewrites dynamically as well, to have a completely dynamic pipeline. Probably the transform dialect could be useful there as well.
This will of course require more work to make the interface nice enough for a user of mlir-opt.

[mehdi_amini]

My feeling is that we explicitly do not want a pass to depend on a specific IRDL dialect. In fact, this is already something that we do not want to have for DynamicDialect.
Having a pass relying on a dynamic dialect would be too dangerous and error-prone, and if you are already paying the cost of recompiling to write your pass, you are willing to pay the cost of compiling your dialect to C++ (in my opinion).
Also, manipulating IRDL dialects in C++ is a bit annoying, since you need to use the generic way of accessing operands/results/attributes, meaning that you have almost no guarantee that those operands/results/attributes exist in the first place.

Sure, but that means that no pass will every create entities (Operation/Type/Attribute) defined by an IRDL dialect? If you think otherwise: how would that happen?

That being said, our objective with having IRDL in mlir-opt is to then be able to load PDL rewrites dynamically as well, to have a completely dynamic pipeline. Probably the transform dialect could be useful there as well.
This will of course require more work to make the interface nice enough for a user of mlir-opt.

I'd have to think more about the whole consistency of the system, but we can punt on this for now :)

mlir/include/mlir/Tools/mlir-opt/MlirOptMain.h

32

[mehdi_amini]

This LGTM, but @rriddle and @Mogball had concerned earlier, it would be great if they could take another look here!

[math-fehr]

In D144693#4187242, @mehdi_amini wrote:

Sure, but that means that no pass will every create entities (Operation/Type/Attribute) defined by an IRDL dialect? If you think otherwise: how would that happen?

For now, I'm fine with this, since there are currently no big benefit on defining a dialect in IRDL if you want to write a C++ pass.
However, I agree that in the future, we might want to lift this in order to allow passes to create entities defined in IRDL, especially once we manage to get traits and interfaces in IRDL.

From my understanding though, mlir::Pass require to specify the dependent dialects as class names. This would probably need to be changed (or we would need a separate function),
if we would like to support this for IRDL. This is because we do not have a class for IRDL dialects, so we cannot just insert the dialects in the registry without knowing in which file
the dialects are defined.

That being said, our objective with having IRDL in mlir-opt is to then be able to load PDL rewrites dynamically as well, to have a completely dynamic pipeline. Probably the transform dialect could be useful there as well.
This will of course require more work to make the interface nice enough for a user of mlir-opt.

I'd have to think more about the whole consistency of the system, but we can punt on this for now :)

[math-fehr]

Update comment (register -> load)

[rriddle]

Looks like a good start to me

mlir/include/mlir/Dialect/IRDL/IRDLLoading.h

16–17 ↗

(On Diff #504477)

Can you use forward declarations here instead?

mlir/include/mlir/Tools/mlir-opt/MlirOptMain.h

37

Is the llvm:: here and above necessary?

mlir/lib/Dialect/IRDL/IRDLLoading.cpp

49–50 ↗

(On Diff #504477)

Is this comment wrapped properly at 80? It looks prematurely split.

mlir/lib/Tools/mlir-opt/MlirOptMain.cpp

133–135

166–169

[math-fehr]

Address comments

[Mogball]

sorry. Forgot I was blocking on this. LGTM

[math-fehr]

Rebase to latests LLVM, and attempt to fix compilation

mlir/include/mlir/Dialect/IRDL/IR/CMakeLists.txt

 add_mlir_dialect(IRDL irdl)
 
+# Add IRDL interfaces
+set(LLVM_TARGET_DEFINITIONS IRDLInterfaces.td)
+mlir_tablegen(IRDLInterfaces.h.inc -gen-op-interface-decls)
+mlir_tablegen(IRDLInterfaces.cpp.inc -gen-op-interface-defs)
+add_public_tablegen_target(MLIRIRDLInterfacesIncGen)
+add_dependencies(mlir-generic-headers MLIRIRDLInterfacesIncGen)
+
 # Add IRDL operations
 set(LLVM_TARGET_DEFINITIONS IRDLOps.td)
 mlir_tablegen(IRDLOps.h.inc -gen-op-decls)
 mlir_tablegen(IRDLOps.cpp.inc -gen-op-defs)
 add_public_tablegen_target(MLIRIRDLOpsIncGen)
 add_dependencies(mlir-generic-headers MLIRIRDLOpsIncGen)
 
 # Add IRDL types
 set(LLVM_TARGET_DEFINITIONS IRDLTypes.td)
 mlir_tablegen(IRDLTypesGen.h.inc -gen-typedef-decls)
 mlir_tablegen(IRDLTypesGen.cpp.inc -gen-typedef-defs)
 add_public_tablegen_target(MLIRIRDLTypesIncGen)
 add_dependencies(mlir-generic-headers MLIRIRDLTypesIncGen)

mlir/include/mlir/Dialect/IRDL/IR/IRDL.h

 //===- IRDL.h - IR Definition Language dialect ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the dialect for the IR Definition Language.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_IRDL_IR_IRDL_H_
 #define MLIR_DIALECT_IRDL_IR_IRDL_H_
 
+#include "mlir/Dialect/IRDL/IR/IRDLInterfaces.h"
 #include "mlir/Dialect/IRDL/IR/IRDLTraits.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/ExtensibleDialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/SymbolTable.h"

mlir/include/mlir/Dialect/IRDL/IR/IRDLInterfaces.h

+//===- IRDLInterfaces.h - IRDL interfaces definition ------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the interfaces used by the IRDL dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_IRDL_IR_IRDLINTERFACES_H_
+#define MLIR_DIALECT_IRDL_IR_IRDLINTERFACES_H_
+
+#include "mlir/Dialect/IRDL/IRDLVerifiers.h"
+#include "mlir/IR/BuiltinAttributes.h"
+#include "mlir/IR/Diagnostics.h"
+#include "mlir/IR/ExtensibleDialect.h"
+#include "mlir/IR/OpImplementation.h"
+#include "mlir/IR/Types.h"
+#include "mlir/Support/LogicalResult.h"
+#include <optional>
+
+namespace mlir {
+namespace irdl {
+class TypeOp;
+class AttributeOp;
+} // namespace irdl
+} // namespace mlir
+
+//===----------------------------------------------------------------------===//
+// IRDL Dialect Interfaces
+//===----------------------------------------------------------------------===//
+#include "mlir/Dialect/IRDL/IR/IRDLInterfaces.h.inc"
+
+#endif //  MLIR_DIALECT_IRDL_IR_IRDLINTERFACES_H_

mlir/include/mlir/Dialect/IRDL/IR/IRDLInterfaces.td

+//===- IRDLInterfaces.td - IRDL Attributes -----------------*- tablegen -*-===//
+//
+// 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 declares the interfaces used by IRDL.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_IRDL_IR_IRDLINTERFACES
+#define MLIR_DIALECT_IRDL_IR_IRDLINTERFACES
+
+include "mlir/IR/OpBase.td"
+
+def VerifyConstraintInterface : OpInterface<"VerifyConstraintInterface"> {
+  let cppNamespace = "::mlir::irdl";
+
+  let description = [{
+    Interface to get an IRDL constraint verifier from an operation. 
+  }];
+
+  let methods = [
+    InterfaceMethod<
+      [{
+        Get an instance of a constraint verifier for the associated operation."
+        Returns `nullptr` upon failure.
+      }],
+      "std::unique_ptr<::mlir::irdl::Constraint>",
+      "getVerifier",
+      (ins "mlir::SmallVector<Value> const&":$valueRes,
+      "llvm::DenseMap<mlir::irdl::TypeOp, std::unique_ptr<mlir::DynamicTypeDefinition>> &":$types,
+      "llvm::DenseMap<mlir::irdl::AttributeOp, std::unique_ptr<mlir::DynamicAttrDefinition>> &":$attrs)
+    >
+  ];
+}
+
+#endif // MLIR_DIALECT_IRDL_IR_IRDLINTERFACES

mlir/include/mlir/Dialect/IRDL/IR/IRDLOps.td

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_IRDL_IR_IRDLOPS
 #define MLIR_DIALECT_IRDL_IR_IRDLOPS
 
 include "IRDL.td"
 include "IRDLTypes.td"
+include "IRDLInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/IR/SymbolInterfaces.td"
 
 class IRDL_Op<string mnemonic, list<Trait> traits = []>
     : Op<IRDL_Dialect, mnemonic, traits> {
 }
 
def IRDL_ResultsOp : IRDL_Op<"results", [HasParent<"OperationOp">]> {
   let assemblyFormat = [{ `(` $args `)` attr-dict }];
 }
 
 //===----------------------------------------------------------------------===//
 // IRDL Constraint operations
 //===----------------------------------------------------------------------===//
 
 class IRDL_ConstraintOp<string mnemonic, list<Trait> traits = []>
-    : IRDL_Op<mnemonic, traits> {
+    : IRDL_Op<mnemonic, [VerifyConstraintInterface,
+        DeclareOpInterfaceMethods<VerifyConstraintInterface>] # traits> {
 }
 
 def IRDL_Is : IRDL_ConstraintOp<"is",
     [ParentOneOf<["TypeOp", "AttributeOp", "OperationOp"]>, Pure]> {
   let summary = "Constraints an attribute/type to be a specific attribute instance";
   let description = [{
     `irdl.is` defines a constraint that only accepts a specific instance of a
     type or attribute.

mlir/include/mlir/Dialect/IRDL/IRDLRegistration.h

+//===- IRDLRegistration.h - IRDL registration -------------------*- C++ -*-===//
+//
+// This file is licensed 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Manages the registration of MLIR objects from IRDL operations.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_IRDL_IRDLREGISTRATION_H
+#define MLIR_DIALECT_IRDL_IRDLREGISTRATION_H
+
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/Support/LogicalResult.h"
+
+namespace mlir {
+namespace irdl {
+
+/// Register all the dialects in a module.
+LogicalResult registerDialects(ModuleOp op);
+
+} // namespace irdl
+} // namespace mlir
+
+#endif // MLIR_DIALECT_IRDL_IRDLREGISTRATION_H

mlir/include/mlir/Dialect/IRDL/IRDLVerifiers.h

+//===- IRDLVerifiers.h - IRDL verifiers --------------------------- C++ -*-===//
+//
+// This file is licensed 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Verifiers for objects declared by IRDL.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_IRDL_IRDLVERIFIERS_H
+#define MLIR_DIALECT_IRDL_IRDLVERIFIERS_H
+
+#include "mlir/IR/ExtensibleDialect.h"
+#include "mlir/IR/Operation.h"
+#include "mlir/Support/LogicalResult.h"
+#include "llvm/ADT/ArrayRef.h"
+
+namespace mlir {
+namespace irdl {
+
+class Constraint;
+
+/// Provides context to the verification of constraints.
+/// It contains the assignment of variables to attributes, and the assignment
+/// of variables to constraints.
+class ConstraintVerifier {
+public:
+  ConstraintVerifier(ArrayRef<std::unique_ptr<Constraint>> constraints);
+
+  /// Check that a constraint is satisfied by an attribute.
+  ///
+  /// Constraints may call other constraint verifiers. If that is the case,
+  /// the constraint verifier will check if the variable is already assigned,
+  /// and if so, check that the attribute is the same as the one assigned.
+  /// If the variable is not assigned, the constraint verifier will
+  /// assign the attribute to the variable, and check that the constraint
+  /// is satisfied.
+  LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                       Attribute attr, unsigned variable);
+
+private:
+  /// The constraints that can be used for verification.
+  ArrayRef<std::unique_ptr<Constraint>> constraints;
+
+  /// The assignment of variables to attributes.
+  /// Variables that are non assigned are represented by a null attribute.
+  SmallVector<std::optional<mlir::Attribute>> assigned;
+};
+
+/// Once turned into IRDL verifiers, all constraints are
+/// attribute constraints. Type constraints are represented
+/// as `TypeAttr` attribute constraints to simplify verification.
+/// Verification that a type constraint must yield a
+/// `TypeAttr` attribute happens before conversion, at the MLIR level.
+class Constraint {
+public:
+  virtual ~Constraint() = default;
+
+  /// Check that an attribute is satisfying the constraint.
+  ///
+  /// Constraints may call other constraint verifiers. If that is the case,
+  /// the constraint verifier will check if the variable is already assigned,
+  /// and if so, check that the attribute is the same as the one assigned.
+  /// If the variable is not assigned, the constraint verifier will
+  /// assign the attribute to the variable, and check that the constraint
+  /// is satisfied.
+  virtual LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                               Attribute attr,
+                               ConstraintVerifier &context) const = 0;
+};
+
+/// A constraint that checks that an attribute is equal to a given attribute.
+class IsConstraint : public Constraint {
+public:
+  IsConstraint(Attribute expectedAttribute)
+      : expectedAttribute(expectedAttribute) {}
+
+  virtual ~IsConstraint() = default;
+
+  LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                       Attribute attr,
+                       ConstraintVerifier &context) const override;
+
+private:
+  Attribute expectedAttribute;
+};
+
+/// A constraint that checks that an attribute is of a
+/// specific dynamic attribute definition, and that all of its parameters
+/// satisfy the given constraints.
+class DynParametricAttrConstraint : public Constraint {
+public:
+  DynParametricAttrConstraint(DynamicAttrDefinition *attrDef,
+                              SmallVector<unsigned> constraints)
+      : attrDef(attrDef), constraints(std::move(constraints)) {}
+
+  virtual ~DynParametricAttrConstraint() = default;
+
+  LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                       Attribute attr,
+                       ConstraintVerifier &context) const override;
+
+private:
+  DynamicAttrDefinition *attrDef;
+  SmallVector<unsigned> constraints;
+};
+
+/// A constraint that checks that a type is of a specific dynamic type
+/// definition, and that all of its parameters satisfy the given constraints.
+class DynParametricTypeConstraint : public Constraint {
+public:
+  DynParametricTypeConstraint(DynamicTypeDefinition *typeDef,
+                              SmallVector<unsigned> constraints)
+      : typeDef(typeDef), constraints(std::move(constraints)) {}
+
+  virtual ~DynParametricTypeConstraint() = default;
+
+  LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                       Attribute attr,
+                       ConstraintVerifier &context) const override;
+
+private:
+  DynamicTypeDefinition *typeDef;
+  SmallVector<unsigned> constraints;
+};
+
+/// A constraint checking that one of the given constraints is satisfied.
+class AnyOfConstraint : public Constraint {
+public:
+  AnyOfConstraint(SmallVector<unsigned> constraints)
+      : constraints(std::move(constraints)) {}
+
+  virtual ~AnyOfConstraint() = default;
+
+  LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                       Attribute attr,
+                       ConstraintVerifier &context) const override;
+
+private:
+  SmallVector<unsigned> constraints;
+};
+
+/// A constraint checking that all of the given constraints are satisfied.
+class AllOfConstraint : public Constraint {
+public:
+  AllOfConstraint(SmallVector<unsigned> constraints)
+      : constraints(std::move(constraints)) {}
+
+  virtual ~AllOfConstraint() = default;
+
+  LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                       Attribute attr,
+                       ConstraintVerifier &context) const override;
+
+private:
+  SmallVector<unsigned> constraints;
+};
+
+/// A constraint that is always satisfied.
+class AnyAttributeConstraint : public Constraint {
+public:
+  virtual ~AnyAttributeConstraint() = default;
+
+  LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                       Attribute attr,
+                       ConstraintVerifier &context) const override;
+};
+
+} // namespace irdl
+} // namespace mlir
+
+#endif // MLIR_DIALECT_IRDL_IRDLVERIFIERS_H

mlir/include/mlir/Tools/mlir-opt/MlirOptMain.h

 class MemoryBuffer;
 } // namespace llvm
 
 namespace mlir {
 class DialectRegistry;
 class PassPipelineCLParser;
 class PassManager;
 
 /// This defines the function type used to setup the pass manager. This can be
 /// used to pass in a callback to setup a default pass pipeline to be applied on
 /// the loaded IR.
 using PassPipelineFn = llvm::function_ref<LogicalResult(PassManager &pm)>;
 
 /// Perform the core processing behind `mlir-opt`:
 /// - outputStream is the stream where the resulting IR is printed.
 /// - buffer is the in-memory file to parser and process.
 /// - passPipeline is the specification of the pipeline that will be applied.
 /// - registry should contain all the dialects that can be parsed in the source.
 /// - splitInputFile will look for a "-----" marker in the input file, and load
 /// each chunk in an individual ModuleOp processed separately.
 /// - verifyDiagnostics enables a verification mode where comments starting with
 /// "expected-(error|note|remark|warning)" are parsed in the input and matched
 /// against emitted diagnostics.
 /// - verifyPasses enables the IR verifier in-between each pass in the pipeline.
 /// - allowUnregisteredDialects allows to parse and create operation without
 /// registering the Dialect in the MLIRContext.
 /// - preloadDialectsInContext will trigger the upfront loading of all
 ///   dialects from the global registry in the MLIRContext. This option is
 ///   deprecated and will be removed soon.
 /// - emitBytecode will generate bytecode output instead of text.
 /// - implicitModule will enable implicit addition of a top-level
 /// 'builtin.module' if one doesn't already exist.
-/// - dumpPassPipeline will dump the pipeline being run to stderr
-LogicalResult
-MlirOptMain(llvm::raw_ostream &outputStream,
-            std::unique_ptr<llvm::MemoryBuffer> buffer,
-            const PassPipelineCLParser &passPipeline, DialectRegistry &registry,
-            bool splitInputFile, bool verifyDiagnostics, bool verifyPasses,
-            bool allowUnregisteredDialects,
-            bool preloadDialectsInContext = false, bool emitBytecode = false,
-            bool implicitModule = false, bool dumpPassPipeline = false);
+/// - dumpPassPipeline will dump the pipeline being run to stderr.
+/// - irdlFile is the path to an IRDL file to load.
+LogicalResult MlirOptMain(
+    llvm::raw_ostream &outputStream, std::unique_ptr<llvm::MemoryBuffer> buffer,
+    bool allowUnregisteredDialects, bool preloadDialectsInContext = false,
+    bool emitBytecode = false, bool implicitModule = false,
+    bool dumpPassPipeline = false, StringRef irdlFile = "");
 
 /// Support a callback to setup the pass manager.
 /// - passManagerSetupFn is the callback invoked to setup the pass manager to
 ///   apply on the loaded IR.
-LogicalResult MlirOptMain(
-    llvm::raw_ostream &outputStream, std::unique_ptr<llvm::MemoryBuffer> buffer,
-    PassPipelineFn passManagerSetupFn, DialectRegistry &registry,
-    bool splitInputFile, bool verifyDiagnostics, bool verifyPasses,
-    bool allowUnregisteredDialects, bool preloadDialectsInContext = false,
-    bool emitBytecode = false, bool implicitModule = false);
+LogicalResult MlirOptMain(llvm::raw_ostream &outputStream,
+                          std::unique_ptr<llvm::MemoryBuffer> buffer,
+                          PassPipelineFn passManagerSetupFn,
+                          DialectRegistry &registry, bool splitInputFile,
+                          bool verifyDiagnostics, bool verifyPasses,
+                          bool allowUnregisteredDialects,
+                          bool preloadDialectsInContext = false,
+                          bool emitBytecode = false,
+                          bool implicitModule = false, StringRef irdlFile = "");
 
 /// Implementation for tools like `mlir-opt`.
 /// - toolName is used for the header displayed by `--help`.
 /// - registry should contain all the dialects that can be parsed in the source.
 /// - preloadDialectsInContext will trigger the upfront loading of all
 ///   dialects from the global registry in the MLIRContext. This option is
 ///   deprecated and will be removed soon.
 LogicalResult MlirOptMain(int argc, char **argv, llvm::StringRef toolName,

mlir/lib/Dialect/IRDL/CMakeLists.txt

 add_mlir_dialect_library(MLIRIRDL
   IR/IRDL.cpp
   IR/IRDLOps.cpp
+  IRDLRegistration.cpp
+  IRDLVerifiers.cpp
 
   DEPENDS
   MLIRIRDLIncGen
   MLIRIRDLOpsIncGen
   MLIRIRDLTypesIncGen
 
   LINK_LIBS PUBLIC
   MLIRIR
   )

mlir/lib/Dialect/IRDL/IR/IRDL.cpp

 //===- IRDL.cpp - IRDL dialect ----------------------------------*- C++ -*-===//
 //
 // This file is licensed under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/IRDL/IR/IRDL.h"
+#include "mlir/Dialect/IRDL/IRDLRegistration.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/ExtensibleDialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/STLExtras.h"

 }
 
 LogicalResult DialectOp::verify() {
   if (!Dialect::isValidNamespace(getName()))
     return emitOpError("invalid dialect name");
   return success();
 }
 
+#include "mlir/Dialect/IRDL/IR/IRDLInterfaces.cpp.inc"
+
 #define GET_TYPEDEF_CLASSES
 #include "mlir/Dialect/IRDL/IR/IRDLTypesGen.cpp.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/IRDL/IR/IRDLOps.cpp.inc"

mlir/lib/Dialect/IRDL/IR/IRDLOps.cpp

 //===- IRDLOps.cpp - IRDL dialect -------------------------------*- C++ -*-===//
 //
 // This file is licensed under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/IRDL/IR/IRDL.h"
+#include "mlir/Support/LogicalResult.h"
+#include "mlir/Support/TypeID.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include <memory>
 
 using namespace mlir;
 using namespace mlir::irdl;
 
 DialectOp AttributeOp::getDialectOp() {
   return cast<DialectOp>(getOperation()->getParentOp());
 }
 
 DialectOp TypeOp::getDialectOp() {
   return cast<DialectOp>(getOperation()->getParentOp());
 }
+
+std::unique_ptr<Constraint> Is::getVerifier(
+    SmallVector<Value> const &valueToConstr,
+    DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> &types,
+    DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> &attrs) {
+  return std::make_unique<IsConstraint>(getExpectedAttr());
+}
+
+std::unique_ptr<Constraint> Parametric::getVerifier(
+    SmallVector<Value> const &valueToConstr,
+    DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> &types,
+    DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> &attrs) {
+  SmallVector<unsigned> constraints;
+  for (Value arg : getArgs()) {
+    for (auto [i, value] : enumerate(valueToConstr)) {
+      if (value == arg) {
+        constraints.push_back(i);
+        break;
+      }
+    }
+  }
+
+  // Symbol reference case for the base
+  SymbolRefAttr symRef = getBaseType();
+  Operation *defOp =
+      SymbolTable::lookupNearestSymbolFrom(getOperation(), symRef);
+  if (!defOp) {
+    emitError() << symRef << " does not refer to any existing symbol";
+    return nullptr;
+  }
+
+  if (auto typeOp = dyn_cast<TypeOp>(defOp))
+    return std::make_unique<DynParametricTypeConstraint>(types[typeOp].get(),
+                                                         constraints);
+
+  if (auto attrOp = dyn_cast<AttributeOp>(defOp))
+    return std::make_unique<DynParametricAttrConstraint>(attrs[attrOp].get(),
+                                                         constraints);
+
+  llvm_unreachable("verifier should ensure that the referenced operation is "
+                   "either a type or an attribute definition");
+}
+
+std::unique_ptr<Constraint> AnyOf::getVerifier(
+    SmallVector<Value> const &valueToConstr,
+    DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> &types,
+    DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> &attrs) {
+  SmallVector<unsigned> constraints;
+  for (Value arg : getArgs()) {
+    for (auto [i, value] : enumerate(valueToConstr)) {
+      if (value == arg) {
+        constraints.push_back(i);
+        break;
+      }
+    }
+  }
+
+  return std::make_unique<AnyOfConstraint>(constraints);
+}
+
+std::unique_ptr<Constraint> AllOf::getVerifier(
+    SmallVector<Value> const &valueToConstr,
+    DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> &types,
+    DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> &attrs) {
+  SmallVector<unsigned> constraints;
+  for (Value arg : getArgs()) {
+    for (auto [i, value] : enumerate(valueToConstr)) {
+      if (value == arg) {
+        constraints.push_back(i);
+        break;
+      }
+    }
+  }
+
+  return std::make_unique<AllOfConstraint>(constraints);
+}
+
+std::unique_ptr<Constraint> Any::getVerifier(
+    SmallVector<Value> const &valueToConstr,
+    DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> &types,
+    DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> &attrs) {
+  return std::make_unique<AnyAttributeConstraint>();
+}

mlir/lib/Dialect/IRDL/IRDLRegistration.cpp

+//===- IRDLRegistration.cpp - IRDL dialect registration ----------- C++ -*-===//
+//
+// This file is licensed 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Manages the registration of MLIR objects from IRDL operations.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/IRDL/IRDLRegistration.h"
+#include "mlir/Dialect/IRDL/IR/IRDL.h"
+#include "mlir/Dialect/IRDL/IR/IRDLInterfaces.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/ExtensibleDialect.h"
+#include "mlir/Support/LogicalResult.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/Support/SMLoc.h"
+
+using namespace mlir;
+using namespace mlir::irdl;
+
+/// Verify that the given list of parameters satisfy the given constraints.
+/// This encodes the logic of the verification method for attributes and types
+/// defined with IRDL.
+static LogicalResult
+irdlAttrOrTypeVerifier(function_ref<InFlightDiagnostic()> emitError,
+                       ArrayRef<Attribute> params,
+                       ArrayRef<std::unique_ptr<Constraint>> constraints,
+                       ArrayRef<size_t> paramConstraints) {
+  if (params.size() != paramConstraints.size()) {
+    emitError() << "expected " << paramConstraints.size()
+                << " type arguments, but had " << params.size();
+    return failure();
+  }
+
+  ConstraintVerifier verifier(constraints);
+
+  // Check that each parameter satisfies its constraint.
+  for (auto [i, param] : enumerate(params))
+    if (failed(verifier.verify(emitError, param, paramConstraints[i])))
+      return failure();
+
+  return success();
+}
+
+/// Verify that the given operation satisfies the given constraints.
+/// This encodes the logic of the verification method for operations defined
+/// with IRDL.
+static LogicalResult
+irdlOpVerifier(Operation *op, ArrayRef<std::unique_ptr<Constraint>> constraints,
+               ArrayRef<size_t> operandConstrs,
+               ArrayRef<size_t> resultConstrs) {
+  /// Check that we have the right number of operands.
+  unsigned numOperands = op->getNumOperands();
+  size_t numExpectedOperands = operandConstrs.size();
+  if (numOperands != numExpectedOperands)
+    return op->emitOpError(std::to_string(numExpectedOperands) +
+                           " operands expected, but got " +
+                           std::to_string(numOperands));
+
+  /// Check that we have the right number of results.
+  unsigned numResults = op->getNumResults();
+  size_t numExpectedResults = resultConstrs.size();
+  if (numResults != numExpectedResults)
+    return op->emitOpError(std::to_string(numExpectedResults) +
+                           " results expected, but got " +
+                           std::to_string(numResults));
+
+  auto emitError = [op]() { return op->emitError(); };
+
+  ConstraintVerifier verifier(constraints);
+
+  /// Check that all operands satisfy the constraints.
+  for (auto [i, operandType] : enumerate(op->getOperandTypes())) {
+    if (failed(verifier.verify({emitError}, TypeAttr::get(operandType),
+                               operandConstrs[i]))) {
+      return failure();
+    }
+  }
+
+  /// Check that all results satisfy the constraints.
+  for (auto [i, resultType] : enumerate(op->getResultTypes())) {
+    if (failed(verifier.verify({emitError}, TypeAttr::get(resultType),
+                               resultConstrs[i]))) {
+      return failure();
+    }
+  }
+
+  return success();
+}
+
+/// Define and register an operation represented by a `irdl.operation`
+/// operation.
+static WalkResult registerOperation(
+    OperationOp op, ExtensibleDialect *dialect,
+    DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> &types,
+    DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> &attrs) {
+  // Resolve SSA values to verifier constraint slots
+  SmallVector<Value> constrToValue;
+  for (Operation &op : op->getRegion(0).getOps()) {
+    if (isa<VerifyConstraintInterface>(op)) {
+      if (op.getNumResults() != 1) {
+        op.emitError()
+            << "IRDL constraint operations must have exactly one result";
+        return WalkResult::interrupt();
+      }
+      constrToValue.push_back(op.getResult(0));
+    }
+  }
+
+  // Build the verifiers for each constraint slot
+  SmallVector<std::unique_ptr<Constraint>> constraints;
+  for (Value v : constrToValue) {
+    VerifyConstraintInterface op =
+        cast<VerifyConstraintInterface>(v.getDefiningOp());
+    std::unique_ptr<Constraint> verifier =
+        op.getVerifier(constrToValue, types, attrs);
+    if (!verifier) {
+      return WalkResult::interrupt();
+    }
+    constraints.push_back(std::move(verifier));
+  }
+
+  SmallVector<size_t> operandConstraints;
+  SmallVector<size_t> resultConstraints;
+
+  // Gather which constraint slots correspond to operand constraints
+  auto operandsOp = op.getOp<OperandsOp>();
+  if (operandsOp.has_value()) {
+    operandConstraints.reserve(operandsOp->getArgs().size());
+    for (Value operand : operandsOp->getArgs()) {
+      for (auto [i, constr] : enumerate(constrToValue)) {
+        if (constr == operand) {
+          operandConstraints.push_back(i);
+          break;
+        }
+      }
+    }
+  }
+
+  // Gather which constraint slots correspond to result constraints
+  auto resultsOp = op.getOp<ResultsOp>();
+  if (resultsOp.has_value()) {
+    resultConstraints.reserve(resultsOp->getArgs().size());
+    for (Value result : resultsOp->getArgs()) {
+      for (auto [i, constr] : enumerate(constrToValue)) {
+        if (constr == result) {
+          resultConstraints.push_back(i);
+          break;
+        }
+      }
+    }
+  }
+
+  // IRDL does not support defining custom parsers or printers.
+  auto parser = [](OpAsmParser &parser, OperationState &result) {
+    return failure();
+  };
+  auto printer = [](Operation *op, OpAsmPrinter &printer, StringRef) {
+    printer.printGenericOp(op);
+  };
+
+  auto verifier =
+      [constraints{std::move(constraints)},
+       operandConstraints{std::move(operandConstraints)},
+       resultConstraints{std::move(resultConstraints)}](Operation *op) {
+        return irdlOpVerifier(op, constraints, operandConstraints,
+                              resultConstraints);
+      };
+
+  // IRDL does not support defining regions.
+  auto regionVerifier = [](Operation *op) { return success(); };
+
+  auto opDef = DynamicOpDefinition::get(
+      op.getName(), dialect, std::move(verifier), std::move(regionVerifier),
+      std::move(parser), std::move(printer));
+  dialect->registerDynamicOp(std::move(opDef));
+
+  return WalkResult::advance();
+}
+
+/// Get the verifier of a type or attribute definition.
+/// Return nullptr if the definition is invalid.
+static DynamicAttrDefinition::VerifierFn getAttrOrTypeVerifier(
+    Operation *attrOrTypeDef, ExtensibleDialect *dialect,
+    DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> &types,
+    DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> &attrs) {
+  assert((isa<AttributeOp>(attrOrTypeDef) || isa<TypeOp>(attrOrTypeDef)) &&
+         "Expected an attribute or type definition");
+
+  // Resolve SSA values to verifier constraint slots
+  SmallVector<Value> constrToValue;
+  for (Operation &op : attrOrTypeDef->getRegion(0).getOps()) {
+    if (isa<VerifyConstraintInterface>(op)) {
+      assert(op.getNumResults() == 1 &&
+             "IRDL constraint operations must have exactly one result");
+      constrToValue.push_back(op.getResult(0));
+    }
+  }
+
+  // Build the verifiers for each constraint slot
+  SmallVector<std::unique_ptr<Constraint>> constraints;
+  for (Value v : constrToValue) {
+    VerifyConstraintInterface op =
+        cast<VerifyConstraintInterface>(v.getDefiningOp());
+    std::unique_ptr<Constraint> verifier =
+        op.getVerifier(constrToValue, types, attrs);
+    if (!verifier) {
+      return {};
+    }
+    constraints.push_back(std::move(verifier));
+  }
+
+  // Get the parameter definitions.
+  std::optional<ParametersOp> params;
+  if (auto attr = dyn_cast<AttributeOp>(attrOrTypeDef))
+    params = attr.getOp<ParametersOp>();
+  else if (auto type = dyn_cast<TypeOp>(attrOrTypeDef))
+    params = type.getOp<ParametersOp>();
+
+  // Gather which constraint slots correspond to parameter constraints
+  SmallVector<size_t> paramConstraints;
+  if (params.has_value()) {
+    paramConstraints.reserve(params->getArgs().size());
+    for (Value param : params->getArgs()) {
+      for (auto [i, constr] : enumerate(constrToValue)) {
+        if (constr == param) {
+          paramConstraints.push_back(i);
+          break;
+        }
+      }
+    }
+  }
+
+  auto verifier = [paramConstraints{std::move(paramConstraints)},
+                   constraints{std::move(constraints)}](
+                      function_ref<InFlightDiagnostic()> emitError,
+                      ArrayRef<Attribute> params) {
+    return irdlAttrOrTypeVerifier(emitError, params, constraints,
+                                  paramConstraints);
+  };
+  return verifier;
+}
+
+/// Get the possible bases of a constraint. Return `true` if all bases can
+/// potentially be matched.
+/// A base is a type or an attribute definition. For instance, the base of
+/// `irdl.parametric "!builtin.complex"(...)` is `builtin.complex`.
+/// This function returns the following information through arguments:
+/// - `paramIds`: the set of type or attribute IDs that are used as bases.
+/// - `paramIrdlOps`: the set of IRDL operations that are used as bases.
+/// - `isIds`: the set of type or attribute IDs that are used in `irdl.is`
+///   constraints.
+static bool getBases(Operation *op, SmallPtrSet<TypeID, 4> &paramIds,
+                     SmallPtrSet<Operation *, 4> &paramIrdlOps,
+                     SmallPtrSet<TypeID, 4> &isIds) {
+  // For `irdl.any_of`, we get the bases from all its arguments.
+  if (auto anyOf = dyn_cast<AnyOf>(op)) {
+    bool has_any = false;
+    for (Value arg : anyOf.getArgs())
+      has_any &= getBases(arg.getDefiningOp(), paramIds, paramIrdlOps, isIds);
+    return has_any;
+  }
+
+  // For `irdl.all_of`, we get the bases from the first argument.
+  // This is restrictive, but we can relax it later if needed.
+  if (auto allOf = dyn_cast<AllOf>(op))
+    return getBases(allOf.getArgs()[0].getDefiningOp(), paramIds, paramIrdlOps,
+                    isIds);
+
+  // For `irdl.parametric`, we get directly the base from the operation.
+  if (auto params = dyn_cast<Parametric>(op)) {
+    SymbolRefAttr symRef = params.getBaseType();
+    Operation *defOp = SymbolTable::lookupNearestSymbolFrom(op, symRef);
+    assert(defOp && "symbol reference should refer to an existing operation");
+    paramIrdlOps.insert(defOp);
+    return false;
+  }
+
+  // For `irdl.is`, we get the base TypeID directly.
+  if (auto is = dyn_cast<Is>(op)) {
+    Attribute expected = is.getExpected();
+    isIds.insert(expected.getTypeID());
+    return false;
+  }
+
+  // For `irdl.any`, we return `false` since we can match any type or attribute
+  // base.
+  if (auto isA = dyn_cast<Any>(op))
+    return true;
+
+  llvm_unreachable("unknown IRDL constraint");
+}
+
+/// Check that an any_of is in the subset IRDL can handle.
+/// IRDL uses a greedy algorithm to match constraints. This means that if we
+/// encounter an `any_of` with multiple constraints, we will match the first
+/// constraint that is satisfied. Thus, the order of constraints matter in
+/// `any_of` with our current algorithm.
+/// In order to make the order of constraints irrelevant, we require that
+/// all `any_of` constraint parameters are disjoint. For this, we check that
+/// the base parameters are all disjoints between `parametric` operations, and
+/// that they are disjoint between `parametric` and `is` operations.
+/// This restriction will be relaxed in the future, when we will change our
+/// algorithm to be non-greedy.
+static LogicalResult checkCorrectAnyOf(AnyOf anyOf) {
+  SmallPtrSet<TypeID, 4> paramIds;
+  SmallPtrSet<Operation *, 4> paramIrdlOps;
+  SmallPtrSet<TypeID, 4> isIds;
+
+  for (Value arg : anyOf.getArgs()) {
+    Operation *argOp = arg.getDefiningOp();
+    SmallPtrSet<TypeID, 4> argParamIds;
+    SmallPtrSet<Operation *, 4> argParamIrdlOps;
+    SmallPtrSet<TypeID, 4> argIsIds;
+
+    // Get the bases of this argument. If it can match any type or attribute,
+    // then our `any_of` should not be allowed.
+    if (getBases(argOp, argParamIds, argParamIrdlOps, argIsIds))
+      return failure();
+
+    // We check that the base parameters are all disjoints between `parametric`
+    // operations, and that they are disjoint between `parametric` and `is`
+    // operations.
+    for (TypeID id : argParamIds) {
+      if (isIds.count(id))
+        return failure();
+      bool inserted = paramIds.insert(id).second;
+      if (!inserted)
+        return failure();
+    }
+
+    // We check that the base parameters are all disjoints with `irdl.is`
+    // operations.
+    for (TypeID id : isIds) {
+      if (paramIds.count(id))
+        return failure();
+      isIds.insert(id);
+    }
+
+    // We check that all `parametric` operations are disjoint. We do not
+    // need to check that they are disjoint with `is` operations, since
+    // `is` operations cannot refer to attributes defined with `irdl.parametric`
+    // operations.
+    for (Operation *op : argParamIrdlOps) {
+      bool inserted = paramIrdlOps.insert(op).second;
+      if (!inserted)
+        return failure();
+    }
+  }
+
+  return success();
+}
+
+/// Register all dialects in the given module, without registering any
+/// operation, type or attribute definitions.
+static DenseMap<DialectOp, ExtensibleDialect *>
+registerEmptyDialects(ModuleOp op) {
+  DenseMap<DialectOp, ExtensibleDialect *> dialects;
+  op.walk([&](DialectOp dialectOp) {
+    MLIRContext *ctx = dialectOp.getContext();
+    StringRef dialectName = dialectOp.getName();
+
+    DynamicDialect *dialect = ctx->getOrLoadDynamicDialect(
+        dialectName, [](DynamicDialect *dialect) {});
+
+    dialects.insert({dialectOp, dialect});
+  });
+  return dialects;
+}
+
+/// Preallocate type definitions objects with empty verifiers.
+/// This in particular allocates a TypeID for each type definition.
+static DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>>
+preallocateTypeDefs(ModuleOp op,
+                    DenseMap<DialectOp, ExtensibleDialect *> dialects) {
+  DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> typeDefs;
+  op.walk([&](TypeOp typeOp) {
+    ExtensibleDialect *dialect = dialects[typeOp.getDialectOp()];
+    auto typeDef = DynamicTypeDefinition::get(
+        typeOp.getName(), dialect,
+        [](function_ref<InFlightDiagnostic()>, ArrayRef<Attribute>) {
+          return success();
+        });
+    typeDefs.try_emplace(typeOp, std::move(typeDef));
+  });
+  return typeDefs;
+}
+
+/// Preallocate attribute definitions objects with empty verifiers.
+/// This in particular allocates a TypeID for each attribute definition.
+static DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>>
+preallocateAttrDefs(ModuleOp op,
+                    DenseMap<DialectOp, ExtensibleDialect *> dialects) {
+  DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> attrDefs;
+  op.walk([&](AttributeOp attrOp) {
+    ExtensibleDialect *dialect = dialects[attrOp.getDialectOp()];
+    auto attrDef = DynamicAttrDefinition::get(
+        attrOp.getName(), dialect,
+        [](function_ref<InFlightDiagnostic()>, ArrayRef<Attribute>) {
+          return success();
+        });
+    attrDefs.try_emplace(attrOp, std::move(attrDef));
+  });
+  return attrDefs;
+}
+
+LogicalResult mlir::irdl::registerDialects(ModuleOp op) {
+
+  // First, check that all any_of constraints are in a correct form.
+  // This is to ensure we can do the verification correctly.
+  WalkResult anyOfCorrects =
+      op.walk([](AnyOf anyOf) { return (WalkResult)checkCorrectAnyOf(anyOf); });
+  if (anyOfCorrects.wasInterrupted()) {
+    op.emitError("any_of constraints are not in the correct form");
+    return failure();
+  }
+
+  // Preallocate all dialects, and type and attribute definitions.
+  // In particular, this allocates TypeIDs so type and attributes can have
+  // verifiers that refer to each other.
+  DenseMap<DialectOp, ExtensibleDialect *> dialects = registerEmptyDialects(op);
+  DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> types =
+      preallocateTypeDefs(op, dialects);
+  DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> attrs =
+      preallocateAttrDefs(op, dialects);
+
+  // Set the verifier for types.
+  WalkResult res = op.walk([&](TypeOp typeOp) {
+    DynamicAttrDefinition::VerifierFn verifier = getAttrOrTypeVerifier(
+        typeOp, dialects[typeOp.getDialectOp()], types, attrs);
+    if (!verifier)
+      return WalkResult::interrupt();
+    types[typeOp]->setVerifyFn(std::move(verifier));
+    return WalkResult::advance();
+  });
+  if (res.wasInterrupted())
+    return failure();
+
+  // Set the verifier for attributes.
+  res = op.walk([&](AttributeOp attrOp) {
+    DynamicAttrDefinition::VerifierFn verifier = getAttrOrTypeVerifier(
+        attrOp, dialects[attrOp.getDialectOp()], types, attrs);
+    if (!verifier)
+      return WalkResult::interrupt();
+    attrs[attrOp]->setVerifyFn(std::move(verifier));
+    return WalkResult::advance();
+  });
+  if (res.wasInterrupted())
+    return failure();
+
+  // Define and register all operations.
+  res = op.walk([&](OperationOp opOp) {
+    return registerOperation(opOp, dialects[opOp.getDialectOp()], types, attrs);
+  });
+  if (res.wasInterrupted())
+    return failure();
+
+  // Register all types to their dialects.
+  for (auto &pair : types) {
+    ExtensibleDialect *dialect = dialects[pair.first.getDialectOp()];
+    dialect->registerDynamicType(std::move(pair.second));
+  }
+
+  // Register all attributes to their dialects.
+  for (auto &pair : attrs) {
+    ExtensibleDialect *dialect = dialects[pair.first.getDialectOp()];
+    dialect->registerDynamicAttr(std::move(pair.second));
+  }
+
+  return success();
+}

mlir/lib/Dialect/IRDL/IRDLVerifiers.cpp

+//===- IRDLVerifiers.cpp - IRDL verifiers ------------------------- C++ -*-===//
+//
+// This file is licensed 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Verifiers for objects declared by IRDL.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/IRDL/IRDLVerifiers.h"
+#include "mlir/Support/LogicalResult.h"
+#include "llvm/ADT/ArrayRef.h"
+
+using namespace mlir;
+using namespace mlir::irdl;
+
+ConstraintVerifier::ConstraintVerifier(
+    ArrayRef<std::unique_ptr<Constraint>> constraints)
+    : constraints(constraints), assigned() {
+  assigned.resize(this->constraints.size());
+}
+
+LogicalResult
+ConstraintVerifier::verify(function_ref<InFlightDiagnostic()> emitError,
+                           Attribute attr, unsigned variable) {
+
+  assert(variable < constraints.size() && "invalid constraint variable");
+
+  // If the variable is already assigned, check that the attribute is the same.
+  if (assigned[variable].has_value()) {
+    if (attr == assigned[variable].value())
+      return success();
+    else {
+      if (emitError)
+        return emitError() << "expected '" << assigned[variable].value()
+                           << "' but got '" << attr << "'";
+      return failure();
+    }
+  }
+
+  // Otherwise, check the constraint and assign the attribute to the variable.
+  LogicalResult result = constraints[variable]->verify(emitError, attr, *this);
+  if (succeeded(result))
+    assigned[variable] = attr;
+
+  return result;
+}
+
+LogicalResult IsConstraint::verify(function_ref<InFlightDiagnostic()> emitError,
+                                   Attribute attr,
+                                   ConstraintVerifier &context) const {
+  if (attr == expectedAttribute)
+    return success();
+
+  if (emitError)
+    return emitError() << "expected '" << expectedAttribute << "' but got '"
+                       << attr << "'";
+  return failure();
+}
+
+LogicalResult DynParametricAttrConstraint::verify(
+    function_ref<InFlightDiagnostic()> emitError, Attribute attr,
+    ConstraintVerifier &context) const {
+
+  // Check that the base is the expected one.
+  auto dynAttr = attr.dyn_cast<DynamicAttr>();
+  if (!dynAttr || dynAttr.getAttrDef() != attrDef) {
+    if (emitError) {
+      StringRef dialectName = attrDef->getDialect()->getNamespace();
+      StringRef attrName = attrDef->getName();
+      return emitError() << "expected base attribute '" << attrName << '.'
+                         << dialectName << "' but got '" << attr << "'";
+    }
+    return failure();
+  }
+
+  // Check that the parameters satisfy the constraints.
+  ArrayRef<Attribute> params = dynAttr.getParams();
+  if (params.size() != constraints.size()) {
+    if (emitError) {
+      StringRef dialectName = attrDef->getDialect()->getNamespace();
+      StringRef attrName = attrDef->getName();
+      emitError() << "attribute '" << dialectName << "." << attrName
+                  << "' expects " << params.size() << " parameters but got "
+                  << constraints.size();
+    }
+    return failure();
+  }
+
+  for (size_t i = 0, s = params.size(); i < s; i++)
+    if (failed(context.verify(emitError, params[i], constraints[i])))
+      return failure();
+
+  return success();
+}
+
+LogicalResult DynParametricTypeConstraint::verify(
+    function_ref<InFlightDiagnostic()> emitError, Attribute attr,
+    ConstraintVerifier &context) const {
+  // Check that the base is a TypeAttr.
+  auto typeAttr = attr.dyn_cast<TypeAttr>();
+  if (!typeAttr) {
+    if (emitError)
+      return emitError() << "expected type, got attribute '" << attr;
+    return failure();
+  }
+
+  // Check that the type base is the expected one.
+  auto dynType = typeAttr.getValue().dyn_cast<DynamicType>();
+  if (!dynType || dynType.getTypeDef() != typeDef) {
+    if (emitError) {
+      StringRef dialectName = typeDef->getDialect()->getNamespace();
+      StringRef attrName = typeDef->getName();
+      return emitError() << "expected base type '" << dialectName << '.'
+                         << attrName << "' but got '" << attr << "'";
+    }
+    return failure();
+  }
+
+  // Check that the parameters satisfy the constraints.
+  ArrayRef<Attribute> params = dynType.getParams();
+  if (params.size() != constraints.size()) {
+    if (emitError) {
+      StringRef dialectName = typeDef->getDialect()->getNamespace();
+      StringRef attrName = typeDef->getName();
+      emitError() << "attribute '" << dialectName << "." << attrName
+                  << "' expects " << params.size() << " parameters but got "
+                  << constraints.size();
+    }
+    return failure();
+  }
+
+  for (size_t i = 0, s = params.size(); i < s; i++)
+    if (failed(context.verify(emitError, params[i], constraints[i])))
+      return failure();
+
+  return success();
+}
+
+LogicalResult
+AnyOfConstraint::verify(function_ref<InFlightDiagnostic()> emitError,
+                        Attribute attr, ConstraintVerifier &context) const {
+  for (unsigned constr : constraints) {
+    // We do not pass the `emitError` here, since we want to emit an error
+    // only if none of the constraints are satisfied.
+    if (succeeded(context.verify({}, attr, constr))) {
+      return success();
+    }
+  }
+
+  if (emitError)
+    return emitError() << "'" << attr << "' does not satisfy the constraint";
+  return failure();
+}
+
+LogicalResult
+AllOfConstraint::verify(function_ref<InFlightDiagnostic()> emitError,
+                        Attribute attr, ConstraintVerifier &context) const {
+  for (unsigned constr : constraints) {
+    if (failed(context.verify(emitError, attr, constr))) {
+      return failure();
+    }
+  }
+
+  return success();
+}
+
+LogicalResult
+AnyAttributeConstraint::verify(function_ref<InFlightDiagnostic()> emitError,
+                               Attribute attr,
+                               ConstraintVerifier &context) const {
+  return success();
+}

mlir/lib/Tools/mlir-opt/MlirOptMain.cpp

 //===- MlirOptMain.cpp - MLIR Optimizer Driver ----------------------------===//
 //
 // 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 is a utility that runs an optimization pass and prints the result back
 // out. It is designed to support unit testing.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Tools/mlir-opt/MlirOptMain.h"
 #include "mlir/Bytecode/BytecodeWriter.h"
+#include "mlir/Dialect/IRDL/IR/IRDL.h"
+#include "mlir/Dialect/IRDL/IRDLRegistration.h"
 #include "mlir/IR/AsmState.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/Parser/Parser.h"
if (emitBytecode) {
     AsmState asmState(op.get(), OpPrintingFlags(), /*locationMap=*/nullptr,
                       &fallbackResourceMap);
     op.get()->print(os, asmState);
     os << '\n';
   }
   return success();
 }
 
+LogicalResult registerIRDL(StringRef irdlFile, MLIRContext &ctx) {
+  DialectRegistry registry;
+  registry.insert<irdl::IRDLDialect>();
+  ctx.appendDialectRegistry(registry);
+
+  // Set up the input file.
+  std::string errorMessage;
+  std::unique_ptr<MemoryBuffer> file = openInputFile(irdlFile, &errorMessage);
+  if (!file) {
+    emitError(UnknownLoc::get(&ctx)) << errorMessage;
+    return failure();
+  }
+
+  // Give the buffer to the source manager.
+  // This will be picked up by the parser.
+  SourceMgr sourceMgr;
+  sourceMgr.AddNewSourceBuffer(std::move(file), SMLoc());
+
+  SourceMgrDiagnosticHandler sourceMgrHandler(sourceMgr, &ctx);
+
+  // Disable multi-threading when parsing the input file. This removes the
+  // unnecessary/costly context synchronization when parsing.
+  // We also disable it during registration of the IRDL dialects.
+  bool wasThreadingEnabled = ctx.isMultithreadingEnabled();
+  ctx.disableMultithreading();
+
+  // Parse the input file.
+  OwningOpRef<ModuleOp> module(parseSourceFile<ModuleOp>(sourceMgr, &ctx));
+
+  // Register IRDL dialects.
+  if (irdl::registerDialects(module.get()).failed())
+    return failure();
+  ctx.enableMultithreading(wasThreadingEnabled);
+
+  return success();
+}
+
 /// Parses the memory buffer.  If successfully, run a series of passes against
 /// it and print the result.
 static LogicalResult
 processBuffer(raw_ostream &os, std::unique_ptr<MemoryBuffer> ownedBuffer,
               bool verifyDiagnostics, bool verifyPasses,
               bool allowUnregisteredDialects, bool preloadDialectsInContext,
               bool emitBytecode, bool implicitModule,
               PassPipelineFn passManagerSetupFn, DialectRegistry &registry,
-              llvm::ThreadPool *threadPool) {
+              llvm::ThreadPool *threadPool, StringRef irdlFile) {
   // Tell sourceMgr about this buffer, which is what the parser will pick up.
   auto sourceMgr = std::make_shared<SourceMgr>();
   sourceMgr->AddNewSourceBuffer(std::move(ownedBuffer), SMLoc());
 
   // Create a context just for the current buffer. Disable threading on creation
   // since we'll inject the thread-pool separately.
   MLIRContext context(registry, MLIRContext::Threading::DISABLED);
   if (threadPool)
     context.setThreadPool(*threadPool);
 
+  if (!irdlFile.empty()) {
+    if (failed(registerIRDL(irdlFile, context)))
+      return failure();
+  }
+
   // Parse the input file.
   if (preloadDialectsInContext)
     context.loadAllAvailableDialects();
   context.allowUnregisteredDialects(allowUnregisteredDialects);
   if (verifyDiagnostics)
     context.printOpOnDiagnostic(false);
   context.getDebugActionManager().registerActionHandler<DebugCounter>();
 
processBuffer(raw_ostream &os, std::unique_ptr<MemoryBuffer> ownedBuffer,
   (void)performActions(os, verifyDiagnostics, verifyPasses, sourceMgr, &context,
                        passManagerSetupFn, emitBytecode, implicitModule);
 
   // Verify the diagnostic handler to make sure that each of the diagnostics
   // matched.
   return sourceMgrHandler.verify();
 }
 
-LogicalResult mlir::MlirOptMain(raw_ostream &outputStream,
-                                std::unique_ptr<MemoryBuffer> buffer,
-                                PassPipelineFn passManagerSetupFn,
-                                DialectRegistry &registry, bool splitInputFile,
-                                bool verifyDiagnostics, bool verifyPasses,
-                                bool allowUnregisteredDialects,
-                                bool preloadDialectsInContext,
-                                bool emitBytecode, bool implicitModule) {
+LogicalResult mlir::MlirOptMain(
+    raw_ostream &outputStream, std::unique_ptr<MemoryBuffer> buffer,
+    PassPipelineFn passManagerSetupFn, DialectRegistry &registry,
+    bool splitInputFile, bool verifyDiagnostics, bool verifyPasses,
+    bool allowUnregisteredDialects, bool preloadDialectsInContext,
+    bool emitBytecode, bool implicitModule, StringRef irdlFile) {
   // The split-input-file mode is a very specific mode that slices the file
   // up into small pieces and checks each independently.
   // We use an explicit threadpool to avoid creating and joining/destroying
   // threads for each of the split.
   ThreadPool *threadPool = nullptr;
 
   // Create a temporary context for the sake of checking if
   // --mlir-disable-threading was passed on the command line.
   // We use the thread-pool this context is creating, and avoid
   // creating any thread when disabled.
   MLIRContext threadPoolCtx;
   if (threadPoolCtx.isMultithreadingEnabled())
     threadPool = &threadPoolCtx.getThreadPool();
 
   auto chunkFn = [&](std::unique_ptr<MemoryBuffer> chunkBuffer,
                      raw_ostream &os) {
     return processBuffer(os, std::move(chunkBuffer), verifyDiagnostics,
                          verifyPasses, allowUnregisteredDialects,
                          preloadDialectsInContext, emitBytecode, implicitModule,
-                         passManagerSetupFn, registry, threadPool);
+                         passManagerSetupFn, registry, threadPool, irdlFile);
   };
   return splitAndProcessBuffer(std::move(buffer), chunkFn, outputStream,
                                splitInputFile, /*insertMarkerInOutput=*/true);
 }
 
-LogicalResult mlir::MlirOptMain(
-    raw_ostream &outputStream, std::unique_ptr<MemoryBuffer> buffer,
-    const PassPipelineCLParser &passPipeline, DialectRegistry &registry,
-    bool splitInputFile, bool verifyDiagnostics, bool verifyPasses,
-    bool allowUnregisteredDialects, bool preloadDialectsInContext,
-    bool emitBytecode, bool implicitModule, bool dumpPassPipeline) {
+LogicalResult mlir::MlirOptMain(raw_ostream &outputStream,
+                                std::unique_ptr<MemoryBuffer> buffer,
+                                const PassPipelineCLParser &passPipeline,
+                                DialectRegistry &registry, bool splitInputFile,
+                                bool verifyDiagnostics, bool verifyPasses,
+                                bool allowUnregisteredDialects,
+                                bool preloadDialectsInContext,
+                                bool emitBytecode, bool implicitModule,
+                                bool dumpPassPipeline, StringRef irdlFile) {
   auto passManagerSetupFn = [&](PassManager &pm) {
     auto errorHandler = [&](const Twine &msg) {
       emitError(UnknownLoc::get(pm.getContext())) << msg;
       return failure();
     };
     if (failed(passPipeline.addToPipeline(pm, errorHandler)))
       return failure();
     if (dumpPassPipeline) {
       pm.dump();
       llvm::errs() << "\n";
     }
     return success();
   };
   return MlirOptMain(outputStream, std::move(buffer), passManagerSetupFn,
                      registry, splitInputFile, verifyDiagnostics, verifyPasses,
                      allowUnregisteredDialects, preloadDialectsInContext,
-                     emitBytecode, implicitModule);
+                     emitBytecode, implicitModule, irdlFile);
 }
 
 LogicalResult mlir::MlirOptMain(int argc, char **argv, llvm::StringRef toolName,
                                 DialectRegistry &registry,
                                 bool preloadDialectsInContext) {
   static cl::opt<std::string> inputFilename(
       cl::Positional, cl::desc("<input file>"), cl::init("-"));
 
static cl::opt<bool> noImplicitModule{
       cl::desc(
           "Disable implicit addition of a top-level module op during parsing"),
       cl::init(false)};
 
   static cl::opt<bool> dumpPassPipeline{
       "dump-pass-pipeline", cl::desc("Print the pipeline that will be run"),
       cl::init(false)};
 
+  static cl::opt<std::string> irdlFile("irdl-file", cl::desc("IRDL file"),
+                                       cl::value_desc("filename"));
+
   InitLLVM y(argc, argv);
 
   // Register any command line options.
   registerAsmPrinterCLOptions();
   registerMLIRContextCLOptions();
   registerPassManagerCLOptions();
   registerDefaultTimingManagerCLOptions();
   DebugCounter::registerCLOptions();
if (!output) {
     llvm::errs() << errorMessage << "\n";
     return failure();
   }
 
   if (failed(MlirOptMain(output->os(), std::move(file), passPipeline, registry,
                          splitInputFile, verifyDiagnostics, verifyPasses,
                          allowUnregisteredDialects, preloadDialectsInContext,
                          emitBytecode, /*implicitModule=*/!noImplicitModule,
-                         dumpPassPipeline)))
+                         dumpPassPipeline, irdlFile)))
     return failure();
 
   // Keep the output file if the invocation of MlirOptMain was successful.
   output->keep();
   return success();
 }

mlir/test/Dialect/IRDL/cyclic-types.mlir

+// RUN: mlir-opt %s --irdl-file=%S/cyclic-types.irdl.mlir -split-input-file -verify-diagnostics | FileCheck %s
+
+// Types that have cyclic references.
+
+// CHECK: !testd.self_referencing<i32>
+func.func @no_references(%v: !testd.self_referencing<i32>) {
+  return
+}
+
+// -----
+
+// CHECK: !testd.self_referencing<!testd.self_referencing<i32>>
+func.func @one_reference(%v: !testd.self_referencing<!testd.self_referencing<i32>>) {
+  return
+}
+
+// -----
+
+// expected-error@+1 {{'i64' does not satisfy the constraint}}
+func.func @wrong_parameter(%v: !testd.self_referencing<i64>) {
+  return
+}
+
+// -----
+
+// CHECK: !testd.type1<i32>
+func.func @type1_no_references(%v: !testd.type1<i32>) {
+  return
+}
+
+// -----
+
+// CHECK: !testd.type1<!testd.type2<i32>>
+func.func @type1_one_references(%v: !testd.type1<!testd.type2<i32>>) {
+  return
+}
+
+// -----
+
+// CHECK: !testd.type1<!testd.type2<!testd.type1<i32>>>
+func.func @type1_two_references(%v: !testd.type1<!testd.type2<!testd.type1<i32>>>) {
+  return
+}
+
+// -----
+
+// expected-error@+1 {{'i64' does not satisfy the constraint}}
+func.func @wrong_parameter_type1(%v: !testd.type1<i64>) {
+  return
+}
+
+// -----
+
+// expected-error@+1 {{'i64' does not satisfy the constraint}}
+func.func @wrong_parameter_type2(%v: !testd.type2<i64>) {
+  return
+}

mlir/test/Dialect/IRDL/test-cmath.mlir

+// RUN: mlir-opt %s --irdl-file=%S/cmath.irdl.mlir | mlir-opt --irdl-file=%S/cmath.irdl.mlir | FileCheck %s
+
+module {
+  // CHECK: func.func @conorm(%[[p:[^:]*]]: !cmath.complex<f32>, %[[q:[^:]*]]: !cmath.complex<f32>) -> f32 {
+  // CHECK:   %[[norm_p:[^ ]*]] = "cmath.norm"(%[[p]]) : (!cmath.complex<f32>) -> f32
+  // CHECK:   %[[norm_q:[^ ]*]] = "cmath.norm"(%[[q]]) : (!cmath.complex<f32>) -> f32
+  // CHECK:   %[[pq:[^ ]*]] = arith.mulf %[[norm_p]], %[[norm_q]] : f32
+  // CHECK:   return %[[pq]] : f32
+  // CHECK: }
+  func.func @conorm(%p: !cmath.complex<f32>, %q: !cmath.complex<f32>) -> f32 {
+    %norm_p = "cmath.norm"(%p) : (!cmath.complex<f32>) -> f32
+    %norm_q = "cmath.norm"(%q) : (!cmath.complex<f32>) -> f32
+    %pq = arith.mulf %norm_p, %norm_q : f32
+    return %pq : f32
+  }
+
+  // CHECK: func.func @conorm2(%[[p:[^:]*]]: !cmath.complex<f32>, %[[q:[^:]*]]: !cmath.complex<f32>) -> f32 {
+  // CHECK:   %[[pq:[^ ]*]] = "cmath.mul"(%[[p]], %[[q]]) : (!cmath.complex<f32>, !cmath.complex<f32>) -> !cmath.complex<f32>
+  // CHECK:   %[[conorm:[^ ]*]] = "cmath.norm"(%[[pq]]) : (!cmath.complex<f32>) -> f32
+  // CHECK:   return %[[conorm]] : f32
+  // CHECK: }
+  func.func @conorm2(%p: !cmath.complex<f32>, %q: !cmath.complex<f32>) -> f32 {
+    %pq = "cmath.mul"(%p, %q) : (!cmath.complex<f32>, !cmath.complex<f32>) -> !cmath.complex<f32>
+    %conorm = "cmath.norm"(%pq) : (!cmath.complex<f32>) -> f32
+    return %conorm : f32
+  }
+}

mlir/test/Dialect/IRDL/test-type.mlir

+// RUN: mlir-opt %s --irdl-file=%S/test-type.irdl.mlir -split-input-file -verify-diagnostics | FileCheck %s
+
+func.func @succeededTypeVerifier() {
+    // CHECK: "testd.any"() : () -> !testd.singleton
+    "testd.any"() : () -> !testd.singleton
+
+    // CHECK-NEXT: "testd.any"() : () -> !testd.parametrized<f32, i32>
+    "testd.any"() : () -> !testd.parametrized<f32, i32>
+
+    // CHECK: "testd.any"() : () -> !testd.parametrized<i1, i64>
+    "testd.any"() : () -> !testd.parametrized<i1, i64>
+
+    return
+}
+
+// -----
+
+func.func @failedSingletonVerifier() {
+     // expected-error@+1 {{expected 0 type arguments, but had 1}}
+     "testd.any"() : () -> !testd.singleton<i32>
+}
+
+// -----
+
+func.func @failedParametrizedVerifierWrongNumOfArgs() {
+     // expected-error@+1 {{expected 2 type arguments, but had 1}}
+     "testd.any"() : () -> !testd.parametrized<i32>
+}
+
+// -----
+
+func.func @failedParametrizedVerifierWrongArgument() {
+     // expected-error@+1 {{'i1' does not satisfy the constraint}}
+     "testd.any"() : () -> !testd.parametrized<i32, i1>
+}

mlir/test/Dialect/IRDL/testd.mlir

+// RUN: mlir-opt %s --irdl-file=%S/testd.irdl.mlir -split-input-file -verify-diagnostics | FileCheck %s
+
+//===----------------------------------------------------------------------===//
+// Type or attribute constraint
+//===----------------------------------------------------------------------===//
+
+func.func @typeFitsType() {
+  // CHECK: "testd.any"() : () -> !testd.parametric<i32>
+  "testd.any"() : () -> !testd.parametric<i32>
+  return
+}
+
+// -----
+
+func.func @attrDoesntFitType() {
+  "testd.any"() : () -> !testd.parametric<"foo">
+  return
+}
+
+// -----
+
+func.func @attrFitsAttr() {
+  // CHECK: "testd.any"() : () -> !testd.attr_in_type_out<"foo">
+  "testd.any"() : () -> !testd.attr_in_type_out<"foo">
+  return
+}
+
+// -----
+
+func.func @typeFitsAttr() {
+  // CHECK: "testd.any"() : () -> !testd.attr_in_type_out<i32>
+  "testd.any"() : () -> !testd.attr_in_type_out<i32>
+  return
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// Equality constraint
+//===----------------------------------------------------------------------===//
+
+func.func @succeededEqConstraint() {
+  // CHECK: "testd.eq"() : () -> i32
+  "testd.eq"() : () -> i32
+  return
+}
+
+// -----
+
+func.func @failedEqConstraint() {
+  // expected-error@+1 {{expected 'i32' but got 'i64'}}
+  "testd.eq"() : () -> i64
+  return
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// AnyOf constraint
+//===----------------------------------------------------------------------===//
+
+func.func @succeededAnyOfConstraint() {
+  // CHECK: "testd.anyof"() : () -> i32
+  "testd.anyof"() : () -> i32
+  // CHECK: "testd.anyof"() : () -> i64
+  "testd.anyof"() : () -> i64
+  return
+}
+
+// -----
+
+func.func @failedAnyOfConstraint() {
+  // expected-error@+1 {{'i1' does not satisfy the constraint}}
+  "testd.anyof"() : () -> i1
+  return
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// AllOf constraint
+//===----------------------------------------------------------------------===//
+
+func.func @succeededAllOfConstraint() {
+  // CHECK: "testd.all_of"() : () -> i64
+  "testd.all_of"() : () -> i64
+  return
+}
+
+// -----
+
+func.func @failedAllOfConstraint1() {
+  // expected-error@+1 {{'i1' does not satisfy the constraint}}
+  "testd.all_of"() : () -> i1
+  return
+}
+
+// -----
+
+func.func @failedAllOfConstraint2() {
+  // expected-error@+1 {{expected 'i64' but got 'i32'}}
+  "testd.all_of"() : () -> i32
+  return
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// Any constraint
+//===----------------------------------------------------------------------===//
+
+func.func @succeededAnyConstraint() {
+  // CHECK: "testd.any"() : () -> i32
+  "testd.any"() : () -> i32
+  // CHECK: "testd.any"() : () -> i64
+  "testd.any"() : () -> i64
+  return
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// Dynamic base constraint
+//===----------------------------------------------------------------------===//
+
+func.func @succeededDynBaseConstraint() {
+  // CHECK: "testd.dynbase"() : () -> !testd.parametric<i32>
+  "testd.dynbase"() : () -> !testd.parametric<i32>
+  // CHECK: "testd.dynbase"() : () -> !testd.parametric<i64>
+  "testd.dynbase"() : () -> !testd.parametric<i64>
+  // CHECK: "testd.dynbase"() : () -> !testd.parametric<!testd.parametric<i64>>
+  "testd.dynbase"() : () -> !testd.parametric<!testd.parametric<i64>>
+  return
+}
+
+// -----
+
+func.func @failedDynBaseConstraint() {
+  // expected-error@+1 {{expected base type 'testd.parametric' but got 'i32'}}
+  "testd.dynbase"() : () -> i32
+  return
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// Dynamic parameters constraint
+//===----------------------------------------------------------------------===//
+
+func.func @succeededDynParamsConstraint() {
+  // CHECK: "testd.dynparams"() : () -> !testd.parametric<i32>
+  "testd.dynparams"() : () -> !testd.parametric<i32>
+  // CHECK: "testd.dynparams"() : () -> !testd.parametric<i64>
+  "testd.dynparams"() : () -> !testd.parametric<i64>
+  return
+}
+
+// -----
+
+func.func @failedDynParamsConstraintBase() {
+  // expected-error@+1 {{expected base type 'testd.parametric' but got 'i32'}}
+  "testd.dynparams"() : () -> i32
+  return
+}
+
+// -----
+
+func.func @failedDynParamsConstraintParam() {
+  // expected-error@+1 {{'i1' does not satisfy the constraint}}
+  "testd.dynparams"() : () -> !testd.parametric<i1>
+  return
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// Constraint variables
+//===----------------------------------------------------------------------===//
+
+func.func @succeededConstraintVars() {
+  // CHECK: "testd.constraint_vars"() : () -> (i32, i32)
+  "testd.constraint_vars"() : () -> (i32, i32)
+  return
+}
+
+// -----
+
+func.func @succeededConstraintVars2() {
+  // CHECK: "testd.constraint_vars"() : () -> (i64, i64)
+  "testd.constraint_vars"() : () -> (i64, i64)
+  return
+}
+
+// -----
+
+func.func @failedConstraintVars() {
+  // expected-error@+1 {{expected 'i64' but got 'i32'}}
+  "testd.constraint_vars"() : () -> (i64, i32)
+  return
+}