[mlir] Add Dynamic Dialects

[math-fehr]

Summary

Dynamic dialects are dialects that can be defined at runtime.
Dynamic dialects are extensible by new operations, types, and
attributes at runtime.

[math-fehr]

I would like to add tests for dynamic dialects, by creating a new dynamic dialect, and then populating it with dynamic operations, types, and attributes.
However, the way mlir-opt currently works is by creating a DialectRegistry, and then passing it to MlirOptMain.

Is there any way of getting somewhere a MLIRContext to register the dialect?
Alternatively, how should we register DynamicDialect from DialectRegistry, since we want to directly access them to add operations/types/attributes?

[math-fehr]

Add parsing and printing of types/attributes

[math-fehr]

Add missing newline at end of file

[rriddle]

In D125201#3499771, @math-fehr wrote:

I would like to add tests for dynamic dialects, by creating a new dynamic dialect, and then populating it with dynamic operations, types, and attributes.
However, the way mlir-opt currently works is by creating a DialectRegistry, and then passing it to MlirOptMain.

Is there any way of getting somewhere a MLIRContext to register the dialect?
Alternatively, how should we register DynamicDialect from DialectRegistry, since we want to directly access them to add operations/types/attributes?

I think for the registry we could have a different type of allocator function that we wrap into the normal dialect allocator function. That way we could do
something like:

registry.insertDynamic("name", [](DynamicDialect *dialect) {
  // Insert the stuff for the dialect here.
});

Inside of the registry though, we should remove the need to create a TypeID upfront for dynamic dialects. Either by using a different registry map, or by using something like TypeID::get<void>() internally. Given that dynamic dialects don't have the same TypeID problems that normal dialects have, the TypeID in the registry doesn't really guard against much IMO.

mlir/include/mlir/IR/ExtensibleDialect.h

553

Is this explicit initialization necessary?

mlir/include/mlir/IR/MLIRContext.h

117–118

This should likely be named getOrLoadDynamicDialect to match the other API. With that, why do we need to abort if a dialect of the same name is already loaded?

mlir/lib/IR/ExtensibleDialect.cpp

549

Diagnostic messages should start with a lower case. Same above.

mlir/lib/IR/MLIRContext.cpp

461

If we are actually loading the dialect, we could copy the string into abstractDialectSymbolAllocator or something. That would remove a lot of the uniquing cost.

Also, can you assert that we aren't in a multithreaded context here?

[math-fehr]

Address comments, and add insertDynamic to DialectRegistry.

[math-fehr]

I added an insertDynamic in the DialectRegistry.

My dynamic.mlir test is currently failing (it seems because of a memory issue), and I'll debug this tomorrow.

mlir/include/mlir/IR/MLIRContext.h

117–118

I think I'll change it so it returns nullptr instead of aborting.

The problem with a getOrLoadDynamicDialect is that we wouldn't know if the dialect was created or not.
With getOrLoadDialect<MyDialect>, we do not care if the dialect was just loaded or not, since the resulting dialect will be the same. However, with a getOrLoadDynamicDialect, we would either get a dialect with already some operations/types/attributes defined, or a new dialect with nothing in it.

Does that make sense?

mlir/lib/IR/MLIRContext.cpp

461

Is this what you meant about abstractDialectSymbolAllocator?

Also, for the multithreading context, adding an assert here seems to fail on my test. Is there some place where I should deactivate it when loading a new dynamic dialect with the DialectRegistry during parsing?

[math-fehr]

Fix bug in dynamic dialect registration

[math-fehr]

In D125201#3505209, @math-fehr wrote:

I added an insertDynamic in the DialectRegistry.

My dynamic.mlir test is currently failing (it seems because of a memory issue), and I'll debug this tomorrow.

This is now fixed

[rriddle]

mlir/include/mlir/IR/MLIRContext.h

117–118

Can we just do what we do in the normal case? i.e. pass in the initializer function and only call it if the dialect needs to be constructed?

mlir/lib/IR/Dialect.cpp

175

Can we move nameStr here? or do something like nameStr = name.str() in the capture list?

mlir/lib/IR/MLIRContext.cpp

461

That feels weird, we can only load a dialect in a non-multithreaded context. We are already asserting in getOrLoadDialect, but we should also assert here as well (just to make sure the assert context is more accurate)

https://github.com/llvm/llvm-project/blob/cb778e9328292b7cfa4e0b43f26e4d1091923a39/mlir/lib/IR/MLIRContext.cpp#L424

mlir/test/lib/Dialect/TestDyn/TestDynDialect.cpp

20

Can we keep this in the test namespace? I don't think there is a good reason to diverge.

27

Could you move the functors out-of-line and the inline the call to DynamicOpDefinition::get?

30–32

mlir/test/lib/Dialect/TestDyn/TestDynDialect.h

1 ↗

(On Diff #428836)

This header shouldn't be necessary, it isn't included anywhere.

[rriddle]

Can you also add documentation on how to add/define a purely dynamic dialect?

[math-fehr]

Address comments

[math-fehr]

Remove unwanted line break

[math-fehr]

This should now be ready for review.
I added documentation for the dynamic dialect definition, and addressed the comments.

[rriddle]

Nice.

mlir/docs/DefiningDialects.md

396

mlir/include/mlir/IR/DialectRegistry.h

141–143

Can you reflow these comments?

mlir/include/mlir/IR/ExtensibleDialect.h

548–549

Can you reflow these comments?

mlir/include/mlir/IR/MLIRContext.h

114

117

Can we pass by pointer here? Dialects are generally interacted with by-pointer, so it would be nice to be consistent here.

mlir/lib/IR/Dialect.cpp

168–169

Can you reflow the comments here?

171

178

Is this to make sure the lambda returns the right type? Can you just mark the type in the lambda declaration? i.e. ...) -> Dialect * {

mlir/lib/IR/MLIRContext.cpp

468

The llvm:: shouldn't be necessary, can you drop it?

487

Can you just pass dialect by-value? It's a pointer so the reference doesn't matter.

1010–1011

This feels unrelated. Same with the comment changes above.

mlir/test/IR/dynamic.mlir

137

Super nit: can you drop the double newline?

143

Missing newline?

mlir/test/lib/Dialect/TestDyn/TestDynDialect.cpp

19–20

21

Can we drop the ::mlir:: on these? Same with the registry.

[math-fehr]

Address comments

[math-fehr]

I should have addressed the comments.
Could you land this for me?

[math-fehr]

Rebased on main

[math-fehr]

Sorry for the delay, I forgot a bit about this patch!
@rriddle, I just rebased it, could you land this for me, I do not have commit access?

[math-fehr]

Remove use of deprecated methods

[rriddle]

In D125201#3799952, @math-fehr wrote:

Remove use of deprecated methods

Is this fully ready? Will land now if so (oops).

[math-fehr]

Yes, this is ready! I just updated it to the main.

mlir/docs/DefiningDialects.md

 `llvm::dyn_cast`, or `llvm::cast`:
 
 ```c++
 if (auto extensibleDialect = llvm::dyn_cast<ExtensibleDialect>(dialect)) {
     ...
 }
 ```
 
+### Defining a dynamic dialect
+
+Dynamic dialects are extensible dialects that can be defined at runtime. They
+are only populated with dynamic operations, types, and attributes. They can be
+registered in a `DialectRegistry` with `insertDynamic`.
+
+```c++
+auto populateDialect = [](MLIRContext *ctx, DynamicDialect* dialect) {
+  // Code that will be ran when the dynamic dialect is created and loaded.
+  // For instance, this is where we register the dynamic operations, types, and
+  // attributes of the dialect.
+  ...
+}
+
+registry.insertDynamic("dialectName", populateDialect);
+```
+
+Once a dynamic dialect is registered in the `MLIRContext`, it can be retrieved
+with `getOrLoadDialect`.
+
+```c++
+Dialect* dialect = ctx->getOrLoadDialect("dialectName");
+```
+
 ### Defining an operation at runtime
 
 The `DynamicOpDefinition` class represents the definition of an operation
 defined at runtime. It is created using the `DynamicOpDefinition::get`
 functions. An operation defined at runtime must provide a name, a dialect in
 which the operation will be registered in, an operation verifier. It may also
 optionally define a custom parser and a printer, fold hook, and more.
 

mlir/include/mlir/IR/DialectRegistry.h

 #include <map>
 #include <tuple>
 
 namespace mlir {
 class Dialect;
 
 using DialectAllocatorFunction = std::function<Dialect *(MLIRContext *)>;
 using DialectAllocatorFunctionRef = function_ref<Dialect *(MLIRContext *)>;
+using DynamicDialectPopulationFunction =
+    std::function<void(MLIRContext *, DynamicDialect *)>;
 
 //===----------------------------------------------------------------------===//
 // DialectExtension
 //===----------------------------------------------------------------------===//
 
 /// This class represents an opaque dialect extension. It contains a set of
 /// required dialects and an application function. The required dialects control
 /// when the extension is applied, i.e. the extension is applied when all
public:
   }
 
   /// Add a new dialect constructor to the registry. The constructor must be
   /// calling MLIRContext::getOrLoadDialect in order for the context to take
   /// ownership of the dialect and for delayed interface registration to happen.
   void insert(TypeID typeID, StringRef name,
               const DialectAllocatorFunction &ctor);
 
-  /// Return an allocation function for constructing the dialect identified by
-  /// its namespace, or nullptr if the namespace is not in this registry.
+  /// Add a new dynamic dialect constructor in the registry.
+  /// The given function is meant to populate the dialect with its types,
+  /// attributes, and ops.
+  void insertDynamic(StringRef name,
+                     const DynamicDialectPopulationFunction &ctor);
+
+  /// Return an allocation function for constructing the dialect identified
+  /// by its namespace, or nullptr if the namespace is not in this registry.
   DialectAllocatorFunctionRef getDialectAllocator(StringRef name) const;
 
   // Register all dialects available in the current registry with the registry
   // in the provided context.
   void appendTo(DialectRegistry &destination) const {
     for (const auto &nameAndRegistrationIt : registry)
       destination.insert(nameAndRegistrationIt.second.first,
                          nameAndRegistrationIt.first,

mlir/include/mlir/IR/ExtensibleDialect.h

private:
   friend DynamicOpDefinition;
 
   /// Allocates a type ID to uniquify operations.
   TypeID allocateTypeID() { return typeIDAllocator.allocate(); }
 
   /// Owns the TypeID generated at runtime for operations.
   TypeIDAllocator typeIDAllocator;
 };
+
+//===----------------------------------------------------------------------===//
+// Dynamic dialect
+//===----------------------------------------------------------------------===//
+
+/// A dialect that can be defined at runtime.
+/// It can be extended with new operations, types, and attributes at runtime.
+class DynamicDialect : public SelfOwningTypeID, public ExtensibleDialect {
+public:
+  DynamicDialect(StringRef name, MLIRContext *ctx);
+
+  TypeID getTypeID() { return SelfOwningTypeID::getTypeID(); }
+
+  /// Check if the dialect is an extensible dialect.
+  static bool classof(const Dialect *dialect);
+
+  virtual Type parseType(DialectAsmParser &parser) const override;
+  virtual void printType(Type type, DialectAsmPrinter &printer) const override;
+
+  virtual Attribute parseAttribute(DialectAsmParser &parser,
+                                   Type type) const override;
+  virtual void printAttribute(Attribute attr,
+                              DialectAsmPrinter &printer) const override;
+};
 } // namespace mlir
 
 namespace llvm {
 /// Provide isa functionality for ExtensibleDialect.
 /// This is to override the isa functionality for Dialect.
 template <>
 struct isa_impl<mlir::ExtensibleDialect, mlir::Dialect> {
   static inline bool doit(const ::mlir::Dialect &dialect) {
     return mlir::ExtensibleDialect::classof(&dialect);
   }
 };
+
+/// Provide isa functionality for DynamicDialect.
+/// This is to override the isa functionality for Dialect.
+template <>
+struct isa_impl<mlir::DynamicDialect, mlir::Dialect> {
+  static inline bool doit(const ::mlir::Dialect &dialect) {
+    return mlir::DynamicDialect::classof(&dialect);
+  }
+};
 } // namespace llvm
 
 #endif // MLIR_IR_EXTENSIBLEDIALECT_H

mlir/include/mlir/IR/MLIRContext.h

 class ThreadPool;
 } // namespace llvm
 
 namespace mlir {
 class DebugActionManager;
 class DiagnosticEngine;
 class Dialect;
 class DialectRegistry;
+class DynamicDialect;
 class InFlightDiagnostic;
 class Location;
 class MLIRContextImpl;
 class RegisteredOperationName;
 class StorageUniquer;
 
 /// MLIRContext is the top-level object for a collection of MLIR operations. It
 /// holds immortal uniqued objects like types, and the tables used to unique
public:
 
   /// Load a list dialects in the context.
   template <typename Dialect, typename OtherDialect, typename... MoreDialects>
   void loadDialect() {
     getOrLoadDialect<Dialect>();
     loadDialect<OtherDialect, MoreDialects...>();
   }
 
+  /// Get (or create) a dialect for the given name.
+  DynamicDialect *
+  getOrLoadDynamicDialect(StringRef dialectNamespace,
+                          function_ref<void(DynamicDialect &)> ctor);
+
   /// Load all dialects available in the registry in this context.
   void loadAllAvailableDialects();
 
   /// Get (or create) a dialect for the given derived dialect name.
   /// The dialect will be loaded from the registry if no dialect is found.
   /// If no dialect is loaded for this name and none is available in the
   /// registry, returns nullptr.
   Dialect *getOrLoadDialect(StringRef name);

mlir/lib/IR/Dialect.cpp

auto inserted = registry.insert(
       std::make_pair(std::string(name), std::make_pair(typeID, ctor)));
   if (!inserted.second && inserted.first->second.first != typeID) {
     llvm::report_fatal_error(
         "Trying to register different dialects for the same namespace: " +
         name);
   }
 }
 
+void DialectRegistry::insertDynamic(
+    StringRef name, const DynamicDialectPopulationFunction &ctor) {
+  // This TypeID marks dynamic dialects.
+  // We cannot give a TypeID for the dialect yet, since the TypeID of a dynamic
+  // dialect is defined at its construction.
+  auto typeID = TypeID::get<void>();
+
+  // Create the dialect, and then call ctor, which allocates its components.
+  auto constructor = [nameStr = name.str(), ctor](MLIRContext *ctx) {
+    auto *dynDialect = ctx->getOrLoadDynamicDialect(
+        nameStr, [ctx, ctor](DynamicDialect &dialect) { ctor(ctx, &dialect); });
+    assert(dynDialect && "Dynamic dialect creation unexpectedly failed");
+    return (Dialect *)dynDialect;
+  };
+
+  insert(typeID, name, constructor);
+}
+
 void DialectRegistry::applyExtensions(Dialect *dialect) const {
   MLIRContext *ctx = dialect->getContext();
   StringRef dialectName = dialect->getNamespace();
 
   // Functor used to try to apply the given extension.
   auto applyExtension = [&](const DialectExtensionBase &extension) {
     ArrayRef<StringRef> dialectNames = extension.getRequiredDialects();
 

mlir/lib/IR/ExtensibleDialect.cpp

 LogicalResult ExtensibleDialect::printIfDynamicAttr(Attribute attribute,
                                                     AsmPrinter &printer) {
   if (auto dynAttr = attribute.dyn_cast<DynamicAttr>()) {
     dynAttr.print(printer);
     return success();
   }
   return failure();
 }
+
+//===----------------------------------------------------------------------===//
+// Dynamic dialect
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// Interface that can only be implemented by extensible dialects.
+/// The interface is used to check if a dialect is extensible or not.
+class IsDynamicDialect : public DialectInterface::Base<IsDynamicDialect> {
+public:
+  IsDynamicDialect(Dialect *dialect) : Base(dialect) {}
+
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(IsDynamicDialect)
+};
+} // namespace
+
+DynamicDialect::DynamicDialect(StringRef name, MLIRContext *ctx)
+    : SelfOwningTypeID(),
+      ExtensibleDialect(name, ctx, SelfOwningTypeID::getTypeID()) {
+  addInterfaces<IsDynamicDialect>();
+}
+
+bool DynamicDialect::classof(const Dialect *dialect) {
+  return const_cast<Dialect *>(dialect)
+      ->getRegisteredInterface<IsDynamicDialect>();
+}
+
+Type DynamicDialect::parseType(DialectAsmParser &parser) const {
+  auto loc = parser.getCurrentLocation();
+  StringRef typeTag;
+  if (failed(parser.parseKeyword(&typeTag)))
+    return Type();
+
+  {
+    Type dynType;
+    auto parseResult = parseOptionalDynamicType(typeTag, parser, dynType);
+    if (parseResult.hasValue()) {
+      if (succeeded(parseResult.getValue()))
+        return dynType;
+      return Type();
+    }
+  }
+
+  parser.emitError(loc, "expected dynamic type");
+  return Type();
+}
+
+void DynamicDialect::printType(Type type, DialectAsmPrinter &printer) const {
+  auto wasDynamic = printIfDynamicType(type, printer);
+  (void)wasDynamic;
+  assert(succeeded(wasDynamic) &&
+         "non-dynamic type defined in dynamic dialect");
+}
+
+Attribute DynamicDialect::parseAttribute(DialectAsmParser &parser,
+                                         Type type) const {
+  auto loc = parser.getCurrentLocation();
+  StringRef typeTag;
+  if (failed(parser.parseKeyword(&typeTag)))
+    return Attribute();
+
+  {
+    Attribute dynAttr;
+    auto parseResult = parseOptionalDynamicAttr(typeTag, parser, dynAttr);
+    if (parseResult.hasValue()) {
+      if (succeeded(parseResult.getValue()))
+        return dynAttr;
+      return Attribute();
+    }
+  }
+
+  parser.emitError(loc, "expected dynamic attribute");
+  return Attribute();
+}
+void DynamicDialect::printAttribute(Attribute attr,
+                                    DialectAsmPrinter &printer) const {
+  auto wasDynamic = printIfDynamicAttr(attr, printer);
+  (void)wasDynamic;
+  assert(succeeded(wasDynamic) &&
+         "non-dynamic attribute defined in dynamic dialect");
+}

mlir/lib/IR/MLIRContext.cpp

 #include "IntegerSetDetail.h"
 #include "TypeDetail.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
+#include "mlir/IR/ExtensibleDialect.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Support/DebugAction.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SetVector.h"
#endif
   std::unique_ptr<Dialect> &dialect = dialectIt->second;
   if (dialect->getTypeID() != dialectID)
     llvm::report_fatal_error("a dialect with namespace '" + dialectNamespace +
                              "' has already been registered");
 
   return dialect.get();
 }
 
+DynamicDialect *MLIRContext::getOrLoadDynamicDialect(
+    StringRef dialectNamespace, function_ref<void(DynamicDialect &)> ctor) {
+  auto &impl = getImpl();
+  // Get the correct insertion position sorted by namespace.
+  auto dialectIt = impl.loadedDialects.find(dialectNamespace);
+
+  if (dialectIt != impl.loadedDialects.end()) {
+    if (auto dynDialect =
+            llvm::dyn_cast<DynamicDialect>(dialectIt->second.get()))
+      return dynDialect;
+    llvm::report_fatal_error("a dialect with namespace '" + dialectNamespace +
+                             "' has already been registered");
+  }
+
+  LLVM_DEBUG(llvm::dbgs() << "Load new dynamic dialect in Context "
+                          << dialectNamespace << "\n");
+#ifndef NDEBUG
+  if (impl.multiThreadedExecutionContext != 0)
+    llvm::report_fatal_error(
+        "Loading a dynamic dialect (" + dialectNamespace +
+        ") while in a multi-threaded execution context (maybe "
+        "the PassManager): this can indicate a "
+        "missing `dependentDialects` in a pass for example.");
+#endif
+
+  auto name = StringAttr::get(this, dialectNamespace);
+  auto *dialect = new DynamicDialect(name, this);
+  (void)getOrLoadDialect(name, dialect->getTypeID(), [&dialect, ctor]() {
+    ctor(*dialect);
+    return std::unique_ptr<DynamicDialect>(dialect);
+  });
+  // This is the same result as `getOrLoadDialect` (if it didn't failed),
+  // since it has the same TypeID, and TypeIDs are unique.
+  return dialect;
+}
+
 void MLIRContext::loadAllAvailableDialects() {
   for (StringRef name : getAvailableDialects())
     getOrLoadDialect(name);
 }
 
 llvm::hash_code MLIRContext::getRegistryHash() {
   llvm::hash_code hash(0);
   // Factor in number of loaded dialects, attributes, operations, types.
void MLIRContext::disableMultithreading(bool disable) {
 
   impl->threadingIsEnabled = !disable;
 
   // Update the threading mode for each of the uniquers.
   impl->affineUniquer.disableMultithreading(disable);
   impl->attributeUniquer.disableMultithreading(disable);
   impl->typeUniquer.disableMultithreading(disable);
 
-  // Destroy thread pool (stop all threads) if it is no longer needed, or create
-  // a new one if multithreading was re-enabled.
+  // Destroy thread pool (stop all threads) if it is no longer needed, or
+  // create a new one if multithreading was re-enabled.
   if (disable) {
     // If the thread pool is owned, explicitly set it to nullptr to avoid
     // keeping a dangling pointer around. If the thread pool is externally
     // owned, we don't do anything.
     if (impl->ownedThreadPool) {
       assert(impl->threadPool);
       impl->threadPool = nullptr;
       impl->ownedThreadPool.reset();

 
 //===----------------------------------------------------------------------===//
 // AbstractType
 //===----------------------------------------------------------------------===//
 
 const AbstractType &AbstractType::lookup(TypeID typeID, MLIRContext *context) {
   const AbstractType *type = lookupMutable(typeID, context);
   if (!type)
-    llvm::report_fatal_error(
-        "Trying to create a Type that was not registered in this MLIRContext.");
+    llvm::report_fatal_error("Trying to create a Type that was not "
+                             "registered in this MLIRContext.");
   return *type;
 }
 
 AbstractType *AbstractType::lookupMutable(TypeID typeID, MLIRContext *context) {
   auto &impl = context->getImpl();
   auto it = impl.registeredTypes.find(typeID);
   if (it == impl.registeredTypes.end())
     return nullptr;
if (auto cached = getCachedIntegerType(width, signedness, context))
     return cached;
   return Base::getChecked(emitError, context, width, signedness);
 }
 
 /// Get an instance of the NoneType.
 NoneType NoneType::get(MLIRContext *context) {
   if (NoneType cachedInst = context->getImpl().noneType)
     return cachedInst;
-  // Note: May happen when initializing the singleton attributes of the builtin
-  // dialect.
+  // Note: May happen when initializing the singleton attributes of the
+  // builtin dialect.
   return Base::get(context);
 }
 
 //===----------------------------------------------------------------------===//
 // Attribute uniquing
 //===----------------------------------------------------------------------===//
 
 /// Returns the storage uniquer used for constructing attribute storage

 
 void StringAttrStorage::initialize(MLIRContext *context) {
   // Check for a dialect namespace prefix, if there isn't one we don't need to
   // do any additional initialization.
   auto dialectNamePair = value.split('.');
   if (dialectNamePair.first.empty() || dialectNamePair.second.empty())
     return;
 
-  // If one exists, we check to see if this dialect is loaded. If it is, we set
-  // the dialect now, if it isn't we record this storage for initialization
-  // later if the dialect ever gets loaded.
+  // If one exists, we check to see if this dialect is loaded. If it is, we
+  // set the dialect now, if it isn't we record this storage for
+  // initialization later if the dialect ever gets loaded.
   if ((referencedDialect = context->getLoadedDialect(dialectNamePair.first)))
     return;
 
   MLIRContextImpl &impl = context->getImpl();
   llvm::sys::SmartScopedLock<true> lock(impl.dialectRefStrAttrMutex);
   impl.dialectReferencingStrAttrs[dialectNamePair.first].push_back(this);
 }
 
AffineMap AffineMap::getImpl(unsigned dimCount, unsigned symbolCount,
   auto *storage = impl.affineUniquer.get<AffineMapStorage>(
       [&](AffineMapStorage *storage) { storage->context = context; }, dimCount,
       symbolCount, results);
   return AffineMap(storage);
 }
 
 /// Check whether the arguments passed to the AffineMap::get() are consistent.
 /// This method checks whether the highest index of dimensional identifier
-/// present in result expressions is less than `dimCount` and the highest index
-/// of symbolic identifier present in result expressions is less than
+/// present in result expressions is less than `dimCount` and the highest
+/// index of symbolic identifier present in result expressions is less than
 /// `symbolCount`.
 LLVM_ATTRIBUTE_UNUSED static bool
 willBeValidAffineMap(unsigned dimCount, unsigned symbolCount,
                      ArrayRef<AffineExpr> results) {
   int64_t maxDimPosition = -1;
   int64_t maxSymbolPosition = -1;
   getMaxDimAndSymbol(ArrayRef<ArrayRef<AffineExpr>>(results), maxDimPosition,
                      maxSymbolPosition);
   if ((maxDimPosition >= dimCount) || (maxSymbolPosition >= symbolCount)) {
     LLVM_DEBUG(
         llvm::dbgs()
-        << "maximum dimensional identifier position in result expression must "
+        << "maximum dimensional identifier position in result expression "
+           "must "
            "be less than `dimCount` and maximum symbolic identifier position "
            "in result expression must be less than `symbolCount`\n");
     return false;
   }
   return true;
 }
 
 AffineMap AffineMap::get(MLIRContext *context) {
   return getImpl(/*dimCount=*/0, /*symbolCount=*/0, /*results=*/{}, context);

mlir/test/IR/dynamic.mlir

 // -----
 
 // CHECK-LABEL: func @customOpParserPrinter
 func.func @customOpParserPrinter() {
   // CHECK: test.dynamic_custom_parser_printer custom_keyword
   test.dynamic_custom_parser_printer custom_keyword
   return
 }
+
+//===----------------------------------------------------------------------===//
+// Dynamic dialect
+//===----------------------------------------------------------------------===//
+
+// -----
+
+// Check that the verifier of a dynamic operation in a dynamic dialect
+// can fail. This shows that the dialect is correctly registered.
+
+
+func.func @failedDynamicDialectOpVerifier() {
+  // expected-error@+1 {{expected a single result, no operands and no regions}}
+  "test_dyn.one_result"() : () -> ()
+  return
+}
 No newline at end of file

mlir/test/lib/Dialect/CMakeLists.txt

 add_subdirectory(Affine)
 add_subdirectory(DLTI)
 add_subdirectory(Func)
 add_subdirectory(GPU)
 add_subdirectory(Linalg)
 add_subdirectory(Math)
 add_subdirectory(MemRef)
 add_subdirectory(SCF)
 add_subdirectory(Shape)
 add_subdirectory(SPIRV)
 add_subdirectory(Tensor)
 add_subdirectory(Test)
+add_subdirectory(TestDyn)
 add_subdirectory(Tosa)
 add_subdirectory(Transform)
 add_subdirectory(Vector)

mlir/test/lib/Dialect/TestDyn/CMakeLists.txt

+add_mlir_dialect_library(MLIRTestDynDialect
+  TestDynDialect.cpp
+
+  EXCLUDE_FROM_LIBMLIR
+
+  LINK_LIBS PUBLIC
+  MLIRIR
+)

mlir/test/lib/Dialect/TestDyn/TestDynDialect.cpp

+//===- TestDynDialect.cpp -------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines a fake 'test_dyn' dynamic dialect that is used to test the
+// registration of dynamic dialects.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/IR/ExtensibleDialect.h"
+
+using namespace mlir;
+
+namespace test {
+
+void registerTestDynDialect(::mlir::DialectRegistry &registry) {
+  registry.insertDynamic("test_dyn", [](::mlir::MLIRContext *ctx,
+                                        ::mlir::DynamicDialect *testDyn) {
+    auto opVerifier = [](Operation *op) -> LogicalResult {
+      if (op->getNumOperands() == 0 && op->getNumResults() == 1 &&
+          op->getNumRegions() == 0)
+        return success();
+      return op->emitError(
+          "expected a single result, no operands and no regions");
+    };
+
+    auto opRegionVerifier = [](Operation *op) { return success(); };
+
+    testDyn->registerDynamicOp(DynamicOpDefinition::get(
+        "one_result", testDyn, opVerifier, opRegionVerifier));
+  });
+}
+} // namespace test

mlir/test/mlir-opt/commandline.mlir

 // CHECK-NEXT: quant
 // CHECK-NEXT: rocdl
 // CHECK-NEXT: scf
 // CHECK-NEXT: shape
 // CHECK-NEXT: sparse_tensor
 // CHECK-NEXT: spv
 // CHECK-NEXT: tensor
 // CHECK-NEXT: test
+// CHECK-NEXT: test_dyn
 // CHECK-NEXT: tosa
 // CHECK-NEXT: transform
 // CHECK-NEXT: vector
 // CHECK-NEXT: x86vector

mlir/tools/mlir-opt/CMakeLists.txt

set(test_libs
     MLIRMathTestPasses
     MLIRMemRefTestPasses
     MLIRSCFTestPasses
     MLIRShapeTestPasses
     MLIRSPIRVTestPasses
     MLIRTensorTestPasses
     MLIRTestAnalysis
     MLIRTestDialect
+    MLIRTestDynDialect
     MLIRTestIR
     MLIRTestPass
     MLIRTestPDLL
     MLIRTestReducer
     MLIRTestRewrite
     MLIRTestTransformDialect
     MLIRTestTransforms
     MLIRVectorTestPasses

mlir/tools/mlir-opt/mlir-opt.cpp

 void registerTestTransformDialectInterpreterPass();
 void registerTestVectorLowerings();
 } // namespace test
 } // namespace mlir
 
 namespace test {
 void registerTestDialect(DialectRegistry &);
 void registerTestTransformDialectExtension(DialectRegistry &);
+void registerTestDynDialect(DialectRegistry &);
 } // namespace test
 
 #ifdef MLIR_INCLUDE_TESTS
 void registerTestPasses() {
   registerCloneTestPasses();
   registerConvertToTargetEnvPass();
   registerPassManagerTestPass();
   registerPrintSpirvAvailabilityPass();

 #ifdef MLIR_INCLUDE_TESTS
   registerTestPasses();
 #endif
   DialectRegistry registry;
   registerAllDialects(registry);
 #ifdef MLIR_INCLUDE_TESTS
   ::test::registerTestDialect(registry);
   ::test::registerTestTransformDialectExtension(registry);
+  ::test::registerTestDynDialect(registry);
 #endif
   return mlir::asMainReturnCode(
       mlir::MlirOptMain(argc, argv, "MLIR modular optimizer driver\n", registry,
                         /*preloadDialectsInContext=*/false));
 }