21 #include "llvm/ADT/ArrayRef.h"
22 #include "llvm/ADT/SmallVector.h"
28 using namespace py::literals;
33 using llvm::StringRef;
41 R
"(Parses the assembly form of a type.
43 Returns a Type object or raises an MLIRError if the type cannot be parsed.
45 See also: https://mlir.llvm.org/docs/LangRef/#type-system
49 R
"(Gets a Location representing a caller and callsite)";
52 R
"(Gets a Location representing a file, line and column)";
55 R
"(Gets a Location representing a fused location with optional metadata)";
58 R
"(Gets a Location representing a named location with optional child location)";
61 R
"(Parses a module's assembly format from a string.
63 Returns a new MlirModule or raises an MLIRError if the parsing fails.
65 See also: https://mlir.llvm.org/docs/LangRef/
69 R
"(Creates a new operation.
72 name: Operation name (e.g. "dialect.operation").
73 results: Sequence of Type representing op result types.
74 attributes: Dict of str:Attribute.
75 successors: List of Block for the operation's successors.
76 regions: Number of regions to create.
77 location: A Location object (defaults to resolve from context manager).
78 ip: An InsertionPoint (defaults to resolve from context manager or set to
79 False to disable insertion, even with an insertion point set in the
81 infer_type: Whether to infer result types.
83 A new "detached" Operation object. Detached operations can be added
84 to blocks, which causes them to become "attached."
88 R
"(Prints the assembly form of the operation to a file like object.
91 file: The file like object to write to. Defaults to sys.stdout.
92 binary: Whether to write bytes (True) or str (False). Defaults to False.
93 large_elements_limit: Whether to elide elements attributes above this
94 number of elements. Defaults to None (no limit).
95 enable_debug_info: Whether to print debug/location information. Defaults
97 pretty_debug_info: Whether to format debug information for easier reading
98 by a human (warning: the result is unparseable).
99 print_generic_op_form: Whether to print the generic assembly forms of all
100 ops. Defaults to False.
101 use_local_Scope: Whether to print in a way that is more optimized for
102 multi-threaded access but may not be consistent with how the overall
104 assume_verified: By default, if not printing generic form, the verifier
105 will be run and if it fails, generic form will be printed with a comment
106 about failed verification. While a reasonable default for interactive use,
107 for systematic use, it is often better for the caller to verify explicitly
108 and report failures in a more robust fashion. Set this to True if doing this
109 in order to avoid running a redundant verification. If the IR is actually
110 invalid, behavior is undefined.
111 skip_regions: Whether to skip printing regions. Defaults to False.
115 R
"(Prints the assembly form of the operation to a file like object.
118 file: The file like object to write to. Defaults to sys.stdout.
119 binary: Whether to write bytes (True) or str (False). Defaults to False.
120 state: AsmState capturing the operation numbering and flags.
124 R
"(Gets the assembly form of the operation with all options available.
127 binary: Whether to return a bytes (True) or str (False) object. Defaults to
129 ... others ...: See the print() method for common keyword arguments for
130 configuring the printout.
132 Either a bytes or str object, depending on the setting of the 'binary'
137 R
"(Write the bytecode form of the operation to a file like object.
140 file: The file like object to write to.
141 desired_version: The version of bytecode to emit.
143 The bytecode writer status.
147 R
"(Gets the assembly form of the operation with default options.
149 If more advanced control over the assembly formatting or I/O options is needed,
150 use the dedicated print or get_asm method, which supports keyword arguments to
155 R
"(Dumps a debug representation of the object to stderr.)";
158 R
"(Appends a new block, with argument types as positional args.
165 R
"(Returns the string form of the value.
167 If the value is a block argument, this is the assembly form of its type and the
168 position in the argument list. If the value is an operation result, this is
169 equivalent to printing the operation that produced it.
173 R
"(Returns the string form of value as an operand (i.e., the ValueID).
177 R
"(Replace all uses of value with the new value, updating anything in
178 the IR that uses 'self' to use the other value instead.
186 template <
class Func,
typename... Args>
188 py::object cf = py::cpp_function(f, args...);
189 return py::reinterpret_borrow<py::object>((PyClassMethod_New(cf.ptr())));
194 py::object dialectDescriptor) {
195 auto dialectClass =
PyGlobals::get().lookupDialectClass(dialectNamespace);
198 return py::cast(
PyDialect(std::move(dialectDescriptor)));
202 return (*dialectClass)(std::move(dialectDescriptor));
212 const std::optional<py::sequence> &pyArgLocs) {
214 argTypes.reserve(pyArgTypes.size());
215 for (
const auto &pyType : pyArgTypes)
216 argTypes.push_back(pyType.cast<
PyType &>());
220 argLocs.reserve(pyArgLocs->size());
221 for (
const auto &pyLoc : *pyArgLocs)
222 argLocs.push_back(pyLoc.cast<
PyLocation &>());
223 }
else if (!argTypes.empty()) {
224 argLocs.assign(argTypes.size(), DefaultingPyLocation::resolve());
227 if (argTypes.size() != argLocs.size())
228 throw py::value_error((
"Expected " + Twine(argTypes.size()) +
229 " locations, got: " + Twine(argLocs.size()))
231 return mlirBlockCreate(argTypes.size(), argTypes.data(), argLocs.data());
240 static void bind(py::module &m) {
242 py::class_<PyGlobalDebugFlag>(m,
"_GlobalDebug", py::module_local())
247 [](
const std::string &type) {
250 "types"_a,
"Sets specific debug types to be produced by LLVM")
251 .def_static(
"set_types", [](
const std::vector<std::string> &types) {
252 std::vector<const char *> pointers;
253 pointers.reserve(types.size());
254 for (
const std::string &str : types)
255 pointers.push_back(str.c_str());
263 return PyGlobals::get().lookupAttributeBuilder(attributeKind).has_value();
266 auto builder =
PyGlobals::get().lookupAttributeBuilder(attributeKind);
268 throw py::key_error(attributeKind);
272 py::function func,
bool replace) {
273 PyGlobals::get().registerAttributeBuilder(attributeKind, std::move(func),
277 static void bind(py::module &m) {
278 py::class_<PyAttrBuilderMap>(m,
"AttrBuilder", py::module_local())
282 "attribute_kind"_a,
"attr_builder"_a,
"replace"_a =
false,
283 "Register an attribute builder for building MLIR "
284 "attributes from python values.");
292 py::object PyBlock::getCapsule() {
302 class PyRegionIterator {
305 : operation(std::move(operation)) {}
307 PyRegionIterator &dunderIter() {
return *
this; }
312 throw py::stop_iteration();
318 static void bind(py::module &m) {
319 py::class_<PyRegionIterator>(m,
"RegionIterator", py::module_local())
320 .def(
"__iter__", &PyRegionIterator::dunderIter)
321 .def(
"__next__", &PyRegionIterator::dunderNext);
333 PyRegionList(
PyOperationRef operation) : operation(std::move(operation)) {}
335 PyRegionIterator dunderIter() {
337 return PyRegionIterator(operation);
340 intptr_t dunderLen() {
341 operation->checkValid();
345 PyRegion dunderGetItem(intptr_t index) {
347 if (index < 0 || index >= dunderLen()) {
348 throw py::index_error(
"attempt to access out of bounds region");
354 static void bind(py::module &m) {
355 py::class_<PyRegionList>(m,
"RegionSequence", py::module_local())
356 .def(
"__len__", &PyRegionList::dunderLen)
357 .def(
"__iter__", &PyRegionList::dunderIter)
358 .def(
"__getitem__", &PyRegionList::dunderGetItem);
365 class PyBlockIterator {
368 : operation(std::move(operation)), next(next) {}
370 PyBlockIterator &dunderIter() {
return *
this; }
375 throw py::stop_iteration();
378 PyBlock returnBlock(operation, next);
383 static void bind(py::module &m) {
384 py::class_<PyBlockIterator>(m,
"BlockIterator", py::module_local())
385 .def(
"__iter__", &PyBlockIterator::dunderIter)
386 .def(
"__next__", &PyBlockIterator::dunderNext);
400 : operation(std::move(operation)), region(region) {}
402 PyBlockIterator dunderIter() {
407 intptr_t dunderLen() {
408 operation->checkValid();
418 PyBlock dunderGetItem(intptr_t index) {
421 throw py::index_error(
"attempt to access out of bounds block");
426 return PyBlock(operation, block);
431 throw py::index_error(
"attempt to access out of bounds block");
434 PyBlock appendBlock(
const py::args &pyArgTypes,
435 const std::optional<py::sequence> &pyArgLocs) {
437 MlirBlock block =
createBlock(pyArgTypes, pyArgLocs);
439 return PyBlock(operation, block);
442 static void bind(py::module &m) {
443 py::class_<PyBlockList>(m,
"BlockList", py::module_local())
444 .def(
"__getitem__", &PyBlockList::dunderGetItem)
445 .def(
"__iter__", &PyBlockList::dunderIter)
446 .def(
"__len__", &PyBlockList::dunderLen)
448 py::arg(
"arg_locs") = std::nullopt);
456 class PyOperationIterator {
458 PyOperationIterator(
PyOperationRef parentOperation, MlirOperation next)
459 : parentOperation(std::move(parentOperation)), next(next) {}
461 PyOperationIterator &dunderIter() {
return *
this; }
463 py::object dunderNext() {
466 throw py::stop_iteration();
470 PyOperation::forOperation(parentOperation->getContext(), next);
475 static void bind(py::module &m) {
476 py::class_<PyOperationIterator>(m,
"OperationIterator", py::module_local())
477 .def(
"__iter__", &PyOperationIterator::dunderIter)
478 .def(
"__next__", &PyOperationIterator::dunderNext);
490 class PyOperationList {
493 : parentOperation(std::move(parentOperation)), block(block) {}
495 PyOperationIterator dunderIter() {
497 return PyOperationIterator(parentOperation,
501 intptr_t dunderLen() {
502 parentOperation->checkValid();
512 py::object dunderGetItem(intptr_t index) {
513 parentOperation->checkValid();
515 throw py::index_error(
"attempt to access out of bounds operation");
520 return PyOperation::forOperation(parentOperation->getContext(), childOp)
526 throw py::index_error(
"attempt to access out of bounds operation");
529 static void bind(py::module &m) {
530 py::class_<PyOperationList>(m,
"OperationList", py::module_local())
531 .def(
"__getitem__", &PyOperationList::dunderGetItem)
532 .def(
"__iter__", &PyOperationList::dunderIter)
533 .def(
"__len__", &PyOperationList::dunderLen);
543 PyOpOperand(MlirOpOperand opOperand) : opOperand(opOperand) {}
545 py::object getOwner() {
549 return PyOperation::forOperation(context, owner)->createOpView();
554 static void bind(py::module &m) {
555 py::class_<PyOpOperand>(m,
"OpOperand", py::module_local())
556 .def_property_readonly(
"owner", &PyOpOperand::getOwner)
557 .def_property_readonly(
"operand_number",
558 &PyOpOperand::getOperandNumber);
562 MlirOpOperand opOperand;
565 class PyOpOperandIterator {
567 PyOpOperandIterator(MlirOpOperand opOperand) : opOperand(opOperand) {}
569 PyOpOperandIterator &dunderIter() {
return *
this; }
571 PyOpOperand dunderNext() {
573 throw py::stop_iteration();
575 PyOpOperand returnOpOperand(opOperand);
577 return returnOpOperand;
580 static void bind(py::module &m) {
581 py::class_<PyOpOperandIterator>(m,
"OpOperandIterator", py::module_local())
582 .def(
"__iter__", &PyOpOperandIterator::dunderIter)
583 .def(
"__next__", &PyOpOperandIterator::dunderNext);
587 MlirOpOperand opOperand;
596 PyMlirContext::PyMlirContext(MlirContext context) : context(context) {
597 py::gil_scoped_acquire acquire;
598 auto &liveContexts = getLiveContexts();
599 liveContexts[context.ptr] =
this;
606 py::gil_scoped_acquire acquire;
607 getLiveContexts().erase(context.ptr);
618 throw py::error_already_set();
628 py::gil_scoped_acquire acquire;
629 auto &liveContexts = getLiveContexts();
630 auto it = liveContexts.find(context.ptr);
631 if (it == liveContexts.end()) {
634 py::object pyRef = py::cast(unownedContextWrapper);
635 assert(pyRef &&
"cast to py::object failed");
636 liveContexts[context.ptr] = unownedContextWrapper;
640 py::object pyRef = py::cast(it->second);
645 static LiveContextMap liveContexts;
654 std::vector<PyOperation *> liveObjects;
655 for (
auto &entry : liveOperations)
656 liveObjects.push_back(entry.second.second);
661 for (
auto &op : liveOperations)
662 op.second.second->setInvalid();
663 size_t numInvalidated = liveOperations.size();
664 liveOperations.clear();
665 return numInvalidated;
669 auto it = liveOperations.find(op.ptr);
670 if (it != liveOperations.end()) {
671 it->second.second->setInvalid();
672 liveOperations.erase(it);
686 callBackData *data =
static_cast<callBackData *
>(userData);
687 if (LLVM_LIKELY(data->rootSeen))
688 data->rootOp.getOperation().getContext()->clearOperation(op);
690 data->rootSeen =
true;
719 const pybind11::object &excVal,
720 const pybind11::object &excTb) {
729 py::object pyHandlerObject =
730 py::cast(pyHandler, py::return_value_policy::take_ownership);
731 pyHandlerObject.inc_ref();
735 auto handlerCallback =
738 py::object pyDiagnosticObject =
739 py::cast(pyDiagnostic, py::return_value_policy::take_ownership);
746 py::gil_scoped_acquire gil;
748 result = py::cast<bool>(pyHandler->callback(pyDiagnostic));
749 }
catch (std::exception &e) {
750 fprintf(stderr,
"MLIR Python Diagnostic handler raised exception: %s\n",
752 pyHandler->hadError =
true;
759 auto deleteCallback = +[](
void *userData) {
761 assert(pyHandler->registeredID &&
"handler is not registered");
762 pyHandler->registeredID.reset();
765 py::object pyHandlerObject =
766 py::cast(pyHandler, py::return_value_policy::reference);
767 pyHandlerObject.dec_ref();
771 get(), handlerCallback,
static_cast<void *
>(pyHandler), deleteCallback);
772 return pyHandlerObject;
779 if (self->ctx->emitErrorDiagnostics)
792 throw std::runtime_error(
793 "An MLIR function requires a Context but none was provided in the call "
794 "or from the surrounding environment. Either pass to the function with "
795 "a 'context=' argument or establish a default using 'with Context():'");
805 static thread_local std::vector<PyThreadContextEntry> stack;
810 auto &stack = getStack();
813 return &stack.back();
816 void PyThreadContextEntry::push(FrameKind frameKind, py::object context,
817 py::object insertionPoint,
818 py::object location) {
819 auto &stack = getStack();
820 stack.emplace_back(frameKind, std::move(context), std::move(insertionPoint),
821 std::move(location));
825 if (stack.size() > 1) {
826 auto &prev = *(stack.rbegin() + 1);
827 auto ¤t = stack.back();
828 if (current.context.is(prev.context)) {
830 if (!current.insertionPoint)
831 current.insertionPoint = prev.insertionPoint;
832 if (!current.location)
833 current.location = prev.location;
841 return py::cast<PyMlirContext *>(context);
847 return py::cast<PyInsertionPoint *>(insertionPoint);
853 return py::cast<PyLocation *>(location);
857 auto *tos = getTopOfStack();
858 return tos ? tos->getContext() :
nullptr;
862 auto *tos = getTopOfStack();
863 return tos ? tos->getInsertionPoint() :
nullptr;
867 auto *tos = getTopOfStack();
868 return tos ? tos->getLocation() :
nullptr;
872 py::object contextObj = py::cast(context);
873 push(FrameKind::Context, contextObj,
880 auto &stack = getStack();
882 throw std::runtime_error(
"Unbalanced Context enter/exit");
883 auto &tos = stack.back();
884 if (tos.frameKind != FrameKind::Context && tos.getContext() != &context)
885 throw std::runtime_error(
"Unbalanced Context enter/exit");
891 py::object contextObj =
893 py::object insertionPointObj = py::cast(insertionPoint);
894 push(FrameKind::InsertionPoint,
898 return insertionPointObj;
902 auto &stack = getStack();
904 throw std::runtime_error(
"Unbalanced InsertionPoint enter/exit");
905 auto &tos = stack.back();
906 if (tos.frameKind != FrameKind::InsertionPoint &&
907 tos.getInsertionPoint() != &insertionPoint)
908 throw std::runtime_error(
"Unbalanced InsertionPoint enter/exit");
914 py::object locationObj = py::cast(location);
915 push(FrameKind::Location, contextObj,
922 auto &stack = getStack();
924 throw std::runtime_error(
"Unbalanced Location enter/exit");
925 auto &tos = stack.back();
926 if (tos.frameKind != FrameKind::Location && tos.getLocation() != &location)
927 throw std::runtime_error(
"Unbalanced Location enter/exit");
937 if (materializedNotes) {
938 for (
auto ¬eObject : *materializedNotes) {
939 PyDiagnostic *note = py::cast<PyDiagnostic *>(noteObject);
947 : context(context), callback(std::move(callback)) {}
956 assert(!registeredID &&
"should have unregistered");
962 void PyDiagnostic::checkValid() {
964 throw std::invalid_argument(
965 "Diagnostic is invalid (used outside of callback)");
983 py::object fileObject = py::module::import(
"io").attr(
"StringIO")();
986 return fileObject.attr(
"getvalue")();
991 if (materializedNotes)
992 return *materializedNotes;
994 materializedNotes = py::tuple(numNotes);
995 for (intptr_t i = 0; i < numNotes; ++i) {
999 return *materializedNotes;
1003 std::vector<DiagnosticInfo> notes;
1016 {key.data(), key.size()});
1018 std::string msg = (Twine(
"Dialect '") + key +
"' not found").str();
1020 throw py::attribute_error(msg);
1021 throw py::index_error(msg);
1027 return py::reinterpret_steal<py::object>(
1032 MlirDialectRegistry rawRegistry =
1035 throw py::error_already_set();
1050 throw py::error_already_set();
1060 const pybind11::object &excVal,
1061 const pybind11::object &excTb) {
1068 throw std::runtime_error(
1069 "An MLIR function requires a Location but none was provided in the "
1070 "call or from the surrounding environment. Either pass to the function "
1071 "with a 'loc=' argument or establish a default using 'with loc:'");
1084 py::gil_scoped_acquire acquire;
1085 auto &liveModules =
getContext()->liveModules;
1086 assert(liveModules.count(module.ptr) == 1 &&
1087 "destroying module not in live map");
1088 liveModules.erase(module.ptr);
1096 py::gil_scoped_acquire acquire;
1097 auto &liveModules = contextRef->liveModules;
1098 auto it = liveModules.find(module.ptr);
1099 if (it == liveModules.end()) {
1106 py::cast(unownedModule, py::return_value_policy::take_ownership);
1107 unownedModule->handle = pyRef;
1108 liveModules[module.ptr] =
1109 std::make_pair(unownedModule->handle, unownedModule);
1110 return PyModuleRef(unownedModule, std::move(pyRef));
1113 PyModule *existing = it->second.second;
1114 py::object pyRef = py::reinterpret_borrow<py::object>(it->second.first);
1121 throw py::error_already_set();
1133 PyOperation::PyOperation(
PyMlirContextRef contextRef, MlirOperation operation)
1154 MlirOperation operation,
1155 py::object parentKeepAlive) {
1156 auto &liveOperations = contextRef->liveOperations;
1159 new PyOperation(std::move(contextRef), operation);
1164 py::cast(unownedOperation, py::return_value_policy::take_ownership);
1165 unownedOperation->handle = pyRef;
1166 if (parentKeepAlive) {
1167 unownedOperation->parentKeepAlive = std::move(parentKeepAlive);
1169 liveOperations[operation.ptr] = std::make_pair(pyRef, unownedOperation);
1174 MlirOperation operation,
1175 py::object parentKeepAlive) {
1176 auto &liveOperations = contextRef->liveOperations;
1177 auto it = liveOperations.find(operation.ptr);
1178 if (it == liveOperations.end()) {
1180 return createInstance(std::move(contextRef), operation,
1181 std::move(parentKeepAlive));
1185 py::object pyRef = py::reinterpret_borrow<py::object>(it->second.first);
1190 MlirOperation operation,
1191 py::object parentKeepAlive) {
1192 auto &liveOperations = contextRef->liveOperations;
1193 assert(liveOperations.count(operation.ptr) == 0 &&
1194 "cannot create detached operation that already exists");
1195 (void)liveOperations;
1197 PyOperationRef created = createInstance(std::move(contextRef), operation,
1198 std::move(parentKeepAlive));
1199 created->attached =
false;
1204 const std::string &sourceStr,
1205 const std::string &sourceName) {
1211 throw MLIRError(
"Unable to parse operation assembly", errors.
take());
1217 throw std::runtime_error(
"the operation has been invalidated");
1222 bool enableDebugInfo,
bool prettyDebugInfo,
1223 bool printGenericOpForm,
bool useLocalScope,
1224 bool assumeVerified, py::object fileObject,
1225 bool binary,
bool skipRegions) {
1228 if (fileObject.is_none())
1229 fileObject = py::module::import(
"sys").attr(
"stdout");
1232 if (largeElementsLimit)
1234 if (enableDebugInfo)
1237 if (printGenericOpForm)
1256 if (fileObject.is_none())
1257 fileObject = py::module::import(
"sys").attr(
"stdout");
1264 std::optional<int64_t> bytecodeVersion) {
1269 if (!bytecodeVersion.has_value())
1279 throw py::value_error((Twine(
"Unable to honor desired bytecode version ") +
1280 Twine(*bytecodeVersion))
1292 std::string exceptionWhat;
1293 py::object exceptionType;
1295 UserData userData{callback,
false, {}, {}};
1298 UserData *calleeUserData =
static_cast<UserData *
>(userData);
1300 return (calleeUserData->callback)(op);
1301 }
catch (py::error_already_set &e) {
1302 calleeUserData->gotException =
true;
1303 calleeUserData->exceptionWhat = e.what();
1304 calleeUserData->exceptionType = e.type();
1309 if (userData.gotException) {
1310 std::string message(
"Exception raised in callback: ");
1311 message.append(userData.exceptionWhat);
1312 throw std::runtime_error(message);
1317 std::optional<int64_t> largeElementsLimit,
1318 bool enableDebugInfo,
bool prettyDebugInfo,
1319 bool printGenericOpForm,
bool useLocalScope,
1320 bool assumeVerified,
bool skipRegions) {
1321 py::object fileObject;
1323 fileObject = py::module::import(
"io").attr(
"BytesIO")();
1325 fileObject = py::module::import(
"io").attr(
"StringIO")();
1327 print(largeElementsLimit,
1337 return fileObject.attr(
"getvalue")();
1346 operation.parentKeepAlive = otherOp.parentKeepAlive;
1355 operation.parentKeepAlive = otherOp.parentKeepAlive;
1369 throw py::value_error(
"Detached operations have no parent");
1380 assert(!
mlirBlockIsNull(block) &&
"Attached operation has null parent");
1381 assert(parentOperation &&
"Operation has no parent");
1382 return PyBlock{std::move(*parentOperation), block};
1393 throw py::error_already_set();
1400 const py::object &maybeIp) {
1402 if (!maybeIp.is(py::cast(
false))) {
1404 if (maybeIp.is_none()) {
1407 ip = py::cast<PyInsertionPoint *>(maybeIp);
1415 std::optional<std::vector<PyType *>> results,
1416 std::optional<std::vector<PyValue *>> operands,
1417 std::optional<py::dict> attributes,
1418 std::optional<std::vector<PyBlock *>> successors,
1420 const py::object &maybeIp,
bool inferType) {
1428 throw py::value_error(
"number of regions must be >= 0");
1432 mlirOperands.reserve(operands->size());
1433 for (
PyValue *operand : *operands) {
1435 throw py::value_error(
"operand value cannot be None");
1436 mlirOperands.push_back(operand->get());
1442 mlirResults.reserve(results->size());
1443 for (
PyType *result : *results) {
1446 throw py::value_error(
"result type cannot be None");
1447 mlirResults.push_back(*result);
1452 mlirAttributes.reserve(attributes->size());
1453 for (
auto &it : *attributes) {
1456 key = it.first.cast<std::string>();
1457 }
catch (py::cast_error &err) {
1458 std::string msg =
"Invalid attribute key (not a string) when "
1459 "attempting to create the operation \"" +
1460 name +
"\" (" + err.what() +
")";
1461 throw py::cast_error(msg);
1464 auto &attribute = it.second.cast<
PyAttribute &>();
1466 mlirAttributes.emplace_back(std::move(key), attribute);
1467 }
catch (py::reference_cast_error &) {
1470 "Found an invalid (`None`?) attribute value for the key \"" + key +
1471 "\" when attempting to create the operation \"" + name +
"\"";
1472 throw py::cast_error(msg);
1473 }
catch (py::cast_error &err) {
1474 std::string msg =
"Invalid attribute value for the key \"" + key +
1475 "\" when attempting to create the operation \"" +
1476 name +
"\" (" + err.what() +
")";
1477 throw py::cast_error(msg);
1483 mlirSuccessors.reserve(successors->size());
1484 for (
auto *successor : *successors) {
1487 throw py::value_error(
"successor block cannot be None");
1488 mlirSuccessors.push_back(successor->get());
1496 if (!mlirOperands.empty())
1498 mlirOperands.data());
1499 state.enableResultTypeInference = inferType;
1500 if (!mlirResults.empty())
1502 mlirResults.data());
1503 if (!mlirAttributes.empty()) {
1508 mlirNamedAttributes.reserve(mlirAttributes.size());
1509 for (
auto &it : mlirAttributes)
1515 mlirNamedAttributes.data());
1517 if (!mlirSuccessors.empty())
1519 mlirSuccessors.data());
1522 mlirRegions.resize(regions);
1523 for (
int i = 0; i < regions; ++i)
1526 mlirRegions.data());
1532 throw py::value_error(
"Operation creation failed");
1571 const py::object &resultSegmentSpecObj,
1572 std::vector<int32_t> &resultSegmentLengths,
1573 std::vector<PyType *> &resultTypes) {
1574 resultTypes.reserve(resultTypeList.size());
1575 if (resultSegmentSpecObj.is_none()) {
1579 resultTypes.push_back(py::cast<PyType *>(it.value()));
1580 if (!resultTypes.back())
1581 throw py::cast_error();
1582 }
catch (py::cast_error &err) {
1583 throw py::value_error((llvm::Twine(
"Result ") +
1584 llvm::Twine(it.index()) +
" of operation \"" +
1585 name +
"\" must be a Type (" + err.what() +
")")
1591 auto resultSegmentSpec = py::cast<std::vector<int>>(resultSegmentSpecObj);
1592 if (resultSegmentSpec.size() != resultTypeList.size()) {
1593 throw py::value_error((llvm::Twine(
"Operation \"") + name +
1595 llvm::Twine(resultSegmentSpec.size()) +
1596 " result segments but was provided " +
1597 llvm::Twine(resultTypeList.size()))
1600 resultSegmentLengths.reserve(resultTypeList.size());
1601 for (
const auto &it :
1603 int segmentSpec = std::get<1>(it.value());
1604 if (segmentSpec == 1 || segmentSpec == 0) {
1607 auto *resultType = py::cast<PyType *>(std::get<0>(it.value()));
1609 resultTypes.push_back(resultType);
1610 resultSegmentLengths.push_back(1);
1611 }
else if (segmentSpec == 0) {
1613 resultSegmentLengths.push_back(0);
1615 throw py::cast_error(
"was None and result is not optional");
1617 }
catch (py::cast_error &err) {
1618 throw py::value_error((llvm::Twine(
"Result ") +
1619 llvm::Twine(it.index()) +
" of operation \"" +
1620 name +
"\" must be a Type (" + err.what() +
1624 }
else if (segmentSpec == -1) {
1627 if (std::get<0>(it.value()).is_none()) {
1629 resultSegmentLengths.push_back(0);
1632 auto segment = py::cast<py::sequence>(std::get<0>(it.value()));
1633 for (py::object segmentItem : segment) {
1634 resultTypes.push_back(py::cast<PyType *>(segmentItem));
1635 if (!resultTypes.back()) {
1636 throw py::cast_error(
"contained a None item");
1639 resultSegmentLengths.push_back(segment.size());
1641 }
catch (std::exception &err) {
1645 throw py::value_error((llvm::Twine(
"Result ") +
1646 llvm::Twine(it.index()) +
" of operation \"" +
1647 name +
"\" must be a Sequence of Types (" +
1652 throw py::value_error(
"Unexpected segment spec");
1659 const py::object &cls, std::optional<py::list> resultTypeList,
1660 py::list operandList, std::optional<py::dict> attributes,
1661 std::optional<std::vector<PyBlock *>> successors,
1663 const py::object &maybeIp) {
1666 std::string name = py::cast<std::string>(cls.attr(
"OPERATION_NAME"));
1672 py::object operandSegmentSpecObj = cls.attr(
"_ODS_OPERAND_SEGMENTS");
1673 py::object resultSegmentSpecObj = cls.attr(
"_ODS_RESULT_SEGMENTS");
1675 std::vector<int32_t> operandSegmentLengths;
1676 std::vector<int32_t> resultSegmentLengths;
1679 auto opRegionSpec = py::cast<std::tuple<int, bool>>(cls.attr(
"_ODS_REGIONS"));
1680 int opMinRegionCount = std::get<0>(opRegionSpec);
1681 bool opHasNoVariadicRegions = std::get<1>(opRegionSpec);
1683 regions = opMinRegionCount;
1685 if (*regions < opMinRegionCount) {
1686 throw py::value_error(
1687 (llvm::Twine(
"Operation \"") + name +
"\" requires a minimum of " +
1688 llvm::Twine(opMinRegionCount) +
1689 " regions but was built with regions=" + llvm::Twine(*regions))
1692 if (opHasNoVariadicRegions && *regions > opMinRegionCount) {
1693 throw py::value_error(
1694 (llvm::Twine(
"Operation \"") + name +
"\" requires a maximum of " +
1695 llvm::Twine(opMinRegionCount) +
1696 " regions but was built with regions=" + llvm::Twine(*regions))
1701 std::vector<PyType *> resultTypes;
1702 if (resultTypeList.has_value()) {
1704 resultSegmentLengths, resultTypes);
1708 std::vector<PyValue *> operands;
1709 operands.reserve(operands.size());
1710 if (operandSegmentSpecObj.is_none()) {
1714 operands.push_back(py::cast<PyValue *>(it.value()));
1715 if (!operands.back())
1716 throw py::cast_error();
1717 }
catch (py::cast_error &err) {
1718 throw py::value_error((llvm::Twine(
"Operand ") +
1719 llvm::Twine(it.index()) +
" of operation \"" +
1720 name +
"\" must be a Value (" + err.what() +
")")
1726 auto operandSegmentSpec = py::cast<std::vector<int>>(operandSegmentSpecObj);
1727 if (operandSegmentSpec.size() != operandList.size()) {
1728 throw py::value_error((llvm::Twine(
"Operation \"") + name +
1730 llvm::Twine(operandSegmentSpec.size()) +
1731 "operand segments but was provided " +
1732 llvm::Twine(operandList.size()))
1735 operandSegmentLengths.reserve(operandList.size());
1736 for (
const auto &it :
1738 int segmentSpec = std::get<1>(it.value());
1739 if (segmentSpec == 1 || segmentSpec == 0) {
1742 auto *operandValue = py::cast<PyValue *>(std::get<0>(it.value()));
1744 operands.push_back(operandValue);
1745 operandSegmentLengths.push_back(1);
1746 }
else if (segmentSpec == 0) {
1748 operandSegmentLengths.push_back(0);
1750 throw py::cast_error(
"was None and operand is not optional");
1752 }
catch (py::cast_error &err) {
1753 throw py::value_error((llvm::Twine(
"Operand ") +
1754 llvm::Twine(it.index()) +
" of operation \"" +
1755 name +
"\" must be a Value (" + err.what() +
1759 }
else if (segmentSpec == -1) {
1762 if (std::get<0>(it.value()).is_none()) {
1764 operandSegmentLengths.push_back(0);
1767 auto segment = py::cast<py::sequence>(std::get<0>(it.value()));
1768 for (py::object segmentItem : segment) {
1769 operands.push_back(py::cast<PyValue *>(segmentItem));
1770 if (!operands.back()) {
1771 throw py::cast_error(
"contained a None item");
1774 operandSegmentLengths.push_back(segment.size());
1776 }
catch (std::exception &err) {
1780 throw py::value_error((llvm::Twine(
"Operand ") +
1781 llvm::Twine(it.index()) +
" of operation \"" +
1782 name +
"\" must be a Sequence of Values (" +
1787 throw py::value_error(
"Unexpected segment spec");
1793 if (!operandSegmentLengths.empty() || !resultSegmentLengths.empty()) {
1796 attributes = py::dict(*attributes);
1798 attributes = py::dict();
1800 if (attributes->contains(
"resultSegmentSizes") ||
1801 attributes->contains(
"operandSegmentSizes")) {
1802 throw py::value_error(
"Manually setting a 'resultSegmentSizes' or "
1803 "'operandSegmentSizes' attribute is unsupported. "
1804 "Use Operation.create for such low-level access.");
1808 if (!resultSegmentLengths.empty()) {
1809 MlirAttribute segmentLengthAttr =
1811 resultSegmentLengths.data());
1812 (*attributes)[
"resultSegmentSizes"] =
1817 if (!operandSegmentLengths.empty()) {
1818 MlirAttribute segmentLengthAttr =
1820 operandSegmentLengths.data());
1821 (*attributes)[
"operandSegmentSizes"] =
1828 std::move(resultTypes),
1829 std::move(operands),
1830 std::move(attributes),
1831 std::move(successors),
1832 *regions, location, maybeIp,
1841 py::handle opViewType = py::detail::get_type_handle(
typeid(
PyOpView),
true);
1842 py::object instance = cls.attr(
"__new__")(cls);
1843 opViewType.attr(
"__init__")(instance, operation);
1851 operationObject(operation.getRef().getObject()) {}
1860 : refOperation(beforeOperationBase.getOperation().getRef()),
1861 block((*refOperation)->getBlock()) {}
1866 throw py::value_error(
1867 "Attempt to insert operation that is already attached");
1868 block.getParentOperation()->checkValid();
1869 MlirOperation beforeOp = {
nullptr};
1872 (*refOperation)->checkValid();
1873 beforeOp = (*refOperation)->get();
1879 throw py::index_error(
"Cannot insert operation at the end of a block "
1880 "that already has a terminator. Did you mean to "
1881 "use 'InsertionPoint.at_block_terminator(block)' "
1882 "versus 'InsertionPoint(block)'?");
1905 throw py::value_error(
"Block has no terminator");
1916 const pybind11::object &excVal,
1917 const pybind11::object &excTb) {
1936 throw py::error_already_set();
1946 : ownedName(new std::string(std::move(ownedName))) {
1968 throw py::error_already_set();
1984 throw py::error_already_set();
2003 "mlirTypeID was expected to be non-null.");
2004 std::optional<pybind11::function> valueCaster =
2008 py::object thisObj = py::cast(
this, py::return_value_policy::move);
2011 return valueCaster.value()(thisObj);
2017 throw py::error_already_set();
2018 MlirOperation owner;
2024 throw py::error_already_set();
2028 return PyValue(ownerRef, value);
2036 : operation(operation.getOperation().getRef()) {
2039 throw py::cast_error(
"Operation is not a Symbol Table.");
2044 operation->checkValid();
2048 throw py::key_error(
"Symbol '" + name +
"' not in the symbol table.");
2051 operation.getObject())
2056 operation->checkValid();
2067 erase(py::cast<PyOperationBase &>(operation));
2071 operation->checkValid();
2076 throw py::value_error(
"Expected operation to have a symbol name.");
2085 MlirAttribute existingNameAttr =
2088 throw py::value_error(
"Expected operation to have a symbol name.");
2089 return existingNameAttr;
2093 const std::string &name) {
2098 MlirAttribute existingNameAttr =
2101 throw py::value_error(
"Expected operation to have a symbol name.");
2102 MlirAttribute newNameAttr =
2111 MlirAttribute existingVisAttr =
2114 throw py::value_error(
"Expected operation to have a symbol visibility.");
2115 return existingVisAttr;
2119 const std::string &visibility) {
2120 if (visibility !=
"public" && visibility !=
"private" &&
2121 visibility !=
"nested")
2122 throw py::value_error(
2123 "Expected visibility to be 'public', 'private' or 'nested'");
2127 MlirAttribute existingVisAttr =
2130 throw py::value_error(
"Expected operation to have a symbol visibility.");
2137 const std::string &newSymbol,
2145 throw py::value_error(
"Symbol rename failed");
2149 bool allSymUsesVisible,
2150 py::object callback) {
2155 py::object callback;
2157 std::string exceptionWhat;
2158 py::object exceptionType;
2161 fromOperation.
getContext(), std::move(callback),
false, {}, {}};
2163 fromOperation.
get(), allSymUsesVisible,
2164 [](MlirOperation foundOp,
bool isVisible,
void *calleeUserDataVoid) {
2165 UserData *calleeUserData = static_cast<UserData *>(calleeUserDataVoid);
2167 PyOperation::forOperation(calleeUserData->context, foundOp);
2168 if (calleeUserData->gotException)
2171 calleeUserData->callback(pyFoundOp.getObject(), isVisible);
2172 } catch (py::error_already_set &e) {
2173 calleeUserData->gotException =
true;
2174 calleeUserData->exceptionWhat = e.what();
2175 calleeUserData->exceptionType = e.type();
2178 static_cast<void *
>(&userData));
2179 if (userData.gotException) {
2180 std::string message(
"Exception raised in callback: ");
2181 message.append(userData.exceptionWhat);
2182 throw std::runtime_error(message);
2190 template <
typename DerivedTy>
2191 class PyConcreteValue :
public PyValue {
2197 using ClassTy = py::class_<DerivedTy, PyValue>;
2198 using IsAFunctionTy = bool (*)(MlirValue);
2200 PyConcreteValue() =
default;
2202 :
PyValue(operationRef, value) {}
2203 PyConcreteValue(
PyValue &orig)
2204 : PyConcreteValue(orig.getParentOperation(), castFrom(orig)) {}
2208 static MlirValue castFrom(
PyValue &orig) {
2209 if (!DerivedTy::isaFunction(orig.
get())) {
2210 auto origRepr = py::repr(py::cast(orig)).cast<std::string>();
2211 throw py::value_error((Twine(
"Cannot cast value to ") +
2212 DerivedTy::pyClassName +
" (from " + origRepr +
2220 static void bind(py::module &m) {
2221 auto cls = ClassTy(m, DerivedTy::pyClassName, py::module_local());
2222 cls.def(py::init<PyValue &>(), py::keep_alive<0, 1>(), py::arg(
"value"));
2225 [](
PyValue &otherValue) ->
bool {
2226 return DerivedTy::isaFunction(otherValue);
2228 py::arg(
"other_value"));
2230 [](
DerivedTy &
self) {
return self.maybeDownCast(); });
2231 DerivedTy::bindDerived(cls);
2235 static void bindDerived(ClassTy &m) {}
2239 class PyBlockArgument :
public PyConcreteValue<PyBlockArgument> {
2242 static constexpr
const char *pyClassName =
"BlockArgument";
2243 using PyConcreteValue::PyConcreteValue;
2245 static void bindDerived(ClassTy &c) {
2246 c.def_property_readonly(
"owner", [](PyBlockArgument &
self) {
2247 return PyBlock(
self.getParentOperation(),
2250 c.def_property_readonly(
"arg_number", [](PyBlockArgument &
self) {
2255 [](PyBlockArgument &
self,
PyType type) {
2263 class PyOpResult :
public PyConcreteValue<PyOpResult> {
2266 static constexpr
const char *pyClassName =
"OpResult";
2267 using PyConcreteValue::PyConcreteValue;
2269 static void bindDerived(ClassTy &c) {
2270 c.def_property_readonly(
"owner", [](PyOpResult &
self) {
2274 "expected the owner of the value in Python to match that in the IR");
2275 return self.getParentOperation().getObject();
2277 c.def_property_readonly(
"result_number", [](PyOpResult &
self) {
2284 template <
typename Container>
2285 static std::vector<MlirType> getValueTypes(Container &container,
2287 std::vector<MlirType> result;
2288 result.reserve(container.size());
2289 for (
int i = 0, e = container.size(); i < e; ++i) {
2299 class PyBlockArgumentList
2300 :
public Sliceable<PyBlockArgumentList, PyBlockArgument> {
2302 static constexpr
const char *pyClassName =
"BlockArgumentList";
2306 intptr_t startIndex = 0, intptr_t length = -1,
2311 operation(std::move(operation)), block(block) {}
2313 static void bindDerived(ClassTy &c) {
2314 c.def_property_readonly(
"types", [](PyBlockArgumentList &
self) {
2315 return getValueTypes(
self,
self.operation->getContext());
2321 friend class Sliceable<PyBlockArgumentList, PyBlockArgument>;
2324 intptr_t getRawNumElements() {
2325 operation->checkValid();
2330 PyBlockArgument getRawElement(intptr_t pos) {
2332 return PyBlockArgument(operation, argument);
2336 PyBlockArgumentList slice(intptr_t startIndex, intptr_t length,
2338 return PyBlockArgumentList(operation, block, startIndex, length, step);
2349 class PyOpOperandList :
public Sliceable<PyOpOperandList, PyValue> {
2351 static constexpr
const char *pyClassName =
"OpOperandList";
2354 PyOpOperandList(
PyOperationRef operation, intptr_t startIndex = 0,
2355 intptr_t length = -1, intptr_t step = 1)
2360 operation(operation) {}
2362 void dunderSetItem(intptr_t index,
PyValue value) {
2363 index = wrapIndex(index);
2367 static void bindDerived(ClassTy &c) {
2368 c.def(
"__setitem__", &PyOpOperandList::dunderSetItem);
2375 intptr_t getRawNumElements() {
2380 PyValue getRawElement(intptr_t pos) {
2382 MlirOperation owner;
2388 assert(
false &&
"Value must be an block arg or op result.");
2390 PyOperation::forOperation(operation->getContext(), owner);
2391 return PyValue(pyOwner, operand);
2394 PyOpOperandList slice(intptr_t startIndex, intptr_t length, intptr_t step) {
2395 return PyOpOperandList(operation, startIndex, length, step);
2405 class PyOpResultList :
public Sliceable<PyOpResultList, PyOpResult> {
2407 static constexpr
const char *pyClassName =
"OpResultList";
2410 PyOpResultList(
PyOperationRef operation, intptr_t startIndex = 0,
2411 intptr_t length = -1, intptr_t step = 1)
2416 operation(std::move(operation)) {}
2418 static void bindDerived(ClassTy &c) {
2419 c.def_property_readonly(
"types", [](PyOpResultList &
self) {
2420 return getValueTypes(
self,
self.operation->getContext());
2422 c.def_property_readonly(
"owner", [](PyOpResultList &
self) {
2423 return self.operation->createOpView();
2429 friend class Sliceable<PyOpResultList, PyOpResult>;
2431 intptr_t getRawNumElements() {
2432 operation->checkValid();
2436 PyOpResult getRawElement(intptr_t index) {
2438 return PyOpResult(value);
2441 PyOpResultList slice(intptr_t startIndex, intptr_t length, intptr_t step) {
2442 return PyOpResultList(operation, startIndex, length, step);
2452 class PyOpSuccessors :
public Sliceable<PyOpSuccessors, PyBlock> {
2454 static constexpr
const char *pyClassName =
"OpSuccessors";
2456 PyOpSuccessors(
PyOperationRef operation, intptr_t startIndex = 0,
2457 intptr_t length = -1, intptr_t step = 1)
2462 operation(operation) {}
2464 void dunderSetItem(intptr_t index,
PyBlock block) {
2465 index = wrapIndex(index);
2469 static void bindDerived(ClassTy &c) {
2470 c.def(
"__setitem__", &PyOpSuccessors::dunderSetItem);
2477 intptr_t getRawNumElements() {
2482 PyBlock getRawElement(intptr_t pos) {
2484 return PyBlock(operation, block);
2487 PyOpSuccessors slice(intptr_t startIndex, intptr_t length, intptr_t step) {
2488 return PyOpSuccessors(operation, startIndex, length, step);
2496 class PyOpAttributeMap {
2499 : operation(std::move(operation)) {}
2501 MlirAttribute dunderGetItemNamed(
const std::string &name) {
2505 throw py::key_error(
"attempt to access a non-existent attribute");
2511 if (index < 0 || index >= dunderLen()) {
2512 throw py::index_error(
"attempt to access out of bounds attribute");
2522 void dunderSetItem(
const std::string &name,
const PyAttribute &attr) {
2527 void dunderDelItem(
const std::string &name) {
2531 throw py::key_error(
"attempt to delete a non-existent attribute");
2534 intptr_t dunderLen() {
2538 bool dunderContains(
const std::string &name) {
2543 static void bind(py::module &m) {
2544 py::class_<PyOpAttributeMap>(m,
"OpAttributeMap", py::module_local())
2545 .def(
"__contains__", &PyOpAttributeMap::dunderContains)
2546 .def(
"__len__", &PyOpAttributeMap::dunderLen)
2547 .def(
"__getitem__", &PyOpAttributeMap::dunderGetItemNamed)
2548 .def(
"__getitem__", &PyOpAttributeMap::dunderGetItemIndexed)
2549 .def(
"__setitem__", &PyOpAttributeMap::dunderSetItem)
2550 .def(
"__delitem__", &PyOpAttributeMap::dunderDelItem);
2567 py::enum_<MlirDiagnosticSeverity>(m,
"DiagnosticSeverity", py::module_local())
2573 py::enum_<MlirWalkOrder>(m,
"WalkOrder", py::module_local())
2577 py::enum_<MlirWalkResult>(m,
"WalkResult", py::module_local())
2585 py::class_<PyDiagnostic>(m,
"Diagnostic", py::module_local())
2586 .def_property_readonly(
"severity", &PyDiagnostic::getSeverity)
2587 .def_property_readonly(
"location", &PyDiagnostic::getLocation)
2588 .def_property_readonly(
"message", &PyDiagnostic::getMessage)
2589 .def_property_readonly(
"notes", &PyDiagnostic::getNotes)
2591 if (!
self.isValid())
2592 return "<Invalid Diagnostic>";
2593 return self.getMessage();
2596 py::class_<PyDiagnostic::DiagnosticInfo>(m,
"DiagnosticInfo",
2599 .def_readonly(
"severity", &PyDiagnostic::DiagnosticInfo::severity)
2600 .def_readonly(
"location", &PyDiagnostic::DiagnosticInfo::location)
2601 .def_readonly(
"message", &PyDiagnostic::DiagnosticInfo::message)
2602 .def_readonly(
"notes", &PyDiagnostic::DiagnosticInfo::notes)
2606 py::class_<PyDiagnosticHandler>(m,
"DiagnosticHandler", py::module_local())
2607 .def(
"detach", &PyDiagnosticHandler::detach)
2608 .def_property_readonly(
"attached", &PyDiagnosticHandler::isAttached)
2609 .def_property_readonly(
"had_error", &PyDiagnosticHandler::getHadError)
2610 .def(
"__enter__", &PyDiagnosticHandler::contextEnter)
2611 .def(
"__exit__", &PyDiagnosticHandler::contextExit);
2619 py::class_<PyMlirContext>(m,
"_BaseContext", py::module_local())
2620 .def(py::init<>(&PyMlirContext::createNewContextForInit))
2621 .def_static(
"_get_live_count", &PyMlirContext::getLiveCount)
2622 .def(
"_get_context_again",
2627 .def(
"_get_live_operation_count", &PyMlirContext::getLiveOperationCount)
2628 .def(
"_get_live_operation_objects",
2629 &PyMlirContext::getLiveOperationObjects)
2630 .def(
"_clear_live_operations", &PyMlirContext::clearLiveOperations)
2631 .def(
"_clear_live_operations_inside",
2632 py::overload_cast<MlirOperation>(
2633 &PyMlirContext::clearOperationsInside))
2634 .def(
"_get_live_module_count", &PyMlirContext::getLiveModuleCount)
2636 &PyMlirContext::getCapsule)
2638 .def(
"__enter__", &PyMlirContext::contextEnter)
2639 .def(
"__exit__", &PyMlirContext::contextExit)
2640 .def_property_readonly_static(
2645 return py::none().cast<py::object>();
2646 return py::cast(context);
2648 "Gets the Context bound to the current thread or raises ValueError")
2649 .def_property_readonly(
2652 "Gets a container for accessing dialects by name")
2653 .def_property_readonly(
2655 "Alias for 'dialect'")
2657 "get_dialect_descriptor",
2660 self.
get(), {name.data(), name.size()});
2662 throw py::value_error(
2663 (Twine(
"Dialect '") + name +
"' not found").str());
2667 py::arg(
"dialect_name"),
2668 "Gets or loads a dialect by name, returning its descriptor object")
2670 "allow_unregistered_dialects",
2677 .def(
"attach_diagnostic_handler", &PyMlirContext::attachDiagnosticHandler,
2678 py::arg(
"callback"),
2679 "Attaches a diagnostic handler that will receive callbacks")
2681 "enable_multithreading",
2687 "is_registered_operation",
2692 py::arg(
"operation_name"))
2694 "append_dialect_registry",
2698 py::arg(
"registry"))
2699 .def_property(
"emit_error_diagnostics",
nullptr,
2700 &PyMlirContext::setEmitErrorDiagnostics,
2701 "Emit error diagnostics to diagnostic handlers. By default "
2702 "error diagnostics are captured and reported through "
2703 "MLIRError exceptions.")
2704 .def(
"load_all_available_dialects", [](
PyMlirContext &
self) {
2711 py::class_<PyDialectDescriptor>(m,
"DialectDescriptor", py::module_local())
2712 .def_property_readonly(
"namespace",
2720 std::string repr(
"<DialectDescriptor ");
2729 py::class_<PyDialects>(m,
"Dialects", py::module_local())
2732 MlirDialect dialect =
2733 self.getDialectForKey(keyName,
false);
2734 py::object descriptor =
2738 .def(
"__getattr__", [=](
PyDialects &
self, std::string attrName) {
2739 MlirDialect dialect =
2740 self.getDialectForKey(attrName,
true);
2741 py::object descriptor =
2749 py::class_<PyDialect>(m,
"Dialect", py::module_local())
2750 .def(py::init<py::object>(), py::arg(
"descriptor"))
2751 .def_property_readonly(
2752 "descriptor", [](
PyDialect &
self) {
return self.getDescriptor(); })
2753 .def(
"__repr__", [](py::object
self) {
2754 auto clazz =
self.attr(
"__class__");
2755 return py::str(
"<Dialect ") +
2756 self.attr(
"descriptor").attr(
"namespace") + py::str(
" (class ") +
2757 clazz.attr(
"__module__") + py::str(
".") +
2758 clazz.attr(
"__name__") + py::str(
")>");
2764 py::class_<PyDialectRegistry>(m,
"DialectRegistry", py::module_local())
2766 &PyDialectRegistry::getCapsule)
2773 py::class_<PyLocation>(m,
"Location", py::module_local())
2776 .def(
"__enter__", &PyLocation::contextEnter)
2777 .def(
"__exit__", &PyLocation::contextExit)
2782 .def(
"__eq__", [](
PyLocation &
self, py::object other) {
return false; })
2783 .def_property_readonly_static(
2786 auto *loc = PyThreadContextEntry::getDefaultLocation();
2788 throw py::value_error(
"No current Location");
2791 "Gets the Location bound to the current thread or raises ValueError")
2798 py::arg(
"context") = py::none(),
2799 "Gets a Location representing an unknown location")
2802 [](
PyLocation callee,
const std::vector<PyLocation> &frames,
2805 throw py::value_error(
"No caller frames provided");
2806 MlirLocation caller = frames.back().get();
2813 py::arg(
"callee"), py::arg(
"frames"), py::arg(
"context") = py::none(),
2817 [](std::string filename,
int line,
int col,
2824 py::arg(
"filename"), py::arg(
"line"), py::arg(
"col"),
2828 [](
const std::vector<PyLocation> &pyLocations,
2829 std::optional<PyAttribute> metadata,
2832 locations.reserve(pyLocations.size());
2833 for (
auto &pyLocation : pyLocations)
2834 locations.push_back(pyLocation.get());
2836 context->
get(), locations.size(), locations.data(),
2837 metadata ? metadata->get() : MlirAttribute{0});
2838 return PyLocation(context->getRef(), location);
2840 py::arg(
"locations"), py::arg(
"metadata") = py::none(),
2844 [](std::string name, std::optional<PyLocation> childLoc,
2850 childLoc ? childLoc->get()
2853 py::arg(
"name"), py::arg(
"childLoc") = py::none(),
2861 py::arg(
"attribute"), py::arg(
"context") = py::none(),
2862 "Gets a Location from a LocationAttr")
2863 .def_property_readonly(
2865 [](
PyLocation &
self) {
return self.getContext().getObject(); },
2866 "Context that owns the Location")
2867 .def_property_readonly(
2870 "Get the underlying LocationAttr")
2876 py::arg(
"message"),
"Emits an error at this location")
2881 return printAccum.
join();
2887 py::class_<PyModule>(m,
"Module", py::module_local())
2897 throw MLIRError(
"Unable to parse module assembly", errors.take());
2898 return PyModule::forModule(module).releaseObject();
2900 py::arg(
"asm"), py::arg(
"context") = py::none(),
2906 return PyModule::forModule(module).releaseObject();
2908 py::arg(
"loc") = py::none(),
"Creates an empty module")
2909 .def_property_readonly(
2911 [](
PyModule &
self) {
return self.getContext().getObject(); },
2912 "Context that created the Module")
2913 .def_property_readonly(
2916 return PyOperation::forOperation(
self.
getContext(),
2918 self.getRef().releaseObject())
2921 "Accesses the module as an operation")
2922 .def_property_readonly(
2927 self.getRef().releaseObject());
2931 "Return the block for this module")
2940 [](py::object
self) {
2942 return self.attr(
"operation").attr(
"__str__")();
2949 py::class_<PyOperationBase>(m,
"_OperationBase", py::module_local())
2952 return self.getOperation().getCapsule();
2964 .def_property_readonly(
"attributes",
2966 return PyOpAttributeMap(
2967 self.getOperation().getRef());
2969 .def_property_readonly(
2976 "Context that owns the Operation")
2977 .def_property_readonly(
"name",
2981 MlirOperation operation =
2982 concreteOperation.
get();
2987 .def_property_readonly(
"operands",
2989 return PyOpOperandList(
2990 self.getOperation().getRef());
2992 .def_property_readonly(
"regions",
2994 return PyRegionList(
2995 self.getOperation().getRef());
2997 .def_property_readonly(
3000 return PyOpResultList(
self.getOperation().getRef());
3002 "Returns the list of Operation results.")
3003 .def_property_readonly(
3006 auto &operation =
self.getOperation();
3008 if (numResults != 1) {
3010 throw py::value_error(
3011 (Twine(
"Cannot call .result on operation ") +
3012 StringRef(name.
data, name.
length) +
" which has " +
3014 " results (it is only valid for operations with a "
3018 return PyOpResult(operation.getRef(),
3022 "Shortcut to get an op result if it has only one (throws an error "
3024 .def_property_readonly(
3031 "Returns the source location the operation was defined or derived "
3033 .def_property_readonly(
"parent",
3036 self.getOperation().getParentOperation();
3038 return parent->getObject();
3044 return self.getAsm(
false,
3053 "Returns the assembly form of the operation.")
3055 py::overload_cast<PyAsmState &, pybind11::object, bool>(
3057 py::arg(
"state"), py::arg(
"file") = py::none(),
3060 py::overload_cast<std::optional<int64_t>,
bool,
bool,
bool,
bool,
3061 bool, py::object,
bool,
bool>(
3064 py::arg(
"large_elements_limit") = py::none(),
3065 py::arg(
"enable_debug_info") =
false,
3066 py::arg(
"pretty_debug_info") =
false,
3067 py::arg(
"print_generic_op_form") =
false,
3068 py::arg(
"use_local_scope") =
false,
3069 py::arg(
"assume_verified") =
false, py::arg(
"file") = py::none(),
3070 py::arg(
"binary") =
false, py::arg(
"skip_regions") =
false,
3072 .def(
"write_bytecode", &PyOperationBase::writeBytecode, py::arg(
"file"),
3073 py::arg(
"desired_version") = py::none(),
3075 .def(
"get_asm", &PyOperationBase::getAsm,
3077 py::arg(
"binary") =
false,
3078 py::arg(
"large_elements_limit") = py::none(),
3079 py::arg(
"enable_debug_info") =
false,
3080 py::arg(
"pretty_debug_info") =
false,
3081 py::arg(
"print_generic_op_form") =
false,
3082 py::arg(
"use_local_scope") =
false,
3083 py::arg(
"assume_verified") =
false, py::arg(
"skip_regions") =
false,
3086 "Verify the operation. Raises MLIRError if verification fails, and "
3087 "returns true otherwise.")
3088 .def(
"move_after", &PyOperationBase::moveAfter, py::arg(
"other"),
3089 "Puts self immediately after the other operation in its parent "
3091 .def(
"move_before", &PyOperationBase::moveBefore, py::arg(
"other"),
3092 "Puts self immediately before the other operation in its parent "
3097 return self.getOperation().clone(ip);
3099 py::arg(
"ip") = py::none())
3101 "detach_from_parent",
3106 throw py::value_error(
"Detached operation has no parent.");
3111 "Detaches the operation from its parent block.")
3112 .def(
"erase", [](
PyOperationBase &
self) {
self.getOperation().erase(); })
3116 py::class_<PyOperation, PyOperationBase>(m,
"Operation", py::module_local())
3117 .def_static(
"create", &PyOperation::create, py::arg(
"name"),
3118 py::arg(
"results") = py::none(),
3119 py::arg(
"operands") = py::none(),
3120 py::arg(
"attributes") = py::none(),
3121 py::arg(
"successors") = py::none(), py::arg(
"regions") = 0,
3122 py::arg(
"loc") = py::none(), py::arg(
"ip") = py::none(),
3126 [](
const std::string &sourceStr,
const std::string &sourceName,
3131 py::arg(
"source"), py::kw_only(), py::arg(
"source_name") =
"",
3132 py::arg(
"context") = py::none(),
3133 "Parses an operation. Supports both text assembly format and binary "
3136 &PyOperation::getCapsule)
3138 .def_property_readonly(
"operation", [](py::object
self) {
return self; })
3139 .def_property_readonly(
"opview", &PyOperation::createOpView)
3140 .def_property_readonly(
3143 return PyOpSuccessors(
self.getOperation().getRef());
3145 "Returns the list of Operation successors.");
3148 py::class_<PyOpView, PyOperationBase>(m,
"OpView", py::module_local())
3149 .def(py::init<py::object>(), py::arg(
"operation"))
3150 .def_property_readonly(
"operation", &PyOpView::getOperationObject)
3151 .def_property_readonly(
"opview", [](py::object
self) {
return self; })
3154 [](
PyOpView &
self) {
return py::str(
self.getOperationObject()); })
3155 .def_property_readonly(
3158 return PyOpSuccessors(
self.getOperation().getRef());
3160 "Returns the list of Operation successors.");
3161 opViewClass.attr(
"_ODS_REGIONS") = py::make_tuple(0,
true);
3162 opViewClass.attr(
"_ODS_OPERAND_SEGMENTS") = py::none();
3163 opViewClass.attr(
"_ODS_RESULT_SEGMENTS") = py::none();
3165 &PyOpView::buildGeneric, py::arg(
"cls"), py::arg(
"results") = py::none(),
3166 py::arg(
"operands") = py::none(), py::arg(
"attributes") = py::none(),
3167 py::arg(
"successors") = py::none(), py::arg(
"regions") = py::none(),
3168 py::arg(
"loc") = py::none(), py::arg(
"ip") = py::none(),
3169 "Builds a specific, generated OpView based on class level attributes.");
3171 [](
const py::object &cls,
const std::string &sourceStr,
3181 std::string clsOpName =
3182 py::cast<std::string>(cls.attr(
"OPERATION_NAME"));
3185 std::string_view parsedOpName(identifier.
data, identifier.
length);
3186 if (clsOpName != parsedOpName)
3187 throw MLIRError(Twine(
"Expected a '") + clsOpName +
"' op, got: '" +
3188 parsedOpName +
"'");
3189 return PyOpView::constructDerived(cls, *parsed.
get());
3191 py::arg(
"cls"), py::arg(
"source"), py::kw_only(),
3192 py::arg(
"source_name") =
"", py::arg(
"context") = py::none(),
3193 "Parses a specific, generated OpView based on class level attributes");
3198 py::class_<PyRegion>(m,
"Region", py::module_local())
3199 .def_property_readonly(
3202 return PyBlockList(
self.getParentOperation(),
self.
get());
3204 "Returns a forward-optimized sequence of blocks.")
3205 .def_property_readonly(
3208 return self.getParentOperation()->createOpView();
3210 "Returns the operation owning this region.")
3216 return PyBlockIterator(
self.getParentOperation(), firstBlock);
3218 "Iterates over blocks in the region.")
3221 return self.get().ptr == other.
get().ptr;
3223 .def(
"__eq__", [](
PyRegion &
self, py::object &other) {
return false; });
3228 py::class_<PyBlock>(m,
"Block", py::module_local())
3230 .def_property_readonly(
3233 return self.getParentOperation()->createOpView();
3235 "Returns the owning operation of this block.")
3236 .def_property_readonly(
3240 return PyRegion(
self.getParentOperation(), region);
3242 "Returns the owning region of this block.")
3243 .def_property_readonly(
3246 return PyBlockArgumentList(
self.getParentOperation(),
self.
get());
3248 "Returns a list of block arguments.")
3254 "Append an argument of the specified type to the block and returns "
3255 "the newly added argument.")
3258 [](
PyBlock &
self,
unsigned index) {
3261 "Erase the argument at 'index' and remove it from the argument list.")
3262 .def_property_readonly(
3265 return PyOperationList(
self.getParentOperation(),
self.
get());
3267 "Returns a forward-optimized sequence of operations.")
3270 [](
PyRegion &parent,
const py::list &pyArgTypes,
3271 const std::optional<py::sequence> &pyArgLocs) {
3273 MlirBlock block =
createBlock(pyArgTypes, pyArgLocs);
3277 py::arg(
"parent"), py::arg(
"arg_types") = py::list(),
3278 py::arg(
"arg_locs") = std::nullopt,
3279 "Creates and returns a new Block at the beginning of the given "
3280 "region (with given argument types and locations).")
3284 MlirBlock b =
self.get();
3289 "Append this block to a region, transferring ownership if necessary")
3292 [](
PyBlock &
self,
const py::args &pyArgTypes,
3293 const std::optional<py::sequence> &pyArgLocs) {
3295 MlirBlock block =
createBlock(pyArgTypes, pyArgLocs);
3298 return PyBlock(
self.getParentOperation(), block);
3300 py::arg(
"arg_locs") = std::nullopt,
3301 "Creates and returns a new Block before this block "
3302 "(with given argument types and locations).")
3305 [](
PyBlock &
self,
const py::args &pyArgTypes,
3306 const std::optional<py::sequence> &pyArgLocs) {
3308 MlirBlock block =
createBlock(pyArgTypes, pyArgLocs);
3311 return PyBlock(
self.getParentOperation(), block);
3313 py::arg(
"arg_locs") = std::nullopt,
3314 "Creates and returns a new Block after this block "
3315 "(with given argument types and locations).")
3320 MlirOperation firstOperation =
3322 return PyOperationIterator(
self.getParentOperation(),
3325 "Iterates over operations in the block.")
3328 return self.get().ptr == other.
get().ptr;
3330 .def(
"__eq__", [](
PyBlock &
self, py::object &other) {
return false; })
3342 return printAccum.
join();
3344 "Returns the assembly form of the block.")
3354 self.getParentOperation().getObject());
3356 py::arg(
"operation"),
3357 "Appends an operation to this block. If the operation is currently "
3358 "in another block, it will be moved.");
3364 py::class_<PyInsertionPoint>(m,
"InsertionPoint", py::module_local())
3365 .def(py::init<PyBlock &>(), py::arg(
"block"),
3366 "Inserts after the last operation but still inside the block.")
3367 .def(
"__enter__", &PyInsertionPoint::contextEnter)
3368 .def(
"__exit__", &PyInsertionPoint::contextExit)
3369 .def_property_readonly_static(
3372 auto *ip = PyThreadContextEntry::getDefaultInsertionPoint();
3374 throw py::value_error(
"No current InsertionPoint");
3377 "Gets the InsertionPoint bound to the current thread or raises "
3378 "ValueError if none has been set")
3379 .def(py::init<PyOperationBase &>(), py::arg(
"beforeOperation"),
3380 "Inserts before a referenced operation.")
3381 .def_static(
"at_block_begin", &PyInsertionPoint::atBlockBegin,
3382 py::arg(
"block"),
"Inserts at the beginning of the block.")
3383 .def_static(
"at_block_terminator", &PyInsertionPoint::atBlockTerminator,
3384 py::arg(
"block"),
"Inserts before the block terminator.")
3385 .def(
"insert", &PyInsertionPoint::insert, py::arg(
"operation"),
3386 "Inserts an operation.")
3387 .def_property_readonly(
3389 "Returns the block that this InsertionPoint points to.")
3390 .def_property_readonly(
3393 auto refOperation =
self.getRefOperation();
3395 return refOperation->getObject();
3398 "The reference operation before which new operations are "
3399 "inserted, or None if the insertion point is at the end of "
3405 py::class_<PyAttribute>(m,
"Attribute", py::module_local())
3408 .def(py::init<PyAttribute &>(), py::arg(
"cast_from_type"),
3409 "Casts the passed attribute to the generic Attribute")
3411 &PyAttribute::getCapsule)
3420 throw MLIRError(
"Unable to parse attribute", errors.take());
3423 py::arg(
"asm"), py::arg(
"context") = py::none(),
3424 "Parses an attribute from an assembly form. Raises an MLIRError on "
3426 .def_property_readonly(
3428 [](
PyAttribute &
self) {
return self.getContext().getObject(); },
3429 "Context that owns the Attribute")
3430 .def_property_readonly(
3437 py::keep_alive<0, 1>(),
"Binds a name to the attribute")
3440 .def(
"__eq__", [](
PyAttribute &
self, py::object &other) {
return false; })
3454 return printAccum.
join();
3456 "Returns the assembly form of the Attribute.")
3465 printAccum.
parts.append(
"Attribute(");
3468 printAccum.
parts.append(
")");
3469 return printAccum.
join();
3471 .def_property_readonly(
3476 "mlirTypeID was expected to be non-null.");
3482 "mlirTypeID was expected to be non-null.");
3483 std::optional<pybind11::function> typeCaster =
3487 return py::cast(
self);
3488 return typeCaster.value()(
self);
3494 py::class_<PyNamedAttribute>(m,
"NamedAttribute", py::module_local())
3498 printAccum.
parts.append(
"NamedAttribute(");
3499 printAccum.
parts.append(
3502 printAccum.
parts.append(
"=");
3506 printAccum.
parts.append(
")");
3507 return printAccum.
join();
3509 .def_property_readonly(
3515 "The name of the NamedAttribute binding")
3516 .def_property_readonly(
3519 py::keep_alive<0, 1>(),
3520 "The underlying generic attribute of the NamedAttribute binding");
3525 py::class_<PyType>(m,
"Type", py::module_local())
3528 .def(py::init<PyType &>(), py::arg(
"cast_from_type"),
3529 "Casts the passed type to the generic Type")
3539 throw MLIRError(
"Unable to parse type", errors.take());
3542 py::arg(
"asm"), py::arg(
"context") = py::none(),
3544 .def_property_readonly(
3545 "context", [](
PyType &
self) {
return self.getContext().getObject(); },
3546 "Context that owns the Type")
3547 .def(
"__eq__", [](
PyType &
self,
PyType &other) {
return self == other; })
3548 .def(
"__eq__", [](
PyType &
self, py::object &other) {
return false; })
3561 return printAccum.
join();
3563 "Returns the assembly form of the type.")
3571 printAccum.
parts.append(
"Type(");
3574 printAccum.
parts.append(
")");
3575 return printAccum.
join();
3581 "mlirTypeID was expected to be non-null.");
3582 std::optional<pybind11::function> typeCaster =
3586 return py::cast(
self);
3587 return typeCaster.value()(
self);
3589 .def_property_readonly(
"typeid", [](
PyType &
self) -> MlirTypeID {
3594 pybind11::repr(pybind11::cast(
self)).cast<std::string>();
3595 throw py::value_error(
3596 (origRepr + llvm::Twine(
" has no typeid.")).str());
3602 py::class_<PyTypeID>(m,
"TypeID", py::module_local())
3611 [](
PyTypeID &
self,
const py::object &other) {
return false; })
3615 .def(
"__hash__", [](
PyTypeID &
self) {
3622 py::class_<PyValue>(m,
"Value", py::module_local())
3623 .def(py::init<PyValue &>(), py::keep_alive<0, 1>(), py::arg(
"value"))
3626 .def_property_readonly(
3629 "Context in which the value lives.")
3633 .def_property_readonly(
3635 [](
PyValue &
self) -> py::object {
3636 MlirValue v =
self.get();
3641 "expected the owner of the value in Python to match that in "
3643 return self.getParentOperation().getObject();
3648 return py::cast(
PyBlock(
self.getParentOperation(), block));
3651 assert(
false &&
"Value must be a block argument or an op result");
3654 .def_property_readonly(
"uses",
3656 return PyOpOperandIterator(
3661 return self.get().ptr == other.
get().ptr;
3663 .def(
"__eq__", [](
PyValue &
self, py::object other) {
return false; })
3672 printAccum.
parts.append(
"Value(");
3675 printAccum.
parts.append(
")");
3676 return printAccum.
join();
3681 [](
PyValue &
self,
bool useLocalScope) {
3686 MlirAsmState valueState =
3693 return printAccum.
join();
3695 py::arg(
"use_local_scope") =
false)
3698 [](
PyValue &
self, std::reference_wrapper<PyAsmState> state) {
3700 MlirAsmState valueState = state.get().get();
3704 return printAccum.
join();
3707 .def_property_readonly(
3716 "replace_all_uses_with",
3722 [](
PyValue &
self) {
return self.maybeDownCast(); });
3723 PyBlockArgument::bind(m);
3724 PyOpResult::bind(m);
3725 PyOpOperand::bind(m);
3727 py::class_<PyAsmState>(m,
"AsmState", py::module_local())
3728 .def(py::init<PyValue &, bool>(), py::arg(
"value"),
3729 py::arg(
"use_local_scope") =
false)
3730 .def(py::init<PyOperationBase &, bool>(), py::arg(
"op"),
3731 py::arg(
"use_local_scope") =
false);
3736 py::class_<PySymbolTable>(m,
"SymbolTable", py::module_local())
3737 .def(py::init<PyOperationBase &>())
3738 .def(
"__getitem__", &PySymbolTable::dunderGetItem)
3739 .def(
"insert", &PySymbolTable::insert, py::arg(
"operation"))
3740 .def(
"erase", &PySymbolTable::erase, py::arg(
"operation"))
3741 .def(
"__delitem__", &PySymbolTable::dunderDel)
3742 .def(
"__contains__",
3748 .def_static(
"set_symbol_name", &PySymbolTable::setSymbolName,
3749 py::arg(
"symbol"), py::arg(
"name"))
3750 .def_static(
"get_symbol_name", &PySymbolTable::getSymbolName,
3752 .def_static(
"get_visibility", &PySymbolTable::getVisibility,
3754 .def_static(
"set_visibility", &PySymbolTable::setVisibility,
3755 py::arg(
"symbol"), py::arg(
"visibility"))
3756 .def_static(
"replace_all_symbol_uses",
3757 &PySymbolTable::replaceAllSymbolUses, py::arg(
"old_symbol"),
3758 py::arg(
"new_symbol"), py::arg(
"from_op"))
3759 .def_static(
"walk_symbol_tables", &PySymbolTable::walkSymbolTables,
3760 py::arg(
"from_op"), py::arg(
"all_sym_uses_visible"),
3761 py::arg(
"callback"));
3764 PyBlockArgumentList::bind(m);
3765 PyBlockIterator::bind(m);
3766 PyBlockList::bind(m);
3767 PyOperationIterator::bind(m);
3768 PyOperationList::bind(m);
3769 PyOpAttributeMap::bind(m);
3770 PyOpOperandIterator::bind(m);
3771 PyOpOperandList::bind(m);
3772 PyOpResultList::bind(m);
3773 PyOpSuccessors::bind(m);
3774 PyRegionIterator::bind(m);
3775 PyRegionList::bind(m);
3783 py::register_local_exception_translator([](std::exception_ptr p) {
3788 std::rethrow_exception(p);
3792 PyErr_SetObject(PyExc_Exception, obj.ptr());
MLIR_CAPI_EXPORTED void mlirSetGlobalDebugType(const char *type)
Sets the current debug type, similarly to -debug-only=type in the command-line tools.
MLIR_CAPI_EXPORTED void mlirSetGlobalDebugTypes(const char **types, intptr_t n)
Sets multiple current debug types, similarly to `-debug-only=type1,type2" in the command-line tools.
MLIR_CAPI_EXPORTED bool mlirIsGlobalDebugEnabled()
Retuns true if the global debugging flag is set, false otherwise.
MLIR_CAPI_EXPORTED void mlirEnableGlobalDebug(bool enable)
Sets the global debugging flag.
static const char kOperationPrintStateDocstring[]
static const char kValueReplaceAllUsesWithDocstring[]
static py::object createCustomDialectWrapper(const std::string &dialectNamespace, py::object dialectDescriptor)
static const char kContextGetNameLocationDocString[]
static const char kGetNameAsOperand[]
static MlirStringRef toMlirStringRef(const std::string &s)
static const char kModuleParseDocstring[]
static const char kOperationStrDunderDocstring[]
static const char kOperationPrintDocstring[]
static const char kContextGetFileLocationDocstring[]
static const char kDumpDocstring[]
static const char kAppendBlockDocstring[]
static const char kContextGetFusedLocationDocstring[]
static void maybeInsertOperation(PyOperationRef &op, const py::object &maybeIp)
static MlirBlock createBlock(const py::sequence &pyArgTypes, const std::optional< py::sequence > &pyArgLocs)
Create a block, using the current location context if no locations are specified.
static const char kOperationPrintBytecodeDocstring[]
static const char kOperationGetAsmDocstring[]
static void populateResultTypes(StringRef name, py::list resultTypeList, const py::object &resultSegmentSpecObj, std::vector< int32_t > &resultSegmentLengths, std::vector< PyType * > &resultTypes)
static const char kOperationCreateDocstring[]
static const char kContextParseTypeDocstring[]
static const char kContextGetCallSiteLocationDocstring[]
static const char kValueDunderStrDocstring[]
py::object classmethod(Func f, Args... args)
Helper for creating an @classmethod.
static MLIRContext * getContext(OpFoldResult val)
static PyObject * mlirPythonModuleToCapsule(MlirModule module)
Creates a capsule object encapsulating the raw C-API MlirModule.
#define MLIR_PYTHON_MAYBE_DOWNCAST_ATTR
Attribute on MLIR Python objects that expose a function for downcasting the corresponding Python obje...
static PyObject * mlirPythonTypeIDToCapsule(MlirTypeID typeID)
Creates a capsule object encapsulating the raw C-API MlirTypeID.
static MlirOperation mlirPythonCapsuleToOperation(PyObject *capsule)
Extracts an MlirOperations from a capsule as produced from mlirPythonOperationToCapsule.
#define MLIR_PYTHON_CAPI_PTR_ATTR
Attribute on MLIR Python objects that expose their C-API pointer.
static MlirAttribute mlirPythonCapsuleToAttribute(PyObject *capsule)
Extracts an MlirAttribute from a capsule as produced from mlirPythonAttributeToCapsule.
static PyObject * mlirPythonAttributeToCapsule(MlirAttribute attribute)
Creates a capsule object encapsulating the raw C-API MlirAttribute.
static PyObject * mlirPythonLocationToCapsule(MlirLocation loc)
Creates a capsule object encapsulating the raw C-API MlirLocation.
#define MLIR_PYTHON_CAPI_FACTORY_ATTR
Attribute on MLIR Python objects that exposes a factory function for constructing the corresponding P...
static MlirModule mlirPythonCapsuleToModule(PyObject *capsule)
Extracts an MlirModule from a capsule as produced from mlirPythonModuleToCapsule.
static MlirContext mlirPythonCapsuleToContext(PyObject *capsule)
Extracts a MlirContext from a capsule as produced from mlirPythonContextToCapsule.
static MlirTypeID mlirPythonCapsuleToTypeID(PyObject *capsule)
Extracts an MlirTypeID from a capsule as produced from mlirPythonTypeIDToCapsule.
static PyObject * mlirPythonDialectRegistryToCapsule(MlirDialectRegistry registry)
Creates a capsule object encapsulating the raw C-API MlirDialectRegistry.
static PyObject * mlirPythonTypeToCapsule(MlirType type)
Creates a capsule object encapsulating the raw C-API MlirType.
static MlirDialectRegistry mlirPythonCapsuleToDialectRegistry(PyObject *capsule)
Extracts an MlirDialectRegistry from a capsule as produced from mlirPythonDialectRegistryToCapsule.
#define MAKE_MLIR_PYTHON_QUALNAME(local)
static MlirType mlirPythonCapsuleToType(PyObject *capsule)
Extracts an MlirType from a capsule as produced from mlirPythonTypeToCapsule.
static MlirValue mlirPythonCapsuleToValue(PyObject *capsule)
Extracts an MlirValue from a capsule as produced from mlirPythonValueToCapsule.
static PyObject * mlirPythonBlockToCapsule(MlirBlock block)
Creates a capsule object encapsulating the raw C-API MlirBlock.
static PyObject * mlirPythonOperationToCapsule(MlirOperation operation)
Creates a capsule object encapsulating the raw C-API MlirOperation.
static MlirLocation mlirPythonCapsuleToLocation(PyObject *capsule)
Extracts an MlirLocation from a capsule as produced from mlirPythonLocationToCapsule.
static PyObject * mlirPythonValueToCapsule(MlirValue value)
Creates a capsule object encapsulating the raw C-API MlirValue.
static PyObject * mlirPythonContextToCapsule(MlirContext context)
Creates a capsule object encapsulating the raw C-API MlirContext.
static LogicalResult nextIndex(ArrayRef< int64_t > shape, MutableArrayRef< int64_t > index)
Walks over the indices of the elements of a tensor of a given shape by updating index in place to the...
static std::string diag(const llvm::Value &value)
static void print(spirv::VerCapExtAttr triple, DialectAsmPrinter &printer)
static sycl::context getDefaultContext()
Accumulates int a python file-like object, either writing text (default) or binary.
MlirStringCallback getCallback()
A CRTP base class for pseudo-containers willing to support Python-type slicing access on top of index...
Base class for all objects that directly or indirectly depend on an MlirContext.
PyMlirContextRef & getContext()
Accesses the context reference.
Used in function arguments when None should resolve to the current context manager set instance.
static PyLocation & resolve()
Used in function arguments when None should resolve to the current context manager set instance.
static PyMlirContext & resolve()
ReferrentTy * get() const
Wrapper around an MlirAsmState.
Wrapper around the generic MlirAttribute.
PyAttribute(PyMlirContextRef contextRef, MlirAttribute attr)
static PyAttribute createFromCapsule(pybind11::object capsule)
Creates a PyAttribute from the MlirAttribute wrapped by a capsule.
pybind11::object getCapsule()
Gets a capsule wrapping the void* within the MlirAttribute.
bool operator==(const PyAttribute &other) const
Wrapper around an MlirBlock.
PyOperationRef & getParentOperation()
Represents a diagnostic handler attached to the context.
void detach()
Detaches the handler. Does nothing if not attached.
PyDiagnosticHandler(MlirContext context, pybind11::object callback)
Python class mirroring the C MlirDiagnostic struct.
pybind11::str getMessage()
PyDiagnostic(MlirDiagnostic diagnostic)
MlirDiagnosticSeverity getSeverity()
pybind11::tuple getNotes()
Wrapper around an MlirDialect.
Wrapper around an MlirDialectRegistry.
static PyDialectRegistry createFromCapsule(pybind11::object capsule)
pybind11::object getCapsule()
User-level dialect object.
User-level object for accessing dialects with dotted syntax such as: ctx.dialect.std.
MlirDialect getDialectForKey(const std::string &key, bool attrError)
static PyGlobals & get()
Most code should get the globals via this static accessor.
std::optional< pybind11::object > lookupOperationClass(llvm::StringRef operationName)
Looks up a registered operation class (deriving from OpView) by operation name.
std::optional< pybind11::function > lookupValueCaster(MlirTypeID mlirTypeID, MlirDialect dialect)
Returns the custom value caster for MlirTypeID mlirTypeID.
An insertion point maintains a pointer to a Block and a reference operation.
static PyInsertionPoint atBlockTerminator(PyBlock &block)
Shortcut to create an insertion point before the block terminator.
PyInsertionPoint(PyBlock &block)
Creates an insertion point positioned after the last operation in the block, but still inside the blo...
static PyInsertionPoint atBlockBegin(PyBlock &block)
Shortcut to create an insertion point at the beginning of the block.
void insert(PyOperationBase &operationBase)
Inserts an operation.
void contextExit(const pybind11::object &excType, const pybind11::object &excVal, const pybind11::object &excTb)
pybind11::object contextEnter()
Enter and exit the context manager.
Wrapper around an MlirLocation.
PyLocation(PyMlirContextRef contextRef, MlirLocation loc)
pybind11::object getCapsule()
Gets a capsule wrapping the void* within the MlirLocation.
static PyLocation createFromCapsule(pybind11::object capsule)
Creates a PyLocation from the MlirLocation wrapped by a capsule.
void contextExit(const pybind11::object &excType, const pybind11::object &excVal, const pybind11::object &excTb)
pybind11::object contextEnter()
Enter and exit the context manager.
pybind11::object attachDiagnosticHandler(pybind11::object callback)
Attaches a Python callback as a diagnostic handler, returning a registration object (internally a PyD...
MlirContext get()
Accesses the underlying MlirContext.
PyMlirContextRef getRef()
Gets a strong reference to this context, which will ensure it is kept alive for the life of the refer...
static pybind11::object createFromCapsule(pybind11::object capsule)
Creates a PyMlirContext from the MlirContext wrapped by a capsule.
void clearOperationsInside(PyOperationBase &op)
Clears all operations nested inside the given op using clearOperation(MlirOperation).
static size_t getLiveCount()
Gets the count of live context objects. Used for testing.
void clearOperationAndInside(PyOperationBase &op)
Clears the operaiton and all operations inside using clearOperation(MlirOperation).
static PyMlirContext * createNewContextForInit()
For the case of a python init (py::init) method, pybind11 is quite strict about needing to return a p...
size_t getLiveModuleCount()
Gets the count of live modules associated with this context.
pybind11::object contextEnter()
Enter and exit the context manager.
size_t clearLiveOperations()
Clears the live operations map, returning the number of entries which were invalidated.
std::vector< PyOperation * > getLiveOperationObjects()
Get a list of Python objects which are still in the live context map.
void contextExit(const pybind11::object &excType, const pybind11::object &excVal, const pybind11::object &excTb)
void clearOperation(MlirOperation op)
Removes an operation from the live operations map and sets it invalid.
static PyMlirContextRef forContext(MlirContext context)
Returns a context reference for the singleton PyMlirContext wrapper for the given context.
size_t getLiveOperationCount()
Gets the count of live operations associated with this context.
pybind11::object getCapsule()
Gets a capsule wrapping the void* within the MlirContext.
MlirModule get()
Gets the backing MlirModule.
static PyModuleRef forModule(MlirModule module)
Returns a PyModule reference for the given MlirModule.
pybind11::object getCapsule()
Gets a capsule wrapping the void* within the MlirModule.
static pybind11::object createFromCapsule(pybind11::object capsule)
Creates a PyModule from the MlirModule wrapped by a capsule.
PyModule(PyModule &)=delete
Represents a Python MlirNamedAttr, carrying an optional owned name.
PyNamedAttribute(MlirAttribute attr, std::string ownedName)
Constructs a PyNamedAttr that retains an owned name.
MlirNamedAttribute namedAttr
pybind11::object getObject()
pybind11::object releaseObject()
Releases the object held by this instance, returning it.
A PyOpView is equivalent to the C++ "Op" wrappers: these are the basis for providing more instance-sp...
PyOpView(const pybind11::object &operationObject)
static pybind11::object buildGeneric(const pybind11::object &cls, std::optional< pybind11::list > resultTypeList, pybind11::list operandList, std::optional< pybind11::dict > attributes, std::optional< std::vector< PyBlock * >> successors, std::optional< int > regions, DefaultingPyLocation location, const pybind11::object &maybeIp)
static pybind11::object constructDerived(const pybind11::object &cls, const PyOperation &operation)
Construct an instance of a class deriving from OpView, bypassing its __init__ method.
Base class for PyOperation and PyOpView which exposes the primary, user visible methods for manipulat...
void print(std::optional< int64_t > largeElementsLimit, bool enableDebugInfo, bool prettyDebugInfo, bool printGenericOpForm, bool useLocalScope, bool assumeVerified, py::object fileObject, bool binary, bool skipRegions)
Implements the bound 'print' method and helps with others.
void walk(std::function< MlirWalkResult(MlirOperation)> callback, MlirWalkOrder walkOrder)
virtual PyOperation & getOperation()=0
Each must provide access to the raw Operation.
void writeBytecode(const pybind11::object &fileObject, std::optional< int64_t > bytecodeVersion)
void moveAfter(PyOperationBase &other)
Moves the operation before or after the other operation.
void moveBefore(PyOperationBase &other)
bool verify()
Verify the operation.
pybind11::object getAsm(bool binary, std::optional< int64_t > largeElementsLimit, bool enableDebugInfo, bool prettyDebugInfo, bool printGenericOpForm, bool useLocalScope, bool assumeVerified, bool skipRegions)
pybind11::object clone(const pybind11::object &ip)
Clones this operation.
void detachFromParent()
Detaches the operation from its parent block and updates its state accordingly.
void erase()
Erases the underlying MlirOperation, removes its pointer from the parent context's live operations ma...
pybind11::object getCapsule()
Gets a capsule wrapping the void* within the MlirOperation.
PyOperation & getOperation() override
Each must provide access to the raw Operation.
MlirOperation get() const
void setAttached(const pybind11::object &parent=pybind11::object())
static pybind11::object create(const std::string &name, std::optional< std::vector< PyType * >> results, std::optional< std::vector< PyValue * >> operands, std::optional< pybind11::dict > attributes, std::optional< std::vector< PyBlock * >> successors, int regions, DefaultingPyLocation location, const pybind11::object &ip, bool inferType)
Creates an operation. See corresponding python docstring.
pybind11::object createOpView()
Creates an OpView suitable for this operation.
static PyOperationRef forOperation(PyMlirContextRef contextRef, MlirOperation operation, pybind11::object parentKeepAlive=pybind11::object())
Returns a PyOperation for the given MlirOperation, optionally associating it with a parentKeepAlive.
std::optional< PyOperationRef > getParentOperation()
Gets the parent operation or raises an exception if the operation has no parent.
PyBlock getBlock()
Gets the owning block or raises an exception if the operation has no owning block.
static PyOperationRef createDetached(PyMlirContextRef contextRef, MlirOperation operation, pybind11::object parentKeepAlive=pybind11::object())
Creates a detached operation.
static PyOperationRef parse(PyMlirContextRef contextRef, const std::string &sourceStr, const std::string &sourceName)
Parses a source string (either text assembly or bytecode), creating a detached operation.
static pybind11::object createFromCapsule(pybind11::object capsule)
Creates a PyOperation from the MlirOperation wrapped by a capsule.
Wrapper around an MlirRegion.
PyOperationRef & getParentOperation()
Bindings for MLIR symbol tables.
void dunderDel(const std::string &name)
Removes the operation with the given name from the symbol table and erases it, throws if there is no ...
static void replaceAllSymbolUses(const std::string &oldSymbol, const std::string &newSymbol, PyOperationBase &from)
Replaces all symbol uses within an operation.
static void setVisibility(PyOperationBase &symbol, const std::string &visibility)
static void setSymbolName(PyOperationBase &symbol, const std::string &name)
MlirAttribute insert(PyOperationBase &symbol)
Inserts the given operation into the symbol table.
void erase(PyOperationBase &symbol)
Removes the given operation from the symbol table and erases it.
PySymbolTable(PyOperationBase &operation)
Constructs a symbol table for the given operation.
static MlirAttribute getSymbolName(PyOperationBase &symbol)
Gets and sets the name of a symbol op.
pybind11::object dunderGetItem(const std::string &name)
Returns the symbol (opview) with the given name, throws if there is no such symbol in the table.
static MlirAttribute getVisibility(PyOperationBase &symbol)
Gets and sets the visibility of a symbol op.
static void walkSymbolTables(PyOperationBase &from, bool allSymUsesVisible, pybind11::object callback)
Walks all symbol tables under and including 'from'.
Tracks an entry in the thread context stack.
static PyThreadContextEntry * getTopOfStack()
Stack management.
static void popLocation(PyLocation &location)
PyLocation * getLocation()
static pybind11::object pushContext(PyMlirContext &context)
static PyLocation * getDefaultLocation()
Gets the top of stack location and returns nullptr if not defined.
static void popInsertionPoint(PyInsertionPoint &insertionPoint)
static void popContext(PyMlirContext &context)
static PyInsertionPoint * getDefaultInsertionPoint()
Gets the top of stack insertion point and return nullptr if not defined.
static pybind11::object pushInsertionPoint(PyInsertionPoint &insertionPoint)
static pybind11::object pushLocation(PyLocation &location)
PyMlirContext * getContext()
static PyMlirContext * getDefaultContext()
Gets the top of stack context and return nullptr if not defined.
static std::vector< PyThreadContextEntry > & getStack()
Gets the thread local stack.
PyInsertionPoint * getInsertionPoint()
A TypeID provides an efficient and unique identifier for a specific C++ type.
bool operator==(const PyTypeID &other) const
static PyTypeID createFromCapsule(pybind11::object capsule)
Creates a PyTypeID from the MlirTypeID wrapped by a capsule.
pybind11::object getCapsule()
Gets a capsule wrapping the void* within the MlirTypeID.
PyTypeID(MlirTypeID typeID)
Wrapper around the generic MlirType.
pybind11::object getCapsule()
Gets a capsule wrapping the void* within the MlirType.
static PyType createFromCapsule(pybind11::object capsule)
Creates a PyType from the MlirType wrapped by a capsule.
PyType(PyMlirContextRef contextRef, MlirType type)
bool operator==(const PyType &other) const
Wrapper around the generic MlirValue.
static PyValue createFromCapsule(pybind11::object capsule)
Creates a PyValue from the MlirValue wrapped by a capsule.
PyValue(PyOperationRef parentOperation, MlirValue value)
pybind11::object getCapsule()
Gets a capsule wrapping the void* within the MlirValue.
pybind11::object maybeDownCast()
MLIR_CAPI_EXPORTED intptr_t mlirDiagnosticGetNumNotes(MlirDiagnostic diagnostic)
Returns the number of notes attached to the diagnostic.
MLIR_CAPI_EXPORTED MlirDiagnosticSeverity mlirDiagnosticGetSeverity(MlirDiagnostic diagnostic)
Returns the severity of the diagnostic.
MLIR_CAPI_EXPORTED void mlirDiagnosticPrint(MlirDiagnostic diagnostic, MlirStringCallback callback, void *userData)
Prints a diagnostic using the provided callback.
MlirDiagnosticSeverity
Severity of a diagnostic.
MLIR_CAPI_EXPORTED MlirDiagnostic mlirDiagnosticGetNote(MlirDiagnostic diagnostic, intptr_t pos)
Returns pos-th note attached to the diagnostic.
MLIR_CAPI_EXPORTED void mlirEmitError(MlirLocation location, const char *message)
Emits an error at the given location through the diagnostics engine.
MLIR_CAPI_EXPORTED MlirDiagnosticHandlerID mlirContextAttachDiagnosticHandler(MlirContext context, MlirDiagnosticHandler handler, void *userData, void(*deleteUserData)(void *))
Attaches the diagnostic handler to the context.
MLIR_CAPI_EXPORTED void mlirContextDetachDiagnosticHandler(MlirContext context, MlirDiagnosticHandlerID id)
Detaches an attached diagnostic handler from the context given its identifier.
uint64_t MlirDiagnosticHandlerID
Opaque identifier of a diagnostic handler, useful to detach a handler.
MLIR_CAPI_EXPORTED MlirLocation mlirDiagnosticGetLocation(MlirDiagnostic diagnostic)
Returns the location at which the diagnostic is reported.
MLIR_CAPI_EXPORTED MlirAttribute mlirDenseI32ArrayGet(MlirContext ctx, intptr_t size, int32_t const *values)
MLIR_CAPI_EXPORTED MlirAttribute mlirStringAttrGet(MlirContext ctx, MlirStringRef str)
Creates a string attribute in the given context containing the given string.
MLIR_CAPI_EXPORTED MlirAttribute mlirLocationGetAttribute(MlirLocation location)
Returns the underlying location attribute of this location.
MLIR_CAPI_EXPORTED intptr_t mlirBlockArgumentGetArgNumber(MlirValue value)
Returns the position of the value in the argument list of its block.
static bool mlirAttributeIsNull(MlirAttribute attr)
Checks whether an attribute is null.
MlirWalkResult(* MlirOperationWalkCallback)(MlirOperation, void *userData)
Operation walker type.
MLIR_CAPI_EXPORTED void mlirOperationWriteBytecode(MlirOperation op, MlirStringCallback callback, void *userData)
Same as mlirOperationPrint but writing the bytecode format.
MLIR_CAPI_EXPORTED MlirIdentifier mlirOperationGetName(MlirOperation op)
Gets the name of the operation as an identifier.
MLIR_CAPI_EXPORTED MlirLocation mlirLocationFileLineColGet(MlirContext context, MlirStringRef filename, unsigned line, unsigned col)
Creates an File/Line/Column location owned by the given context.
MLIR_CAPI_EXPORTED void mlirSymbolTableWalkSymbolTables(MlirOperation from, bool allSymUsesVisible, void(*callback)(MlirOperation, bool, void *userData), void *userData)
Walks all symbol table operations nested within, and including, op.
MLIR_CAPI_EXPORTED MlirStringRef mlirDialectGetNamespace(MlirDialect dialect)
Returns the namespace of the given dialect.
MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumResults(MlirOperation op)
Returns the number of results of the operation.
MLIR_CAPI_EXPORTED MlirAttribute mlirSymbolTableInsert(MlirSymbolTable symbolTable, MlirOperation operation)
Inserts the given operation into the given symbol table.
MlirWalkOrder
Traversal order for operation walk.
MLIR_CAPI_EXPORTED MlirNamedAttribute mlirOperationGetAttribute(MlirOperation op, intptr_t pos)
Return pos-th attribute of the operation.
MLIR_CAPI_EXPORTED void mlirOperationStateAddOperands(MlirOperationState *state, intptr_t n, MlirValue const *operands)
MLIR_CAPI_EXPORTED void mlirModuleDestroy(MlirModule module)
Takes a module owned by the caller and deletes it.
MLIR_CAPI_EXPORTED MlirNamedAttribute mlirNamedAttributeGet(MlirIdentifier name, MlirAttribute attr)
Associates an attribute with the name. Takes ownership of neither.
MLIR_CAPI_EXPORTED void mlirSymbolTableErase(MlirSymbolTable symbolTable, MlirOperation operation)
Removes the given operation from the symbol table and erases it.
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags)
Use local scope when printing the operation.
MLIR_CAPI_EXPORTED bool mlirValueIsABlockArgument(MlirValue value)
Returns 1 if the value is a block argument, 0 otherwise.
MLIR_CAPI_EXPORTED void mlirContextAppendDialectRegistry(MlirContext ctx, MlirDialectRegistry registry)
Append the contents of the given dialect registry to the registry associated with the context.
MLIR_CAPI_EXPORTED MlirStringRef mlirIdentifierStr(MlirIdentifier ident)
Gets the string value of the identifier.
static bool mlirModuleIsNull(MlirModule module)
Checks whether a module is null.
MLIR_CAPI_EXPORTED MlirType mlirTypeParseGet(MlirContext context, MlirStringRef type)
Parses a type. The type is owned by the context.
MLIR_CAPI_EXPORTED MlirOpOperand mlirOpOperandGetNextUse(MlirOpOperand opOperand)
Returns an op operand representing the next use of the value, or a null op operand if there is no nex...
MLIR_CAPI_EXPORTED MlirType mlirAttributeGetType(MlirAttribute attribute)
Gets the type of this attribute.
MLIR_CAPI_EXPORTED void mlirContextSetAllowUnregisteredDialects(MlirContext context, bool allow)
Sets whether unregistered dialects are allowed in this context.
MLIR_CAPI_EXPORTED void mlirRegionInsertOwnedBlockBefore(MlirRegion region, MlirBlock reference, MlirBlock block)
Takes a block owned by the caller and inserts it before the (non-owned) reference block in the given ...
MLIR_CAPI_EXPORTED void mlirValueReplaceAllUsesOfWith(MlirValue of, MlirValue with)
Replace all uses of 'of' value with the 'with' value, updating anything in the IR that uses 'of' to u...
MLIR_CAPI_EXPORTED MlirBlock mlirOperationGetSuccessor(MlirOperation op, intptr_t pos)
Returns pos-th successor of the operation.
MLIR_CAPI_EXPORTED void mlirValuePrintAsOperand(MlirValue value, MlirAsmState state, MlirStringCallback callback, void *userData)
Prints a value as an operand (i.e., the ValueID).
MLIR_CAPI_EXPORTED MlirLocation mlirLocationUnknownGet(MlirContext context)
Creates a location with unknown position owned by the given context.
MLIR_CAPI_EXPORTED void mlirTypePrint(MlirType type, MlirStringCallback callback, void *userData)
Prints a location by sending chunks of the string representation and forwarding userData tocallback`.
MLIR_CAPI_EXPORTED void mlirOperationSetAttributeByName(MlirOperation op, MlirStringRef name, MlirAttribute attr)
Sets an attribute by name, replacing the existing if it exists or adding a new one otherwise.
MLIR_CAPI_EXPORTED MlirOperation mlirOpOperandGetOwner(MlirOpOperand opOperand)
Returns the owner operation of an op operand.
MLIR_CAPI_EXPORTED MlirDialect mlirAttributeGetDialect(MlirAttribute attribute)
Gets the dialect of the attribute.
MLIR_CAPI_EXPORTED void mlirAttributePrint(MlirAttribute attr, MlirStringCallback callback, void *userData)
Prints an attribute by sending chunks of the string representation and forwarding userData tocallback...
MLIR_CAPI_EXPORTED MlirRegion mlirBlockGetParentRegion(MlirBlock block)
Returns the region that contains this block.
MLIR_CAPI_EXPORTED void mlirOperationMoveBefore(MlirOperation op, MlirOperation other)
Moves the given operation immediately before the other operation in its parent block.
static bool mlirValueIsNull(MlirValue value)
Returns whether the value is null.
MLIR_CAPI_EXPORTED void mlirOperationPrintWithState(MlirOperation op, MlirAsmState state, MlirStringCallback callback, void *userData)
Same as mlirOperationPrint but accepts AsmState controlling the printing behavior as well as caching ...
MlirWalkResult
Operation walk result.
@ MlirWalkResultInterrupt
MLIR_CAPI_EXPORTED void mlirRegionInsertOwnedBlock(MlirRegion region, intptr_t pos, MlirBlock block)
Takes a block owned by the caller and inserts it at pos to the given region.
MLIR_CAPI_EXPORTED MlirAttribute mlirOperationGetAttributeByName(MlirOperation op, MlirStringRef name)
Returns an attribute attached to the operation given its name.
static bool mlirTypeIsNull(MlirType type)
Checks whether a type is null.
MLIR_CAPI_EXPORTED bool mlirContextIsRegisteredOperation(MlirContext context, MlirStringRef name)
Returns whether the given fully-qualified operation (i.e.
MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumSuccessors(MlirOperation op)
Returns the number of successor blocks of the operation.
MLIR_CAPI_EXPORTED MlirOperation mlirOperationClone(MlirOperation op)
Creates a deep copy of an operation.
MLIR_CAPI_EXPORTED intptr_t mlirBlockGetNumArguments(MlirBlock block)
Returns the number of arguments of the block.
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsPrintGenericOpForm(MlirOpPrintingFlags flags)
Always print operations in the generic form.
MLIR_CAPI_EXPORTED MlirLocation mlirLocationFusedGet(MlirContext ctx, intptr_t nLocations, MlirLocation const *locations, MlirAttribute metadata)
Creates a fused location with an array of locations and metadata.
MLIR_CAPI_EXPORTED void mlirBlockInsertOwnedOperationBefore(MlirBlock block, MlirOperation reference, MlirOperation operation)
Takes an operation owned by the caller and inserts it before the (non-owned) reference operation in t...
MLIR_CAPI_EXPORTED void mlirAsmStateDestroy(MlirAsmState state)
Destroys printing flags created with mlirAsmStateCreate.
static bool mlirContextIsNull(MlirContext context)
Checks whether a context is null.
MLIR_CAPI_EXPORTED MlirDialect mlirContextGetOrLoadDialect(MlirContext context, MlirStringRef name)
Gets the dialect instance owned by the given context using the dialect namespace to identify it,...
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsElideLargeElementsAttrs(MlirOpPrintingFlags flags, intptr_t largeElementLimit)
Enables the elision of large elements attributes by printing a lexically valid but otherwise meaningl...
MLIR_CAPI_EXPORTED void mlirRegionInsertOwnedBlockAfter(MlirRegion region, MlirBlock reference, MlirBlock block)
Takes a block owned by the caller and inserts it after the (non-owned) reference block in the given r...
MLIR_CAPI_EXPORTED void mlirBlockArgumentSetType(MlirValue value, MlirType type)
Sets the type of the block argument to the given type.
MLIR_CAPI_EXPORTED MlirContext mlirOperationGetContext(MlirOperation op)
Gets the context this operation is associated with.
MLIR_CAPI_EXPORTED MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType const *args, MlirLocation const *locs)
Creates a new empty block with the given argument types and transfers ownership to the caller.
static bool mlirBlockIsNull(MlirBlock block)
Checks whether a block is null.
MLIR_CAPI_EXPORTED void mlirBlockAppendOwnedOperation(MlirBlock block, MlirOperation operation)
Takes an operation owned by the caller and appends it to the block.
MLIR_CAPI_EXPORTED MlirValue mlirBlockGetArgument(MlirBlock block, intptr_t pos)
Returns pos-th argument of the block.
MLIR_CAPI_EXPORTED MlirOperation mlirSymbolTableLookup(MlirSymbolTable symbolTable, MlirStringRef name)
Looks up a symbol with the given name in the given symbol table and returns the operation that corres...
MLIR_CAPI_EXPORTED MlirContext mlirTypeGetContext(MlirType type)
Gets the context that a type was created with.
MLIR_CAPI_EXPORTED void mlirValueDump(MlirValue value)
Prints the value to the standard error stream.
MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateEmpty(MlirLocation location)
Creates a new, empty module and transfers ownership to the caller.
MLIR_CAPI_EXPORTED bool mlirOpOperandIsNull(MlirOpOperand opOperand)
Returns whether the op operand is null.
MLIR_CAPI_EXPORTED MlirSymbolTable mlirSymbolTableCreate(MlirOperation operation)
Creates a symbol table for the given operation.
MLIR_CAPI_EXPORTED bool mlirLocationEqual(MlirLocation l1, MlirLocation l2)
Checks if two locations are equal.
MLIR_CAPI_EXPORTED MlirBlock mlirOperationGetBlock(MlirOperation op)
Gets the block that owns this operation, returning null if the operation is not owned.
static bool mlirLocationIsNull(MlirLocation location)
Checks if the location is null.
MLIR_CAPI_EXPORTED bool mlirOperationEqual(MlirOperation op, MlirOperation other)
Checks whether two operation handles point to the same operation.
MLIR_CAPI_EXPORTED MlirValue mlirBlockAddArgument(MlirBlock block, MlirType type, MlirLocation loc)
Appends an argument of the specified type to the block.
MLIR_CAPI_EXPORTED void mlirOperationPrintWithFlags(MlirOperation op, MlirOpPrintingFlags flags, MlirStringCallback callback, void *userData)
Same as mlirOperationPrint but accepts flags controlling the printing behavior.
MLIR_CAPI_EXPORTED MlirOpOperand mlirValueGetFirstUse(MlirValue value)
Returns an op operand representing the first use of the value, or a null op operand if there are no u...
MLIR_CAPI_EXPORTED void mlirLocationPrint(MlirLocation location, MlirStringCallback callback, void *userData)
Prints a location by sending chunks of the string representation and forwarding userData tocallback`.
MLIR_CAPI_EXPORTED bool mlirOperationVerify(MlirOperation op)
Verify the operation and return true if it passes, false if it fails.
MLIR_CAPI_EXPORTED MlirOperation mlirModuleGetOperation(MlirModule module)
Views the module as a generic operation.
MLIR_CAPI_EXPORTED bool mlirTypeEqual(MlirType t1, MlirType t2)
Checks if two types are equal.
MLIR_CAPI_EXPORTED MlirOperationState mlirOperationStateGet(MlirStringRef name, MlirLocation loc)
Constructs an operation state from a name and a location.
MLIR_CAPI_EXPORTED unsigned mlirOpOperandGetOperandNumber(MlirOpOperand opOperand)
Returns the operand number of an op operand.
MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetTerminator(MlirBlock block)
Returns the terminator operation in the block or null if no terminator.
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsSkipRegions(MlirOpPrintingFlags flags)
Skip printing regions.
MLIR_CAPI_EXPORTED MlirOperation mlirOperationGetNextInBlock(MlirOperation op)
Returns an operation immediately following the given operation it its enclosing block.
MLIR_CAPI_EXPORTED MlirOperation mlirOperationGetParentOperation(MlirOperation op)
Gets the operation that owns this operation, returning null if the operation is not owned.
MLIR_CAPI_EXPORTED MlirContext mlirModuleGetContext(MlirModule module)
Gets the context that a module was created with.
MLIR_CAPI_EXPORTED MlirLocation mlirLocationFromAttribute(MlirAttribute attribute)
Creates a location from a location attribute.
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsAssumeVerified(MlirOpPrintingFlags flags)
Do not verify the operation when using custom operation printers.
MLIR_CAPI_EXPORTED MlirTypeID mlirTypeGetTypeID(MlirType type)
Gets the type ID of the type.
MLIR_CAPI_EXPORTED MlirStringRef mlirSymbolTableGetVisibilityAttributeName(void)
Returns the name of the attribute used to store symbol visibility.
static bool mlirDialectIsNull(MlirDialect dialect)
Checks if the dialect is null.
MLIR_CAPI_EXPORTED void mlirBytecodeWriterConfigDestroy(MlirBytecodeWriterConfig config)
Destroys printing flags created with mlirBytecodeWriterConfigCreate.
MLIR_CAPI_EXPORTED MlirValue mlirOperationGetOperand(MlirOperation op, intptr_t pos)
Returns pos-th operand of the operation.
MLIR_CAPI_EXPORTED void mlirOperationStateAddAttributes(MlirOperationState *state, intptr_t n, MlirNamedAttribute const *attributes)
MLIR_CAPI_EXPORTED MlirBlock mlirBlockGetNextInRegion(MlirBlock block)
Returns the block immediately following the given block in its parent region.
MLIR_CAPI_EXPORTED MlirLocation mlirLocationCallSiteGet(MlirLocation callee, MlirLocation caller)
Creates a call site location with a callee and a caller.
MLIR_CAPI_EXPORTED MlirOperation mlirOpResultGetOwner(MlirValue value)
Returns an operation that produced this value as its result.
MLIR_CAPI_EXPORTED bool mlirValueIsAOpResult(MlirValue value)
Returns 1 if the value is an operation result, 0 otherwise.
MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumOperands(MlirOperation op)
Returns the number of operands of the operation.
static bool mlirDialectRegistryIsNull(MlirDialectRegistry registry)
Checks if the dialect registry is null.
MLIR_CAPI_EXPORTED void mlirOperationWalk(MlirOperation op, MlirOperationWalkCallback callback, void *userData, MlirWalkOrder walkOrder)
Walks operation op in walkOrder and calls callback on that operation.
MLIR_CAPI_EXPORTED MlirContext mlirContextCreateWithThreading(bool threadingEnabled)
Creates an MLIR context with an explicit setting of the multithreading setting and transfers its owne...
MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetParentOperation(MlirBlock)
Returns the closest surrounding operation that contains this block.
MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumRegions(MlirOperation op)
Returns the number of regions attached to the given operation.
MLIR_CAPI_EXPORTED MlirContext mlirLocationGetContext(MlirLocation location)
Gets the context that a location was created with.
MLIR_CAPI_EXPORTED void mlirBlockEraseArgument(MlirBlock block, unsigned index)
Erase the argument at 'index' and remove it from the argument list.
MLIR_CAPI_EXPORTED bool mlirOperationRemoveAttributeByName(MlirOperation op, MlirStringRef name)
Removes an attribute by name.
MLIR_CAPI_EXPORTED void mlirAttributeDump(MlirAttribute attr)
Prints the attribute to the standard error stream.
MLIR_CAPI_EXPORTED MlirLogicalResult mlirSymbolTableReplaceAllSymbolUses(MlirStringRef oldSymbol, MlirStringRef newSymbol, MlirOperation from)
Attempt to replace all uses that are nested within the given operation of the given symbol 'oldSymbol...
MLIR_CAPI_EXPORTED MlirAttribute mlirAttributeParseGet(MlirContext context, MlirStringRef attr)
Parses an attribute. The attribute is owned by the context.
MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateParse(MlirContext context, MlirStringRef module)
Parses a module from the string and transfers ownership to the caller.
MLIR_CAPI_EXPORTED void mlirRegionAppendOwnedBlock(MlirRegion region, MlirBlock block)
Takes a block owned by the caller and appends it to the given region.
MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetFirstOperation(MlirBlock block)
Returns the first operation in the block.
MLIR_CAPI_EXPORTED void mlirTypeDump(MlirType type)
Prints the type to the standard error stream.
MLIR_CAPI_EXPORTED MlirValue mlirOperationGetResult(MlirOperation op, intptr_t pos)
Returns pos-th result of the operation.
MLIR_CAPI_EXPORTED MlirBytecodeWriterConfig mlirBytecodeWriterConfigCreate(void)
Creates new printing flags with defaults, intended for customization.
MLIR_CAPI_EXPORTED MlirContext mlirAttributeGetContext(MlirAttribute attribute)
Gets the context that an attribute was created with.
MLIR_CAPI_EXPORTED MlirBlock mlirBlockArgumentGetOwner(MlirValue value)
Returns the block in which this value is defined as an argument.
static bool mlirRegionIsNull(MlirRegion region)
Checks whether a region is null.
MLIR_CAPI_EXPORTED void mlirOperationDestroy(MlirOperation op)
Takes an operation owned by the caller and destroys it.
MLIR_CAPI_EXPORTED MlirRegion mlirOperationGetRegion(MlirOperation op, intptr_t pos)
Returns pos-th region attached to the operation.
MLIR_CAPI_EXPORTED MlirDialect mlirTypeGetDialect(MlirType type)
Gets the dialect a type belongs to.
MLIR_CAPI_EXPORTED MlirIdentifier mlirIdentifierGet(MlirContext context, MlirStringRef str)
Gets an identifier with the given string value.
MLIR_CAPI_EXPORTED void mlirOperationSetSuccessor(MlirOperation op, intptr_t pos, MlirBlock block)
Set pos-th successor of the operation.
MLIR_CAPI_EXPORTED void mlirContextLoadAllAvailableDialects(MlirContext context)
Eagerly loads all available dialects registered with a context, making them available for use for IR ...
MLIR_CAPI_EXPORTED void mlirOperationStateAddOwnedRegions(MlirOperationState *state, intptr_t n, MlirRegion const *regions)
MLIR_CAPI_EXPORTED void mlirOperationStateAddSuccessors(MlirOperationState *state, intptr_t n, MlirBlock const *successors)
MLIR_CAPI_EXPORTED MlirBlock mlirModuleGetBody(MlirModule module)
Gets the body of the module, i.e. the only block it contains.
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsDestroy(MlirOpPrintingFlags flags)
Destroys printing flags created with mlirOpPrintingFlagsCreate.
MLIR_CAPI_EXPORTED MlirLocation mlirLocationNameGet(MlirContext context, MlirStringRef name, MlirLocation childLoc)
Creates a name location owned by the given context.
MLIR_CAPI_EXPORTED void mlirContextEnableMultithreading(MlirContext context, bool enable)
Set threading mode (must be set to false to mlir-print-ir-after-all).
MLIR_CAPI_EXPORTED void mlirBlockPrint(MlirBlock block, MlirStringCallback callback, void *userData)
Prints a block by sending chunks of the string representation and forwarding userData tocallback`.
MLIR_CAPI_EXPORTED void mlirBytecodeWriterConfigDesiredEmitVersion(MlirBytecodeWriterConfig flags, int64_t version)
Sets the version to emit in the writer config.
MLIR_CAPI_EXPORTED MlirStringRef mlirSymbolTableGetSymbolAttributeName(void)
Returns the name of the attribute used to store symbol names compatible with symbol tables.
MLIR_CAPI_EXPORTED MlirRegion mlirRegionCreate(void)
Creates a new empty region and transfers ownership to the caller.
MLIR_CAPI_EXPORTED void mlirBlockDetach(MlirBlock block)
Detach a block from the owning region and assume ownership.
MLIR_CAPI_EXPORTED void mlirOperationStateAddResults(MlirOperationState *state, intptr_t n, MlirType const *results)
Adds a list of components to the operation state.
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsEnableDebugInfo(MlirOpPrintingFlags flags, bool enable, bool prettyForm)
Enable or disable printing of debug information (based on enable).
MLIR_CAPI_EXPORTED MlirLocation mlirOperationGetLocation(MlirOperation op)
Gets the location of the operation.
MLIR_CAPI_EXPORTED MlirTypeID mlirAttributeGetTypeID(MlirAttribute attribute)
Gets the type id of the attribute.
MLIR_CAPI_EXPORTED void mlirOperationSetOperand(MlirOperation op, intptr_t pos, MlirValue newValue)
Sets the pos-th operand of the operation.
MLIR_CAPI_EXPORTED void mlirOperationDump(MlirOperation op)
Prints an operation to stderr.
MLIR_CAPI_EXPORTED intptr_t mlirOpResultGetResultNumber(MlirValue value)
Returns the position of the value in the list of results of the operation that produced it.
MLIR_CAPI_EXPORTED MlirOpPrintingFlags mlirOpPrintingFlagsCreate(void)
Creates new printing flags with defaults, intended for customization.
MLIR_CAPI_EXPORTED MlirAsmState mlirAsmStateCreateForValue(MlirValue value, MlirOpPrintingFlags flags)
Creates new AsmState from value.
MLIR_CAPI_EXPORTED MlirOperation mlirOperationCreate(MlirOperationState *state)
Creates an operation and transfers ownership to the caller.
static bool mlirSymbolTableIsNull(MlirSymbolTable symbolTable)
Returns true if the symbol table is null.
MLIR_CAPI_EXPORTED bool mlirContextGetAllowUnregisteredDialects(MlirContext context)
Returns whether the context allows unregistered dialects.
MLIR_CAPI_EXPORTED void mlirOperationMoveAfter(MlirOperation op, MlirOperation other)
Moves the given operation immediately after the other operation in its parent block.
MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumAttributes(MlirOperation op)
Returns the number of attributes attached to the operation.
MLIR_CAPI_EXPORTED void mlirValuePrint(MlirValue value, MlirStringCallback callback, void *userData)
Prints a value by sending chunks of the string representation and forwarding userData tocallback`.
MLIR_CAPI_EXPORTED MlirLogicalResult mlirOperationWriteBytecodeWithConfig(MlirOperation op, MlirBytecodeWriterConfig config, MlirStringCallback callback, void *userData)
Same as mlirOperationWriteBytecode but with writer config and returns failure only if desired bytecod...
MLIR_CAPI_EXPORTED void mlirValueSetType(MlirValue value, MlirType type)
Set the type of the value.
MLIR_CAPI_EXPORTED MlirType mlirValueGetType(MlirValue value)
Returns the type of the value.
MLIR_CAPI_EXPORTED void mlirContextDestroy(MlirContext context)
Takes an MLIR context owned by the caller and destroys it.
MLIR_CAPI_EXPORTED MlirOperation mlirOperationCreateParse(MlirContext context, MlirStringRef sourceStr, MlirStringRef sourceName)
Parses an operation, giving ownership to the caller.
MLIR_CAPI_EXPORTED bool mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2)
Checks if two attributes are equal.
static bool mlirOperationIsNull(MlirOperation op)
Checks whether the underlying operation is null.
MLIR_CAPI_EXPORTED MlirBlock mlirRegionGetFirstBlock(MlirRegion region)
Gets the first block in the region.
static MlirStringRef mlirStringRefCreate(const char *str, size_t length)
Constructs a string reference from the pointer and length.
static MlirLogicalResult mlirLogicalResultFailure(void)
Creates a logical result representing a failure.
MLIR_CAPI_EXPORTED size_t mlirTypeIDHashValue(MlirTypeID typeID)
Returns the hash value of the type id.
static MlirLogicalResult mlirLogicalResultSuccess(void)
Creates a logical result representing a success.
static bool mlirLogicalResultIsFailure(MlirLogicalResult res)
Checks if the given logical result represents a failure.
static bool mlirTypeIDIsNull(MlirTypeID typeID)
Checks whether a type id is null.
MLIR_CAPI_EXPORTED bool mlirTypeIDEqual(MlirTypeID typeID1, MlirTypeID typeID2)
Checks if two type ids are equal.
void walk(Operation *op, function_ref< void(Region *)> callback, WalkOrder order)
Walk all of the regions, blocks, or operations nested under (and including) the given operation.
constexpr void enumerate(std::tuple< Tys... > &tuple, CallbackT &&callback)
inline ::llvm::hash_code hash_value(const PolynomialBase< D, T > &arg)
PyObjectRef< PyMlirContext > PyMlirContextRef
Wrapper around MlirContext.
PyObjectRef< PyModule > PyModuleRef
void populateIRCore(pybind11::module &m)
PyObjectRef< PyOperation > PyOperationRef
QueryRef parse(llvm::StringRef line, const QuerySession &qs)
Include the generated interface declarations.
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
LogicalResult verify(Operation *op, bool verifyRecursively=true)
Perform (potentially expensive) checks of invariants, used to detect compiler bugs,...
An opaque reference to a diagnostic, always owned by the diagnostics engine (context).
A logical result value, essentially a boolean with named states.
An auxiliary class for constructing operations.
A pointer to a sized fragment of a string, not necessarily null-terminated.
const char * data
Pointer to the first symbol.
size_t length
Length of the fragment.
static bool dunderContains(const std::string &attributeKind)
static void dundeSetItemNamed(const std::string &attributeKind, py::function func, bool replace)
static py::function dundeGetItemNamed(const std::string &attributeKind)
static void bind(py::module &m)
Wrapper for the global LLVM debugging flag.
static void bind(py::module &m)
static bool get(const py::object &)
static void set(py::object &o, bool enable)
Accumulates into a python string from a method that accepts an MlirStringCallback.
MlirStringCallback getCallback()
Custom exception that allows access to error diagnostic information.
std::vector< PyDiagnostic::DiagnosticInfo > errorDiagnostics
Materialized diagnostic information.
RAII object that captures any error diagnostics emitted to the provided context.
std::vector< PyDiagnostic::DiagnosticInfo > take()
ErrorCapture(PyMlirContextRef ctx)