Add basic JIT Python Bindings

[mehdi_amini]

Summary

This offers the ability to create a JIT and invoke a function by passing
ctypes pointers to the argument and the result.

[mehdi_amini]

Switch to use ctypes for argument passing

[mehdi_amini]

Fix jit.py

[ftynse]

mlir/lib/Bindings/Python/Conversions/CMakeLists.txt

11

Please add the newline

mlir/lib/Bindings/Python/Jit.cpp

62

I think you can now throw py::runtime_error("message")

67

Nit: dialects

mlir/lib/Bindings/Python/Jit.h

2

Wrong header

mlir/lib/Bindings/Python/mlir/jit.py

12

Other files use 2 spaces for indentation

mlir/lib/CAPI/ExecutionEngine/ExecutionEngine.cpp

26

We need some mechanism of exposing this registration to Python so that out-of-tree dialects can also register their translations.

mlir/test/Bindings/Python/jit.py

38

Nit: add an empty line above

[mehdi_amini]

Address comments

[mehdi_amini]

mlir/lib/CAPI/ExecutionEngine/ExecutionEngine.cpp

26

ack. Not sure what we'll do for this? I suspect we'll push this on the dialects to provide an API to register them and push on the user to register before invoking the Jit?

[mehdi_amini]

mlir/lib/Bindings/Python/Jit.cpp

62

Any link to a doc or an example, it does not work for me?

[mehdi_amini]

Revert back to throw SetPyError(PyExc_RuntimeError and add a test for the failure

[stellaraccident]

mlir/lib/Bindings/Python/Jit.cpp

22

Stale comment: ... around an MlirExecutionEngine

Maybe also a brief comment about why you switch terminology to Jit.

60

Does the input Module need to survive past this call (or is it converted and then not needed)? If the former, then we have a lifetime hazard here.

62

Just throw std::exception. See the mapping here: https://pybind11.readthedocs.io/en/stable/advanced/exceptions.html

(this SetPyError form is something I carried forward from the distant past/other projects and in newer code, we are throwing exceptions directly if possible)

66

... must contain only ...

mlir/lib/Bindings/Python/mlir/jit.py

13

Elsewhere we exclusively use triple-double quotes ("""). Our style guide is silent on it, so your call.

mlir/lib/CAPI/ExecutionEngine/ExecutionEngine.cpp

26

"Standalone" out of tree dialects have quite a few issues with them being usable in practice. Things like npcomp that bring their own C-API, can provide their own entry point for registering their local translations. I wish we had a better story here, but this is far from the only thing that will have such problems.

[mehdi_amini]

mlir/lib/Bindings/Python/Jit.cpp

22

I guess I've always used "jit" intuitively so it fit better my mental model, but I should probably stick to "ExecutionEngine" for consistency with the rest of the project.

60

It isn't needed after this call.

I checked the header and it is called out for this function: "the module ownership stays with the client and can be destroyed as soon as the call returns."

62

Couldn't throw a std::exception as there is no constructor from a string literal, but we can throw a std::runtime_error error here :)

mlir/lib/Bindings/Python/mlir/jit.py

13

Consistency is important to me: I switched to triple quotes.

[mehdi_amini]

Address Stella's comments

[ftynse]

mlir/lib/CAPI/ExecutionEngine/ExecutionEngine.cpp

26

I suppose we can use a mechanism similar to dialect registration: in the C API, this is pushed down to the dialect that provides a registration function taking MlirContext. In Python, I would love to see something like import mlir.dialect.llvm.translation that calls the relevant function in its __init__.py. Not necessary for this commit.

mlir/include/mlir-c/Bindings/Python/Interop.h

 
 #ifndef MLIR_C_BINDINGS_PYTHON_INTEROP_H
 #define MLIR_C_BINDINGS_PYTHON_INTEROP_H
 
 #include <Python.h>
 
 #include "mlir-c/AffineExpr.h"
 #include "mlir-c/AffineMap.h"
+#include "mlir-c/ExecutionEngine.h"
 #include "mlir-c/IR.h"
 #include "mlir-c/IntegerSet.h"
 #include "mlir-c/Pass.h"
 
 #define MLIR_PYTHON_CAPSULE_AFFINE_EXPR "mlir.ir.AffineExpr._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_AFFINE_MAP "mlir.ir.AffineMap._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_ATTRIBUTE "mlir.ir.Attribute._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_CONTEXT "mlir.ir.Context._CAPIPtr"
+#define MLIR_PYTHON_CAPSULE_EXECUTION_ENGINE "mlir.jit.Jit._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_INTEGER_SET "mlir.ir.IntegerSet._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_LOCATION "mlir.ir.Location._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_MODULE "mlir.ir.Module._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_OPERATION "mlir.ir.Operation._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_TYPE "mlir.ir.Type._CAPIPtr"
 #define MLIR_PYTHON_CAPSULE_PASS_MANAGER "mlir.passmanager.PassManager._CAPIPtr"
 
 /** Attribute on MLIR Python objects that expose their C-API pointer.

  * a null set is returned (as checked via mlirIntegerSetIsNull). In such a
  * case, the Python APIs will have already set an error. */
 static inline MlirIntegerSet mlirPythonCapsuleToIntegerSet(PyObject *capsule) {
   void *ptr = PyCapsule_GetPointer(capsule, MLIR_PYTHON_CAPSULE_INTEGER_SET);
   MlirIntegerSet integerSet = {ptr};
   return integerSet;
 }
 
+/** Creates a capsule object encapsulating the raw C-API MlirExecutionEngine.
+ * The returned capsule does not extend or affect ownership of any Python
+ * objects that reference the set in any way. */
+static inline PyObject *
+mlirPythonExecutionEngineToCapsule(MlirExecutionEngine jit) {
+  return PyCapsule_New(MLIR_PYTHON_GET_WRAPPED_POINTER(jit),
+                       MLIR_PYTHON_CAPSULE_EXECUTION_ENGINE, NULL);
+}
+
+/** Extracts an MlirExecutionEngine from a capsule as produced from
+ * mlirPythonIntegerSetToCapsule. If the capsule is not of the right type, then
+ * a null set is returned (as checked via mlirExecutionEngineIsNull). In such a
+ * case, the Python APIs will have already set an error. */
+static inline MlirExecutionEngine
+mlirPythonCapsuleToExecutionEngine(PyObject *capsule) {
+  void *ptr =
+      PyCapsule_GetPointer(capsule, MLIR_PYTHON_CAPSULE_EXECUTION_ENGINE);
+  MlirExecutionEngine jit = {ptr};
+  return jit;
+}
+
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_BINDINGS_PYTHON_INTEROP_H

mlir/include/mlir-c/ExecutionEngine.h

 /// Invoke a native function in the execution engine by name with the arguments
 /// and result of the invoked function passed as an array of pointers. The
 /// function must have been tagged with the `llvm.emit_c_interface` attribute.
 /// Returns a failure if the execution fails for any reason (the function name
 /// can't be resolved for instance).
 MLIR_CAPI_EXPORTED MlirLogicalResult mlirExecutionEngineInvokePacked(
     MlirExecutionEngine jit, MlirStringRef name, void **arguments);
 
+/// Lookup a native function in the execution engine by name, returns nullptr
+/// if the name can't be looked-up.
+MLIR_CAPI_EXPORTED void *mlirExecutionEngineLookup(MlirExecutionEngine jit,
+                                                   MlirStringRef name);
+
 #ifdef __cplusplus
 }
 #endif
 
 #endif // EXECUTIONENGINE_H

mlir/lib/Bindings/Python/CMakeLists.txt

 include(AddMLIRPythonExtension)
 add_custom_target(MLIRBindingsPythonExtension)
 
 ################################################################################
 # Copy python source tree.
 ################################################################################
 
 set(PY_SRC_FILES
   mlir/__init__.py
   mlir/_dlloader.py
-  mlir/ir.py
+  mlir/conversions/__init__.py
   mlir/dialects/__init__.py
   mlir/dialects/_linalg.py
   mlir/dialects/_builtin.py
   mlir/ir.py
+  mlir/jit.py
   mlir/passmanager.py
   mlir/transforms/__init__.py
 )
 
 add_custom_target(MLIRBindingsPythonSources ALL
   DEPENDS ${PY_SRC_FILES}
 )
 add_dependencies(MLIRBindingsPythonExtension MLIRBindingsPythonSources)

 add_mlir_python_extension(MLIRCoreBindingsPythonExtension _mlir
   INSTALL_DIR
     python
   SOURCES
     MainModule.cpp
     IRModules.cpp
     PybindUtils.cpp
     Pass.cpp
+    Jit.cpp
 )
 add_dependencies(MLIRBindingsPythonExtension MLIRCoreBindingsPythonExtension)
 
 # Note that we copy from the source tree just like for headers because
 # it will not be polluted with py_cache runtime artifacts (from testing and
 # such).
 install(
   DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/mlir

 if (NOT LLVM_ENABLE_IDE)
   add_llvm_install_targets(
     install-MLIRBindingsPythonDialects
     DEPENDS MLIRBindingsPythonSources
     COMPONENT MLIRBindingsPythonDialects)
 endif()
 
 add_subdirectory(Transforms)
+add_subdirectory(Conversions)

mlir/lib/Bindings/Python/Conversions/CMakeLists.txt

+################################################################################
+# Build python extension
+################################################################################
+
+add_mlir_python_extension(MLIRConversionsBindingsPythonExtension _mlirConversions
+  INSTALL_DIR
+    python
+  SOURCES
+  Conversions.cpp
+)

mlir/lib/Bindings/Python/Conversions/Conversions.cpp

+//===- Conversions.cpp - Pybind module for the Conversionss library -------===//
+//
+// 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 "mlir-c/Conversion.h"
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+// -----------------------------------------------------------------------------
+// Module initialization.
+// -----------------------------------------------------------------------------
+
+PYBIND11_MODULE(_mlirConversions, m) {
+  m.doc() = "MLIR Conversions library";
+
+  // Register all the passes in the Conversions library on load.
+  mlirRegisterConversionPasses();
+}

mlir/lib/Bindings/Python/Jit.h

+//===- Jit.h - Jit submodule of pybind module -----------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_BINDINGS_PYTHON_JIT_H
+#define MLIR_BINDINGS_PYTHON_JIT_H
+
+#include "PybindUtils.h"
+
+namespace mlir {
+namespace python {
+
+void populateJitSubmodule(pybind11::module &m);
+
+} // namespace python
+} // namespace mlir
+
+#endif // MLIR_BINDINGS_PYTHON_JIT_H

mlir/lib/Bindings/Python/Jit.cpp

+//===- Jit.cpp - Python MLIR JIT Bindings ---------------------------------===//
+//
+// 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 "Jit.h"
+
+#include "IRModules.h"
+#include "mlir-c/Bindings/Python/Interop.h"
+#include "mlir-c/ExecutionEngine.h"
+
+namespace py = pybind11;
+using namespace mlir;
+using namespace mlir::python;
+
+namespace {
+
+/// Owning Wrapper around a PassManager.
+class PyJit {
+public:
+  PyJit(MlirExecutionEngine jit) : jit(jit) {}
+  PyJit(PyJit &&other) : jit(other.jit) { other.jit.ptr = nullptr; }
+  ~PyJit() {
+    if (!mlirExecutionEngineIsNull(jit))
+      mlirExecutionEngineDestroy(jit);
+  }
+  MlirExecutionEngine get() { return jit; }
+
+  void release() { jit.ptr = nullptr; }
+  pybind11::object getCapsule() {
+    return py::reinterpret_steal<py::object>(
+        mlirPythonExecutionEngineToCapsule(get()));
+  }
+
+  static pybind11::object createFromCapsule(pybind11::object capsule) {
+    MlirExecutionEngine rawPm =
+        mlirPythonCapsuleToExecutionEngine(capsule.ptr());
+    if (mlirExecutionEngineIsNull(rawPm))
+      throw py::error_already_set();
+    return py::cast(PyJit(rawPm), py::return_value_policy::move);
+  }
+
+private:
+  MlirExecutionEngine jit;
+};
+
+} // anonymous namespace
+
+/// Create the `mlir.jit` here.
+void mlir::python::populateJitSubmodule(py::module &m) {
+  //----------------------------------------------------------------------------
+  // Mapping of the top-level PassManager
+  //----------------------------------------------------------------------------
+  py::class_<PyJit>(m, "Jit")
+      .def(py::init<>([](PyModule &module) {
+             MlirExecutionEngine jit = mlirExecutionEngineCreate(module.get());
+             if (mlirExecutionEngineIsNull(jit))
+               throw py::runtime_error("Failure while creating the JIT.");
+             return new PyJit(jit);
+           }),
+           "Create a new jit instance for the given Module. The module must be "
+           "containing only dialects that can be translated to LLVM.")
+      .def_property_readonly(MLIR_PYTHON_CAPI_PTR_ATTR, &PyJit::getCapsule)
+      .def("_testing_release", &PyJit::release,
+           "Releases (leaks) the backing jit (for testing purpose)")
+      .def(MLIR_PYTHON_CAPI_FACTORY_ATTR, &PyJit::createFromCapsule)
+      .def(
+          "raw_lookup",
+          [](PyJit &jit, const std::string &func) {
+            auto *res = mlirExecutionEngineLookup(
+                jit.get(), mlirStringRefCreate(func.c_str(), func.size()));
+            return (int64_t)res;
+          },
+          "Lookup function `func` in the jit.");
+}

mlir/lib/Bindings/Python/MainModule.cpp

 //===- MainModule.cpp - Main pybind module --------------------------------===//
 //
 // 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 <tuple>
 
 #include "PybindUtils.h"
 
 #include "Globals.h"
 #include "IRModules.h"
+#include "Jit.h"
 #include "Pass.h"
 
 namespace py = pybind11;
 using namespace mlir;
 using namespace mlir::python;
 
 // -----------------------------------------------------------------------------
 // PyGlobals
PYBIND11_MODULE(_mlir, m) {
   // Define and populate IR submodule.
   auto irModule = m.def_submodule("ir", "MLIR IR Bindings");
   populateIRSubmodule(irModule);
 
   // Define and populate PassManager submodule.
   auto passModule =
       m.def_submodule("passmanager", "MLIR Pass Management Bindings");
   populatePassManagerSubmodule(passModule);
+
+  // Define and populate JIT submodule.
+  auto jitModule = m.def_submodule("jit", "MLIR JIT Execution Engine");
+  populateJitSubmodule(jitModule);
 }

mlir/lib/Bindings/Python/mlir/__init__.py

 #  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
 
 # Note that the only function of this module is currently to load the
 # native module and re-export its symbols. In the future, this file is
 # reserved as a trampoline to handle environment specific loading needs
 # and arbitrate any one-time initialization needed in various shared-library
 # scenarios.
 
 __all__ = [
   "ir",
+  "jit",
   "passmanager",
 ]
 
 # Packaged installs have a top-level _mlir_libs package with symbols:
 #   load_extension(name): Loads a named extension module
 #   preload_dependency(public_name): Loads a shared-library/DLL into the
 #     namespace. TODO: Remove this in favor of a more robust mechanism.
 # Conditionally switch based on whether we are in a package context.
def _reexport_cext(cext_module_name, target_module_name):
   source_module = getattr(_cext, cext_module_name)
   for attr_name in dir(source_module):
     if not attr_name.startswith("__"):
       setattr(target_module, attr_name, getattr(source_module, attr_name))
 
 
 # Import sub-modules. Since these may import from here, this must come after
 # any exported definitions.
-from . import ir, passmanager
+from . import ir, jit, passmanager
 
 # Add our 'dialects' parent module to the search path for implementations.
 _cext.globals.append_dialect_search_prefix("mlir.dialects")

mlir/lib/Bindings/Python/mlir/conversions/__init__.py

+#  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
+
+# Expose the corresponding C-Extension module with a well-known name at this
+# level.
+from .. import _load_extension
+_cextConversions = _load_extension("_mlirConversions")

mlir/lib/Bindings/Python/mlir/jit.py

+#  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
+
+# Simply a wrapper around the extension module of the same name.
+from . import _cext
+import ctypes
+
+class Jit(_cext.jit.Jit):
+
+  def lookup(self, name):
+    '''Lookup a function emitted with the `llvm.emit_c_interface`
+    attribute and returns a ctype callable.
+    Raise a RuntimeError if the function isn't found.
+    '''
+    func = self.raw_lookup("_mlir_ciface_" + name)
+    if not func:
+      raise RuntimeError("Unknown function " + name)
+    prototype = ctypes.CFUNCTYPE(None, ctypes.c_void_p)
+    return prototype(func)
+
+ def invoke(self, name, *ctypes_args):
+    '''Invoke a function with the list of ctypes arguments.
+    All arguments must be pointers.
+    Raise a RuntimeError if the function isn't found.
+    '''
+    func = self.lookup(name)
+    packed_args = (ctypes.c_void_p * len(ctypes_args))()
+    for argNum in range(len(ctypes_args)):
+      packed_args[argNum] = ctypes.cast(ctypes_args[argNum], ctypes.c_void_p)
+    func(packed_args)

mlir/lib/CAPI/ExecutionEngine/ExecutionEngine.cpp

 //===- ExecutionEngine.cpp - C API for MLIR JIT ---------------------------===//
 //
 // 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 "mlir-c/ExecutionEngine.h"
 #include "mlir/CAPI/ExecutionEngine.h"
 #include "mlir/CAPI/IR.h"
 #include "mlir/CAPI/Support.h"
+#include "mlir/Target/LLVMIR.h"
 #include "llvm/Support/TargetSelect.h"
 
 using namespace mlir;
 
 extern "C" MlirExecutionEngine mlirExecutionEngineCreate(MlirModule op) {
   static bool init_once = [] {
     llvm::InitializeNativeTarget();
     llvm::InitializeNativeTargetAsmPrinter();
     return true;
   }();
   (void)init_once;
 
+  mlir::registerLLVMDialectTranslation(*unwrap(op)->getContext());
   auto jitOrError = ExecutionEngine::create(unwrap(op));
   if (!jitOrError) {
     consumeError(jitOrError.takeError());
     return MlirExecutionEngine{nullptr};
   }
   return wrap(jitOrError->release());
 }
 
 extern "C" void mlirExecutionEngineDestroy(MlirExecutionEngine jit) {
   delete (unwrap(jit));
 }
 
 extern "C" MlirLogicalResult
 mlirExecutionEngineInvokePacked(MlirExecutionEngine jit, MlirStringRef name,
                                 void **arguments) {
   const std::string ifaceName = ("_mlir_ciface_" + unwrap(name)).str();
   llvm::Error error = unwrap(jit)->invokePacked(
       ifaceName, MutableArrayRef<void *>{arguments, (size_t)0});
   if (error)
     return wrap(failure());
   return wrap(success());
 }
+
+extern "C" void *mlirExecutionEngineLookup(MlirExecutionEngine jit,
+                                           MlirStringRef name) {
+  auto expectedFPtr = unwrap(jit)->lookup(unwrap(name));
+  if (!expectedFPtr)
+    return nullptr;
+  return reinterpret_cast<void *>(*expectedFPtr);
+}

mlir/test/Bindings/Python/jit.py

+# RUN: %PYTHON %s 2>&1 | FileCheck %s
+
+import gc, sys
+from mlir.ir import *
+from mlir.passmanager import *
+from mlir.jit import *
+
+# Log everything to stderr and flush so that we have a unified stream to match
+# errors/info emitted by MLIR to stderr.
+def log(*args):
+  print(*args, file=sys.stderr)
+  sys.stderr.flush()
+
+def run(f):
+  log("\nTEST:", f.__name__)
+  f()
+  gc.collect()
+  assert Context._get_live_count() == 0
+
+# Verify capsule interop.
+# CHECK-LABEL: TEST: testCapsule
+def testCapsule():
+  with Context():
+    module = Module.parse(r"""
+llvm.func @none() {
+  llvm.return
+}
+    """)
+    jit = Jit(module)
+    jit_capsule = jit._CAPIPtr
+    # CHECK: mlir.jit.Jit._CAPIPtr
+    log(repr(jit_capsule))
+    jit._testing_release()
+    jit1 = Jit._CAPICreate(jit_capsule)
+    # CHECK: _mlir.jit.Jit
+    log(repr(jit1))
+
+run(testCapsule)
+
+
+def lowerToLLVM(module):
+  import mlir.conversions
+  pm = PassManager.parse("convert-std-to-llvm")
+  pm.run(module)
+  return module
+
+# Test simple JIT execution
+# CHECK-LABEL: TEST: testInvokeVoid
+def testInvokeVoid():
+  with Context():
+    module = Module.parse(r"""
+func @void() attributes { llvm.emit_c_interface } {
+  return
+}
+    """)    
+    jit = Jit(lowerToLLVM(module))
+    # Nothing to check other than no exception thrown here.
+    jit.invoke("void")
+
+run(testInvokeVoid)
+
+
+# Test argument passing and result with a simple float addition.
+# CHECK-LABEL: TEST: testInvokeFloatAdd
+def testInvokeFloatAdd():
+  with Context():
+    module = Module.parse(r"""
+func @add(%arg0: f32, %arg1: f32) -> f32 attributes { llvm.emit_c_interface } {
+  %add = std.addf %arg0, %arg1 : f32
+  return %add : f32
+}
+    """)
+    jit = Jit(lowerToLLVM(module))
+    # Prepare arguments: two input floats and one result.
+    # Arguments must be passed as pointers.
+    c_float_p = ctypes.c_float * 1
+    arg0 = c_float_p(42.)
+    arg1 = c_float_p(2.)
+    res = c_float_p(-1.)
+    jit.invoke("add", arg0, arg1, res)
+    # CHECK: 42.0 + 2.0 = 44.0
+    print("{0} + {1} = {2}".format(arg0[0], arg1[0], res[0]))
+
+run(testInvokeFloatAdd)

mlir/test/CMakeLists.txt

if(MLIR_VULKAN_RUNNER_ENABLED)
   )
 endif()
 
 if(MLIR_BINDINGS_PYTHON_ENABLED)
   list(APPEND MLIR_TEST_DEPENDS
     MLIRBindingsPythonExtension
     MLIRBindingsPythonTestOps
     MLIRTransformsBindingsPythonExtension
+    MLIRConversionsBindingsPythonExtension
   )
 endif()
 
 add_lit_testsuite(check-mlir "Running the MLIR regression tests"
   ${CMAKE_CURRENT_BINARY_DIR}
   DEPENDS ${MLIR_TEST_DEPENDS}
   )
 set_target_properties(check-mlir PROPERTIES FOLDER "Tests")
 
 add_lit_testsuites(MLIR ${CMAKE_CURRENT_SOURCE_DIR}
   DEPENDS ${MLIR_TEST_DEPENDS}
 )