Refactor OperationName to use virtual tables for dispatch (NFC)

[mehdi_amini]

Summary

This streamlines the implementation and makes it so that the virtual tables are in the binary instead of dynamically assembled during initialization.
The dynamic allocation size of op registration is also smaller with this
change.

[mehdi_amini]

Make OperationName::Impl itself having a vtable instead of having an extra level of indirection

[rriddle]

mlir/unittests/Interfaces/InferTypeOpInterfaceTest.cpp

39

Debugging?

[mehdi_amini]

Some more cleanup, moved many APIs from RegisteredOperationName to OperationName since they are just dynamic dispatch and the UnregisteredModel implementation does the right thing.

[mehdi_amini]

mlir/unittests/Interfaces/InferTypeOpInterfaceTest.cpp

39

Yes, but I figured it makes sense to keep it in the unit-test: it is mildly better than a bad segfault on the next line.

[ashay-github]

Hi @mehdi_amini, this patch is causing MSVC-compiled mlir-opt to crash at runtime with the following stack trace. Could you revert the patch for now to get the build working again please?

Exception Code: 0xC0000005

 #0 0x00007ff6a30cf153 llvm::function_ref<(class mlir::OpAsmParser &, struct mlir::OperationState &)>::callback_fn<class mlir::ParseResult (__cdecl *)(class mlir::OpAsmParser &, struct mlir::OperationState &)>(__int64, class mlir::OpAsmParser &, struct mlir::OperationState &) llvm-project\llvm\include\llvm\ADT\STLFunctionalExtras.h:45:0

 #1 0x00007ff6a85d82aa llvm::function_ref<(class mlir::OpAsmParser &, struct mlir::OperationState &)>::operator()(class mlir::OpAsmParser &, struct mlir::OperationState &) const llvm-project\llvm\include\llvm\ADT\STLFunctionalExtras.h:68:0

 #2 0x00007ff6a8a27468 `anonymous namespace'::CustomOpAsmParser::parseOperation llvm-project\mlir\lib\AsmParser\Parser.cpp:1439:0

 #3 0x00007ff6a8a207e4 `anonymous namespace'::OperationParser::parseCustomOperation llvm-project\mlir\lib\AsmParser\Parser.cpp:1934:0

 #4 0x00007ff6a8a1ce68 `anonymous namespace'::OperationParser::parseOperation llvm-project\mlir\lib\AsmParser\Parser.cpp:1143:0

 #5 0x00007ff6a8a2b366 `anonymous namespace'::TopLevelOperationParser::parse llvm-project\mlir\lib\AsmParser\Parser.cpp:2611:0

 ...

I'm not sure why the pre-merge checks didn't catch this. Perhaps they're not running, since I don't see build results here.

[mehdi_amini]

Sorry for the breakage! Is Exception Code: 0xC0000005 a segfault?
Any chance you could get a debug build symbolized backtrace here?

[mehdi_amini]

I see you posted a symbolized trace here, sorry I was looking directly at the logs on the bot :)

I think I should be able to re-land this with a fix soon

[mehdi_amini]

Green build after re-land: https://lab.llvm.org/buildbot/#/builders/13/builds/30874

[ashay-github]

No worries, thanks for reverting! As I understand, Exception Code: 0xC0000005 does mean a segfault.

mlir/include/mlir/IR/ExtensibleDialect.h

 };
 
 //===----------------------------------------------------------------------===//
 // Dynamic operation
 //===----------------------------------------------------------------------===//
 
 /// The definition of a dynamic op. A dynamic op is an op that is defined at
 /// runtime, and that can be registered at runtime by an extensible dialect (a
-/// dialect inheriting ExtensibleDialect). This class stores the functions that
-/// are in the OperationName class, and in addition defines the TypeID of the op
-/// that will be defined.
-/// Each dynamic operation definition refers to one instance of this class.
-class DynamicOpDefinition {
+/// dialect inheriting ExtensibleDialect). This class implements the method
+/// exposed by the OperationName class, and in addition defines the TypeID of
+/// the op that will be defined. Each dynamic operation definition refers to one
+/// instance of this class.
+class DynamicOpDefinition : public OperationName::Impl {
 public:
+  using GetCanonicalizationPatternsFn =
+      llvm::unique_function<void(RewritePatternSet &, MLIRContext *) const>;
+
   /// Create a new op at runtime. The op is registered only after passing it to
   /// the dialect using registerDynamicOp.
   static std::unique_ptr<DynamicOpDefinition>
   get(StringRef name, ExtensibleDialect *dialect,
       OperationName::VerifyInvariantsFn &&verifyFn,
       OperationName::VerifyRegionInvariantsFn &&verifyRegionFn);
   static std::unique_ptr<DynamicOpDefinition>
   get(StringRef name, ExtensibleDialect *dialect,
       OperationName::VerifyInvariantsFn &&verifyFn,
       OperationName::VerifyRegionInvariantsFn &&verifyRegionFn,
       OperationName::ParseAssemblyFn &&parseFn,
       OperationName::PrintAssemblyFn &&printFn);
   static std::unique_ptr<DynamicOpDefinition>
   get(StringRef name, ExtensibleDialect *dialect,
       OperationName::VerifyInvariantsFn &&verifyFn,
       OperationName::VerifyRegionInvariantsFn &&verifyRegionFn,
       OperationName::ParseAssemblyFn &&parseFn,
       OperationName::PrintAssemblyFn &&printFn,
       OperationName::FoldHookFn &&foldHookFn,
-      OperationName::GetCanonicalizationPatternsFn
-          &&getCanonicalizationPatternsFn,
+      GetCanonicalizationPatternsFn &&getCanonicalizationPatternsFn,
       OperationName::PopulateDefaultAttrsFn &&populateDefaultAttrsFn);
 
   /// Returns the op typeID.
   TypeID getTypeID() { return typeID; }
 
   /// Sets the verifier function for this operation. It should emits an error
   /// message and returns failure if a problem is detected, or returns success
   /// if everything is ok.
public:
   /// Sets the hook implementing a generalized folder for the op. See
   /// `RegisteredOperationName::foldHook` for more details
   void setFoldHookFn(OperationName::FoldHookFn &&foldHook) {
     foldHookFn = std::move(foldHook);
   }
 
   /// Set the hook returning any canonicalization pattern rewrites that the op
   /// supports, for use by the canonicalization pass.
-  void
-  setGetCanonicalizationPatternsFn(OperationName::GetCanonicalizationPatternsFn
-                                       &&getCanonicalizationPatterns) {
+  void setGetCanonicalizationPatternsFn(
+      GetCanonicalizationPatternsFn &&getCanonicalizationPatterns) {
     getCanonicalizationPatternsFn = std::move(getCanonicalizationPatterns);
   }
 
   /// Set the hook populating default attributes.
   void setPopulateDefaultAttrsFn(
       OperationName::PopulateDefaultAttrsFn &&populateDefaultAttrs) {
     populateDefaultAttrsFn = std::move(populateDefaultAttrs);
   }
 
+  LogicalResult foldHook(Operation *op, ArrayRef<Attribute> attrs,
+                         SmallVectorImpl<OpFoldResult> &results) final {
+    return foldHookFn(op, attrs, results);
+  }
+  void getCanonicalizationPatterns(RewritePatternSet &set,
+                                   MLIRContext *context) final {
+    getCanonicalizationPatternsFn(set, context);
+  }
+  bool hasTrait(TypeID id) final { return false; }
+  OperationName::ParseAssemblyFn getParseAssemblyFn() final { return parseFn; }
+  void populateDefaultAttrs(const OperationName &name,
+                            NamedAttrList &attrs) final {
+    populateDefaultAttrsFn(name, attrs);
+  }
+  void printAssembly(Operation *op, OpAsmPrinter &printer,
+                     StringRef name) final {
+    printFn(op, printer, name);
+  }
+  LogicalResult verifyInvariants(Operation *op) final { return verifyFn(op); }
+  LogicalResult verifyRegionInvariants(Operation *op) final {
+    return verifyRegionFn(op);
+  }
+
 private:
   DynamicOpDefinition(
       StringRef name, ExtensibleDialect *dialect,
       OperationName::VerifyInvariantsFn &&verifyFn,
       OperationName::VerifyRegionInvariantsFn &&verifyRegionFn,
       OperationName::ParseAssemblyFn &&parseFn,
       OperationName::PrintAssemblyFn &&printFn,
       OperationName::FoldHookFn &&foldHookFn,
-      OperationName::GetCanonicalizationPatternsFn
-          &&getCanonicalizationPatternsFn,
+      GetCanonicalizationPatternsFn &&getCanonicalizationPatternsFn,
       OperationName::PopulateDefaultAttrsFn &&populateDefaultAttrsFn);
 
-  /// Unique identifier for this operation.
-  TypeID typeID;
-
-  /// Name of the operation.
-  /// The name is prefixed with the dialect name.
-  std::string name;
-
   /// Dialect defining this operation.
-  ExtensibleDialect *dialect;
+  ExtensibleDialect *getdialect();
 
   OperationName::VerifyInvariantsFn verifyFn;
   OperationName::VerifyRegionInvariantsFn verifyRegionFn;
   OperationName::ParseAssemblyFn parseFn;
   OperationName::PrintAssemblyFn printFn;
   OperationName::FoldHookFn foldHookFn;
-  OperationName::GetCanonicalizationPatternsFn getCanonicalizationPatternsFn;
+  GetCanonicalizationPatternsFn getCanonicalizationPatternsFn;
   OperationName::PopulateDefaultAttrsFn populateDefaultAttrsFn;
 
   friend ExtensibleDialect;
 };
 
 //===----------------------------------------------------------------------===//
 // Extensible dialect
 //===----------------------------------------------------------------------===//

mlir/include/mlir/IR/OpDefinition.h

public:
   // These are default implementations of customization hooks.
 public:
   /// This hook returns any canonicalization pattern rewrites that the operation
   /// supports, for use by the canonicalization pass.
   static void getCanonicalizationPatterns(RewritePatternSet &results,
                                           MLIRContext *context) {}
 
   /// This hook populates any unset default attrs.
-  static void populateDefaultAttrs(const RegisteredOperationName &,
-                                   NamedAttrList &) {}
+  static void populateDefaultAttrs(const OperationName &, NamedAttrList &) {}
 
 protected:
   /// If the concrete type didn't implement a custom verifier hook, just fall
   /// back to this one which accepts everything.
   LogicalResult verify() { return success(); }
   LogicalResult verifyRegions() { return success(); }
 
   /// Parse the custom form of an operation. Unless overridden, this method will
static LogicalResult foldHook(Operation *op, ArrayRef<Attribute> operands,
     if (failed(result) || results.empty()) {
       if (succeeded(op_definition_impl::foldTraits<Traits<ConcreteType>...>(
               op, operands, results)))
         return success();
     }
     return result;
   }
 
-  /// Implementation of `GetCanonicalizationPatternsFn` OperationName hook.
-  static OperationName::GetCanonicalizationPatternsFn
-  getGetCanonicalizationPatternsFn() {
-    return &ConcreteType::getCanonicalizationPatterns;
-  }
   /// Implementation of `GetHasTraitFn`
   static OperationName::HasTraitFn getHasTraitFn() {
     return
         [](TypeID id) { return op_definition_impl::hasTrait<Traits...>(id); };
   }
-  /// Implementation of `ParseAssemblyFn` OperationName hook.
-  static OperationName::ParseAssemblyFn getParseAssemblyFn() {
-    return &ConcreteType::parse;
-  }
   /// Implementation of `PrintAssemblyFn` OperationName hook.
   static OperationName::PrintAssemblyFn getPrintAssemblyFn() {
     if constexpr (detect_has_print<ConcreteType>::value)
       return [](Operation *op, OpAsmPrinter &p, StringRef defaultDialect) {
         OpState::printOpName(op, p, defaultDialect);
         return cast<ConcreteType>(op).print(p);
       };
     return [](Operation *op, OpAsmPrinter &printer, StringRef defaultDialect) {

mlir/include/mlir/IR/Operation.h

void setDialectAttrs(DialectAttrT &&dialectAttrs) {
     for (auto attr : getAttrs())
       if (!attr.getName().strref().contains('.'))
         attrs.push_back(attr);
     setAttrs(attrs.getDictionary(getContext()));
   }
 
   /// Sets default attributes on unset attributes.
   void populateDefaultAttrs() {
-    if (auto registered = getRegisteredInfo()) {
       NamedAttrList attrs(getAttrDictionary());
-      registered->populateDefaultAttrs(attrs);
+      name.populateDefaultAttrs(attrs);
       setAttrs(attrs.getDictionary(getContext()));
-    }
-  }
 
   //===--------------------------------------------------------------------===//
   // Blocks
   //===--------------------------------------------------------------------===//
 
   /// Returns the number of regions held by this operation.
   unsigned getNumRegions() { return numRegions; }
 

mlir/include/mlir/IR/OperationSupport.h

 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/TypeRange.h"
 #include "mlir/IR/Types.h"
 #include "mlir/IR/Value.h"
 #include "mlir/Support/InterfaceSupport.h"
 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/PointerUnion.h"
+#include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include "llvm/Support/TrailingObjects.h"
 #include <memory>
 
 namespace llvm {
 class BitVector;
 } // namespace llvm
 

 class ValueTypeRange;
 
 //===----------------------------------------------------------------------===//
 // OperationName
 //===----------------------------------------------------------------------===//
 
 class OperationName {
 public:
-  using GetCanonicalizationPatternsFn =
-      llvm::unique_function<void(RewritePatternSet &, MLIRContext *) const>;
   using FoldHookFn = llvm::unique_function<LogicalResult(
       Operation *, ArrayRef<Attribute>, SmallVectorImpl<OpFoldResult> &) const>;
   using HasTraitFn = llvm::unique_function<bool(TypeID) const>;
   using ParseAssemblyFn =
-      llvm::unique_function<ParseResult(OpAsmParser &, OperationState &) const>;
+      llvm::function_ref<ParseResult(OpAsmParser &, OperationState &)>;
   // Note: RegisteredOperationName is passed as reference here as the derived
   // class is defined below.
-  using PopulateDefaultAttrsFn = llvm::unique_function<void(
-      const RegisteredOperationName &, NamedAttrList &) const>;
+  using PopulateDefaultAttrsFn =
+      llvm::unique_function<void(const OperationName &, NamedAttrList &) const>;
   using PrintAssemblyFn =
       llvm::unique_function<void(Operation *, OpAsmPrinter &, StringRef) const>;
   using VerifyInvariantsFn =
       llvm::unique_function<LogicalResult(Operation *) const>;
   using VerifyRegionInvariantsFn =
       llvm::unique_function<LogicalResult(Operation *) const>;
 
-protected:
   /// This class represents a type erased version of an operation. It contains
   /// all of the components necessary for opaquely interacting with an
   /// operation. If the operation is not registered, some of these components
   /// may not be populated.
-  struct Impl {
-    Impl(StringAttr name)
-        : name(name), dialect(nullptr), interfaceMap(std::nullopt) {}
+  struct InterfaceConcept {
+    virtual ~InterfaceConcept() = default;
+    virtual LogicalResult foldHook(Operation *, ArrayRef<Attribute>,
+                                   SmallVectorImpl<OpFoldResult> &) = 0;
+    virtual void getCanonicalizationPatterns(RewritePatternSet &,
+                                             MLIRContext *) = 0;
+    virtual bool hasTrait(TypeID) = 0;
+    virtual OperationName::ParseAssemblyFn getParseAssemblyFn() = 0;
+    virtual void populateDefaultAttrs(const OperationName &,
+                                      NamedAttrList &) = 0;
+    virtual void printAssembly(Operation *, OpAsmPrinter &, StringRef) = 0;
+    virtual LogicalResult verifyInvariants(Operation *) = 0;
+    virtual LogicalResult verifyRegionInvariants(Operation *) = 0;
+  };
 
-    /// The name of the operation.
-    StringAttr name;
+public:
+  class Impl : public InterfaceConcept {
+  public:
+    Impl(StringRef, Dialect *dialect, TypeID typeID,
+         detail::InterfaceMap interfaceMap);
+    Impl(StringAttr name, Dialect *dialect, TypeID typeID,
+         detail::InterfaceMap interfaceMap)
+        : name(name), typeID(typeID), dialect(dialect),
+          interfaceMap(std::move(interfaceMap)) {}
+
+    /// Returns true if this is a registered operation.
+    bool isRegistered() const { return typeID != TypeID::get<void>(); }
+    detail::InterfaceMap &getInterfaceMap() { return interfaceMap; }
+    Dialect *getDialect() const { return dialect; }
+    StringAttr getName() const { return name; }
+    TypeID getTypeID() const { return typeID; }
+    ArrayRef<StringAttr> getAttributeNames() const { return attributeNames; }
 
+  protected:
     //===------------------------------------------------------------------===//
     // Registered Operation Info
 
+    /// The name of the operation.
+    StringAttr name;
+
+    /// The unique identifier of the derived Op class.
+    TypeID typeID;
+
     /// The following fields are only populated when the operation is
     /// registered.
 
-    /// Returns true if the operation has been registered, i.e. if the
-    /// registration info has been populated.
-    bool isRegistered() const { return dialect; }
-
     /// This is the dialect that this operation belongs to.
     Dialect *dialect;
 
-    /// The unique identifier of the derived Op class.
-    TypeID typeID;
-
     /// A map of interfaces that were registered to this operation.
     detail::InterfaceMap interfaceMap;
 
-    /// Internal callback hooks provided by the op implementation.
-    FoldHookFn foldHookFn;
-    GetCanonicalizationPatternsFn getCanonicalizationPatternsFn;
-    HasTraitFn hasTraitFn;
-    ParseAssemblyFn parseAssemblyFn;
-    PopulateDefaultAttrsFn populateDefaultAttrsFn;
-    PrintAssemblyFn printAssemblyFn;
-    VerifyInvariantsFn verifyInvariantsFn;
-    VerifyRegionInvariantsFn verifyRegionInvariantsFn;
-
     /// A list of attribute names registered to this operation in StringAttr
     /// form. This allows for operation classes to use StringAttr for attribute
     /// lookup/creation/etc., as opposed to raw strings.
     ArrayRef<StringAttr> attributeNames;
+
+    friend class RegisteredOperationName;
+  };
+
+protected:
+  /// Default implementation for unregistered operations.
+  struct UnregisteredOpModel : public Impl {
+    using Impl::Impl;
+    LogicalResult foldHook(Operation *, ArrayRef<Attribute>,
+                           SmallVectorImpl<OpFoldResult> &) final;
+    void getCanonicalizationPatterns(RewritePatternSet &, MLIRContext *) final;
+    bool hasTrait(TypeID) final;
+    virtual OperationName::ParseAssemblyFn getParseAssemblyFn() final;
+    void populateDefaultAttrs(const OperationName &, NamedAttrList &) final;
+    void printAssembly(Operation *, OpAsmPrinter &, StringRef) final;
+    LogicalResult verifyInvariants(Operation *) final;
+    LogicalResult verifyRegionInvariants(Operation *) final;
   };
 
 public:
   OperationName(StringRef name, MLIRContext *context);
 
   /// Return if this operation is registered.
-  bool isRegistered() const { return impl->isRegistered(); }
+  bool isRegistered() const { return getImpl()->isRegistered(); }
+
+  /// Return the unique identifier of the derived Op class, or null if not
+  /// registered.
+  TypeID getTypeID() const { return getImpl()->getTypeID(); }
 
   /// If this operation is registered, returns the registered information,
   /// std::nullopt otherwise.
   Optional<RegisteredOperationName> getRegisteredInfo() const;
 
+  /// This hook implements a generalized folder for this operation. Operations
+  /// can implement this to provide simplifications rules that are applied by
+  /// the Builder::createOrFold API and the canonicalization pass.
+  ///
+  /// This is an intentionally limited interface - implementations of this
+  /// hook can only perform the following changes to the operation:
+  ///
+  ///  1. They can leave the operation alone and without changing the IR, and
+  ///     return failure.
+  ///  2. They can mutate the operation in place, without changing anything
+  ///  else
+  ///     in the IR.  In this case, return success.
+  ///  3. They can return a list of existing values that can be used instead
+  ///  of
+  ///     the operation.  In this case, fill in the results list and return
+  ///     success.  The caller will remove the operation and use those results
+  ///     instead.
+  ///
+  /// This allows expression of some simple in-place canonicalizations (e.g.
+  /// "x+0 -> x", "min(x,y,x,z) -> min(x,y,z)", "x+y-x -> y", etc), as well as
+  /// generalized constant folding.
+  LogicalResult foldHook(Operation *op, ArrayRef<Attribute> operands,
+                         SmallVectorImpl<OpFoldResult> &results) const {
+    return getImpl()->foldHook(op, operands, results);
+  }
+
+  /// This hook returns any canonicalization pattern rewrites that the
+  /// operation supports, for use by the canonicalization pass.
+  void getCanonicalizationPatterns(RewritePatternSet &results,
+                                   MLIRContext *context) const {
+    return getImpl()->getCanonicalizationPatterns(results, context);
+  }
+
   /// Returns true if the operation was registered with a particular trait, e.g.
   /// hasTrait<OperandsAreSignlessIntegerLike>(). Returns false if the operation
   /// is unregistered.
   template <template <typename T> class Trait>
   bool hasTrait() const {
     return hasTrait(TypeID::get<Trait>());
   }
-  bool hasTrait(TypeID traitID) const {
-    return isRegistered() && impl->hasTraitFn(traitID);
-  }
+  bool hasTrait(TypeID traitID) const { return getImpl()->hasTrait(traitID); }
 
   /// Returns true if the operation *might* have the provided trait. This
   /// means that either the operation is unregistered, or it was registered with
   /// the provide trait.
   template <template <typename T> class Trait>
   bool mightHaveTrait() const {
     return mightHaveTrait(TypeID::get<Trait>());
   }
   bool mightHaveTrait(TypeID traitID) const {
-    return !isRegistered() || impl->hasTraitFn(traitID);
+    return !isRegistered() || getImpl()->hasTrait(traitID);
+  }
+
+  /// Return the static hook for parsing this operation assembly.
+  ParseAssemblyFn getParseAssemblyFn() const {
+    return getImpl()->getParseAssemblyFn();
+  }
+
+  /// This hook implements the method to populate defaults attributes that are
+  /// unset.
+  void populateDefaultAttrs(NamedAttrList &attrs) const {
+    getImpl()->populateDefaultAttrs(*this, attrs);
+  }
+
+  /// This hook implements the AsmPrinter for this operation.
+  void printAssembly(Operation *op, OpAsmPrinter &p,
+                     StringRef defaultDialect) const {
+    return getImpl()->printAssembly(op, p, defaultDialect);
+  }
+
+  /// These hooks implement the verifiers for this operation.  It should emits
+  /// an error message and returns failure if a problem is detected, or
+  /// returns success if everything is ok.
+  LogicalResult verifyInvariants(Operation *op) const {
+    return getImpl()->verifyInvariants(op);
+  }
+  LogicalResult verifyRegionInvariants(Operation *op) const {
+    return getImpl()->verifyRegionInvariants(op);
+  }
+
+  /// Return the list of cached attribute names registered to this operation.
+  /// The order of attributes cached here is unique to each type of operation,
+  /// and the interpretation of this attribute list should generally be driven
+  /// by the respective operation. In many cases, this caching removes the
+  /// need to use the raw string name of a known attribute.
+  ///
+  /// For example the ODS generator, with an op defining the following
+  /// attributes:
+  ///
+  ///   let arguments = (ins I32Attr:$attr1, I32Attr:$attr2);
+  ///
+  /// ... may produce an order here of ["attr1", "attr2"]. This allows for the
+  /// ODS generator to directly access the cached name for a known attribute,
+  /// greatly simplifying the cost and complexity of attribute usage produced
+  /// by the generator.
+  ///
+  ArrayRef<StringAttr> getAttributeNames() const {
+    return getImpl()->getAttributeNames();
   }
 
   /// Returns an instance of the concept object for the given interface if it
   /// was registered to this operation, null otherwise. This should not be used
   /// directly.
   template <typename T>
   typename T::Concept *getInterface() const {
-    return impl->interfaceMap.lookup<T>();
+    return getImpl()->getInterfaceMap().lookup<T>();
+  }
+
+  /// Attach the given models as implementations of the corresponding
+  /// interfaces for the concrete operation.
+  template <typename... Models> void attachInterface() {
+    getImpl()->getInterfaceMap().insert<Models...>();
   }
 
   /// Returns true if this operation has the given interface registered to it.
   template <typename T>
   bool hasInterface() const {
     return hasInterface(TypeID::get<T>());
   }
   bool hasInterface(TypeID interfaceID) const {
-    return impl->interfaceMap.contains(interfaceID);
+    return getImpl()->getInterfaceMap().contains(interfaceID);
   }
 
   /// Returns true if the operation *might* have the provided interface. This
   /// means that either the operation is unregistered, or it was registered with
   /// the provide interface.
   template <typename T>
   bool mightHaveInterface() const {
     return mightHaveInterface(TypeID::get<T>());
   }
   bool mightHaveInterface(TypeID interfaceID) const {
     return !isRegistered() || hasInterface(interfaceID);
   }
 
   /// Return the dialect this operation is registered to if the dialect is
   /// loaded in the context, or nullptr if the dialect isn't loaded.
   Dialect *getDialect() const {
-    return isRegistered() ? impl->dialect : impl->name.getReferencedDialect();
+    return isRegistered() ? getImpl()->getDialect()
+                          : getImpl()->getName().getReferencedDialect();
   }
 
   /// Return the name of the dialect this operation is registered to.
   StringRef getDialectNamespace() const;
 
   /// Return the operation name with dialect name stripped, if it has one.
   StringRef stripDialect() const { return getStringRef().split('.').second; }
 
   /// Return the name of this operation. This always succeeds.
   StringRef getStringRef() const { return getIdentifier(); }
 
   /// Return the name of this operation as a StringAttr.
-  StringAttr getIdentifier() const { return impl->name; }
+  StringAttr getIdentifier() const { return getImpl()->getName(); }
 
   void print(raw_ostream &os) const;
   void dump() const;
 
   /// Represent the operation name as an opaque pointer. (Used to support
   /// PointerLikeTypeTraits).
   void *getAsOpaquePointer() const { return const_cast<Impl *>(impl); }
   static OperationName getFromOpaquePointer(const void *pointer) {
     return OperationName(
         const_cast<Impl *>(reinterpret_cast<const Impl *>(pointer)));
   }
 
   bool operator==(const OperationName &rhs) const { return impl == rhs.impl; }
   bool operator!=(const OperationName &rhs) const { return !(*this == rhs); }
 
 protected:
   OperationName(Impl *impl) : impl(impl) {}
+  Impl *getImpl() const { return impl; }
+  void setImpl(Impl *rhs) { impl = rhs; }
 
+private:
   /// The internal implementation of the operation name.
-  Impl *impl;
+  Impl *impl = nullptr;
 
   /// Allow access to the Impl struct.
   friend MLIRContextImpl;
+  friend DenseMapInfo<mlir::OperationName>;
+  friend DenseMapInfo<mlir::RegisteredOperationName>;
 };
 
 inline raw_ostream &operator<<(raw_ostream &os, OperationName info) {
   info.print(os);
   return os;
 }
 
 // Make operation names hashable.
 inline llvm::hash_code hash_value(OperationName arg) {
   return llvm::hash_value(arg.getAsOpaquePointer());
 }
 
 //===----------------------------------------------------------------------===//
 // RegisteredOperationName
 //===----------------------------------------------------------------------===//
 
 /// This is a "type erased" representation of a registered operation. This
 /// should only be used by things like the AsmPrinter and other things that need
 /// to be parameterized by generic operation hooks. Most user code should use
 /// the concrete operation types.
 class RegisteredOperationName : public OperationName {
 public:
+  /// Implementation of the InterfaceConcept for operation APIs that forwarded
+  /// to a concrete op implementation.
+  template <typename ConcreteOp> struct Model : public Impl {
+    Model(Dialect *dialect)
+        : Impl(ConcreteOp::getOperationName(), dialect,
+               TypeID::get<ConcreteOp>(), ConcreteOp::getInterfaceMap()) {}
+    LogicalResult foldHook(Operation *op, ArrayRef<Attribute> attrs,
+                           SmallVectorImpl<OpFoldResult> &results) final {
+      return ConcreteOp::getFoldHookFn()(op, attrs, results);
+    }
+    void getCanonicalizationPatterns(RewritePatternSet &set,
+                                     MLIRContext *context) final {
+      ConcreteOp::getCanonicalizationPatterns(set, context);
+    }
+    bool hasTrait(TypeID id) final { return ConcreteOp::getHasTraitFn()(id); }
+    OperationName::ParseAssemblyFn getParseAssemblyFn() final {
+      return ConcreteOp::parse;
+    }
+    void populateDefaultAttrs(const OperationName &name,
+                              NamedAttrList &attrs) final {
+      ConcreteOp::populateDefaultAttrs(name, attrs);
+    }
+    void printAssembly(Operation *op, OpAsmPrinter &printer,
+                       StringRef name) final {
+      ConcreteOp::getPrintAssemblyFn()(op, printer, name);
+    }
+    LogicalResult verifyInvariants(Operation *op) final {
+      return ConcreteOp::getVerifyInvariantsFn()(op);
+    }
+    LogicalResult verifyRegionInvariants(Operation *op) final {
+      return ConcreteOp::getVerifyRegionInvariantsFn()(op);
+    }
+  };
+
   /// Lookup the registered operation information for the given operation.
   /// Returns std::nullopt if the operation isn't registered.
   static Optional<RegisteredOperationName> lookup(StringRef name,
                                                   MLIRContext *ctx);
 
   /// Register a new operation in a Dialect object.
-  /// This constructor is used by Dialect objects when they register the list of
-  /// operations they contain.
-  template <typename T>
-  static void insert(Dialect &dialect) {
-    insert(T::getOperationName(), dialect, TypeID::get<T>(),
-           T::getParseAssemblyFn(), T::getPrintAssemblyFn(),
-           T::getVerifyInvariantsFn(), T::getVerifyRegionInvariantsFn(),
-           T::getFoldHookFn(), T::getGetCanonicalizationPatternsFn(),
-           T::getInterfaceMap(), T::getHasTraitFn(), T::getAttributeNames(),
-           T::getPopulateDefaultAttrsFn());
+  /// This constructor is used by Dialect objects when they register the list
+  /// of operations they contain.
+  template <typename T> static void insert(Dialect &dialect) {
+    insert(std::make_unique<Model<T>>(&dialect), T::getAttributeNames());
   }
   /// The use of this method is in general discouraged in favor of
   /// 'insert<CustomOp>(dialect)'.
-  static void
-  insert(StringRef name, Dialect &dialect, TypeID typeID,
-         ParseAssemblyFn &&parseAssembly, PrintAssemblyFn &&printAssembly,
-         VerifyInvariantsFn &&verifyInvariants,
-         VerifyRegionInvariantsFn &&verifyRegionInvariants,
-         FoldHookFn &&foldHook,
-         GetCanonicalizationPatternsFn &&getCanonicalizationPatterns,
-         detail::InterfaceMap &&interfaceMap, HasTraitFn &&hasTrait,
-         ArrayRef<StringRef> attrNames,
-         PopulateDefaultAttrsFn &&populateDefaultAttrs);
+  static void insert(std::unique_ptr<OperationName::Impl> ownedImpl,
+                     ArrayRef<StringRef> attrNames);
 
   /// Return the dialect this operation is registered to.
-  Dialect &getDialect() const { return *impl->dialect; }
-
-  /// Return the unique identifier of the derived Op class.
-  TypeID getTypeID() const { return impl->typeID; }
+  Dialect &getDialect() const { return *getImpl()->getDialect(); }
 
   /// Use the specified object to parse this ops custom assembly format.
   ParseResult parseAssembly(OpAsmParser &parser, OperationState &result) const;
 
-  /// Return the static hook for parsing this operation assembly.
-  const ParseAssemblyFn &getParseAssemblyFn() const {
-    return impl->parseAssemblyFn;
-  }
-
-  /// This hook implements the AsmPrinter for this operation.
-  void printAssembly(Operation *op, OpAsmPrinter &p,
-                     StringRef defaultDialect) const {
-    return impl->printAssemblyFn(op, p, defaultDialect);
-  }
-
-  /// These hooks implement the verifiers for this operation.  It should emits
-  /// an error message and returns failure if a problem is detected, or returns
-  /// success if everything is ok.
-  LogicalResult verifyInvariants(Operation *op) const {
-    return impl->verifyInvariantsFn(op);
-  }
-  LogicalResult verifyRegionInvariants(Operation *op) const {
-    return impl->verifyRegionInvariantsFn(op);
-  }
-
-  /// This hook implements a generalized folder for this operation.  Operations
-  /// can implement this to provide simplifications rules that are applied by
-  /// the Builder::createOrFold API and the canonicalization pass.
-  ///
-  /// This is an intentionally limited interface - implementations of this hook
-  /// can only perform the following changes to the operation:
-  ///
-  ///  1. They can leave the operation alone and without changing the IR, and
-  ///     return failure.
-  ///  2. They can mutate the operation in place, without changing anything else
-  ///     in the IR.  In this case, return success.
-  ///  3. They can return a list of existing values that can be used instead of
-  ///     the operation.  In this case, fill in the results list and return
-  ///     success.  The caller will remove the operation and use those results
-  ///     instead.
-  ///
-  /// This allows expression of some simple in-place canonicalizations (e.g.
-  /// "x+0 -> x", "min(x,y,x,z) -> min(x,y,z)", "x+y-x -> y", etc), as well as
-  /// generalized constant folding.
-  LogicalResult foldHook(Operation *op, ArrayRef<Attribute> operands,
-                         SmallVectorImpl<OpFoldResult> &results) const {
-    return impl->foldHookFn(op, operands, results);
-  }
-
-  /// This hook returns any canonicalization pattern rewrites that the operation
-  /// supports, for use by the canonicalization pass.
-  void getCanonicalizationPatterns(RewritePatternSet &results,
-                                   MLIRContext *context) const {
-    return impl->getCanonicalizationPatternsFn(results, context);
-  }
-
-  /// Attach the given models as implementations of the corresponding interfaces
-  /// for the concrete operation.
-  template <typename... Models>
-  void attachInterface() {
-    impl->interfaceMap.insert<Models...>();
-  }
-
-  /// Returns true if the operation has a particular trait.
-  template <template <typename T> class Trait>
-  bool hasTrait() const {
-    return hasTrait(TypeID::get<Trait>());
-  }
-
-  /// Returns true if the operation has a particular trait.
-  bool hasTrait(TypeID traitID) const { return impl->hasTraitFn(traitID); }
-
-  /// Return the list of cached attribute names registered to this operation.
-  /// The order of attributes cached here is unique to each type of operation,
-  /// and the interpretation of this attribute list should generally be driven
-  /// by the respective operation. In many cases, this caching removes the need
-  /// to use the raw string name of a known attribute.
-  ///
-  /// For example the ODS generator, with an op defining the following
-  /// attributes:
-  ///
-  ///   let arguments = (ins I32Attr:$attr1, I32Attr:$attr2);
-  ///
-  /// ... may produce an order here of ["attr1", "attr2"]. This allows for the
-  /// ODS generator to directly access the cached name for a known attribute,
-  /// greatly simplifying the cost and complexity of attribute usage produced by
-  /// the generator.
-  ///
-  ArrayRef<StringAttr> getAttributeNames() const {
-    return impl->attributeNames;
-  }
-
-  /// This hook implements the method to populate defaults attributes that are
-  /// unset.
-  void populateDefaultAttrs(NamedAttrList &attrs) const;
-
   /// Represent the operation name as an opaque pointer. (Used to support
   /// PointerLikeTypeTraits).
   static RegisteredOperationName getFromOpaquePointer(const void *pointer) {
     return RegisteredOperationName(
         const_cast<Impl *>(reinterpret_cast<const Impl *>(pointer)));
   }
 
 private:

mlir/lib/AsmParser/Parser.cpp

Operation *OperationParser::parseGenericOperation() {
 
   OperationState result(srcLocation, name);
   CleanupOpStateRegions guard{result};
 
   // Lazy load dialects in the context as needed.
   if (!result.name.isRegistered()) {
     StringRef dialectName = StringRef(name).split('.').first;
     if (!getContext()->getLoadedDialect(dialectName) &&
-        !getContext()->getOrLoadDialect(dialectName) &&
-        !getContext()->allowsUnregisteredDialects()) {
+        !getContext()->getOrLoadDialect(dialectName)) {
+      if (!getContext()->allowsUnregisteredDialects()) {
         // Emit an error if the dialect couldn't be loaded (i.e., it was not
         // registered) and unregistered dialects aren't allowed.
         emitError("operation being parsed with an unregistered dialect. If "
                   "this is intended, please use -allow-unregistered-dialect "
                   "with the MLIR tool used");
         return nullptr;
       }
+    } else {
+      // Reload the OperationName now that the dialect is loaded.
+      result.name = OperationName(name, getContext());
+    }
   }
 
   // If we are populating the parser state, start a new operation definition.
   if (state.asmState)
     state.asmState->startOperationDefinition(result.name);
 
   if (parseGenericOperationAfterOpName(result))
     return nullptr;

mlir/lib/IR/AsmPrinter.cpp

public:
   /// or the generic assembly form, otherwise.
   void printCustomOrGenericOp(Operation *op) override {
     // Visit the operation location.
     if (printerFlags.shouldPrintDebugInfo())
       initializer.visit(op->getLoc(), /*canBeDeferred=*/true);
 
     // If requested, always print the generic form.
     if (!printerFlags.shouldPrintGenericOpForm()) {
-      // Check to see if this is a known operation.  If so, use the registered
-      // custom printer hook.
-      if (auto opInfo = op->getRegisteredInfo()) {
-        opInfo->printAssembly(op, *this, /*defaultDialect=*/"");
-        return;
-      }
-    }
+      op->getName().printAssembly(op, *this, /*defaultDialect=*/"");
 
     // Otherwise print with the generic assembly form.
     printGenericOp(op);
   }
 
 private:
   /// Print the given operation in the generic form.
   void printGenericOp(Operation *op, bool printOpName = true) override {

mlir/lib/IR/ExtensibleDialect.cpp

 
 DynamicOpDefinition::DynamicOpDefinition(
     StringRef name, ExtensibleDialect *dialect,
     OperationName::VerifyInvariantsFn &&verifyFn,
     OperationName::VerifyRegionInvariantsFn &&verifyRegionFn,
     OperationName::ParseAssemblyFn &&parseFn,
     OperationName::PrintAssemblyFn &&printFn,
     OperationName::FoldHookFn &&foldHookFn,
-    OperationName::GetCanonicalizationPatternsFn
-        &&getCanonicalizationPatternsFn,
+    GetCanonicalizationPatternsFn &&getCanonicalizationPatternsFn,
     OperationName::PopulateDefaultAttrsFn &&populateDefaultAttrsFn)
-    : typeID(dialect->allocateTypeID()),
-      name((dialect->getNamespace() + "." + name).str()), dialect(dialect),
+    : Impl(StringAttr::get(dialect->getContext(),
+                           (dialect->getNamespace() + "." + name).str()),
+           dialect, dialect->allocateTypeID(),
+           /*interfaceMap=*/detail::InterfaceMap(std::nullopt)),
       verifyFn(std::move(verifyFn)), verifyRegionFn(std::move(verifyRegionFn)),
       parseFn(std::move(parseFn)), printFn(std::move(printFn)),
       foldHookFn(std::move(foldHookFn)),
       getCanonicalizationPatternsFn(std::move(getCanonicalizationPatternsFn)),
-      populateDefaultAttrsFn(std::move(populateDefaultAttrsFn)) {}
+      populateDefaultAttrsFn(std::move(populateDefaultAttrsFn)) {
+  typeID = dialect->allocateTypeID();
+}
 
 std::unique_ptr<DynamicOpDefinition> DynamicOpDefinition::get(
     StringRef name, ExtensibleDialect *dialect,
     OperationName::VerifyInvariantsFn &&verifyFn,
     OperationName::VerifyRegionInvariantsFn &&verifyRegionFn) {
   auto parseFn = [](OpAsmParser &parser, OperationState &result) {
     return parser.emitError(
         parser.getCurrentLocation(),
std::unique_ptr<DynamicOpDefinition> DynamicOpDefinition::get(
   auto foldHookFn = [](Operation *op, ArrayRef<Attribute> operands,
                        SmallVectorImpl<OpFoldResult> &results) {
     return failure();
   };
 
   auto getCanonicalizationPatternsFn = [](RewritePatternSet &, MLIRContext *) {
   };
 
-  auto populateDefaultAttrsFn = [](const RegisteredOperationName &,
-                                   NamedAttrList &) {};
+  auto populateDefaultAttrsFn = [](const OperationName &, NamedAttrList &) {};
 
   return DynamicOpDefinition::get(name, dialect, std::move(verifyFn),
                                   std::move(verifyRegionFn), std::move(parseFn),
                                   std::move(printFn), std::move(foldHookFn),
                                   std::move(getCanonicalizationPatternsFn),
                                   std::move(populateDefaultAttrsFn));
 }
 
 std::unique_ptr<DynamicOpDefinition> DynamicOpDefinition::get(
     StringRef name, ExtensibleDialect *dialect,
     OperationName::VerifyInvariantsFn &&verifyFn,
     OperationName::VerifyInvariantsFn &&verifyRegionFn,
     OperationName::ParseAssemblyFn &&parseFn,
     OperationName::PrintAssemblyFn &&printFn,
     OperationName::FoldHookFn &&foldHookFn,
-    OperationName::GetCanonicalizationPatternsFn
-        &&getCanonicalizationPatternsFn,
+    GetCanonicalizationPatternsFn &&getCanonicalizationPatternsFn,
     OperationName::PopulateDefaultAttrsFn &&populateDefaultAttrsFn) {
   return std::unique_ptr<DynamicOpDefinition>(new DynamicOpDefinition(
       name, dialect, std::move(verifyFn), std::move(verifyRegionFn),
       std::move(parseFn), std::move(printFn), std::move(foldHookFn),
       std::move(getCanonicalizationPatternsFn),
       std::move(populateDefaultAttrsFn)));
 }
 
void ExtensibleDialect::registerDynamicAttr(
   addAttribute(typeID, std::move(abstractAttr));
   attrPtr->registerInAttrUniquer();
 }
 
 void ExtensibleDialect::registerDynamicOp(
     std::unique_ptr<DynamicOpDefinition> &&op) {
   assert(op->dialect == this &&
          "trying to register a dynamic op in the wrong dialect");
-  auto hasTraitFn = [](TypeID traitId) { return false; };
-
-  RegisteredOperationName::insert(
-      op->name, *op->dialect, op->typeID, std::move(op->parseFn),
-      std::move(op->printFn), std::move(op->verifyFn),
-      std::move(op->verifyRegionFn), std::move(op->foldHookFn),
-      std::move(op->getCanonicalizationPatternsFn),
-      detail::InterfaceMap::get<>(), std::move(hasTraitFn), {},
-      std::move(op->populateDefaultAttrsFn));
+  RegisteredOperationName::insert(std::move(op), /*attrNames=*/{});
 }
 
 bool ExtensibleDialect::classof(const Dialect *dialect) {
   return const_cast<Dialect *>(dialect)
       ->getRegisteredInterface<IsExtensibleDialect>();
 }
 
 OptionalParseResult ExtensibleDialect::parseOptionalDynamicType(

mlir/lib/IR/MLIRContext.cpp

#endif
   /// The MLIRContext owns the objects.
   DenseMap<StringRef, std::unique_ptr<Dialect>> loadedDialects;
   DialectRegistry dialectsRegistry;
 
   /// An allocator used for AbstractAttribute and AbstractType objects.
   llvm::BumpPtrAllocator abstractDialectSymbolAllocator;
 
   /// This is a mapping from operation name to the operation info describing it.
-  llvm::StringMap<OperationName::Impl> operations;
+  llvm::StringMap<std::unique_ptr<OperationName::Impl>> operations;
 
   /// A vector of operation info specifically for registered operations.
   llvm::StringMap<RegisteredOperationName> registeredOperations;
 
   /// This is a sorted container of registered operations for a deterministic
   /// and efficient `getRegisteredOperations` implementation.
   SmallVector<RegisteredOperationName, 0> sortedRegisteredOperations;
 
if (it == impl.registeredAttributes.end())
     return nullptr;
   return it->second;
 }
 
 //===----------------------------------------------------------------------===//
 // OperationName
 //===----------------------------------------------------------------------===//
 
+OperationName::Impl::Impl(StringRef name, Dialect *dialect, TypeID typeID,
+                          detail::InterfaceMap interfaceMap)
+    : Impl(StringAttr::get(dialect->getContext(), name), dialect, typeID,
+           std::move(interfaceMap)) {}
+
 OperationName::OperationName(StringRef name, MLIRContext *context) {
   MLIRContextImpl &ctxImpl = context->getImpl();
 
   // Check for an existing name in read-only mode.
   bool isMultithreadingEnabled = context->isMultithreadingEnabled();
   if (isMultithreadingEnabled) {
     // Check the registered info map first. In the overwhelmingly common case,
     // the entry will be in here and it also removes the need to acquire any
     // locks.
     auto registeredIt = ctxImpl.registeredOperations.find(name);
     if (LLVM_LIKELY(registeredIt != ctxImpl.registeredOperations.end())) {
       impl = registeredIt->second.impl;
       return;
     }
 
     llvm::sys::SmartScopedReader<true> contextLock(ctxImpl.operationInfoMutex);
     auto it = ctxImpl.operations.find(name);
     if (it != ctxImpl.operations.end()) {
-      impl = &it->second;
+      impl = it->second.get();
       return;
     }
   }
 
   // Acquire a writer-lock so that we can safely create the new instance.
   ScopedWriterLock lock(ctxImpl.operationInfoMutex, isMultithreadingEnabled);
 
-  auto it = ctxImpl.operations.insert({name, OperationName::Impl(nullptr)});
-  if (it.second)
-    it.first->second.name = StringAttr::get(context, name);
-  impl = &it.first->second;
+  auto it = ctxImpl.operations.insert({name, nullptr});
+  if (it.second) {
+    auto nameAttr = StringAttr::get(context, name);
+    it.first->second = std::make_unique<UnregisteredOpModel>(
+        nameAttr, nameAttr.getReferencedDialect(), TypeID::get<void>(),
+        detail::InterfaceMap(std::nullopt));
+  }
+  impl = it.first->second.get();
 }
 
 StringRef OperationName::getDialectNamespace() const {
   if (Dialect *dialect = getDialect())
     return dialect->getNamespace();
   return getStringRef().split('.').first;
 }
 
+LogicalResult
+OperationName::UnregisteredOpModel::foldHook(Operation *, ArrayRef<Attribute>,
+                                             SmallVectorImpl<OpFoldResult> &) {
+  return failure();
+}
+void OperationName::UnregisteredOpModel::getCanonicalizationPatterns(
+    RewritePatternSet &, MLIRContext *) {}
+bool OperationName::UnregisteredOpModel::hasTrait(TypeID) { return false; }
+
+OperationName::ParseAssemblyFn
+OperationName::UnregisteredOpModel::getParseAssemblyFn() {
+  llvm::report_fatal_error("getParseAssemblyFn hook called on unregistered op");
+}
+void OperationName::UnregisteredOpModel::populateDefaultAttrs(
+    const OperationName &, NamedAttrList &) {}
+void OperationName::UnregisteredOpModel::printAssembly(
+    Operation *op, OpAsmPrinter &p, StringRef defaultDialect) {
+  p.printGenericOp(op);
+}
+LogicalResult
+OperationName::UnregisteredOpModel::verifyInvariants(Operation *) {
+  return success();
+}
+LogicalResult
+OperationName::UnregisteredOpModel::verifyRegionInvariants(Operation *) {
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // RegisteredOperationName
 //===----------------------------------------------------------------------===//
 
 Optional<RegisteredOperationName>
 RegisteredOperationName::lookup(StringRef name, MLIRContext *ctx) {
   auto &impl = ctx->getImpl();
   auto it = impl.registeredOperations.find(name);
   if (it != impl.registeredOperations.end())
     return it->getValue();
   return std::nullopt;
 }
 
-ParseResult
-RegisteredOperationName::parseAssembly(OpAsmParser &parser,
-                                       OperationState &result) const {
-  return impl->parseAssemblyFn(parser, result);
-}
-
-void RegisteredOperationName::populateDefaultAttrs(NamedAttrList &attrs) const {
-  impl->populateDefaultAttrsFn(*this, attrs);
-}
-
 void RegisteredOperationName::insert(
-    StringRef name, Dialect &dialect, TypeID typeID,
-    ParseAssemblyFn &&parseAssembly, PrintAssemblyFn &&printAssembly,
-    VerifyInvariantsFn &&verifyInvariants,
-    VerifyRegionInvariantsFn &&verifyRegionInvariants, FoldHookFn &&foldHook,
-    GetCanonicalizationPatternsFn &&getCanonicalizationPatterns,
-    detail::InterfaceMap &&interfaceMap, HasTraitFn &&hasTrait,
-    ArrayRef<StringRef> attrNames,
-    PopulateDefaultAttrsFn &&populateDefaultAttrs) {
-  MLIRContext *ctx = dialect.getContext();
+    std::unique_ptr<RegisteredOperationName::Impl> ownedImpl,
+    ArrayRef<StringRef> attrNames) {
+  RegisteredOperationName::Impl *impl = ownedImpl.get();
+  MLIRContext *ctx = impl->getDialect()->getContext();
   auto &ctxImpl = ctx->getImpl();
   assert(ctxImpl.multiThreadedExecutionContext == 0 &&
          "registering a new operation kind while in a multi-threaded execution "
          "context");
 
   // Register the attribute names of this operation.
   MutableArrayRef<StringAttr> cachedAttrNames;
   if (!attrNames.empty()) {
     cachedAttrNames = MutableArrayRef<StringAttr>(
         ctxImpl.abstractDialectSymbolAllocator.Allocate<StringAttr>(
             attrNames.size()),
         attrNames.size());
     for (unsigned i : llvm::seq<unsigned>(0, attrNames.size()))
       new (&cachedAttrNames[i]) StringAttr(StringAttr::get(ctx, attrNames[i]));
+    impl->attributeNames = cachedAttrNames;
   }
-
+  StringRef name = impl->getName().strref();
   // Insert the operation info if it doesn't exist yet.
-  auto it = ctxImpl.operations.insert({name, OperationName::Impl(nullptr)});
-  if (it.second)
-    it.first->second.name = StringAttr::get(ctx, name);
-  OperationName::Impl &impl = it.first->second;
-
-  if (impl.isRegistered()) {
-    llvm::errs() << "error: operation named '" << name
-                 << "' is already registered.\n";
-    abort();
-  }
+  auto it = ctxImpl.operations.insert({name, nullptr});
+  it.first->second = std::move(ownedImpl);
+
+  // Update the registered info for this operation.
   auto emplaced = ctxImpl.registeredOperations.try_emplace(
-      name, RegisteredOperationName(&impl));
+      name, RegisteredOperationName(impl));
   assert(emplaced.second && "operation name registration must be successful");
 
   // Add emplaced operation name to the sorted operations container.
   RegisteredOperationName &value = emplaced.first->getValue();
   ctxImpl.sortedRegisteredOperations.insert(
       llvm::upper_bound(ctxImpl.sortedRegisteredOperations, value,
                         [](auto &lhs, auto &rhs) {
                           return lhs.getIdentifier().compare(
                               rhs.getIdentifier());
                         }),
       value);
-
-  // Update the registered info for this operation.
-  impl.dialect = &dialect;
-  impl.typeID = typeID;
-  impl.interfaceMap = std::move(interfaceMap);
-  impl.foldHookFn = std::move(foldHook);
-  impl.getCanonicalizationPatternsFn = std::move(getCanonicalizationPatterns);
-  impl.hasTraitFn = std::move(hasTrait);
-  impl.parseAssemblyFn = std::move(parseAssembly);
-  impl.printAssemblyFn = std::move(printAssembly);
-  impl.verifyInvariantsFn = std::move(verifyInvariants);
-  impl.verifyRegionInvariantsFn = std::move(verifyRegionInvariants);
-  impl.attributeNames = cachedAttrNames;
-  impl.populateDefaultAttrsFn = std::move(populateDefaultAttrs);
 }
 
 //===----------------------------------------------------------------------===//
 // AbstractType
 //===----------------------------------------------------------------------===//
 
 const AbstractType &AbstractType::lookup(TypeID typeID, MLIRContext *context) {
   const AbstractType *type = lookupMutable(typeID, context);

mlir/lib/IR/Operation.cpp

size_t byteSize =
           needsOperandStorage ? 1 : 0, numSuccessors, numRegions, numOperands);
   size_t prefixByteSize = llvm::alignTo(
       Operation::prefixAllocSize(numTrailingResults, numInlineResults),
       alignof(Operation));
   char *mallocMem = reinterpret_cast<char *>(malloc(byteSize + prefixByteSize));
   void *rawMem = mallocMem + prefixByteSize;
 
   // Populate default attributes.
-  if (Optional<RegisteredOperationName> info = name.getRegisteredInfo())
-    info->populateDefaultAttrs(attributes);
+  name.populateDefaultAttrs(attributes);
 
   // Create the new Operation.
   Operation *op = ::new (rawMem) Operation(
       location, name, numResults, numSuccessors, numRegions,
       attributes.getDictionary(location.getContext()), needsOperandStorage);
 
   assert((numSuccessors == 0 || op->mightHaveTrait<OpTrait::IsTerminator>()) &&
          "unexpected successors in a non-terminator operation");
void Operation::setSuccessor(Block *block, unsigned index) {
   getBlockOperands()[index].set(block);
 }
 
 /// Attempt to fold this operation using the Op's registered foldHook.
 LogicalResult Operation::fold(ArrayRef<Attribute> operands,
                               SmallVectorImpl<OpFoldResult> &results) {
   // If we have a registered operation definition matching this one, use it to
   // try to constant fold the operation.
-  Optional<RegisteredOperationName> info = getRegisteredInfo();
-  if (info && succeeded(info->foldHook(this, operands, results)))
+  if (succeeded(name.foldHook(this, operands, results)))
     return success();
 
   // Otherwise, fall back on the dialect hook to handle it.
   Dialect *dialect = getDialect();
   if (!dialect)
     return failure();
 
   auto *interface = dyn_cast<DialectFoldInterface>(dialect);

mlir/lib/Rewrite/ByteCode.cpp

if (Attribute attr = read<Attribute>())
       state.addAttribute(name, attr);
   }
 
   // Read in the result types. If the "size" is the sentinel value, this
   // indicates that the result types should be inferred.
   unsigned numResults = read();
   if (numResults == kInferTypesMarker) {
     InferTypeOpInterface::Concept *inferInterface =
-        state.name.getRegisteredInfo()->getInterface<InferTypeOpInterface>();
+        state.name.getInterface<InferTypeOpInterface>();
     assert(inferInterface &&
            "expected operation to provide InferTypeOpInterface");
 
     // TODO: Handle failure.
     if (failed(inferInterface->inferReturnTypes(
             state.getContext(), state.location, state.operands,
             state.attributes.getDictionary(state.getContext()), state.regions,
             state.types)))

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

auto *method = opClass.addStaticInlineMethod<Method::Private>(
         "::mlir::StringAttr", "getAttributeNameForIndex",
         MethodParameter("::mlir::OperationName", "name"),
         MethodParameter("unsigned", "index"));
     ERROR_IF_PRUNED(method, "getAttributeNameForIndex", op);
 
     const char *const getAttrName = R"(
   assert(index < {0} && "invalid attribute index");
   assert(name.getStringRef() == getOperationName() && "invalid operation name");
-  return name.getRegisteredInfo()->getAttributeNames()[index];
+  return name.getAttributeNames()[index];
 )";
     method->body() << formatv(getAttrName, attributes.size());
   }
 
   // Generate the <attr>AttrName methods, that expose the attribute names to
   // users.
   const char *attrNameMethodBody = "  return getAttributeNameForIndex({0});";
   for (auto &attrIt : llvm::enumerate(llvm::make_first_range(attributes))) {

 void OpEmitter::genPopulateDefaultAttributes() {
   // All done if no attributes, except optional ones, have default values.
   if (llvm::all_of(op.getAttributes(), [](const NamedAttribute &named) {
         return !named.attr.hasDefaultValue() || named.attr.isOptional();
       }))
     return;
 
   SmallVector<MethodParameter> paramList;
-  paramList.emplace_back("const ::mlir::RegisteredOperationName &", "opName");
+  paramList.emplace_back("const ::mlir::OperationName &", "opName");
   paramList.emplace_back("::mlir::NamedAttrList &", "attributes");
   auto *m = opClass.addStaticMethod("void", "populateDefaultAttrs", paramList);
   ERROR_IF_PRUNED(m, "populateDefaultAttrs", op);
   auto &body = m->body();
   body.indent();
 
   // Set default attributes that are unset.
   body << "auto attrNames = opName.getAttributeNames();\n";

mlir/unittests/Interfaces/InferTypeOpInterfaceTest.cpp

const char *ir = R"MLIR(
         %1 = arith.addi %arg, %0 : tensor<1xi64>
         return
       }
     )MLIR";
 
     registry.insert<func::FuncDialect, arith::ArithDialect>();
     ctx.appendDialectRegistry(registry);
     module = parseSourceString<ModuleOp>(ir, &ctx);
+    assert(module);
     mapFn = cast<func::FuncOp>(module->front());
   }
 
   // Create ValueShapeRange on the arith.addi operation.
   ValueShapeRange addiRange() {
     auto &fnBody = mapFn.getBody();
     return std::next(fnBody.front().begin())->getOperands();
   }