[mlir:PDL] Add support for DialectConversion with pattern configurations

[rriddle]

Summary

Up until now PDL(L) has not supported dialect conversion because we had no
way of remapping values or integrating with type conversions. This commit
rectifies that by adding a new "pattern configuration" concept to PDL. This
essentially allows for attaching external configurations to patterns, which
can hook into pattern events (for now just the scope of a rewrite, but we
could also pass configs to native rewrites as well). This allows for injecting
the type converter into the conversion pattern rewriter.

[jpienaar]

The type converter scopes is a bit new, is this solely for this or where else would you see this be used?

mlir/lib/IR/PatternMatch.cpp

192

This is creative use of bookkeeping :-) Is this due to invalidation of Value hash maps ? (E.g.,. Why couldn't this just be an Analysis that gets populated)

mlir/lib/Transforms/Utils/DialectConversion.cpp

3298

This is a bit undesirable as this is at runtime. And this could be for a dynamically compiled pattern which gets invoked from a pass that can actually flag a failure. I'd rather have an error propagated.

[rriddle]

mlir/lib/IR/PatternMatch.cpp

192

That gives me an idea, let me rework this.

mlir/lib/Transforms/Utils/DialectConversion.cpp

3298

Let me rework this then. We'll have to build failable rewrites into PDL, which will require some more substantial changes. I'll start building that under this.

[rriddle]

In D133142#3775985, @jpienaar wrote:

The type converter scopes is a bit new, is this solely for this or where else would you see this be used?

Removed it, thanks. We used to need that, but I hadn't checked in a while.

[jpienaar]

Nice, thanks! Haven't tried it out yet though :)

mlir/include/mlir/IR/PatternMatch.h

875

s/and/or/ ?

1243

So these could both fail but still be run and success returned? What should be expectation ? (fail if one fails, fails if both fails, shortcircuit return or evaluate both)

mlir/include/mlir/Transforms/DialectConversion.pdll

2

pdll ?

mlir/lib/Transforms/Utils/DialectConversion.cpp

3277

This pulls PDL into DialectConversion proper, any cost if PDL is not used? Could these be in a helper PDL side?

mlir/test/lib/Transforms/TestDialectConversion.pdll

16

OOC when would one not want the result types converted if there is a type converter registered? (I believe dialect conversion side that's implicit too). Is this to avoid making dialect conversion/type converter too ingrained in PDL? (although as you've done it above it is a config only).

I could see this maybe differ for intermediate results. But can't think of good example. (not a blocker, explicit "default" is good)

[rriddle]

mlir/include/mlir/IR/PatternMatch.h

1243

Originally I wasn't expecting nested logicalresult/failable things within pair/tuple. Just switched this to properly check for failure though (just in case).

mlir/lib/Transforms/Utils/DialectConversion.cpp

3277

No cost if it's unused. The class is just defined in DialectConversion, it's attached on the PDL patterns directly so you only pay a cost if you're using a PDL pattern that wants dialect conversion stuff.

mlir/test/lib/Transforms/TestDialectConversion.pdll

16

Most of the cases you wouldn't want result type conversion is for intermediate results. I'm a bit hesitant on implicit behavior changes here because then the underlying behavior would likely become harder to understand. If we could come up with a good model for it I'd be okay, but right now IMO being explicit is a better starting point (and matches the C++ side).

mlir/include/mlir/IR/PatternMatch.h

 /// be tracking various state that would be invalidated when a mutation takes
 /// place.
 class PatternRewriter : public RewriterBase {
 public:
   using RewriterBase::RewriterBase;
 };
 
 //===----------------------------------------------------------------------===//
-// PDLPatternModule
+// PDL Patterns
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // PDLValue
 
 /// Storage type of byte-code interpreter values. These are passed to constraint
 /// functions as arguments.
 class PDLValue {
protected:
   SmallVector<ValueRange> valueRanges;
   /// Memory allocated to store ranges in the result list whose lifetime was
   /// generated in the native function.
   SmallVector<llvm::OwningArrayRef<Type>> allocatedTypeRanges;
   SmallVector<llvm::OwningArrayRef<Value>> allocatedValueRanges;
 };
 
 //===----------------------------------------------------------------------===//
+// PDLPatternConfig
+
+/// An individual configuration for a pattern, which can be accessed by native
+/// functions via the PDLPatternConfigSet. This allows for injecting additional
+/// configuration into PDL patterns that is specific to certain compilation
+/// flows.
+class PDLPatternConfig {
+public:
+  virtual ~PDLPatternConfig() = default;
+
+  /// Hooks that are invoked at the beginning and end of a rewrite of a matched
+  /// pattern. These can be used to setup any specific state necessary for the
+  /// rewrite.
+  virtual void notifyRewriteBegin(PatternRewriter &rewriter) {}
+  virtual void notifyRewriteEnd(PatternRewriter &rewriter) {}
+
+  /// Return the TypeID that represents this configuration.
+  TypeID getTypeID() const { return id; }
+
+protected:
+  PDLPatternConfig(TypeID id) : id(id) {}
+
+private:
+  TypeID id;
+};
+
+/// This class provides a base class for users implementing a type of pattern
+/// configuration.
+template <typename T>
+class PDLPatternConfigBase : public PDLPatternConfig {
+public:
+  /// Support LLVM style casting.
+  static bool classof(const PDLPatternConfig *config) {
+    return config->getTypeID() == getConfigID();
+  }
+
+  /// Return the type id used for this configuration.
+  static TypeID getConfigID() { return TypeID::get<T>(); }
+
+protected:
+  PDLPatternConfigBase() : PDLPatternConfig(getConfigID()) {}
+};
+
+/// This class contains a set of configurations for a specific pattern.
+/// Configurations are uniqued by TypeID, meaning that only one configuration of
+/// each type is allowed.
+class PDLPatternConfigSet {
+public:
+  PDLPatternConfigSet() = default;
+
+  /// Construct a set with the given configurations.
+  template <typename... ConfigsT>
+  PDLPatternConfigSet(ConfigsT &&...configs) {
+    (addConfig(std::forward<ConfigsT>(configs)), ...);
+  }
+
+  /// Get the configuration defined by the given type. Asserts that the
+  /// configuration of the provided type exists.
+  template <typename T>
+  const T &get() const {
+    const T *config = tryGet<T>();
+    assert(config && "configuration not found");
+    return *config;
+  }
+
+  /// Get the configuration defined by the given type, returns nullptr if the
+  /// configuration does not exist.
+  template <typename T>
+  const T *tryGet() const {
+    for (const auto &configIt : configs)
+      if (const T *config = dyn_cast<T>(configIt.get()))
+        return config;
+    return nullptr;
+  }
+
+  /// Notify the configurations within this set at the beginning and end of a
+  /// rewrite of a matched pattern.
+  void notifyRewriteBegin(PatternRewriter &rewriter) {
+    for (const auto &config : configs)
+      config->notifyRewriteBegin(rewriter);
+  }
+  void notifyRewriteEnd(PatternRewriter &rewriter) {
+    for (const auto &config : configs)
+      config->notifyRewriteEnd(rewriter);
+  }
+
+protected:
+  /// Add a configuration to the set.
+  template <typename T>
+  void addConfig(T &&config) {
+    assert(!tryGet<std::decay_t<T>>() && "configuration already exists");
+    configs.emplace_back(
+        std::make_unique<std::decay_t<T>>(std::forward<T>(config)));
+  }
+
+  /// The set of configurations for this pattern. This uses a vector instead of
+  /// a map with the expectation that the number of configurations per set is
+  /// small (<= 1).
+  SmallVector<std::unique_ptr<PDLPatternConfig>> configs;
+};
+
+//===----------------------------------------------------------------------===//
 // PDLPatternModule
 
 /// A generic PDL pattern constraint function. This function applies a
 /// constraint to a given set of opaque PDLValue entities. Returns success if
 /// the constraint successfully held, failure otherwise.
 using PDLConstraintFunction =
     std::function<LogicalResult(PatternRewriter &, ArrayRef<PDLValue>)>;
 /// A native PDL rewrite function. This function performs a rewrite on the

 };
 template <>
 struct ProcessPDLValue<ValueTypeRange<ResultRange>> {
   static void processAsResult(PatternRewriter &, PDLResultList &results,
                               ValueTypeRange<ResultRange> types) {
     results.push_back(types);
   }
 };
+template <unsigned N>
+struct ProcessPDLValue<SmallVector<Type, N>> {
+  static void processAsResult(PatternRewriter &, PDLResultList &results,
+                              SmallVector<Type, N> values) {
+    results.push_back(TypeRange(values));
+  }
+};
 
 //===----------------------------------------------------------------------===//
 // Value
 
 template <>
 struct ProcessPDLValue<Value> : public ProcessBuiltinPDLValue<Value> {};
 
 //===----------------------------------------------------------------------===//

 };
 template <>
 struct ProcessPDLValue<ResultRange> {
   static void processAsResult(PatternRewriter &, PDLResultList &results,
                               ResultRange values) {
     results.push_back(values);
   }
 };
+template <unsigned N>
+struct ProcessPDLValue<SmallVector<Value, N>> {
+  static void processAsResult(PatternRewriter &, PDLResultList &results,
+                              SmallVector<Value, N> values) {
+    results.push_back(ValueRange(values));
+  }
+};
 
 //===----------------------------------------------------------------------===//
 // PDL Function Builder: Argument Handling
 //===----------------------------------------------------------------------===//
 
 /// Validate the given PDLValues match the constraints defined by the argument
 /// types of the given function. In the case of failure, a match failure
 /// diagnostic is emitted.

 /// Store a std::pair<> as individual results within the result list.
 template <typename T1, typename T2>
 static void processResults(PatternRewriter &rewriter, PDLResultList &results,
                            std::pair<T1, T2> &&pair) {
   processResults(rewriter, results, std::move(pair.first));
   processResults(rewriter, results, std::move(pair.second));
 }
 
 /// Store a std::tuple<> as individual results within the result list.
 template <typename... Ts>
 static void processResults(PatternRewriter &rewriter, PDLResultList &results,
                            std::tuple<Ts...> &&tuple) {
   auto applyFn = [&](auto &&...args) {
     (processResults(rewriter, results, std::move(args)), ...);
   };
   std::apply(applyFn, std::move(tuple));
 }
return [rewriteFn = std::forward<RewriteFnT>(rewriteFn)](
     processArgsAndInvokeRewrite(rewriteFn, rewriter, results, values,
                                 argIndices);
   };
 }
 
 } // namespace pdl_function_builder
 } // namespace detail
 
+//===----------------------------------------------------------------------===//
+// PDLPatternModule
+
 /// This class contains all of the necessary data for a set of PDL patterns, or
 /// pattern rewrites specified in the form of the PDL dialect. This PDL module
 /// contained by this pattern may contain any number of `pdl.pattern`
 /// operations.
 class PDLPatternModule {
 public:
   PDLPatternModule() = default;
 
-  /// Construct a PDL pattern with the given module.
-  PDLPatternModule(OwningOpRef<ModuleOp> pdlModule)
-      : pdlModule(std::move(pdlModule)) {}
+  /// Construct a PDL pattern with the given module and configurations.
+  PDLPatternModule(OwningOpRef<ModuleOp> module)
+      : pdlModule(std::move(module)) {}
+  template <typename... ConfigsT>
+  PDLPatternModule(OwningOpRef<ModuleOp> module, ConfigsT &&...patternConfigs)
+      : PDLPatternModule(std::move(module)) {
+    auto configSet = std::make_unique<PDLPatternConfigSet>(
+        std::forward<ConfigsT>(patternConfigs)...);
+    attachConfigToPatterns(*pdlModule, *configSet);
+    configs.emplace_back(std::move(configSet));
+  }
 
   /// Merge the state in `other` into this pattern module.
   void mergeIn(PDLPatternModule &&other);
 
   /// Return the internal PDL module of this pattern.
   ModuleOp getModule() { return pdlModule.get(); }
 
   //===--------------------------------------------------------------------===//
public:
   /// Return the set of the registered rewrite functions.
   const llvm::StringMap<PDLRewriteFunction> &getRewriteFunctions() const {
     return rewriteFunctions;
   }
   llvm::StringMap<PDLRewriteFunction> takeRewriteFunctions() {
     return rewriteFunctions;
   }
 
+  /// Return the set of the registered pattern configs.
+  SmallVector<std::unique_ptr<PDLPatternConfigSet>> takeConfigs() {
+    return std::move(configs);
+  }
+
   /// Clear out the patterns and functions within this module.
   void clear() {
     pdlModule = nullptr;
     constraintFunctions.clear();
     rewriteFunctions.clear();
   }
 
 private:
+  /// Attach the given pattern config set to the patterns defined within the
+  /// given module.
+  void attachConfigToPatterns(ModuleOp module, PDLPatternConfigSet &configSet);
+
   /// The module containing the `pdl.pattern` operations.
   OwningOpRef<ModuleOp> pdlModule;
 
+  /// The set of configuration sets referenced by patterns within `pdlModule`.
+  SmallVector<std::unique_ptr<PDLPatternConfigSet>> configs;
+
   /// The external functions referenced from within the PDL module.
   llvm::StringMap<PDLConstraintFunction> constraintFunctions;
   llvm::StringMap<PDLRewriteFunction> rewriteFunctions;
 };
 
 //===----------------------------------------------------------------------===//
 // RewritePatternSet
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Transforms/DialectConversion.h

private:
   /// An optional legality callback for unknown operations.
   DynamicLegalityCallbackFn unknownLegalityFn;
 
   /// The current context this target applies to.
   MLIRContext &ctx;
 };
 
 //===----------------------------------------------------------------------===//
+// PDL Configuration
+//===----------------------------------------------------------------------===//
+
+/// A PDL configuration that is used to supported dialect conversion
+/// functionality.
+class PDLConversionConfig final
+    : public PDLPatternConfigBase<PDLConversionConfig> {
+public:
+  PDLConversionConfig(TypeConverter *converter) : converter(converter) {}
+  ~PDLConversionConfig() final = default;
+
+  /// Return the type converter used by this configuration, which may be nullptr
+  /// if no type conversions are expected.
+  TypeConverter *getTypeConverter() const { return converter; }
+
+  /// Hooks that are invoked at the beginning and end of a rewrite of a matched
+  /// pattern.
+  void notifyRewriteBegin(PatternRewriter &rewriter) final;
+  void notifyRewriteEnd(PatternRewriter &rewriter) final;
+
+private:
+  /// An optional type converter to use for the pattern.
+  TypeConverter *converter;
+};
+
+/// Register the dialect conversion PDL functions with the given pattern set.
+void registerConversionPDLFunctions(RewritePatternSet &patterns);
+
+//===----------------------------------------------------------------------===//
 // Op Conversion Entry Points
 //===----------------------------------------------------------------------===//
 
 /// Below we define several entry points for operation conversion. It is
 /// important to note that the patterns provided to the conversion framework may
 /// have additional constraints. See the `PatternRewriter Hooks` section of the
 /// ConversionPatternRewriter, to see what additional constraints are imposed on
 /// the use of the PatternRewriter.

mlir/include/mlir/Transforms/DialectConversion.pdll

+//===- DialectConversion.pdll - DialectConversion PDLL Support --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines various utilities for interacting with dialect conversion
+// within PDLL.
+//
+//===----------------------------------------------------------------------===//
+
+/// This rewrite returns the converted value of `value`, whose type is defined 
+/// by the type converted specified in the `PDLConversionConfig` of the current
+/// pattern.
+Rewrite convertValue(value: Value) -> Value;
+
+/// This rewrite returns the converted values of `values`, whose type is defined 
+/// by the type converted specified in the `PDLConversionConfig` of the current
+/// pattern.
+Rewrite convertValues(values: ValueRange) -> ValueRange;
+
+/// This rewrite returns the converted type of `type` as defined by the type
+/// converted specified in the `PDLConversionConfig` of the current pattern.
+Rewrite convertType(type: Type) -> Type;
+
+/// This rewrite returns the converted types of `types` as defined by the type
+/// converted specified in the `PDLConversionConfig` of the current pattern.
+Rewrite convertTypes(types: TypeRange) -> TypeRange;

mlir/lib/IR/PatternMatch.cpp

 // PDLPatternModule
 //===----------------------------------------------------------------------===//
 
 void PDLPatternModule::mergeIn(PDLPatternModule &&other) {
   // Ignore the other module if it has no patterns.
   if (!other.pdlModule)
     return;
 
-  // Steal the functions of the other module.
+  // Steal the functions and config of the other module.
   for (auto &it : other.constraintFunctions)
     registerConstraintFunction(it.first(), std::move(it.second));
   for (auto &it : other.rewriteFunctions)
     registerRewriteFunction(it.first(), std::move(it.second));
+  for (auto &it : other.configs)
+    configs.emplace_back(std::move(it));
 
   // Steal the other state if we have no patterns.
   if (!pdlModule) {
     pdlModule = std::move(other.pdlModule);
     return;
   }
 
   // Merge the pattern operations from the other module into this one.
   Block *block = pdlModule->getBody();
   block->getOperations().splice(block->end(),
                                 other.pdlModule->getBody()->getOperations());
 }
 
+void PDLPatternModule::attachConfigToPatterns(ModuleOp module,
+                                              PDLPatternConfigSet &configSet) {
+  // Attach the configuration as an opaque location to the symbols within the
+  // module. We use locations to avoid other more expensive and complex means of
+  // bookkeeping.
+  module->walk([&](Operation *op) {
+    // We only add to symbols to avoid hardcoding any specific operation names
+    // here (given that we don't depend on any PDL dialect). We can't use
+    // cast<SymbolOpInterface> here because patterns may be optional symbols.
+    if (!op->hasTrait<SymbolOpInterface::Trait>())
+      return;
+    op->setLoc(OpaqueLoc::get(&configSet, op->getLoc()));
+  });
+}
+
 //===----------------------------------------------------------------------===//
 // Function Registry
 
 void PDLPatternModule::registerConstraintFunction(
     StringRef name, PDLConstraintFunction constraintFn) {
   // TODO: Is it possible to diagnose when `name` is already registered to
   // a function that is not equivalent to `constraintFn`?
   // Allow existing mappings in the case multiple patterns depend on the same

mlir/lib/Rewrite/ByteCode.h

 class PDLByteCodePattern : public Pattern {
 public:
   static PDLByteCodePattern create(pdl_interp::RecordMatchOp matchOp,
                                    ByteCodeAddr rewriterAddr);
 
   /// Return the bytecode address of the rewriter for this pattern.
   ByteCodeAddr getRewriterAddr() const { return rewriterAddr; }
 
+  /// Return the configuration set for this pattern, or null if there is none.
+  PDLPatternConfigSet *getConfigSet() const { return configSet; }
+
 private:
   template <typename... Args>
-  PDLByteCodePattern(ByteCodeAddr rewriterAddr, Args &&...patternArgs)
-      : Pattern(std::forward<Args>(patternArgs)...),
-        rewriterAddr(rewriterAddr) {}
+  PDLByteCodePattern(ByteCodeAddr rewriterAddr, PDLPatternConfigSet *configSet,
+                     Args &&...patternArgs)
+      : Pattern(std::forward<Args>(patternArgs)...), rewriterAddr(rewriterAddr),
+        configSet(configSet) {}
 
   /// The address of the rewriter for this pattern.
   ByteCodeAddr rewriterAddr;
+
+  /// The optional config set for this pattern.
+  PDLPatternConfigSet *configSet;
 };
 
 //===----------------------------------------------------------------------===//
 // PDLByteCodeMutableState
 //===----------------------------------------------------------------------===//
 
 /// This class contains the mutable state of a bytecode instance. This allows
 /// for a bytecode instance to be cached and reused across various different
struct MatchResult {
     const PDLByteCodePattern *pattern;
     /// The current benefit of the pattern that was matched.
     PatternBenefit benefit;
   };
 
   /// Create a ByteCode instance from the given module containing operations in
   /// the PDL interpreter dialect.
   PDLByteCode(ModuleOp module,
+              SmallVector<std::unique_ptr<PDLPatternConfigSet>> configs,
               llvm::StringMap<PDLConstraintFunction> constraintFns,
               llvm::StringMap<PDLRewriteFunction> rewriteFns);
 
   /// Return the patterns held by the bytecode.
   ArrayRef<PDLByteCodePattern> getPatterns() const { return patterns; }
 
   /// Initialize the given state such that it can be used to execute the current
   /// bytecode.

 private:
   /// Execute the given byte code starting at the provided instruction `inst`.
   /// `matches` is an optional field provided when this function is executed in
   /// a matching context.
   void executeByteCode(const ByteCodeField *inst, PatternRewriter &rewriter,
                        PDLByteCodeMutableState &state,
                        SmallVectorImpl<MatchResult> *matches) const;
 
+  /// The set of pattern configs referenced within the bytecode.
+  SmallVector<std::unique_ptr<PDLPatternConfigSet>> configs;
+
   /// A vector containing pointers to uniqued data. The storage is intentionally
   /// opaque such that we can store a wide range of data types. The types of
   /// data stored here include:
   ///  * Attribute, OperationName, Type
   std::vector<const void *> uniquedData;
 
   /// A vector containing the generated bytecode for the matcher.
   SmallVector<ByteCodeField, 64> matcherByteCode;

mlir/lib/Rewrite/ByteCode.cpp

 using namespace mlir::detail;
 
 //===----------------------------------------------------------------------===//
 // PDLByteCodePattern
 //===----------------------------------------------------------------------===//
 
 PDLByteCodePattern PDLByteCodePattern::create(pdl_interp::RecordMatchOp matchOp,
                                               ByteCodeAddr rewriterAddr) {
+  PatternBenefit benefit = matchOp.getBenefit();
+  MLIRContext *ctx = matchOp.getContext();
+
+  // Collect the set of generated operations.
   SmallVector<StringRef, 8> generatedOps;
   if (ArrayAttr generatedOpsAttr = matchOp.getGeneratedOpsAttr())
     generatedOps =
         llvm::to_vector<8>(generatedOpsAttr.getAsValueRange<StringAttr>());
 
-  PatternBenefit benefit = matchOp.getBenefit();
-  MLIRContext *ctx = matchOp.getContext();
+  // Check to see if this pattern has a config set.
+  PDLPatternConfigSet *configSet =
+      OpaqueLoc::getUnderlyingLocationOrNull<PDLPatternConfigSet *>(
+          matchOp.getLoc());
 
   // Check to see if this is pattern matches a specific operation type.
   if (Optional<StringRef> rootKind = matchOp.getRootKind())
-    return PDLByteCodePattern(rewriterAddr, *rootKind, benefit, ctx,
-                              generatedOps);
-  return PDLByteCodePattern(rewriterAddr, MatchAnyOpTypeTag(), benefit, ctx,
+    return PDLByteCodePattern(rewriterAddr, configSet, *rootKind, benefit, ctx,
                               generatedOps);
+  return PDLByteCodePattern(rewriterAddr, configSet, MatchAnyOpTypeTag(),
+                            benefit, ctx, generatedOps);
 }
 
 //===----------------------------------------------------------------------===//
 // PDLByteCodeMutableState
 //===----------------------------------------------------------------------===//
 
 /// Set the new benefit for a bytecode pattern. The `patternIndex` corresponds
 /// to the position of the pattern within the range returned by
void Generator::generate(pdl_interp::SwitchTypesOp op, ByteCodeWriter &writer) {
   writer.append(OpCode::SwitchTypes, op.getValue(), op.getCaseValuesAttr(),
                 op.getSuccessors());
 }
 
 //===----------------------------------------------------------------------===//
 // PDLByteCode
 //===----------------------------------------------------------------------===//
 
-PDLByteCode::PDLByteCode(ModuleOp module,
-                         llvm::StringMap<PDLConstraintFunction> constraintFns,
-                         llvm::StringMap<PDLRewriteFunction> rewriteFns) {
+PDLByteCode::PDLByteCode(
+    ModuleOp module, SmallVector<std::unique_ptr<PDLPatternConfigSet>> configs,
+    llvm::StringMap<PDLRewriteFunction> rewriteFns)
+    : configs(std::move(configs)) {
   Generator generator(module.getContext(), uniquedData, matcherByteCode,
                       rewriterByteCode, patterns, maxValueMemoryIndex,
                       maxOpRangeCount, maxTypeRangeCount, maxValueRangeCount,
                       maxLoopLevel, constraintFns, rewriteFns);
   generator.generate(module);
 
   // Initialize the external functions.
   for (auto &it : constraintFns)
std::stable_sort(matches.begin(), matches.end(),
                    [](const MatchResult &lhs, const MatchResult &rhs) {
                      return lhs.benefit > rhs.benefit;
                    });
 }
 
 /// Run the rewriter of the given pattern on the root operation `op`.
 void PDLByteCode::rewrite(PatternRewriter &rewriter, const MatchResult &match,
                           PDLByteCodeMutableState &state) const {
+  auto *configSet = match.pattern->getConfigSet();
+  if (configSet)
+    configSet->notifyRewriteBegin(rewriter);
+
   // The arguments of the rewrite function are stored at the start of the
   // memory buffer.
   llvm::copy(match.values, state.memory.begin());
 
   ByteCodeExecutor executor(
       &rewriterByteCode[match.pattern->getRewriterAddr()], state.memory,
       state.opRangeMemory, state.typeRangeMemory,
       state.allocatedTypeRangeMemory, state.valueRangeMemory,
       state.allocatedValueRangeMemory, state.loopIndex, uniquedData,
       rewriterByteCode, state.currentPatternBenefits, patterns,
       constraintFunctions, rewriteFunctions);
   executor.execute(rewriter, /*matches=*/nullptr, match.location);
+
+  if (configSet)
+    configSet->notifyRewriteEnd(rewriter);
 }

mlir/lib/Rewrite/FrozenRewritePatternSet.cpp

FrozenRewritePatternSet::FrozenRewritePatternSet(
   if (!pdlModule)
     return;
   if (failed(convertPDLToPDLInterp(pdlModule)))
     llvm::report_fatal_error(
         "failed to lower PDL pattern module to the PDL Interpreter");
 
   // Generate the pdl bytecode.
   impl->pdlByteCode = std::make_unique<detail::PDLByteCode>(
-      pdlModule, pdlPatterns.takeConstraintFunctions(),
+      pdlModule, pdlPatterns.takeConfigs(),
+      pdlPatterns.takeConstraintFunctions(),
       pdlPatterns.takeRewriteFunctions());
 }
 
 FrozenRewritePatternSet::~FrozenRewritePatternSet() = default;

mlir/lib/Tools/PDLL/CodeGen/CPPGen.cpp

if (Optional<StringRef> patternName = pattern.sym_name()) {
       } while (!patternNames.insert(name));
     }
 
     generate(pattern, patternNames.back(), nativeFunctions);
   }
   os << "} // end namespace\n\n";
 
   // Emit function to add the generated matchers to the pattern list.
-  os << "static void LLVM_ATTRIBUTE_UNUSED populateGeneratedPDLLPatterns("
-        "::mlir::RewritePatternSet &patterns) {\n";
+  os << "template <typename... ConfigsT>\n"
+        "static void LLVM_ATTRIBUTE_UNUSED populateGeneratedPDLLPatterns("
+        "::mlir::RewritePatternSet &patterns, ConfigsT &&...configs) {\n";
   for (const auto &name : patternNames)
-    os << "  patterns.add<" << name << ">(patterns.getContext());\n";
+    os << "  patterns.add<" << name
+       << ">(patterns.getContext(), configs...);\n";
   os << "}\n";
 }
 
 void CodeGen::generate(pdl::PatternOp pattern, StringRef patternName,
                        StringSet<> &nativeFunctions) {
   const char *patternClassStartStr = R"(
 struct {0} : ::mlir::PDLPatternModule {{
-  {0}(::mlir::MLIRContext *context)
+  template <typename... ConfigsT>
+  {0}(::mlir::MLIRContext *context, ConfigsT &&...configs)
     : ::mlir::PDLPatternModule(::mlir::parseSourceString<::mlir::ModuleOp>(
 )";
   os << llvm::formatv(patternClassStartStr, patternName);
 
   os << "R\"mlir(";
   pattern->print(os, OpPrintingFlags().enableDebugInfo());
-  os << "\n    )mlir\", context)) {\n";
+  os << "\n    )mlir\", context), std::forward<ConfigsT>(configs)...) {\n";
 
   // Register any native functions used within the pattern.
   StringSet<> registeredNativeFunctions;
   auto checkRegisterNativeFn = [&](StringRef fnName, StringRef fnType) {
     if (!nativeFunctions.count(fnName) ||
         !registeredNativeFunctions.insert(fnName).second)
       return;
     os << "    register" << fnType << "Function(\"" << fnName << "\", "

mlir/lib/Transforms/Utils/DialectConversion.cpp

struct ConversionPatternRewriterImpl {
   /// Recursively marks the nested operations under 'op' as ignored. This
   /// removes them from being considered for legalization.
   void markNestedOpsIgnored(Operation *op);
 
   //===--------------------------------------------------------------------===//
   // Type Conversion
   //===--------------------------------------------------------------------===//
 
+  /// Push a new type converter scope onto the rewritee.
+  void pushTypeConverter(TypeConverter *converter) {
+    typeConverterStack.push_back(converter);
+  }
+
+  /// Pop the current type converter from the rewriter.
+  void popTypeConverter() {
+    assert(!typeConverterStack.empty() && "type converter stack is empty");
+    typeConverterStack.pop_back();
+  }
+
+  /// Return the current type converter.
+  TypeConverter *getCurrentTypeConverter() const {
+    return typeConverterStack.empty() ? nullptr : typeConverterStack.back();
+  }
+
   /// Convert the signature of the given block.
   FailureOr<Block *> convertBlockSignature(
       Block *block, TypeConverter *converter,
       TypeConverter::SignatureConversion *conversion = nullptr);
 
   /// Apply a signature conversion on the given region, using `converter` for
   /// materializations if not null.
   Block *
struct ConversionPatternRewriterImpl {
   /// A transaction state for each of operations that were updated in-place.
   SmallVector<OperationTransactionState, 4> rootUpdates;
 
   /// A vector of indices into `replacements` of operations that were replaced
   /// with values with different result types than the original operation, e.g.
   /// 1->N conversion of some kind.
   SmallVector<unsigned, 4> operationsWithChangedResults;
 
-  /// The current type converter, or nullptr if no type converter is currently
-  /// active.
-  TypeConverter *currentTypeConverter = nullptr;
+  /// The current stack of type converters, which may contain null entries if no
+  /// type converter is currently active for that level of the stack.
+  SmallVector<TypeConverter *, 4> typeConverterStack;
 
   /// This allows the user to collect the match failure message.
   function_ref<void(Diagnostic &)> notifyCallback;
 
 #ifndef NDEBUG
   /// A set of operations that have pending updates. This tracking isn't
   /// strictly necessary, and is thus only active during debug builds for extra
   /// verification.
void ConversionPatternRewriterImpl::undoBlockActions(
   }
   blockActions.resize(numActionsToKeep);
 }
 
 LogicalResult ConversionPatternRewriterImpl::remapValues(
     StringRef valueDiagTag, Optional<Location> inputLoc,
     PatternRewriter &rewriter, ValueRange values,
     SmallVectorImpl<Value> &remapped) {
+  TypeConverter *currentTypeConverter = getCurrentTypeConverter();
   remapped.reserve(llvm::size(values));
 
   SmallVector<Type, 1> legalTypes;
   for (const auto &it : llvm::enumerate(values)) {
     Value operand = it.value();
     Type origType = operand.getType();
 
     // If a converter was provided, get the desired legal types for this
for (auto [newValue, result] : llvm::zip(newValues, op->getResults())) {
     // Remap, and check for any result type changes.
     mapping.map(result, newValue);
     resultChanged |= (newValue.getType() != result.getType());
   }
   if (resultChanged)
     operationsWithChangedResults.push_back(replacements.size());
 
   // Record the requested operation replacement.
-  replacements.insert(std::make_pair(op, OpReplacement(currentTypeConverter)));
+  replacements.insert(
+      std::make_pair(op, OpReplacement(getCurrentTypeConverter())));
 
   // Mark this operation as recursively ignored so that we don't need to
   // convert any nested operations.
   markNestedOpsIgnored(op);
 }
 
 void ConversionPatternRewriterImpl::notifyBlockIsBeingErased(Block *block) {
   Region *region = block->getParent();

 
 LogicalResult
 ConversionPattern::matchAndRewrite(Operation *op,
                                    PatternRewriter &rewriter) const {
   auto &dialectRewriter = static_cast<ConversionPatternRewriter &>(rewriter);
   auto &rewriterImpl = dialectRewriter.getImpl();
 
   // Track the current conversion pattern type converter in the rewriter.
-  llvm::SaveAndRestore<TypeConverter *> currentConverterGuard(
-      rewriterImpl.currentTypeConverter, getTypeConverter());
+  rewriterImpl.pushTypeConverter(getTypeConverter());
 
-  // Remap the operands of the operation.
+  // Remap the operands of the operation and attempt to match this pattern.
   SmallVector<Value, 4> operands;
   if (failed(rewriterImpl.remapValues("operand", op->getLoc(), rewriter,
-                                      op->getOperands(), operands))) {
+                                      op->getOperands(), operands)) ||
+      failed(matchAndRewrite(op, operands, dialectRewriter))) {
     return failure();
   }
-  return matchAndRewrite(op, operands, dialectRewriter);
+
+  // Pop the current converter from the rewriter.
+  rewriterImpl.popTypeConverter();
+  return success();
 }
 
 //===----------------------------------------------------------------------===//
 // OperationLegalizer
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// A set of rewrite patterns that can be used to legalize a given operation.
auto ConversionTarget::getOpInfo(OperationName op) const
   // Otherwise, check if we mark unknown operations as dynamic.
   if (unknownLegalityFn)
     return LegalizationInfo{LegalizationAction::Dynamic,
                             /*isRecursivelyLegal=*/false, unknownLegalityFn};
   return llvm::None;
 }
 
 //===----------------------------------------------------------------------===//
+// PDL Configuration
+//===----------------------------------------------------------------------===//
+
+void PDLConversionConfig::notifyRewriteBegin(PatternRewriter &rewriter) {
+  auto &rewriterImpl =
+      static_cast<ConversionPatternRewriter &>(rewriter).getImpl();
+  rewriterImpl.pushTypeConverter(getTypeConverter());
+}
+
+void PDLConversionConfig::notifyRewriteEnd(PatternRewriter &rewriter) {
+  auto &rewriterImpl =
+      static_cast<ConversionPatternRewriter &>(rewriter).getImpl();
+  rewriterImpl.popTypeConverter();
+}
+
+/// Remap the given value using the rewriter and the type converter in the
+/// provided config.
+static SmallVector<Value> pdllConvertValues(ConversionPatternRewriter &rewriter,
+                                            ValueRange values) {
+  // If remapping fails, the best we can do for now is to error out. This
+  // is because PDL rewrites aren't failable, though maybe one day they
+  // could be (given that dialect conversion supports rollback).
+  SmallVector<Value> mappedValues;
+  if (failed(rewriter.getRemappedValues(values, mappedValues)))
+    llvm::report_fatal_error("dialect conversion failed to remap values");
+  return mappedValues;
+}
+
+void mlir::registerConversionPDLFunctions(RewritePatternSet &patterns) {
+  patterns.getPDLPatterns().registerRewriteFunction(
+      "convertValue", [](PatternRewriter &rewriter, Value value) {
+        auto results = pdllConvertValues(
+            static_cast<ConversionPatternRewriter &>(rewriter), value);
+        return results.front();
+      });
+  patterns.getPDLPatterns().registerRewriteFunction(
+      "convertValues", [](PatternRewriter &rewriter, ValueRange values) {
+        return pdllConvertValues(
+            static_cast<ConversionPatternRewriter &>(rewriter), values);
+      });
+  patterns.getPDLPatterns().registerRewriteFunction(
+      "convertType", [](PatternRewriter &rewriter, Type type) {
+        auto &rewriterImpl =
+            static_cast<ConversionPatternRewriter &>(rewriter).getImpl();
+        if (TypeConverter *converter = rewriterImpl.getCurrentTypeConverter())
+          return converter->convertType(type);
+        return type;
+      });
+  patterns.getPDLPatterns().registerRewriteFunction(
+      "convertTypes",
+      [](PatternRewriter &rewriter, TypeRange types) -> SmallVector<Type> {
+        auto &rewriterImpl =
+            static_cast<ConversionPatternRewriter &>(rewriter).getImpl();
+        TypeConverter *converter = rewriterImpl.getCurrentTypeConverter();
+        if (!converter)
+          return types;
+
+        // If remapping fails, the best we can do for now is to error out. This
+        // is because PDL rewrites aren't failable, though maybe one day they
+        // could be (given that dialect conversion supports rollback).
+        SmallVector<Type> remappedTypes;
+        if (failed(converter->convertTypes(types, remappedTypes)))
+          llvm::report_fatal_error(
+              "dialect conversion failed to convert types");
+        return remappedTypes;
+      });
+}
+
+//===----------------------------------------------------------------------===//
 // Op Conversion Entry Points
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Partial Conversion
 
 LogicalResult
 mlir::applyPartialConversion(ArrayRef<Operation *> ops,

mlir/test/Transforms/test-dialect-conversion-pdll.mlir

+// RUN: mlir-opt %s -test-dialect-conversion-pdll | FileCheck %s
+
+// CHECK-LABEL: @TestSingleConversion
+func.func @TestSingleConversion() {
+  // CHECK: %[[CAST:.*]] = "test.cast"() : () -> f64
+  // CHECK-NEXT: "test.return"(%[[CAST]]) : (f64) -> ()
+  %result = "test.cast"() : () -> (i64)
+  "test.return"(%result) : (i64) -> ()
+}
+
+// CHECK-LABEL: @TestLingeringConversion
+func.func @TestLingeringConversion() -> i64 {
+  // CHECK: %[[ORIG_CAST:.*]] = "test.cast"() : () -> f64
+  // CHECK: %[[MATERIALIZE_CAST:.*]] = builtin.unrealized_conversion_cast %[[ORIG_CAST]] : f64 to i64
+  // CHECK-NEXT: return %[[MATERIALIZE_CAST]] : i64
+  %result = "test.cast"() : () -> (i64)
+  return %result : i64
+}

mlir/test/lib/Transforms/CMakeLists.txt

+add_mlir_pdll_library(MLIRTestDialectConversionPDLLPatternsIncGen
+  TestDialectConversion.pdll
+  TestDialectConversionPDLLPatterns.h.inc
+
+  EXTRA_INCLUDES
+  ${CMAKE_CURRENT_SOURCE_DIR}/../Dialect/Test
+  ${CMAKE_CURRENT_BINARY_DIR}/../Dialect/Test
+  )
+
 # Exclude tests from libMLIR.so
 add_mlir_library(MLIRTestTransforms
   TestCommutativityUtils.cpp
   TestConstantFold.cpp
   TestControlFlowSink.cpp
+  TestDialectConversion.cpp
   TestInlining.cpp
   TestIntRangeInference.cpp
   TestTopologicalSort.cpp
 
   EXCLUDE_FROM_LIBMLIR
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Transforms
 
+  DEPENDS
+  MLIRTestDialectConversionPDLLPatternsIncGen
+
   LINK_LIBS PUBLIC
   MLIRAnalysis
+  MLIRFuncDialect
   MLIRInferIntRangeInterface
   MLIRTestDialect
   MLIRTransforms
   )
 
 target_include_directories(MLIRTestTransforms
   PRIVATE
   ${CMAKE_CURRENT_SOURCE_DIR}/../Dialect/Test
   ${CMAKE_CURRENT_BINARY_DIR}/../Dialect/Test
   )

mlir/test/lib/Transforms/TestDialectConversion.cpp

+//===- TestDialectConversion.cpp - Test DialectConversion functionality ---===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "TestDialect.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/PDL/IR/PDL.h"
+#include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
+#include "mlir/Parser/Parser.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Pass/PassManager.h"
+#include "mlir/Transforms/DialectConversion.h"
+
+using namespace mlir;
+using namespace test;
+
+//===----------------------------------------------------------------------===//
+// Test PDLL Support
+//===----------------------------------------------------------------------===//
+
+#include "TestDialectConversionPDLLPatterns.h.inc"
+
+namespace {
+struct PDLLTypeConverter : public TypeConverter {
+  PDLLTypeConverter() {
+    addConversion(convertType);
+    addArgumentMaterialization(materializeCast);
+    addSourceMaterialization(materializeCast);
+  }
+
+  static LogicalResult convertType(Type t, SmallVectorImpl<Type> &results) {
+    // Convert I64 to F64.
+    if (t.isSignlessInteger(64)) {
+      results.push_back(FloatType::getF64(t.getContext()));
+      return success();
+    }
+
+    // Otherwise, convert the type directly.
+    results.push_back(t);
+    return success();
+  }
+  /// Hook for materializing a conversion.
+  static Optional<Value> materializeCast(OpBuilder &builder, Type resultType,
+                                         ValueRange inputs, Location loc) {
+    return builder.create<UnrealizedConversionCastOp>(loc, resultType, inputs)
+        .getResult(0);
+  }
+};
+
+struct TestDialectConversionPDLLPass
+    : public PassWrapper<TestDialectConversionPDLLPass, OperationPass<>> {
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestDialectConversionPDLLPass)
+
+  StringRef getArgument() const final { return "test-dialect-conversion-pdll"; }
+  StringRef getDescription() const final {
+    return "Test DialectConversion PDLL functionality";
+  }
+  void getDependentDialects(DialectRegistry &registry) const override {
+    registry.insert<pdl::PDLDialect, pdl_interp::PDLInterpDialect>();
+  }
+  LogicalResult initialize(MLIRContext *ctx) override {
+    // Build the pattern set within the `initialize` to avoid recompiling PDL
+    // patterns during each `runOnOperation` invocation.
+    RewritePatternSet patternList(ctx);
+    registerConversionPDLFunctions(patternList);
+    populateGeneratedPDLLPatterns(patternList, PDLConversionConfig(&converter));
+    patterns = std::move(patternList);
+    return success();
+  }
+
+  void runOnOperation() final {
+    mlir::ConversionTarget target(getContext());
+    target.addLegalOp<ModuleOp, func::FuncOp, func::ReturnOp>();
+    target.addDynamicallyLegalDialect<TestDialect>(
+        [this](Operation *op) { return converter.isLegal(op); });
+
+    if (failed(mlir::applyFullConversion(getOperation(), target, patterns)))
+      signalPassFailure();
+  }
+
+  FrozenRewritePatternSet patterns;
+  PDLLTypeConverter converter;
+};
+} // namespace
+
+namespace mlir {
+namespace test {
+void registerTestDialectConversionPasses() {
+  PassRegistration<TestDialectConversionPDLLPass>();
+}
+} // namespace test
+} // namespace mlir

mlir/test/lib/Transforms/TestDialectConversion.pdll

+//===- TestPDLL.pdll - Test PDLL functionality ----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "TestOps.td"
+#include "mlir/Transforms/DialectConversion.pdll"
+
+/// Change the result type of a producer.
+// FIXME: We shouldn't need to specify arguments for the result cast.
+Pattern => replace op<test.cast>(args: ValueRange) -> (results: TypeRange)
+  with op<test.cast>(args) -> (convertTypes(results));
+
+/// Pass through test.return conversion.
+Pattern => replace op<test.return>(args: ValueRange)
+  with op<test.return>(convertValues(args));

mlir/test/lib/Transforms/lit.local.cfg

+config.suffixes.remove('.pdll')

mlir/test/mlir-pdll/CodeGen/CPP/general.pdll

 // RUN: mlir-pdll %s -I %S -split-input-file -x cpp | FileCheck %s
 
 // Check that we generate a wrapper pattern for each PDL pattern. Also
 // add in a pattern awkwardly named the same as our generated patterns to
 // check that we handle overlap.
 
 // CHECK: struct GeneratedPDLLPattern0 : ::mlir::PDLPatternModule {
+// CHECK:  template <typename... ConfigsT>
 // CHECK:  : ::mlir::PDLPatternModule(::mlir::parseSourceString<::mlir::ModuleOp>(
 // CHECK:  R"mlir(
 // CHECK:    pdl.pattern
 // CHECK:      operation "test.op"
-// CHECK:  )mlir", context))
+// CHECK:  )mlir", context), std::forward<ConfigsT>(configs)...)
 
 // CHECK: struct NamedPattern : ::mlir::PDLPatternModule {
 // CHECK:  : ::mlir::PDLPatternModule(::mlir::parseSourceString<::mlir::ModuleOp>(
 // CHECK:  R"mlir(
 // CHECK:    pdl.pattern
 // CHECK:      operation "test.op2"
-// CHECK:  )mlir", context))
+// CHECK:  )mlir", context), std::forward<ConfigsT>(configs)...)
 
 // CHECK: struct GeneratedPDLLPattern1 : ::mlir::PDLPatternModule {
 
 // CHECK: struct GeneratedPDLLPattern2 : ::mlir::PDLPatternModule {
 // CHECK:  : ::mlir::PDLPatternModule(::mlir::parseSourceString<::mlir::ModuleOp>(
 // CHECK:  R"mlir(
 // CHECK:    pdl.pattern
 // CHECK:      operation "test.op3"
-// CHECK:  )mlir", context))
+// CHECK:  )mlir", context), std::forward<ConfigsT>(configs)...)
 
-// CHECK:      static void LLVM_ATTRIBUTE_UNUSED populateGeneratedPDLLPatterns(::mlir::RewritePatternSet &patterns) {
-// CHECK-NEXT:   patterns.add<GeneratedPDLLPattern0>(patterns.getContext());
-// CHECK-NEXT:   patterns.add<NamedPattern>(patterns.getContext());
-// CHECK-NEXT:   patterns.add<GeneratedPDLLPattern1>(patterns.getContext());
-// CHECK-NEXT:   patterns.add<GeneratedPDLLPattern2>(patterns.getContext());
+// CHECK:      static void LLVM_ATTRIBUTE_UNUSED populateGeneratedPDLLPatterns(::mlir::RewritePatternSet &patterns, ConfigsT &&...configs) {
+// CHECK-NEXT:   patterns.add<GeneratedPDLLPattern0>(patterns.getContext(), configs...);
+// CHECK-NEXT:   patterns.add<NamedPattern>(patterns.getContext(), configs...);
+// CHECK-NEXT:   patterns.add<GeneratedPDLLPattern1>(patterns.getContext(), configs...);
+// CHECK-NEXT:   patterns.add<GeneratedPDLLPattern2>(patterns.getContext(), configs...);
 // CHECK-NEXT: }
 
 Pattern => erase op<test.op>;
 Pattern NamedPattern => erase op<test.op2>;
 Pattern GeneratedPDLLPattern1 => erase op<>;
 Pattern => erase op<test.op3>;
 
 // -----

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

 void registerTestConstantFold();
 void registerTestControlFlowSink();
 void registerTestGpuSerializeToCubinPass();
 void registerTestGpuSerializeToHsacoPass();
 void registerTestDataLayoutQuery();
 void registerTestDeadCodeAnalysisPass();
 void registerTestDecomposeCallGraphTypes();
 void registerTestDiagnosticsPass();
+void registerTestDialectConversionPasses();
 void registerTestDominancePass();
 void registerTestDynamicPipelinePass();
 void registerTestExpandMathPass();
 void registerTestFooAnalysisPass();
 void registerTestComposeSubView();
 void registerTestMultiBuffering();
 void registerTestIntRangeInference();
 void registerTestIRVisitorsPass();
void registerTestPasses() {
   mlir::test::registerSimpleParametricTilingPass();
   mlir::test::registerTestAffineLoopParametricTilingPass();
   mlir::test::registerTestAliasAnalysisPass();
   mlir::test::registerTestBuiltinAttributeInterfaces();
   mlir::test::registerTestCallGraphPass();
   mlir::test::registerTestConstantFold();
   mlir::test::registerTestControlFlowSink();
   mlir::test::registerTestDiagnosticsPass();
+  mlir::test::registerTestDialectConversionPasses();
 #if MLIR_CUDA_CONVERSIONS_ENABLED
   mlir::test::registerTestGpuSerializeToCubinPass();
 #endif
 #if MLIR_ROCM_CONVERSIONS_ENABLED
   mlir::test::registerTestGpuSerializeToHsacoPass();
 #endif
   mlir::test::registerTestDecomposeCallGraphTypes();
   mlir::test::registerTestDataLayoutQuery();