[mlir] Refactor AbstractOperation and OperationName

[rriddle]

Summary

The current implementation is quite clunky; OperationName stores either an Identifier
or an AbstractOperation that corresponds to an operation. This has several problems:

• OperationNames created before and after an operation are registered are different
• Accessing the identifier name/dialect/etc. from an OperationName are overly branchy
  • they need to dyn_cast a PointerUnion to check the state

This commit refactors this such that we create a single information struct for every
operation name, even operations that aren't registered yet. When an OperationName is
created for an unregistered operation, we only populate the name field. When the
operation is registered, we populate the remaining fields. With this we now have two
new classes: OperationName and RegisteredOperationName. These both point to the
same underlying operation information struct, but only RegisteredOperationName can
assume that the operation is actually registered. This leads to a much cleaner API, and
we can also move some AbstractOperation functionality directly to OperationName.

[rriddle]

In a followup I plan to rename OperationName/RegisteredOperationName to OperationInfo/RegisteredOperationInfo (given that these are actually closer to what they represent). I also want to use OperationName instead of Identifier in a few places now that the created before registration != created after registration problem is fixed.

[mehdi_amini]

mlir/include/mlir/IR/OperationSupport.h

103

That seems redundant with the StringAttr, isn't it?

122

Aren't Identifier replaced with StringAttr now?

[rriddle]

mlir/include/mlir/IR/OperationSupport.h

103

Yes, but I've delayed removing it until I can see if there is a performance hit from removing this. There are a few other cleanups that I also want to make in this area (e.g. inlining traits array) in followups.

122

Thanks for the catch, I hadn't rebased on the Identifier reference removal yet.

mlir/include/mlir/IR/Builders.h

public:
   /// Insert the given operation at the current insertion point and return it.
   Operation *insert(Operation *op);
 
   /// Creates an operation given the fields represented as an OperationState.
   Operation *createOperation(const OperationState &state);
 
 private:
   /// Helper for sanity checking preconditions for create* methods below.
-  void checkHasAbstractOperation(const OperationName &name) {
-    if (LLVM_UNLIKELY(!name.getAbstractOperation()))
+  void checkHasRegisteredInfo(const OperationName &name) {
+    if (LLVM_UNLIKELY(!name.isRegistered()))
       llvm::report_fatal_error(
           "Building op `" + name.getStringRef() +
           "` but it isn't registered in this MLIRContext: the dialect may not "
           "be loaded or this operation isn't registered by the dialect. See "
           "also https://mlir.llvm.org/getting_started/Faq/"
           "#registered-loaded-dependent-whats-up-with-dialects-management");
   }
 
 public:
   /// Create an operation of specific op type at the current insertion point.
   template <typename OpTy, typename... Args>
   OpTy create(Location location, Args &&...args) {
     OperationState state(location, OpTy::getOperationName());
-    checkHasAbstractOperation(state.name);
+    checkHasRegisteredInfo(state.name);
     OpTy::build(*this, state, std::forward<Args>(args)...);
     auto *op = createOperation(state);
     auto result = dyn_cast<OpTy>(op);
     assert(result && "builder didn't return the right type");
     return result;
   }
 
   /// Create an operation of specific op type at the current insertion point,
   /// and immediately try to fold it. This functions populates 'results' with
   /// the results after folding the operation.
   template <typename OpTy, typename... Args>
   void createOrFold(SmallVectorImpl<Value> &results, Location location,
                     Args &&...args) {
     // Create the operation without using 'createOperation' as we don't want to
     // insert it yet.
     OperationState state(location, OpTy::getOperationName());
-    checkHasAbstractOperation(state.name);
+    checkHasRegisteredInfo(state.name);
     OpTy::build(*this, state, std::forward<Args>(args)...);
     Operation *op = Operation::create(state);
 
     // Fold the operation. If successful destroy it, otherwise insert it.
     if (succeeded(tryFold(op, results)))
       op->destroy();
     else
       insert(op);

mlir/include/mlir/IR/Dialect.h

public:
 
   /// Print a type registered to this dialect.
   virtual void printType(Type, DialectAsmPrinter &) const {
     llvm_unreachable("dialect has no registered type printing hook");
   }
 
   /// Return the hook to parse an operation registered to this dialect, if any.
   /// By default this will lookup for registered operations and return the
-  /// `parse()` method registered on the AbstractOperation. Dialects can
+  /// `parse()` method registered on the RegisteredOperationName. Dialects can
   /// override this behavior and handle unregistered operations as well.
   virtual Optional<ParseOpHook> getParseOperationHook(StringRef opName) const;
 
   /// Print an operation registered to this dialect.
   /// This hook is invoked for registered operation which don't override the
   /// `print()` method to define their own custom assembly.
   virtual llvm::unique_function<void(Operation *, OpAsmPrinter &printer)>
   getOperationPrinter(Operation *op) const;
protected:
   /// Example:
   ///       - "tf" for the TensorFlow ops like "tf.add".
   Dialect(StringRef name, MLIRContext *context, TypeID id);
 
   /// This method is used by derived classes to add their operations to the set.
   ///
   template <typename... Args> void addOperations() {
     (void)std::initializer_list<int>{
-        0, (AbstractOperation::insert<Args>(*this), 0)...};
+        0, (RegisteredOperationName::insert<Args>(*this), 0)...};
   }
 
   /// Register a set of type classes with this dialect.
   template <typename... Args> void addTypes() {
     (void)std::initializer_list<int>{0, (addType<Args>(), 0)...};
   }
 
   /// Register a type instance with this dialect.

mlir/include/mlir/IR/MLIRContext.h

 #include <memory>
 #include <vector>
 
 namespace llvm {
 class ThreadPool;
 } // end namespace llvm
 
 namespace mlir {
-class AbstractOperation;
 class DebugActionManager;
 class DiagnosticEngine;
 class Dialect;
 class DialectRegistry;
 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
 /// them.
 ///
 /// MLIRContext gets a redundant "MLIR" prefix because otherwise it ends up with
 /// a very generic name ("Context") and because it is uncommon for clients to
public:
 
   /// Set the flag specifying if we should attach the current stacktrace when
   /// emitting diagnostics.
   void printStackTraceOnDiagnostic(bool enable);
 
   /// Return information about all registered operations.  This isn't very
   /// efficient: typically you should ask the operations about their properties
   /// directly.
-  std::vector<AbstractOperation *> getRegisteredOperations();
+  std::vector<RegisteredOperationName> getRegisteredOperations();
 
   /// Return true if this operation name is registered in this context.
   bool isOperationRegistered(StringRef name);
 
   // This is effectively private given that only MLIRContext.cpp can see the
   // MLIRContextImpl type.
   MLIRContextImpl &getImpl() { return *impl; }
 

mlir/include/mlir/IR/OpDefinition.h

protected:
   /// Mutability management is handled by the OpWrapper/OpConstWrapper classes,
   /// so we can cast it away here.
   explicit OpState(Operation *state) : state(state) {}
 
 private:
   Operation *state;
 
   /// Allow access to internal hook implementation methods.
-  friend AbstractOperation;
+  friend RegisteredOperationName;
 };
 
 // Allow comparing operators.
 inline bool operator==(OpState lhs, OpState rhs) {
   return lhs.getOperation() == rhs.getOperation();
 }
 inline bool operator!=(OpState lhs, OpState rhs) {
   return lhs.getOperation() != rhs.getOperation();
public:
   /// regions. The new operation will have the same number of regions as the
   /// original one, but they will be left empty.
   ConcreteType cloneWithoutRegions() {
     return cast<ConcreteType>(getOperation()->cloneWithoutRegions());
   }
 
   /// Return true if this "op class" can match against the specified operation.
   static bool classof(Operation *op) {
-    if (auto *abstractOp = op->getAbstractOperation())
-      return TypeID::get<ConcreteType>() == abstractOp->typeID;
+    if (auto info = op->getRegisteredInfo())
+      return TypeID::get<ConcreteType>() == info->getTypeID();
 #ifndef NDEBUG
     if (op->getName().getStringRef() == ConcreteType::getOperationName())
       llvm::report_fatal_error(
           "classof on '" + ConcreteType::getOperationName() +
           "' failed due to the operation not being registered");
 #endif
     return false;
   }
static ConcreteOpType getFromOpaquePointer(const void *pointer) {
     return ConcreteOpType(
         reinterpret_cast<Operation *>(const_cast<void *>(pointer)));
   }
 
   /// Attach the given models as implementations of the corresponding interfaces
   /// for the concrete operation.
   template <typename... Models>
   static void attachInterface(MLIRContext &context) {
-    AbstractOperation *abstract = AbstractOperation::lookupMutable(
+    Optional<RegisteredOperationName> info = RegisteredOperationName::lookup(
         ConcreteType::getOperationName(), &context);
-    if (!abstract)
+    if (!info)
       llvm::report_fatal_error(
           "Attempting to attach an interface to an unregistered operation " +
           ConcreteType::getOperationName() + ".");
-    abstract->interfaceMap.insert<Models...>();
+    info->attachInterface<Models...>();
   }
 
 private:
   /// Trait to check if T provides a 'fold' method for a single result op.
   template <typename T, typename... Args>
   using has_single_result_fold =
       decltype(std::declval<T>().fold(std::declval<ArrayRef<Attribute>>()));
   template <typename T>
using VerifiableTraitsTupleT =
                                    Traits<ConcreteType>...>::type;
 
   /// Returns an interface map containing the interfaces registered to this
   /// operation.
   static detail::InterfaceMap getInterfaceMap() {
     return detail::InterfaceMap::template get<Traits<ConcreteType>...>();
   }
 
-  /// Return the internal implementations of each of the AbstractOperation
+  /// Return the internal implementations of each of the OperationName
   /// hooks.
-  /// Implementation of `FoldHookFn` AbstractOperation hook.
-  static AbstractOperation::FoldHookFn getFoldHookFn() {
+  /// Implementation of `FoldHookFn` OperationName hook.
+  static OperationName::FoldHookFn getFoldHookFn() {
     return getFoldHookFnImpl<ConcreteType>();
   }
   /// The internal implementation of `getFoldHookFn` above that is invoked if
   /// the operation is single result and defines a `fold` method.
   template <typename ConcreteOpT>
   static std::enable_if_t<llvm::is_one_of<OpTrait::OneResult<ConcreteOpT>,
                                           Traits<ConcreteOpT>...>::value &&
                               detect_has_single_result_fold<ConcreteOpT>::value,
-                          AbstractOperation::FoldHookFn>
+                          OperationName::FoldHookFn>
   getFoldHookFnImpl() {
     return [](Operation *op, ArrayRef<Attribute> operands,
               SmallVectorImpl<OpFoldResult> &results) {
       return foldSingleResultHook<ConcreteOpT>(op, operands, results);
     };
   }
   /// The internal implementation of `getFoldHookFn` above that is invoked if
   /// the operation is not single result and defines a `fold` method.
   template <typename ConcreteOpT>
   static std::enable_if_t<!llvm::is_one_of<OpTrait::OneResult<ConcreteOpT>,
                                            Traits<ConcreteOpT>...>::value &&
                               detect_has_fold<ConcreteOpT>::value,
-                          AbstractOperation::FoldHookFn>
+                          OperationName::FoldHookFn>
   getFoldHookFnImpl() {
     return [](Operation *op, ArrayRef<Attribute> operands,
               SmallVectorImpl<OpFoldResult> &results) {
       return foldHook<ConcreteOpT>(op, operands, results);
     };
   }
   /// The internal implementation of `getFoldHookFn` above that is invoked if
   /// the operation does not define a `fold` method.
   template <typename ConcreteOpT>
   static std::enable_if_t<!detect_has_single_result_fold<ConcreteOpT>::value &&
                               !detect_has_fold<ConcreteOpT>::value,
-                          AbstractOperation::FoldHookFn>
+                          OperationName::FoldHookFn>
   getFoldHookFnImpl() {
     return [](Operation *op, ArrayRef<Attribute> operands,
               SmallVectorImpl<OpFoldResult> &results) {
       // In this case, we only need to fold the traits of the operation.
       return op_definition_impl::foldTraits<FoldableTraitsTupleT>(op, operands,
                                                                   results);
     };
   }
static LogicalResult foldHook(Operation *op, ArrayRef<Attribute> operands,
     if (failed(result) || results.empty()) {
       if (succeeded(op_definition_impl::foldTraits<FoldableTraitsTupleT>(
               op, operands, results)))
         return success();
     }
     return result;
   }
 
-  /// Implementation of `GetCanonicalizationPatternsFn` AbstractOperation hook.
-  static AbstractOperation::GetCanonicalizationPatternsFn
+  /// Implementation of `GetCanonicalizationPatternsFn` OperationName hook.
+  static OperationName::GetCanonicalizationPatternsFn
   getGetCanonicalizationPatternsFn() {
     return &ConcreteType::getCanonicalizationPatterns;
   }
   /// Implementation of `GetHasTraitFn`
-  static AbstractOperation::HasTraitFn getHasTraitFn() {
+  static OperationName::HasTraitFn getHasTraitFn() {
     return
         [](TypeID id) { return op_definition_impl::hasTrait<Traits...>(id); };
   }
-  /// Implementation of `ParseAssemblyFn` AbstractOperation hook.
-  static AbstractOperation::ParseAssemblyFn getParseAssemblyFn() {
+  /// Implementation of `ParseAssemblyFn` OperationName hook.
+  static OperationName::ParseAssemblyFn getParseAssemblyFn() {
     return &ConcreteType::parse;
   }
-  /// Implementation of `PrintAssemblyFn` AbstractOperation hook.
-  static AbstractOperation::PrintAssemblyFn getPrintAssemblyFn() {
+  /// Implementation of `PrintAssemblyFn` OperationName hook.
+  static OperationName::PrintAssemblyFn getPrintAssemblyFn() {
     return getPrintAssemblyFnImpl<ConcreteType>();
   }
   /// The internal implementation of `getPrintAssemblyFn` that is invoked when
   /// the concrete operation does not define a `print` method.
   template <typename ConcreteOpT>
   static std::enable_if_t<!detect_has_print<ConcreteOpT>::value,
-                          AbstractOperation::PrintAssemblyFn>
+                          OperationName::PrintAssemblyFn>
   getPrintAssemblyFnImpl() {
     return [](Operation *op, OpAsmPrinter &printer, StringRef defaultDialect) {
       return OpState::print(op, printer);
     };
   }
   /// The internal implementation of `getPrintAssemblyFn` that is invoked when
   /// the concrete operation defines a `print` method.
   template <typename ConcreteOpT>
   static std::enable_if_t<detect_has_print<ConcreteOpT>::value,
-                          AbstractOperation::PrintAssemblyFn>
+                          OperationName::PrintAssemblyFn>
   getPrintAssemblyFnImpl() {
     return &printAssembly;
   }
   static void printAssembly(Operation *op, OpAsmPrinter &p,
                             StringRef defaultDialect) {
     OpState::printOpName(op, p, defaultDialect);
     return cast<ConcreteType>(op).print(p);
   }
-  /// Implementation of `VerifyInvariantsFn` AbstractOperation hook.
-  static AbstractOperation::VerifyInvariantsFn getVerifyInvariantsFn() {
+  /// Implementation of `VerifyInvariantsFn` OperationName hook.
+  static OperationName::VerifyInvariantsFn getVerifyInvariantsFn() {
     return &verifyInvariants;
   }
 
   static constexpr bool hasNoDataMembers() {
     // Checking that the derived class does not define any member by comparing
     // its size to an ad-hoc EmptyOp.
     class EmptyOp : public Op<EmptyOp, Traits...> {};
     return sizeof(ConcreteType) == sizeof(EmptyOp);
   }
 
   static LogicalResult verifyInvariants(Operation *op) {
     static_assert(hasNoDataMembers(),
                   "Op class shouldn't define new data members");
     return failure(
         failed(op_definition_impl::verifyTraits<VerifiableTraitsTupleT>(op)) ||
         failed(cast<ConcreteType>(op).verify()));
   }
 
   /// Allow access to internal implementation methods.
-  friend AbstractOperation;
+  friend RegisteredOperationName;
 };
 
 /// This class represents the base of an operation interface. See the definition
 /// of `detail::Interface` for requirements on the `Traits` type.
 template <typename ConcreteType, typename Traits>
 class OpInterface
     : public detail::Interface<ConcreteType, Operation *, Traits,
                                Op<ConcreteType>, OpTrait::TraitBase> {
 public:
   using Base = OpInterface<ConcreteType, Traits>;
   using InterfaceBase = detail::Interface<ConcreteType, Operation *, Traits,
                                           Op<ConcreteType>, OpTrait::TraitBase>;
 
   /// Inherit the base class constructor.
   using InterfaceBase::InterfaceBase;
 
 protected:
   /// Returns the impl interface instance for the given operation.
   static typename InterfaceBase::Concept *getInterfaceFor(Operation *op) {
-    // Access the raw interface from the abstract operation.
-    auto *abstractOp = op->getAbstractOperation();
-    if (abstractOp) {
-      if (auto *opIface = abstractOp->getInterface<ConcreteType>())
+    OperationName name = op->getName();
+
+    // Access the raw interface from the operation info.
+    if (Optional<RegisteredOperationName> rInfo = name.getRegisteredInfo()) {
+      if (auto *opIface = rInfo->getInterface<ConcreteType>())
         return opIface;
       // Fallback to the dialect to provide it with a chance to implement this
       // interface for this operation.
-      return abstractOp->dialect.getRegisteredInterfaceForOp<ConcreteType>(
+      return rInfo->getDialect().getRegisteredInterfaceForOp<ConcreteType>(
           op->getName());
     }
     // Fallback to the dialect to provide it with a chance to implement this
     // interface for this operation.
-    Dialect *dialect = op->getName().getDialect();
-    return dialect ? dialect->getRegisteredInterfaceForOp<ConcreteType>(
-                         op->getName())
-                   : nullptr;
+    if (Dialect *dialect = name.getDialect())
+      return dialect->getRegisteredInterfaceForOp<ConcreteType>(name);
+    return nullptr;
   }
 
   /// Allow access to `getInterfaceFor`.
   friend InterfaceBase;
 };
 
 //===----------------------------------------------------------------------===//
 // Common Operation Folders/Parsers/Printers

mlir/include/mlir/IR/Operation.h

static Operation *create(Location location, OperationName name,
                            DictionaryAttr attributes,
                            BlockRange successors = {},
                            RegionRange regions = {});
 
   /// The name of an operation is the key identifier for it.
   OperationName getName() { return name; }
 
   /// If this operation has a registered operation description, return it.
-  /// Otherwise return null.
-  const AbstractOperation *getAbstractOperation() {
-    return getName().getAbstractOperation();
+  /// Otherwise return None.
+  Optional<RegisteredOperationName> getRegisteredInfo() {
+    return getName().getRegisteredInfo();
   }
 
   /// Returns true if this operation has a registered operation description,
   /// otherwise false.
-  bool isRegistered() { return getAbstractOperation(); }
+  bool isRegistered() { return getName().isRegistered(); }
 
   /// Remove this operation from its parent block and delete it.
   void erase();
 
   /// Remove the operation from its parent block, but don't delete it.
   void remove();
 
   /// Create a deep copy of this operation, remapping any operands that use
public:
   /// the operation, but may be null if non-constant. If folding is successful,
   /// this fills in the `results` vector. If not, `results` is unspecified.
   LogicalResult fold(ArrayRef<Attribute> operands,
                      SmallVectorImpl<OpFoldResult> &results);
 
   /// Returns true if the operation was registered with a particular trait, e.g.
   /// hasTrait<OperandsAreSignlessIntegerLike>().
   template <template <typename T> class Trait> bool hasTrait() {
-    const AbstractOperation *abstractOp = getAbstractOperation();
-    return abstractOp ? abstractOp->hasTrait<Trait>() : false;
+    return name.hasTrait<Trait>();
   }
 
-  /// Returns true if the operation is *might* have the provided trait. This
+  /// 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 AbstractOperation *abstractOp = getAbstractOperation();
-    return abstractOp ? abstractOp->hasTrait<Trait>() : true;
+    return name.mightHaveTrait<Trait>();
   }
 
   //===--------------------------------------------------------------------===//
   // Operation Walkers
   //===--------------------------------------------------------------------===//
 
   /// Walk the operation by calling the callback for each nested operation
   /// (including this one), block or region, depending on the callback provided.

mlir/include/mlir/IR/OperationSupport.h

 class ValueRange;
 template <typename ValueRangeT>
 class ValueTypeRange;
 
 class RewritePatternSet;
 using OwningRewritePatternList = RewritePatternSet;
 
 //===----------------------------------------------------------------------===//
-// AbstractOperation
+// OperationName
 //===----------------------------------------------------------------------===//
 
-/// 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 AbstractOperation {
+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>;
   using PrintAssemblyFn =
       llvm::unique_function<void(Operation *, OpAsmPrinter &, StringRef) const>;
   using VerifyInvariantsFn =
       llvm::unique_function<LogicalResult(Operation *) const>;
 
-  /// This is the name of the operation.
-  const Identifier name;
+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(llvm::None) {}
+
+    /// The name of the operation.
+    StringAttr name;
+
+    //===------------------------------------------------------------------===//
+    // Registered Operation Info
+
+    /// 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;
+    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;
+    PrintAssemblyFn printAssemblyFn;
+    VerifyInvariantsFn verifyInvariantsFn;
+
+    /// A list of attribute names registered to this operation in identifier
+    /// form. This allows for operation classes to use identifiers for attribute
+    /// lookup/creation/etc., as opposed to strings.
+    ArrayRef<Identifier> attributeNames;
+  };
+
+public:
+  OperationName(StringRef name, MLIRContext *context);
+
+  /// Return if this operation is registered.
+  bool isRegistered() const { return impl->isRegistered(); }
+
+  /// If this operation is registered, returns the registered information, None
+  /// otherwise.
+  Optional<RegisteredOperationName> getRegisteredInfo() const;
+
+  /// 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);
+  }
+
+  /// 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);
+  }
+
+  /// 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>();
+  }
+
+  /// 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 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 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; }
+
+  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((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) {}
+
+  /// The internal implementation of the operation name.
+  Impl *impl;
+
+  /// Allow access to the Impl struct.
+  friend MLIRContextImpl;
+};
+
+inline raw_ostream &operator<<(raw_ostream &os, OperationName identifier) {
+  identifier.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:
+  /// Lookup the registered operation information for the given operation.
+  /// Returns None if the operation isn't registered.
+  static Optional<RegisteredOperationName> lookup(StringRef name,
+                                                  MLIRContext *ctx) {
+    return OperationName(name, ctx).getRegisteredInfo();
+  }
+
+  /// 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::getFoldHookFn(),
+           T::getGetCanonicalizationPatternsFn(), T::getInterfaceMap(),
+           T::getHasTraitFn(), 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, FoldHookFn &&foldHook,
+         GetCanonicalizationPatternsFn &&getCanonicalizationPatterns,
+         detail::InterfaceMap &&interfaceMap, HasTraitFn &&hasTrait,
+         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; }
+
   /// 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 parseAssemblyFn; }
+  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 printAssemblyFn(op, p, defaultDialect);
+    return impl->printAssemblyFn(op, p, defaultDialect);
   }
 
   /// This hook implements the verifier 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 verifyInvariantsFn(op);
+    return impl->verifyInvariantsFn(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 foldHookFn(op, operands, results);
+    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 getCanonicalizationPatternsFn(results, context);
-  }
-
-  /// 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 interfaceMap.lookup<T>();
+    return impl->getCanonicalizationPatternsFn(results, context);
   }
 
-  /// Returns true if this operation has the given interface registered to it.
-  bool hasInterface(TypeID interfaceID) const {
-    return interfaceMap.contains(interfaceID);
+  /// 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 hasTraitFn(TypeID::get<Trait>());
+    return hasTrait(TypeID::get<Trait>());
   }
 
   /// Returns true if the operation has a particular trait.
-  bool hasTrait(TypeID traitID) const { return hasTraitFn(traitID); }
-
-  /// Look up the specified operation in the specified MLIRContext and return a
-  /// pointer to it if present.  Otherwise, return a null pointer.
-  static const AbstractOperation *lookup(StringRef opName,
-                                         MLIRContext *context) {
-    return lookupMutable(opName, context);
-  }
-
-  /// 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::getFoldHookFn(),
-           T::getGetCanonicalizationPatternsFn(), T::getInterfaceMap(),
-           T::getHasTraitFn(), T::getAttributeNames());
-  }
-
-  /// Register a new operation in a Dialect object.
-  /// 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, FoldHookFn &&foldHook,
-         GetCanonicalizationPatternsFn &&getCanonicalizationPatterns,
-         detail::InterfaceMap &&interfaceMap, HasTraitFn &&hasTrait,
-         ArrayRef<StringRef> attrNames);
+  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<Identifier> getAttributeNames() const { return attributeNames; }
-
-private:
-  AbstractOperation(StringRef name, Dialect &dialect, TypeID typeID,
-                    ParseAssemblyFn &&parseAssembly,
-                    PrintAssemblyFn &&printAssembly,
-                    VerifyInvariantsFn &&verifyInvariants,
-                    FoldHookFn &&foldHook,
-                    GetCanonicalizationPatternsFn &&getCanonicalizationPatterns,
-                    detail::InterfaceMap &&interfaceMap, HasTraitFn &&hasTrait,
-                    ArrayRef<Identifier> attrNames);
-
-  /// Give Op access to lookupMutable.
-  template <typename ConcreteType, template <typename T> class... Traits>
-  friend class Op;
-
-  /// Look up the specified operation in the specified MLIRContext and return a
-  /// pointer to it if present.  Otherwise, return a null pointer.
-  static AbstractOperation *lookupMutable(StringRef opName,
-                                          MLIRContext *context);
+  ArrayRef<Identifier> getAttributeNames() const {
+    return impl->attributeNames;
+  }
 
-  /// A map of interfaces that were registered to this operation.
-  detail::InterfaceMap interfaceMap;
+  /// Represent the operation name as an opaque pointer. (Used to support
+  /// PointerLikeTypeTraits).
+  static RegisteredOperationName getFromOpaquePointer(const void *pointer) {
+    return RegisteredOperationName((Impl *)pointer);
+  }
 
-  /// Internal callback hooks provided by the op implementation.
-  FoldHookFn foldHookFn;
-  GetCanonicalizationPatternsFn getCanonicalizationPatternsFn;
-  HasTraitFn hasTraitFn;
-  ParseAssemblyFn parseAssemblyFn;
-  PrintAssemblyFn printAssemblyFn;
-  VerifyInvariantsFn verifyInvariantsFn;
+private:
+  RegisteredOperationName(Impl *impl) : OperationName(impl) {}
 
-  /// A list of attribute names registered to this operation in identifier form.
-  /// This allows for operation classes to use identifiers for attribute
-  /// lookup/creation/etc., as opposed to strings.
-  ArrayRef<Identifier> attributeNames;
+  /// Allow access to the constructor.
+  friend OperationName;
 };
 
+inline Optional<RegisteredOperationName>
+OperationName::getRegisteredInfo() const {
+  return isRegistered() ? RegisteredOperationName(impl)
+                        : Optional<RegisteredOperationName>();
+}
+
 //===----------------------------------------------------------------------===//
 // Attribute Dictionary-Like Interface
 //===----------------------------------------------------------------------===//
 
 /// Attribute collections provide a dictionary-like interface. Define common
 /// lookup functions.
 namespace impl {
 
private:
   // Pair with cached DictionaryAttr and status of whether attrs is sorted.
   // Note: just because sorted does not mean a DictionaryAttr has been created
   // but the case where there is a DictionaryAttr but attrs isn't sorted should
   // not occur.
   mutable llvm::PointerIntPair<Attribute, 1, bool> dictionarySorted;
 };
 
 //===----------------------------------------------------------------------===//
-// OperationName
-//===----------------------------------------------------------------------===//
-
-class OperationName {
-public:
-  using RepresentationUnion =
-      PointerUnion<Identifier, const AbstractOperation *>;
-
-  OperationName(AbstractOperation *op) : representation(op) {}
-  OperationName(StringRef name, MLIRContext *context);
-
-  /// Return the name of the dialect this operation is registered to.
-  StringRef getDialectNamespace() const;
-
-  /// 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 {
-    if (const auto *abstractOp = getAbstractOperation())
-      return &abstractOp->dialect;
-    return representation.get<Identifier>().getReferencedDialect();
-  }
-
-  /// Return the operation name with dialect name stripped, if it has one.
-  StringRef stripDialect() const;
-
-  /// Return the name of this operation. This always succeeds.
-  StringRef getStringRef() const;
-
-  /// Return the name of this operation as an identifier. This always succeeds.
-  Identifier getIdentifier() const;
-
-  /// If this operation has a registered operation description, return it.
-  /// Otherwise return null.
-  const AbstractOperation *getAbstractOperation() const {
-    return representation.dyn_cast<const AbstractOperation *>();
-  }
-
-  void print(raw_ostream &os) const;
-  void dump() const;
-
-  void *getAsOpaquePointer() const {
-    return static_cast<void *>(representation.getOpaqueValue());
-  }
-  static OperationName getFromOpaquePointer(const void *pointer);
-
-private:
-  RepresentationUnion representation;
-  OperationName(RepresentationUnion representation)
-      : representation(representation) {}
-};
-
-inline raw_ostream &operator<<(raw_ostream &os, OperationName identifier) {
-  identifier.print(os);
-  return os;
-}
-
-inline bool operator==(OperationName lhs, OperationName rhs) {
-  return lhs.getAsOpaquePointer() == rhs.getAsOpaquePointer();
-}
-
-inline bool operator!=(OperationName lhs, OperationName rhs) {
-  return lhs.getAsOpaquePointer() != rhs.getAsOpaquePointer();
-}
-
-// Make operation names hashable.
-inline llvm::hash_code hash_value(OperationName arg) {
-  return llvm::hash_value(arg.getAsOpaquePointer());
-}
-
-//===----------------------------------------------------------------------===//
 // OperationState
 //===----------------------------------------------------------------------===//
 
 /// This represents an operation in an abstracted form, suitable for use with
 /// the builder APIs.  This object is a large and heavy weight object meant to
 /// be used as a temporary object on the stack.  It is generally unwise to put
 /// this in a collection.
 struct OperationState {

 };
 
 /// Enable Bitmask enums for OperationEquivalence::Flags.
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 
 } // end namespace mlir
 
 namespace llvm {
-// Identifiers hash just like pointers, there is no need to hash the bytes.
 template <>
 struct DenseMapInfo<mlir::OperationName> {
   static mlir::OperationName getEmptyKey() {
-    auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
+    void *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::OperationName::getFromOpaquePointer(pointer);
   }
   static mlir::OperationName getTombstoneKey() {
-    auto pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
+    void *pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
     return mlir::OperationName::getFromOpaquePointer(pointer);
   }
-  static unsigned getHashValue(mlir::OperationName Val) {
-    return DenseMapInfo<void *>::getHashValue(Val.getAsOpaquePointer());
+  static unsigned getHashValue(mlir::OperationName val) {
+    return DenseMapInfo<void *>::getHashValue(val.getAsOpaquePointer());
   }
-  static bool isEqual(mlir::OperationName LHS, mlir::OperationName RHS) {
-    return LHS == RHS;
+  static bool isEqual(mlir::OperationName lhs, mlir::OperationName rhs) {
+    return lhs == rhs;
+  }
+};
+template <>
+struct DenseMapInfo<mlir::RegisteredOperationName>
+    : public DenseMapInfo<mlir::OperationName> {
+  static mlir::RegisteredOperationName getEmptyKey() {
+    void *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
+    return mlir::RegisteredOperationName::getFromOpaquePointer(pointer);
+  }
+  static mlir::RegisteredOperationName getTombstoneKey() {
+    void *pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
+    return mlir::RegisteredOperationName::getFromOpaquePointer(pointer);
   }
 };
 
-/// The pointer inside of an identifier comes from a StringMap, so its alignment
-/// is always at least 4 and probably 8 (on 64-bit machines).  Allow LLVM to
-/// steal the low bits.
 template <>
 struct PointerLikeTypeTraits<mlir::OperationName> {
-public:
   static inline void *getAsVoidPointer(mlir::OperationName I) {
     return const_cast<void *>(I.getAsOpaquePointer());
   }
   static inline mlir::OperationName getFromVoidPointer(void *P) {
     return mlir::OperationName::getFromOpaquePointer(P);
   }
-  static constexpr int NumLowBitsAvailable = PointerLikeTypeTraits<
-      mlir::OperationName::RepresentationUnion>::NumLowBitsAvailable;
+  static constexpr int NumLowBitsAvailable =
+      PointerLikeTypeTraits<void *>::NumLowBitsAvailable;
+};
+template <>
+struct PointerLikeTypeTraits<mlir::RegisteredOperationName>
+    : public PointerLikeTypeTraits<mlir::OperationName> {
+  static inline mlir::RegisteredOperationName getFromVoidPointer(void *P) {
+    return mlir::RegisteredOperationName::getFromOpaquePointer(P);
+  }
 };
 
 } // end namespace llvm
 
 #endif

mlir/include/mlir/Support/InterfaceSupport.h

class InterfaceMap {
   template <typename T>
   using detect_get_interface_id = llvm::is_detected<has_get_interface_id, T>;
   template <typename... Types>
   using num_interface_types = typename std::tuple_size<
       typename FilterTypes<detect_get_interface_id, Types...>::type>;
 
 public:
   InterfaceMap(InterfaceMap &&) = default;
+  InterfaceMap &operator=(InterfaceMap &&rhs) {
+    for (auto &it : interfaces)
+      free(it.second);
+    interfaces = std::move(rhs.interfaces);
+    return *this;
+  }
   ~InterfaceMap() {
     for (auto &it : interfaces)
       free(it.second);
   }
 
   /// Construct an InterfaceMap with the given set of template types. For
   /// convenience given that object trait lists may contain other non-interface
   /// types, not all of the types need to be interfaces. The provided types that

mlir/lib/CAPI/IR/IR.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // Operation API.
 //===----------------------------------------------------------------------===//
 
 static LogicalResult inferOperationTypes(OperationState &state) {
   MLIRContext *context = state.getContext();
-  const AbstractOperation *abstractOp =
-      AbstractOperation::lookup(state.name.getStringRef(), context);
-  if (!abstractOp) {
+  Optional<RegisteredOperationName> info = state.name.getRegisteredInfo();
+  if (!info) {
     emitError(state.location)
         << "type inference was requested for the operation " << state.name
         << ", but the operation was not registered. Ensure that the dialect "
            "containing the operation is linked into MLIR and registered with "
            "the context";
     return failure();
   }
 
   // Fallback to inference via an op interface.
-  auto *inferInterface = abstractOp->getInterface<InferTypeOpInterface>();
+  auto *inferInterface = info->getInterface<InferTypeOpInterface>();
   if (!inferInterface) {
     emitError(state.location)
         << "type inference was requested for the operation " << state.name
         << ", but the operation does not support type inference. Result "
            "types must be specified explicitly.";
     return failure();
   }
 
MlirContext mlirOperationGetContext(MlirOperation op) {
   return wrap(unwrap(op)->getContext());
 }
 
 MlirLocation mlirOperationGetLocation(MlirOperation op) {
   return wrap(unwrap(op)->getLoc());
 }
 
 MlirTypeID mlirOperationGetTypeID(MlirOperation op) {
-  if (const auto *abstractOp = unwrap(op)->getAbstractOperation()) {
-    return wrap(abstractOp->typeID);
-  }
+  if (auto info = unwrap(op)->getRegisteredInfo())
+    return wrap(info->getTypeID());
   return {nullptr};
 }
 
 MlirIdentifier mlirOperationGetName(MlirOperation op) {
   return wrap(unwrap(op)->getName().getIdentifier());
 }
 
 MlirBlock mlirOperationGetBlock(MlirOperation op) {

mlir/lib/CAPI/Interfaces/Interfaces.cpp

 #include "mlir/CAPI/Wrap.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "llvm/ADT/ScopeExit.h"
 
 using namespace mlir;
 
 bool mlirOperationImplementsInterface(MlirOperation operation,
                                       MlirTypeID interfaceTypeID) {
-  const AbstractOperation *abstractOp =
-      unwrap(operation)->getAbstractOperation();
-  return abstractOp && abstractOp->hasInterface(unwrap(interfaceTypeID));
+  Optional<RegisteredOperationName> info =
+      unwrap(operation)->getRegisteredInfo();
+  return info && info->hasInterface(unwrap(interfaceTypeID));
 }
 
 bool mlirOperationImplementsInterfaceStatic(MlirStringRef operationName,
                                             MlirContext context,
                                             MlirTypeID interfaceTypeID) {
-  const AbstractOperation *abstractOp = AbstractOperation::lookup(
+  Optional<RegisteredOperationName> info = RegisteredOperationName::lookup(
       StringRef(operationName.data, operationName.length), unwrap(context));
-  return abstractOp && abstractOp->hasInterface(unwrap(interfaceTypeID));
+  return info && info->hasInterface(unwrap(interfaceTypeID));
 }
 
 MlirTypeID mlirInferTypeOpInterfaceTypeID() {
   return wrap(InferTypeOpInterface::getInterfaceID());
 }
 
 MlirLogicalResult mlirInferTypeOpInterfaceInferReturnTypes(
     MlirStringRef opName, MlirContext context, MlirLocation location,
     intptr_t nOperands, MlirValue *operands, MlirAttribute attributes,
     intptr_t nRegions, MlirRegion *regions, MlirTypesCallback callback,
     void *userData) {
   StringRef name(opName.data, opName.length);
-  const AbstractOperation *abstractOp =
-      AbstractOperation::lookup(name, unwrap(context));
-  if (!abstractOp)
+  Optional<RegisteredOperationName> info =
+      RegisteredOperationName::lookup(name, unwrap(context));
+  if (!info)
     return mlirLogicalResultFailure();
 
   llvm::Optional<Location> maybeLocation = llvm::None;
   if (!mlirLocationIsNull(location))
     maybeLocation = unwrap(location);
   SmallVector<Value> unwrappedOperands;
   (void)unwrapList(nOperands, operands, unwrappedOperands);
   DictionaryAttr attributeDict;
MlirLogicalResult mlirInferTypeOpInterfaceInferReturnTypes(
   for (intptr_t i = 0; i < nRegions; ++i)
     unwrappedRegions.emplace_back(unwrap(*(regions + i)));
   auto cleaner = llvm::make_scope_exit([&]() {
     for (auto &region : unwrappedRegions)
       region.release();
   });
 
   SmallVector<Type> inferredTypes;
-  if (failed(abstractOp->getInterface<InferTypeOpInterface>()->inferReturnTypes(
+  if (failed(info->getInterface<InferTypeOpInterface>()->inferReturnTypes(
           unwrap(context), maybeLocation, unwrappedOperands, attributeDict,
           unwrappedRegions, inferredTypes)))
     return mlirLogicalResultFailure();
 
   SmallVector<MlirType> wrappedInferredTypes;
   wrappedInferredTypes.reserve(inferredTypes.size());
   for (Type t : inferredTypes)
     wrappedInferredTypes.push_back(wrap(t));
   callback(wrappedInferredTypes.size(), wrappedInferredTypes.data(), userData);
   return mlirLogicalResultSuccess();
 }

mlir/lib/Dialect/PDL/IR/PDL.cpp

static LogicalResult verify(OperationOp op) {
   return verifyHasBindingUseInMatcher(op, "`pdl.operation` or `pdl.rewrite`");
 }
 
 bool OperationOp::hasTypeInference() {
   Optional<StringRef> opName = name();
   if (!opName)
     return false;
 
-  OperationName name(*opName, getContext());
-  if (const AbstractOperation *op = name.getAbstractOperation())
-    return op->getInterface<InferTypeOpInterface>();
+  if (auto rInfo = RegisteredOperationName::lookup(*opName, getContext()))
+    return rInfo->hasInterface<InferTypeOpInterface>();
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::PatternOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(PatternOp pattern) {

mlir/lib/IR/AsmPrinter.cpp

void print(Operation *op) {
     // 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->getAbstractOperation()) {
+      if (auto opInfo = op->getRegisteredInfo()) {
         opInfo->printAssembly(op, *this, /*defaultDialect=*/"");
         return;
       }
     }
 
     // Otherwise print with the generic assembly form.
     printGenericOp(op);
   }
if (!resultGroups.empty()) {
       printResultGroup(/*resultNo=*/0, /*resultCount=*/numResults);
     }
 
     os << " = ";
   }
 
   // If requested, always print the generic form.
   if (!printerFlags.shouldPrintGenericOpForm()) {
-    // Check to see if this is a known operation.  If so, use the registered
+    // Check to see if this is a known operation. If so, use the registered
     // custom printer hook.
-    if (auto *opInfo = op->getAbstractOperation()) {
+    if (auto opInfo = op->getRegisteredInfo()) {
       opInfo->printAssembly(op, *this, defaultDialectStack.back());
       return;
     }
     // Otherwise try to dispatch to the dialect, if available.
     if (Dialect *dialect = op->getDialect()) {
       if (auto opPrinter = dialect->getOperationPrinter(op)) {
         // Print the op name first.
         StringRef name = op->getName().getStringRef();

mlir/lib/IR/MLIRContext.cpp

void mlir::registerMLIRContextCLOptions() {
   *clOptions;
 }
 
 //===----------------------------------------------------------------------===//
 // Locking Utilities
 //===----------------------------------------------------------------------===//
 
 namespace {
-/// Utility reader lock that takes a runtime flag that specifies if we really
-/// need to lock.
-struct ScopedReaderLock {
-  ScopedReaderLock(llvm::sys::SmartRWMutex<true> &mutexParam, bool shouldLock)
-      : mutex(shouldLock ? &mutexParam : nullptr) {
-    if (mutex)
-      mutex->lock_shared();
-  }
-  ~ScopedReaderLock() {
-    if (mutex)
-      mutex->unlock_shared();
-  }
-  llvm::sys::SmartRWMutex<true> *mutex;
-};
 /// Utility writer lock that takes a runtime flag that specifies if we really
 /// need to lock.
 struct ScopedWriterLock {
   ScopedWriterLock(llvm::sys::SmartRWMutex<true> &mutexParam, bool shouldLock)
       : mutex(shouldLock ? &mutexParam : nullptr) {
     if (mutex)
       mutex->lock();
   }
#endif
   /// destruction with the context.
   std::unique_ptr<llvm::ThreadPool> ownedThreadPool;
 
   /// This is a list of dialects that are created referring to this context.
   /// The MLIRContext owns the objects.
   DenseMap<StringRef, std::unique_ptr<Dialect>> loadedDialects;
   DialectRegistry dialectsRegistry;
 
-  /// This is a mapping from operation name to AbstractOperation for registered
-  /// operations.
-  llvm::StringMap<AbstractOperation> registeredOperations;
-
   /// 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;
+
+  /// A vector of operation info specifically for registered operations.
+  SmallVector<RegisteredOperationName> registeredOperations;
+
+  /// A mutex used when accessing operation information.
+  llvm::sys::SmartRWMutex<true> operationInfoMutex;
+
   //===--------------------------------------------------------------------===//
   // Affine uniquing
   //===--------------------------------------------------------------------===//
 
   // Affine allocator and mutex for thread safety.
   llvm::BumpPtrAllocator affineAllocator;
   llvm::sys::SmartRWMutex<true> affineMutex;
 

 /// emitting diagnostics.
 void MLIRContext::printStackTraceOnDiagnostic(bool enable) {
   impl->printStackTraceOnDiagnostic = enable;
 }
 
 /// Return information about all registered operations.  This isn't very
 /// efficient, typically you should ask the operations about their properties
 /// directly.
-std::vector<AbstractOperation *> MLIRContext::getRegisteredOperations() {
+std::vector<RegisteredOperationName> MLIRContext::getRegisteredOperations() {
   // We just have the operations in a non-deterministic hash table order. Dump
   // into a temporary array, then sort it by operation name to get a stable
   // ordering.
-  llvm::StringMap<AbstractOperation> &registeredOps =
-      impl->registeredOperations;
-
-  std::vector<AbstractOperation *> result;
-  result.reserve(registeredOps.size());
-  for (auto &elt : registeredOps)
-    result.push_back(&elt.second);
-  llvm::array_pod_sort(
-      result.begin(), result.end(),
-      [](AbstractOperation *const *lhs, AbstractOperation *const *rhs) {
-        return (*lhs)->name.compare((*rhs)->name);
+  std::vector<RegisteredOperationName> result(
+      impl->registeredOperations.begin(), impl->registeredOperations.end());
+  llvm::array_pod_sort(result.begin(), result.end(),
+                       [](const RegisteredOperationName *lhs,
+                          const RegisteredOperationName *rhs) {
+                         return lhs->getIdentifier().compare(
+                             rhs->getIdentifier());
                        });
 
   return result;
 }
 
 bool MLIRContext::isOperationRegistered(StringRef name) {
-  return impl->registeredOperations.count(name);
+  return OperationName(name, this).isRegistered();
 }
 
 void Dialect::addType(TypeID typeID, AbstractType &&typeInfo) {
   auto &impl = context->getImpl();
   assert(impl.multiThreadedExecutionContext == 0 &&
          "Registering a new type kind while in a multi-threaded execution "
          "context");
   auto *newInfo =
AbstractAttribute *AbstractAttribute::lookupMutable(TypeID typeID,
   auto &impl = context->getImpl();
   auto it = impl.registeredAttributes.find(typeID);
   if (it == impl.registeredAttributes.end())
     return nullptr;
   return it->second;
 }
 
 //===----------------------------------------------------------------------===//
-// AbstractOperation
+// OperationName
 //===----------------------------------------------------------------------===//
 
-ParseResult AbstractOperation::parseAssembly(OpAsmParser &parser,
-                                             OperationState &result) const {
-  return parseAssemblyFn(parser, result);
+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) {
+    llvm::sys::SmartScopedReader<true> contextLock(ctxImpl.operationInfoMutex);
+    auto it = ctxImpl.operations.find(name);
+    if (it != ctxImpl.operations.end()) {
+      impl = &it->second;
+      return;
+    }
   }
 
-/// Look up the specified operation in the operation set and return a pointer
-/// to it if present. Otherwise, return a null pointer.
-AbstractOperation *AbstractOperation::lookupMutable(StringRef opName,
-                                                    MLIRContext *context) {
-  auto &impl = context->getImpl();
-  auto it = impl.registeredOperations.find(opName);
-  if (it != impl.registeredOperations.end())
-    return &it->second;
-  return nullptr;
+  // 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;
+}
+
+StringRef OperationName::getDialectNamespace() const {
+  if (Dialect *dialect = getDialect())
+    return dialect->getNamespace();
+  return getStringRef().split('.').first;
+}
+
+//===----------------------------------------------------------------------===//
+// RegisteredOperationName
+//===----------------------------------------------------------------------===//
+
+ParseResult
+RegisteredOperationName::parseAssembly(OpAsmParser &parser,
+                                       OperationState &result) const {
+  return impl->parseAssemblyFn(parser, result);
 }
 
-void AbstractOperation::insert(
+void RegisteredOperationName::insert(
     StringRef name, Dialect &dialect, TypeID typeID,
     ParseAssemblyFn &&parseAssembly, PrintAssemblyFn &&printAssembly,
     VerifyInvariantsFn &&verifyInvariants, FoldHookFn &&foldHook,
     GetCanonicalizationPatternsFn &&getCanonicalizationPatterns,
     detail::InterfaceMap &&interfaceMap, HasTraitFn &&hasTrait,
     ArrayRef<StringRef> attrNames) {
   MLIRContext *ctx = dialect.getContext();
-  auto &impl = ctx->getImpl();
-  assert(impl.multiThreadedExecutionContext == 0 &&
-         "Registering a new operation kind while in a multi-threaded execution "
+  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<Identifier> cachedAttrNames;
   if (!attrNames.empty()) {
     cachedAttrNames = MutableArrayRef<Identifier>(
-        impl.abstractDialectSymbolAllocator.Allocate<Identifier>(
+        ctxImpl.abstractDialectSymbolAllocator.Allocate<Identifier>(
             attrNames.size()),
         attrNames.size());
     for (unsigned i : llvm::seq<unsigned>(0, attrNames.size()))
       new (&cachedAttrNames[i]) Identifier(Identifier::get(attrNames[i], ctx));
   }
 
-  // Register the information for this operation.
-  AbstractOperation opInfo(
-      name, dialect, typeID, std::move(parseAssembly), std::move(printAssembly),
-      std::move(verifyInvariants), std::move(foldHook),
-      std::move(getCanonicalizationPatterns), std::move(interfaceMap),
-      std::move(hasTrait), cachedAttrNames);
-  if (!impl.registeredOperations.insert({name, std::move(opInfo)}).second) {
+  // 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();
   }
-}
+  ctxImpl.registeredOperations.push_back(RegisteredOperationName(&impl));
 
-AbstractOperation::AbstractOperation(
-    StringRef name, Dialect &dialect, TypeID typeID,
-    ParseAssemblyFn &&parseAssembly, PrintAssemblyFn &&printAssembly,
-    VerifyInvariantsFn &&verifyInvariants, FoldHookFn &&foldHook,
-    GetCanonicalizationPatternsFn &&getCanonicalizationPatterns,
-    detail::InterfaceMap &&interfaceMap, HasTraitFn &&hasTrait,
-    ArrayRef<Identifier> attrNames)
-    : name(Identifier::get(name, dialect.getContext())), dialect(dialect),
-      typeID(typeID), interfaceMap(std::move(interfaceMap)),
-      foldHookFn(std::move(foldHook)),
-      getCanonicalizationPatternsFn(std::move(getCanonicalizationPatterns)),
-      hasTraitFn(std::move(hasTrait)),
-      parseAssemblyFn(std::move(parseAssembly)),
-      printAssemblyFn(std::move(printAssembly)),
-      verifyInvariantsFn(std::move(verifyInvariants)),
-      attributeNames(attrNames) {}
+  // 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.attributeNames = cachedAttrNames;
+}
 
 //===----------------------------------------------------------------------===//
 // AbstractType
 //===----------------------------------------------------------------------===//
 
 const AbstractType &AbstractType::lookup(TypeID typeID, MLIRContext *context) {
   const AbstractType *type = lookupMutable(typeID, context);
   if (!type)

mlir/lib/IR/Operation.cpp

 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/Interfaces/FoldInterfaces.h"
 #include "llvm/ADT/StringExtras.h"
 #include <numeric>
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
-// OperationName
-//===----------------------------------------------------------------------===//
-
-/// Form the OperationName for an op with the specified string.  This either is
-/// a reference to an AbstractOperation if one is known, or a uniqued Identifier
-/// if not.
-OperationName::OperationName(StringRef name, MLIRContext *context) {
-  if (auto *op = AbstractOperation::lookup(name, context))
-    representation = op;
-  else
-    representation = Identifier::get(name, context);
-}
-
-/// Return the name of the dialect this operation is registered to.
-StringRef OperationName::getDialectNamespace() const {
-  if (Dialect *dialect = getDialect())
-    return dialect->getNamespace();
-  return getStringRef().split('.').first;
-}
-
-/// Return the operation name with dialect name stripped, if it has one.
-StringRef OperationName::stripDialect() const {
-  return getStringRef().split('.').second;
-}
-
-/// Return the name of this operation. This always succeeds.
-StringRef OperationName::getStringRef() const {
-  return getIdentifier().strref();
-}
-
-/// Return the name of this operation as an identifier. This always succeeds.
-Identifier OperationName::getIdentifier() const {
-  if (auto *op = representation.dyn_cast<const AbstractOperation *>())
-    return op->name;
-  return representation.get<Identifier>();
-}
-
-OperationName OperationName::getFromOpaquePointer(const void *pointer) {
-  return OperationName(
-      RepresentationUnion::getFromOpaqueValue(const_cast<void *>(pointer)));
-}
-
-//===----------------------------------------------------------------------===//
 // Operation
 //===----------------------------------------------------------------------===//
 
 /// Create a new Operation with the specific fields.
 Operation *Operation::create(Location location, OperationName name,
                              TypeRange resultTypes, ValueRange operands,
                              ArrayRef<NamedAttribute> attributes,
                              BlockRange successors, unsigned numRegions) {
Operation *Operation::create(Location location, OperationName name,
   unsigned numTrailingResults = OpResult::getNumTrailing(resultTypes.size());
   unsigned numInlineResults = OpResult::getNumInline(resultTypes.size());
   unsigned numSuccessors = successors.size();
   unsigned numOperands = operands.size();
   unsigned numResults = resultTypes.size();
 
   // If the operation is known to have no operands, don't allocate an operand
   // storage.
-  bool needsOperandStorage = true;
-  if (operands.empty()) {
-    if (const AbstractOperation *abstractOp = name.getAbstractOperation())
-      needsOperandStorage = !abstractOp->hasTrait<OpTrait::ZeroOperands>();
-  }
+  bool needsOperandStorage =
+      operands.empty() ? !name.hasTrait<OpTrait::ZeroOperands>() : true;
 
   // Compute the byte size for the operation and the operand storage. This takes
   // into account the size of the operation, its trailing objects, and its
   // prefixed objects.
   size_t byteSize =
       totalSizeToAlloc<detail::OperandStorage, BlockOperand, Region, OpOperand>(
           needsOperandStorage ? 1 : 0, numSuccessors, numRegions, numOperands);
   size_t prefixByteSize = llvm::alignTo(
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.
-  auto *abstractOp = getAbstractOperation();
-  if (abstractOp && succeeded(abstractOp->foldHook(this, operands, results)))
+  Optional<RegisteredOperationName> info = getRegisteredInfo();
+  if (info && succeeded(info->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 = dialect->getRegisteredInterface<DialectFoldInterface>();

mlir/lib/IR/Verifier.cpp

for (auto attr : op.getAttrs()) {
     // Check for any optional dialect specific attributes.
     if (auto *dialect = attr.first.getReferencedDialect())
       if (failed(dialect->verifyOperationAttribute(&op, attr)))
         return failure();
   }
 
   // If we can get operation info for this, check the custom hook.
   OperationName opName = op.getName();
-  auto *opInfo = opName.getAbstractOperation();
-  if (opInfo && failed(opInfo->verifyInvariants(&op)))
+  Optional<RegisteredOperationName> registeredInfo = opName.getRegisteredInfo();
+  if (registeredInfo && failed(registeredInfo->verifyInvariants(&op)))
     return failure();
 
   if (unsigned numRegions = op.getNumRegions()) {
     auto kindInterface = dyn_cast<RegionKindInterface>(op);
 
     // Verify that all child regions are ok.
     for (unsigned i = 0; i < numRegions; ++i) {
       Region &region = op.getRegion(i);
for (unsigned i = 0; i < numRegions; ++i) {
       // Verify each of the blocks within the region.
       for (Block &block : region)
         if (failed(verifyBlock(block, opsWithIsolatedRegions)))
           return failure();
     }
   }
 
   // If this is a registered operation, there is nothing left to do.
-  if (opInfo)
+  if (registeredInfo)
     return success();
 
   // Otherwise, verify that the parent dialect allows un-registered operations.
   Dialect *dialect = opName.getDialect();
   if (!dialect) {
     if (!op.getContext()->allowsUnregisteredDialects()) {
       return op.emitOpError()
              << "created with unregistered dialect. If this is "

mlir/lib/Parser/AsmParserState.cpp

 
 struct AsmParserState::Impl {
   /// A map from a SymbolRefAttr to a range of uses.
   using SymbolUseMap =
       DenseMap<Attribute, SmallVector<SmallVector<llvm::SMRange>, 0>>;
 
   struct PartialOpDef {
     explicit PartialOpDef(const OperationName &opName) {
-      const auto *abstractOp = opName.getAbstractOperation();
-      if (abstractOp && abstractOp->hasTrait<OpTrait::SymbolTable>())
+      if (opName.hasTrait<OpTrait::SymbolTable>())
         symbolTable = std::make_unique<SymbolUseMap>();
     }
 
     /// Return if this operation is a symbol table.
     bool isSymbolTable() const { return symbolTable.get(); }
 
     /// If this operation is a symbol table, the following contains symbol uses
     /// within this operation.

mlir/lib/Parser/Parser.cpp

Operation *OperationParser::parseGenericOperation() {
   if (name.find('\0') != StringRef::npos)
     return (emitError("null character not allowed in operation name"), nullptr);
 
   consumeToken(Token::string);
 
   OperationState result(srcLocation, name);
 
   // Lazy load dialects in the context as needed.
-  if (!result.name.getAbstractOperation()) {
+  if (!result.name.isRegistered()) {
     StringRef dialectName = StringRef(name).split('.').first;
-    if (!getContext()->getLoadedDialect(dialectName)) {
-      if (getContext()->getOrLoadDialect(dialectName)) {
-        result.name = OperationName(name, getContext());
-      } else 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.
-        return emitError(
-                   "operation being parsed with an unregistered dialect. If "
-                   "this is intended, please use -allow-unregistered-dialect "
-                   "with the MLIR tool used"),
-               nullptr;
-      }
+    if (!getContext()->getLoadedDialect(dialectName) &&
+        !getContext()->getOrLoadDialect(dialectName) &&
+        !getContext()->allowsUnregisteredDialects()) {
+      emitError("operation being parsed with an unregistered dialect. If "
+                "with the MLIR tool used");
+      return nullptr;
     }
   }
 
   // If we are populating the parser state, start a new operation definition.
   if (state.asmState)
     state.asmState->startOperationDefinition(result.name);
 
   // Parse the operand list.
   SmallVector<SSAUseInfo, 8> operandInfos;
   if (parseToken(Token::l_paren, "expected '(' to start operand list") ||
       parseOptionalSSAUseList(operandInfos) ||
       parseToken(Token::r_paren, "expected ')' to end operand list")) {
     return nullptr;
   }
 
   // Parse the successor list.
   if (getToken().is(Token::l_square)) {
-    // Check if the operation is a known terminator.
-    const AbstractOperation *abstractOp = result.name.getAbstractOperation();
-    if (abstractOp && !abstractOp->hasTrait<OpTrait::IsTerminator>())
+    // Check if the operation is not a known terminator.
+    if (!result.name.mightHaveTrait<OpTrait::IsTerminator>())
       return emitError("successors in non-terminator"), nullptr;
 
     SmallVector<Block *, 2> successors;
     if (parseSuccessors(successors))
       return nullptr;
     result.addSuccessors(successors);
   }
 
private:
   OperationParser &parser;
 };
 } // end anonymous namespace.
 
 Operation *
 OperationParser::parseCustomOperation(ArrayRef<ResultRecord> resultIDs) {
   llvm::SMLoc opLoc = getToken().getLoc();
   std::string opName = getTokenSpelling().str();
-  auto *opDefinition = AbstractOperation::lookup(opName, getContext());
+  Optional<RegisteredOperationName> opInfo =
+      RegisteredOperationName::lookup(opName, getContext());
   StringRef defaultDialect = getState().defaultDialectStack.back();
   Dialect *dialect = nullptr;
-  if (opDefinition) {
-    dialect = &opDefinition->dialect;
+  if (opInfo) {
+    dialect = &opInfo->getDialect();
   } else {
     if (StringRef(opName).contains('.')) {
       // This op has a dialect, we try to check if we can register it in the
       // context on the fly.
       StringRef dialectName = StringRef(opName).split('.').first;
       dialect = getContext()->getLoadedDialect(dialectName);
       if (!dialect && (dialect = getContext()->getOrLoadDialect(dialectName)))
-        opDefinition = AbstractOperation::lookup(opName, getContext());
+        opInfo = RegisteredOperationName::lookup(opName, getContext());
     } else {
       // If the operation name has no namespace prefix we lookup the current
       // default dialect (set through OpAsmOpInterface).
-      opDefinition = AbstractOperation::lookup(
+      opInfo = RegisteredOperationName::lookup(
           Twine(defaultDialect + "." + opName).str(), getContext());
-      if (!opDefinition && getContext()->getOrLoadDialect("std")) {
-        opDefinition = AbstractOperation::lookup(Twine("std." + opName).str(),
+      if (!opInfo && getContext()->getOrLoadDialect("std")) {
+        opInfo = RegisteredOperationName::lookup(Twine("std." + opName).str(),
                                                  getContext());
       }
-      if (opDefinition) {
-        dialect = &opDefinition->dialect;
-        opName = opDefinition->name.str();
+      if (opInfo) {
+        dialect = &opInfo->getDialect();
+        opName = opInfo->getStringRef().str();
       } else if (!defaultDialect.empty()) {
         dialect = getContext()->getOrLoadDialect(defaultDialect);
         opName = (defaultDialect + "." + opName).str();
       }
     }
   }
 
   // This is the actual hook for the custom op parsing, usually implemented by
   // the op itself (`Op::parse()`). We retrieve it either from the
-  // AbstractOperation or from the Dialect.
+  // RegisteredOperationName or from the Dialect.
   function_ref<ParseResult(OpAsmParser &, OperationState &)> parseAssemblyFn;
   bool isIsolatedFromAbove = false;
 
   defaultDialect = "";
-  if (opDefinition) {
-    parseAssemblyFn = opDefinition->getParseAssemblyFn();
-    isIsolatedFromAbove =
-        opDefinition->hasTrait<OpTrait::IsIsolatedFromAbove>();
-    auto *iface = opDefinition->getInterface<OpAsmOpInterface>();
+  if (opInfo) {
+    parseAssemblyFn = opInfo->getParseAssemblyFn();
+    isIsolatedFromAbove = opInfo->hasTrait<OpTrait::IsIsolatedFromAbove>();
+    auto *iface = opInfo->getInterface<OpAsmOpInterface>();
     if (iface && !iface->getDefaultDialect().empty())
       defaultDialect = iface->getDefaultDialect();
   } else {
     Optional<Dialect::ParseOpHook> dialectHook;
     if (dialect)
       dialectHook = dialect->getParseOperationHook(opName);
     if (!dialectHook.hasValue()) {
       emitError(opLoc) << "custom op '" << opName << "' is unknown";

mlir/lib/Rewrite/ByteCode.cpp

for (unsigned i = 0, e = read(); i != e; ++i) {
     // If we find a null range, this signals that the types are infered.
     if (TypeRange *resultTypes = read<TypeRange *>()) {
       state.types.append(resultTypes->begin(), resultTypes->end());
       continue;
     }
 
     // Handle the case where the operation has inferred types.
     InferTypeOpInterface::Concept *concept =
-        state.name.getAbstractOperation()->getInterface<InferTypeOpInterface>();
+        state.name.getRegisteredInfo()->getInterface<InferTypeOpInterface>();
 
     // TODO: Handle failure.
     state.types.clear();
     if (failed(concept->inferReturnTypes(
             state.getContext(), state.location, state.operands,
             state.attributes.getDictionary(state.getContext()), state.regions,
             state.types)))
       return;

mlir/lib/Rewrite/FrozenRewritePatternSet.cpp

FrozenRewritePatternSet::FrozenRewritePatternSet(
   disabledPatterns.insert(disabledPatternLabels.begin(),
                           disabledPatternLabels.end());
   enabledPatterns.insert(enabledPatternLabels.begin(),
                          enabledPatternLabels.end());
 
   // Functor used to walk all of the operations registered in the context. This
   // is useful for patterns that get applied to multiple operations, such as
   // interface and trait based patterns.
-  std::vector<AbstractOperation *> abstractOps;
-  auto addToOpsWhen = [&](std::unique_ptr<RewritePattern> &pattern,
-                          function_ref<bool(AbstractOperation *)> callbackFn) {
-    if (abstractOps.empty())
-      abstractOps = pattern->getContext()->getRegisteredOperations();
-    for (AbstractOperation *absOp : abstractOps) {
-      if (callbackFn(absOp)) {
-        OperationName opName(absOp);
-        impl->nativeOpSpecificPatternMap[opName].push_back(pattern.get());
-      }
-    }
+  std::vector<RegisteredOperationName> opInfos;
+  auto addToOpsWhen =
+      [&](std::unique_ptr<RewritePattern> &pattern,
+          function_ref<bool(RegisteredOperationName)> callbackFn) {
+        if (opInfos.empty())
+          opInfos = pattern->getContext()->getRegisteredOperations();
+        for (RegisteredOperationName info : opInfos)
+          if (callbackFn(info))
+            impl->nativeOpSpecificPatternMap[info].push_back(pattern.get());
         impl->nativeOpSpecificPatternList.push_back(std::move(pattern));
       };
 
   for (std::unique_ptr<RewritePattern> &pat : patterns.getNativePatterns()) {
     // Don't add patterns that haven't been enabled by the user.
     if (!enabledPatterns.empty()) {
       auto isEnabledFn = [&](StringRef label) {
         return enabledPatterns.count(label);
       };
       if (!isEnabledFn(pat->getDebugName()) &&
for (std::unique_ptr<RewritePattern> &pat : patterns.getNativePatterns()) {
     }
 
     if (Optional<OperationName> rootName = pat->getRootKind()) {
       impl->nativeOpSpecificPatternMap[*rootName].push_back(pat.get());
       impl->nativeOpSpecificPatternList.push_back(std::move(pat));
       continue;
     }
     if (Optional<TypeID> interfaceID = pat->getRootInterfaceID()) {
-      addToOpsWhen(pat, [&](AbstractOperation *absOp) {
-        return absOp->hasInterface(*interfaceID);
+      addToOpsWhen(pat, [&](RegisteredOperationName info) {
+        return info.hasInterface(*interfaceID);
       });
       continue;
     }
     if (Optional<TypeID> traitID = pat->getRootTraitID()) {
-      addToOpsWhen(pat, [&](AbstractOperation *absOp) {
-        return absOp->hasTrait(*traitID);
+      addToOpsWhen(pat, [&](RegisteredOperationName info) {
+        return info.hasTrait(*traitID);
       });
       continue;
     }
     impl->nativeAnyOpPatterns.push_back(std::move(pat));
   }
 
   // Generate the bytecode for the PDL patterns if any were provided.
   PDLPatternModule &pdlPatterns = patterns.getPDLPatterns();

mlir/lib/Transforms/Canonicalizer.cpp

struct Canonicalizer : public CanonicalizerBase<Canonicalizer> {
   }
 
   /// Initialize the canonicalizer by building the set of patterns used during
   /// execution.
   LogicalResult initialize(MLIRContext *context) override {
     RewritePatternSet owningPatterns(context);
     for (auto *dialect : context->getLoadedDialects())
       dialect->getCanonicalizationPatterns(owningPatterns);
-    for (auto *op : context->getRegisteredOperations())
-      op->getCanonicalizationPatterns(owningPatterns, context);
+    for (RegisteredOperationName op : context->getRegisteredOperations())
+      op.getCanonicalizationPatterns(owningPatterns, context);
 
     patterns = FrozenRewritePatternSet(std::move(owningPatterns),
                                        disabledPatterns, enabledPatterns);
     return success();
   }
   void runOnOperation() override {
     (void)applyPatternsAndFoldGreedily(getOperation()->getRegions(), patterns,
                                        config);

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

void OpEmitter::genAttrNameGetters() {
   {
     auto *method = opClass.addStaticInlineMethod<Method::MP_Private>(
         "::mlir::Identifier", "getAttributeNameForIndex",
         MethodParameter("::mlir::OperationName", "name"),
         MethodParameter("unsigned", "index"));
     ERROR_IF_PRUNED(method, "getAttributeNameForIndex", op);
     method->body() << "assert(index < " << attributeNames.size()
                    << " && \"invalid attribute index\");\n"
-                      "  return name.getAbstractOperation()"
+                      "  return name.getRegisteredInfo()"
                       "->getAttributeNames()[index];";
   }
 
   // Generate the <attr>AttrName methods, that expose the attribute names to
   // users.
   const char *attrNameMethodBody = "  return getAttributeNameForIndex({0});";
   for (const std::pair<StringRef, unsigned> &attrIt : attributeNames) {
     for (StringRef name : op.getGetterNames(attrIt.first)) {