1//===- MainModule.cpp - Main pybind module --------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9
10#include "Globals.h"
11#include "IRModule.h"
12#include "NanobindUtils.h"
13#include "Pass.h"
14#include "Rewrite.h"
15#include "mlir/Bindings/Python/Nanobind.h"
16
17namespace nb = nanobind;
18using namespace mlir;
19using namespace nb::literals;
20using namespace mlir::python;
21
22// -----------------------------------------------------------------------------
23// Module initialization.
24// -----------------------------------------------------------------------------
25
26NB_MODULE(_mlir, m) {
27 m.doc() = "MLIR Python Native Extension";
28
29 nb::class_<PyGlobals>(m, "_Globals")
30 .def_prop_rw("dialect_search_modules",
31 &PyGlobals::getDialectSearchPrefixes,
32 &PyGlobals::setDialectSearchPrefixes)
33 .def("append_dialect_search_prefix", &PyGlobals::addDialectSearchPrefix,
34 "module_name"_a)
35 .def(
36 "_check_dialect_module_loaded",
37 [](PyGlobals &self, const std::string &dialectNamespace) {
38 return self.loadDialectModule(dialectNamespace);
39 },
40 "dialect_namespace"_a)
41 .def("_register_dialect_impl", &PyGlobals::registerDialectImpl,
42 "dialect_namespace"_a, "dialect_class"_a,
43 "Testing hook for directly registering a dialect")
44 .def("_register_operation_impl", &PyGlobals::registerOperationImpl,
45 "operation_name"_a, "operation_class"_a, nb::kw_only(),
46 "replace"_a = false,
47 "Testing hook for directly registering an operation");
48
49 // Aside from making the globals accessible to python, having python manage
50 // it is necessary to make sure it is destroyed (and releases its python
51 // resources) properly.
52 m.attr("globals") = nb::cast(new PyGlobals, nb::rv_policy::take_ownership);
53
54 // Registration decorators.
55 m.def(
56 "register_dialect",
57 [](nb::type_object pyClass) {
58 std::string dialectNamespace =
59 nanobind::cast<std::string>(pyClass.attr("DIALECT_NAMESPACE"));
60 PyGlobals::get().registerDialectImpl(dialectNamespace, pyClass);
61 return pyClass;
62 },
63 "dialect_class"_a,
64 "Class decorator for registering a custom Dialect wrapper");
65 m.def(
66 "register_operation",
67 [](const nb::type_object &dialectClass, bool replace) -> nb::object {
68 return nb::cpp_function(
69 [dialectClass,
70 replace](nb::type_object opClass) -> nb::type_object {
71 std::string operationName =
72 nanobind::cast<std::string>(opClass.attr("OPERATION_NAME"));
73 PyGlobals::get().registerOperationImpl(operationName, opClass,
74 replace);
75 // Dict-stuff the new opClass by name onto the dialect class.
76 nb::object opClassName = opClass.attr("__name__");
77 dialectClass.attr(opClassName) = opClass;
78 return opClass;
79 });
80 },
81 "dialect_class"_a, nb::kw_only(), "replace"_a = false,
82 "Produce a class decorator for registering an Operation class as part of "
83 "a dialect");
84 m.def(
85 MLIR_PYTHON_CAPI_TYPE_CASTER_REGISTER_ATTR,
86 [](MlirTypeID mlirTypeID, bool replace) -> nb::object {
87 return nb::cpp_function([mlirTypeID, replace](
88 nb::callable typeCaster) -> nb::object {
89 PyGlobals::get().registerTypeCaster(mlirTypeID, typeCaster, replace);
90 return typeCaster;
91 });
92 },
93 "typeid"_a, nb::kw_only(), "replace"_a = false,
94 "Register a type caster for casting MLIR types to custom user types.");
95 m.def(
96 MLIR_PYTHON_CAPI_VALUE_CASTER_REGISTER_ATTR,
97 [](MlirTypeID mlirTypeID, bool replace) -> nb::object {
98 return nb::cpp_function(
99 [mlirTypeID, replace](nb::callable valueCaster) -> nb::object {
100 PyGlobals::get().registerValueCaster(mlirTypeID, valueCaster,
101 replace);
102 return valueCaster;
103 });
104 },
105 "typeid"_a, nb::kw_only(), "replace"_a = false,
106 "Register a value caster for casting MLIR values to custom user values.");
107
108 // Define and populate IR submodule.
109 auto irModule = m.def_submodule("ir", "MLIR IR Bindings");
110 populateIRCore(irModule);
111 populateIRAffine(irModule);
112 populateIRAttributes(irModule);
113 populateIRInterfaces(irModule);
114 populateIRTypes(irModule);
115
116 auto rewriteModule = m.def_submodule("rewrite", "MLIR Rewrite Bindings");
117 populateRewriteSubmodule(rewriteModule);
118
119 // Define and populate PassManager submodule.
120 auto passModule =
121 m.def_submodule("passmanager", "MLIR Pass Management Bindings");
122 populatePassManagerSubmodule(passModule);
123}
124

source code of mlir/lib/Bindings/Python/MainModule.cpp