10 #ifndef MLIR_BINDINGS_PYTHON_IRMODULES_H
11 #define MLIR_BINDINGS_PYTHON_IRMODULES_H
29 #include "llvm/ADT/DenseMap.h"
30 #include "llvm/Support/ThreadPool.h"
37 class PyDiagnosticHandler;
38 class PyInsertionPoint;
40 class DefaultingPyLocation;
42 class DefaultingPyMlirContext;
45 class PyOperationBase;
56 : referrent(referrent), object(std::move(object)) {
57 assert(this->referrent &&
58 "cannot construct PyObjectRef with null referrent");
59 assert(this->
object &&
"cannot construct PyObjectRef with null object");
62 : referrent(other.referrent), object(std::move(other.object)) {
63 other.referrent =
nullptr;
64 assert(!other.object);
67 : referrent(other.referrent), object(other.object ) {}
73 return Py_REFCNT(
object.ptr());
80 assert(referrent &&
object);
82 auto stolen = std::move(
object);
86 T *
get() {
return referrent; }
88 assert(referrent &&
object);
92 assert(referrent &&
object);
95 operator bool()
const {
return referrent && object; }
97 using NBTypedT = nanobind::typed<nanobind::object, T>;
101 nanobind::object object;
121 nanobind::object insertionPoint,
122 nanobind::object location)
123 : context(std::move(context)), insertionPoint(std::move(insertionPoint)),
124 location(std::move(location)), frameKind(frameKind) {}
142 static nanobind::object
pushContext(nanobind::object context);
146 static nanobind::object
pushLocation(nanobind::object location);
150 static std::vector<PyThreadContextEntry> &
getStack();
153 static void push(
FrameKind frameKind, nanobind::object context,
154 nanobind::object insertionPoint, nanobind::object location);
157 nanobind::object context;
159 nanobind::object insertionPoint;
161 nanobind::object location;
171 ownedThreadPool = std::make_unique<llvm::DefaultThreadPool>();
177 MlirLlvmThreadPool
get() {
return wrap(ownedThreadPool.get()); }
180 std::stringstream ss;
181 ss << ownedThreadPool.get();
186 std::unique_ptr<llvm::ThreadPoolInterface> ownedThreadPool;
204 MlirContext
get() {
return context; }
229 static nanobind::object
contextEnter(nanobind::object context);
231 const nanobind::object &excVal,
232 const nanobind::object &excTb);
252 static nanobind::ft_mutex live_contexts_mutex;
253 static LiveContextMap &getLiveContexts();
259 using LiveModuleMap =
261 LiveModuleMap liveModules;
263 bool emitErrorDiagnostics =
false;
273 :
public Defaulting<DefaultingPyMlirContext, PyMlirContext> {
288 assert(this->contextRef &&
289 "context object constructed with null context ref");
305 operator MlirLocation()
const {
return loc; }
306 MlirLocation
get()
const {
return loc; }
309 static nanobind::object
contextEnter(nanobind::object location);
311 const nanobind::object &excVal,
312 const nanobind::object &excTb);
358 std::optional<nanobind::tuple> materializedNotes;
394 const nanobind::object &excVal,
395 const nanobind::object &excTb) {
401 nanobind::object callback;
402 std::optional<MlirDiagnosticHandlerID> registeredID;
403 bool hadError =
false;
412 ctx->
get(), handler, this,
416 assert(errors.empty() &&
"unhandled captured errors");
419 std::vector<PyDiagnostic::DiagnosticInfo>
take() {
420 return std::move(errors);
426 std::vector<PyDiagnostic::DiagnosticInfo> errors;
441 MlirDialect
get() {
return dialect; }
462 PyDialect(nanobind::object descriptor) : descriptor(std::move(descriptor)) {}
467 nanobind::object descriptor;
483 : registry(other.registry) {
484 other.registry = {
nullptr};
487 operator MlirDialectRegistry()
const {
return registry; }
488 MlirDialectRegistry
get()
const {
return registry; }
494 MlirDialectRegistry registry;
500 :
public Defaulting<DefaultingPyLocation, PyLocation> {
507 operator MlirLocation()
const {
return *
get(); }
524 MlirModule
get() {
return module; }
528 return PyModuleRef(
this, nanobind::borrow<nanobind::object>(handle));
547 nanobind::handle handle;
558 void print(std::optional<int64_t> largeElementsLimit,
559 std::optional<int64_t> largeResourceLimit,
bool enableDebugInfo,
560 bool prettyDebugInfo,
bool printGenericOpForm,
bool useLocalScope,
561 bool useNameLocAsPrefix,
bool assumeVerified,
562 nanobind::object fileObject,
bool binary,
bool skipRegions);
566 getAsm(
bool binary, std::optional<int64_t> largeElementsLimit,
567 std::optional<int64_t> largeResourceLimit,
bool enableDebugInfo,
568 bool prettyDebugInfo,
bool printGenericOpForm,
bool useLocalScope,
569 bool useNameLocAsPrefix,
bool assumeVerified,
bool skipRegions);
573 std::optional<int64_t> bytecodeVersion);
616 nanobind::object parentKeepAlive = nanobind::object());
622 nanobind::object parentKeepAlive = nanobind::object());
627 const std::string &sourceStr,
628 const std::string &sourceName);
635 parentKeepAlive = nanobind::object();
639 operator MlirOperation()
const {
return get(); }
640 MlirOperation
get()
const {
646 return PyOperationRef(
this, nanobind::borrow<nanobind::object>(handle));
650 void setAttached(
const nanobind::object &parent = nanobind::object()) {
651 assert(!attached &&
"operation already attached");
655 assert(attached &&
"operation already detached");
677 static nanobind::object
678 create(std::string_view name, std::optional<std::vector<PyType *>> results,
680 std::optional<nanobind::dict> attributes,
681 std::optional<std::vector<PyBlock *>> successors,
int regions,
682 PyLocation &location,
const nanobind::object &ip,
bool inferType);
695 nanobind::object
clone(
const nanobind::object &ip);
701 MlirOperation operation,
702 nanobind::object parentKeepAlive);
704 MlirOperation operation;
705 nanobind::handle handle;
712 nanobind::object parentKeepAlive;
713 bool attached =
true;
727 PyOpView(
const nanobind::object &operationObject);
732 static nanobind::object
733 buildGeneric(std::string_view name, std::tuple<int, bool> opRegionSpec,
734 nanobind::object operandSegmentSpecObj,
735 nanobind::object resultSegmentSpecObj,
736 std::optional<nanobind::list> resultTypeList,
737 nanobind::list operandList,
738 std::optional<nanobind::dict> attributes,
739 std::optional<std::vector<PyBlock *>> successors,
740 std::optional<int> regions,
PyLocation &location,
741 const nanobind::object &maybeIp);
751 const nanobind::object &operation);
755 nanobind::object operationObject;
764 : parentOperation(std::move(parentOperation)), region(region) {
767 operator MlirRegion()
const {
return region; }
769 MlirRegion
get() {
return region; }
805 MlirAsmState
get() {
return state; }
809 MlirOpPrintingFlags flags;
818 : parentOperation(std::move(parentOperation)), block(block) {
822 MlirBlock
get() {
return block; }
859 static nanobind::object
contextEnter(nanobind::object insertionPoint);
861 const nanobind::object &excVal,
862 const nanobind::object &excTb);
871 : refOperation(std::move(refOperation)), block(std::move(block)) {}
873 std::optional<PyOperationRef> refOperation;
883 operator MlirType()
const {
return type; }
884 MlirType
get()
const {
return type; }
911 operator MlirTypeID()
const {
return typeID; }
912 MlirTypeID
get() {
return typeID; }
929 template <
typename DerivedTy,
typename BaseTy = PyType>
935 using ClassTy = nanobind::class_<DerivedTy, BaseTy>;
942 : BaseTy(std::move(contextRef), t) {}
947 if (!DerivedTy::isaFunction(orig)) {
949 nanobind::cast<std::string>(nanobind::repr(nanobind::cast(orig)));
950 throw nanobind::value_error((llvm::Twine(
"Cannot cast type to ") +
951 DerivedTy::pyClassName +
" (from " +
959 static void bind(nanobind::module_ &m) {
960 auto cls =
ClassTy(m, DerivedTy::pyClassName);
961 cls.def(nanobind::init<PyType &>(), nanobind::keep_alive<0, 1>(),
962 nanobind::arg(
"cast_from_type"));
965 [](
PyType &otherType) ->
bool {
966 return DerivedTy::isaFunction(otherType);
968 nanobind::arg(
"other"));
969 cls.def_prop_ro_static(
971 [](nanobind::object & ) {
972 if (DerivedTy::getTypeIdFunction)
973 return PyTypeID(DerivedTy::getTypeIdFunction());
974 throw nanobind::attribute_error(
975 (DerivedTy::pyClassName + llvm::Twine(
" has no typeid."))
979 nanobind::sig(
"def static_typeid(/) -> TypeID"));
980 cls.def_prop_ro(
"typeid", [](
PyType &
self) {
981 return nanobind::cast<PyTypeID>(nanobind::cast(
self).attr(
"typeid"));
983 cls.def(
"__repr__", [](
DerivedTy &
self) {
985 printAccum.
parts.append(DerivedTy::pyClassName);
986 printAccum.
parts.append(
"(");
988 printAccum.
parts.append(
")");
989 return printAccum.
join();
992 if (DerivedTy::getTypeIdFunction) {
994 DerivedTy::getTypeIdFunction(),
995 nanobind::cast<nanobind::callable>(nanobind::cpp_function(
999 DerivedTy::bindDerived(cls);
1013 operator MlirAttribute()
const {
return attr; }
1014 MlirAttribute
get()
const {
return attr; }
1051 std::unique_ptr<std::string> ownedName;
1059 template <
typename DerivedTy,
typename BaseTy = PyAttribute>
1065 using ClassTy = nanobind::class_<DerivedTy, BaseTy>;
1072 : BaseTy(std::move(contextRef), attr) {}
1077 if (!DerivedTy::isaFunction(orig)) {
1079 nanobind::cast<std::string>(nanobind::repr(nanobind::cast(orig)));
1080 throw nanobind::value_error((llvm::Twine(
"Cannot cast attribute to ") +
1081 DerivedTy::pyClassName +
" (from " +
1089 static void bind(nanobind::module_ &m, PyType_Slot *slots =
nullptr) {
1092 cls =
ClassTy(m, DerivedTy::pyClassName, nanobind::type_slots(slots));
1094 cls =
ClassTy(m, DerivedTy::pyClassName);
1096 cls.def(nanobind::init<PyAttribute &>(), nanobind::keep_alive<0, 1>(),
1097 nanobind::arg(
"cast_from_attr"));
1101 return DerivedTy::isaFunction(otherAttr);
1103 nanobind::arg(
"other"));
1108 cls.def_prop_ro_static(
1110 [](nanobind::object & ) ->
PyTypeID {
1111 if (DerivedTy::getTypeIdFunction)
1112 return PyTypeID(DerivedTy::getTypeIdFunction());
1113 throw nanobind::attribute_error(
1114 (DerivedTy::pyClassName + llvm::Twine(
" has no typeid."))
1118 nanobind::sig(
"def static_typeid(/) -> TypeID"));
1120 return nanobind::cast<PyTypeID>(nanobind::cast(
self).attr(
"typeid"));
1122 cls.def(
"__repr__", [](
DerivedTy &
self) {
1124 printAccum.
parts.append(DerivedTy::pyClassName);
1125 printAccum.
parts.append(
"(");
1128 printAccum.
parts.append(
")");
1129 return printAccum.
join();
1132 if (DerivedTy::getTypeIdFunction) {
1134 DerivedTy::getTypeIdFunction(),
1135 nanobind::cast<nanobind::callable>(
1141 DerivedTy::bindDerived(cls);
1172 : parentOperation(std::move(parentOperation)), value(value) {}
1173 operator MlirValue()
const {
return value; }
1175 MlirValue
get() {
return value; }
1200 operator MlirAffineExpr()
const {
return affineExpr; }
1201 MlirAffineExpr
get()
const {
return affineExpr; }
1219 MlirAffineExpr affineExpr;
1227 operator MlirAffineMap()
const {
return affineMap; }
1228 MlirAffineMap
get()
const {
return affineMap; }
1240 MlirAffineMap affineMap;
1248 operator MlirIntegerSet()
const {
return integerSet; }
1249 MlirIntegerSet
get()
const {
return integerSet; }
1260 MlirIntegerSet integerSet;
1281 void dunderDel(
const std::string &name);
1294 const std::string &visibility);
1299 const std::string &newSymbol,
1304 nanobind::object callback);
1307 operator MlirSymbolTable() {
return symbolTable; }
1311 MlirSymbolTable symbolTable;
1337 struct type_caster<
mlir::python::DefaultingPyMlirContext>
1340 struct type_caster<
mlir::python::DefaultingPyLocation>
#define MAKE_MLIR_PYTHON_QUALNAME(local)
static std::string diag(const llvm::Value &value)
Base class for all objects that directly or indirectly depend on an MlirContext.
PyMlirContextRef & getContext()
Accesses the context reference.
BaseContextObject(PyMlirContextRef ref)
Used in function arguments when None should resolve to the current context manager set instance.
static PyLocation & resolve()
static constexpr const char kTypeDescription[]
Used in function arguments when None should resolve to the current context manager set instance.
static constexpr const char kTypeDescription[]
static PyMlirContext & resolve()
CRTP template for special wrapper types that are allowed to be passed in as 'None' function arguments...
ReferrentTy * get() const
Defaulting()=default
Type casters require the type to be default constructible, but using such an instance is illegal.
Wrapper around MlirAffineExpr. Affine expressions are owned by the context.
nanobind::object getCapsule()
Gets a capsule wrapping the void* within the MlirAffineExpr.
static PyAffineExpr createFromCapsule(const nanobind::object &capsule)
Creates a PyAffineExpr from the MlirAffineExpr wrapped by a capsule.
PyAffineExpr(PyMlirContextRef contextRef, MlirAffineExpr affineExpr)
PyAffineExpr ceilDiv(const PyAffineExpr &other) const
PyAffineExpr mul(const PyAffineExpr &other) const
PyAffineExpr mod(const PyAffineExpr &other) const
PyAffineExpr floorDiv(const PyAffineExpr &other) const
bool operator==(const PyAffineExpr &other) const
PyAffineExpr add(const PyAffineExpr &other) const
MlirAffineExpr get() const
PyAffineMap(PyMlirContextRef contextRef, MlirAffineMap affineMap)
bool operator==(const PyAffineMap &other) const
nanobind::object getCapsule()
Gets a capsule wrapping the void* within the MlirAffineMap.
MlirAffineMap get() const
static PyAffineMap createFromCapsule(const nanobind::object &capsule)
Creates a PyAffineMap from the MlirAffineMap wrapped by a capsule.
Wrapper around an MlirAsmState.
PyAsmState(PyOperationBase &operation, bool useLocalScope)
PyAsmState(MlirValue value, bool useLocalScope)
PyAsmState(PyAsmState &other)=delete
PyAsmState(const PyAsmState &other)=delete
Wrapper around the generic MlirAttribute.
PyAttribute(PyMlirContextRef contextRef, MlirAttribute attr)
nanobind::object getCapsule()
Gets a capsule wrapping the void* within the MlirAttribute.
static PyAttribute createFromCapsule(nanobind::object capsule)
Creates a PyAttribute from the MlirAttribute wrapped by a capsule.
nanobind::object maybeDownCast()
MlirAttribute get() const
bool operator==(const PyAttribute &other) const
Wrapper around an MlirBlock.
PyOperationRef & getParentOperation()
nanobind::object getCapsule()
Gets a capsule wrapping the void* within the MlirBlock.
PyBlock(PyOperationRef parentOperation, MlirBlock block)
CRTP base classes for Python attributes that subclass Attribute and should be castable from it (i....
MlirTypeID(*)() GetTypeIDFunctionTy
static MlirAttribute castFrom(PyAttribute &orig)
nanobind::class_< DerivedTy, BaseTy > ClassTy
static constexpr GetTypeIDFunctionTy getTypeIdFunction
PyConcreteAttribute()=default
static void bind(nanobind::module_ &m, PyType_Slot *slots=nullptr)
bool(*)(MlirAttribute) IsAFunctionTy
PyConcreteAttribute(PyAttribute &orig)
PyConcreteAttribute(PyMlirContextRef contextRef, MlirAttribute attr)
static void bindDerived(ClassTy &m)
Implemented by derived classes to add methods to the Python subclass.
CRTP base classes for Python types that subclass Type and should be castable from it (i....
nanobind::class_< DerivedTy, BaseTy > ClassTy
static void bind(nanobind::module_ &m)
PyConcreteType(PyType &orig)
MlirTypeID(*)() GetTypeIDFunctionTy
bool(*)(MlirType) IsAFunctionTy
static void bindDerived(ClassTy &m)
Implemented by derived classes to add methods to the Python subclass.
static constexpr GetTypeIDFunctionTy getTypeIdFunction
PyConcreteType(PyMlirContextRef contextRef, MlirType t)
static MlirType castFrom(PyType &orig)
Represents a diagnostic handler attached to the context.
PyDiagnosticHandler(MlirContext context, nanobind::object callback)
nanobind::object contextEnter()
void detach()
Detaches the handler. Does nothing if not attached.
void contextExit(const nanobind::object &excType, const nanobind::object &excVal, const nanobind::object &excTb)
Python class mirroring the C MlirDiagnostic struct.
nanobind::tuple getNotes()
nanobind::str getMessage()
PyDiagnostic(MlirDiagnostic diagnostic)
MlirDiagnosticSeverity getSeverity()
Wrapper around an MlirDialect.
PyDialectDescriptor(PyMlirContextRef contextRef, MlirDialect dialect)
Wrapper around an MlirDialectRegistry.
PyDialectRegistry(PyDialectRegistry &&other) noexcept
nanobind::object getCapsule()
PyDialectRegistry(PyDialectRegistry &)=delete
static PyDialectRegistry createFromCapsule(nanobind::object capsule)
MlirDialectRegistry get() const
PyDialectRegistry(MlirDialectRegistry registry)
User-level dialect object.
PyDialect(nanobind::object descriptor)
nanobind::object getDescriptor()
User-level object for accessing dialects with dotted syntax such as: ctx.dialect.std.
PyDialects(PyMlirContextRef contextRef)
MlirDialect getDialectForKey(const std::string &key, bool attrError)
void registerTypeCaster(MlirTypeID mlirTypeID, nanobind::callable typeCaster, bool replace=false)
Adds a user-friendly type caster.
static PyGlobals & get()
Most code should get the globals via this static accessor.
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.
static PyInsertionPoint atBlockBegin(PyBlock &block)
Shortcut to create an insertion point at the beginning of the block.
void contextExit(const nanobind::object &excType, const nanobind::object &excVal, const nanobind::object &excTb)
static PyInsertionPoint after(PyOperationBase &op)
Shortcut to create an insertion point to the node after the specified operation.
PyInsertionPoint(const PyBlock &block)
Creates an insertion point positioned after the last operation in the block, but still inside the blo...
void insert(PyOperationBase &operationBase)
Inserts an operation.
std::optional< PyOperationRef > & getRefOperation()
static nanobind::object contextEnter(nanobind::object insertionPoint)
Enter and exit the context manager.
static PyIntegerSet createFromCapsule(const nanobind::object &capsule)
Creates a PyIntegerSet from the MlirAffineMap wrapped by a capsule.
MlirIntegerSet get() const
bool operator==(const PyIntegerSet &other) const
PyIntegerSet(PyMlirContextRef contextRef, MlirIntegerSet integerSet)
nanobind::object getCapsule()
Gets a capsule wrapping the void* within the MlirIntegerSet.
Wrapper around an MlirLocation.
nanobind::object getCapsule()
Gets a capsule wrapping the void* within the MlirLocation.
PyLocation(PyMlirContextRef contextRef, MlirLocation loc)
static PyLocation createFromCapsule(nanobind::object capsule)
Creates a PyLocation from the MlirLocation wrapped by a capsule.
void contextExit(const nanobind::object &excType, const nanobind::object &excVal, const nanobind::object &excTb)
static nanobind::object contextEnter(nanobind::object location)
Enter and exit the context manager.
PyMlirContext(const PyMlirContext &)=delete
PyMlirContext(PyMlirContext &&)=delete
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 size_t getLiveCount()
Gets the count of live context objects. Used for testing.
size_t getLiveModuleCount()
Gets the count of live modules associated with this context.
nanobind::object attachDiagnosticHandler(nanobind::object callback)
Attaches a Python callback as a diagnostic handler, returning a registration object (internally a PyD...
nanobind::object getCapsule()
Gets a capsule wrapping the void* within the MlirContext.
void contextExit(const nanobind::object &excType, const nanobind::object &excVal, const nanobind::object &excTb)
static PyMlirContextRef forContext(MlirContext context)
Returns a context reference for the singleton PyMlirContext wrapper for the given context.
static nanobind::object createFromCapsule(nanobind::object capsule)
Creates a PyMlirContext from the MlirContext wrapped by a capsule.
static nanobind::object contextEnter(nanobind::object context)
Enter and exit the context manager.
void setEmitErrorDiagnostics(bool value)
Controls whether error diagnostics should be propagated to diagnostic handlers, instead of being capt...
bool getEmitErrorDiagnostics()
MlirModule get()
Gets the backing MlirModule.
static PyModuleRef forModule(MlirModule module)
Returns a PyModule reference for the given MlirModule.
static nanobind::object createFromCapsule(nanobind::object capsule)
Creates a PyModule from the MlirModule wrapped by a capsule.
PyModuleRef getRef()
Gets a strong reference to this module.
nanobind::object getCapsule()
Gets a capsule wrapping the void* within the MlirModule.
PyModule(PyModule &)=delete
PyModule(PyMlirContext &&)=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
Template for a reference to a concrete type which captures a python reference to its underlying pytho...
nanobind::typed< nanobind::object, T > NBTypedT
nanobind::object getObject()
PyObjectRef(T *referrent, nanobind::object object)
nanobind::object releaseObject()
Releases the object held by this instance, returning it.
PyObjectRef(PyObjectRef &&other) noexcept
PyObjectRef(const PyObjectRef &other)
A PyOpView is equivalent to the C++ "Op" wrappers: these are the basis for providing more instance-sp...
static nanobind::object constructDerived(const nanobind::object &cls, const nanobind::object &operation)
Construct an instance of a class deriving from OpView, bypassing its __init__ method.
nanobind::object getOperationObject()
static nanobind::object buildGeneric(std::string_view name, std::tuple< int, bool > opRegionSpec, nanobind::object operandSegmentSpecObj, nanobind::object resultSegmentSpecObj, std::optional< nanobind::list > resultTypeList, nanobind::list operandList, std::optional< nanobind::dict > attributes, std::optional< std::vector< PyBlock * >> successors, std::optional< int > regions, PyLocation &location, const nanobind::object &maybeIp)
PyOpView(const nanobind::object &operationObject)
PyOperation & getOperation() override
Each must provide access to the raw Operation.
Base class for PyOperation and PyOpView which exposes the primary, user visible methods for manipulat...
void walk(std::function< MlirWalkResult(MlirOperation)> callback, MlirWalkOrder walkOrder)
bool isBeforeInBlock(PyOperationBase &other)
Given an operation 'other' that is within the same parent block, return whether the current operation...
virtual PyOperation & getOperation()=0
Each must provide access to the raw Operation.
nanobind::object getAsm(bool binary, std::optional< int64_t > largeElementsLimit, std::optional< int64_t > largeResourceLimit, bool enableDebugInfo, bool prettyDebugInfo, bool printGenericOpForm, bool useLocalScope, bool useNameLocAsPrefix, bool assumeVerified, bool skipRegions)
void print(PyAsmState &state, nanobind::object fileObject, bool binary)
virtual ~PyOperationBase()=default
void moveAfter(PyOperationBase &other)
Moves the operation before or after the other operation.
void print(std::optional< int64_t > largeElementsLimit, std::optional< int64_t > largeResourceLimit, bool enableDebugInfo, bool prettyDebugInfo, bool printGenericOpForm, bool useLocalScope, bool useNameLocAsPrefix, bool assumeVerified, nanobind::object fileObject, bool binary, bool skipRegions)
Implements the bound 'print' method and helps with others.
void writeBytecode(const nanobind::object &fileObject, std::optional< int64_t > bytecodeVersion)
void moveBefore(PyOperationBase &other)
bool verify()
Verify the operation.
void detachFromParent()
Detaches the operation from its parent block and updates its state accordingly.
PyOperation(PyMlirContextRef contextRef, MlirOperation operation)
void erase()
Erases the underlying MlirOperation, removes its pointer from the parent context's live operations ma...
nanobind::object getCapsule()
Gets a capsule wrapping the void* within the MlirOperation.
static PyOperationRef createDetached(PyMlirContextRef contextRef, MlirOperation operation, nanobind::object parentKeepAlive=nanobind::object())
Creates a detached operation.
nanobind::object clone(const nanobind::object &ip)
Clones this operation.
PyOperation & getOperation() override
Each must provide access to the raw Operation.
static nanobind::object createFromCapsule(nanobind::object capsule)
Creates a PyOperation from the MlirOperation wrapped by a capsule.
MlirOperation get() const
static PyOperationRef forOperation(PyMlirContextRef contextRef, MlirOperation operation, nanobind::object parentKeepAlive=nanobind::object())
Returns a PyOperation for the given MlirOperation, optionally associating it with a parentKeepAlive.
void setAttached(const nanobind::object &parent=nanobind::object())
std::optional< PyOperationRef > getParentOperation()
Gets the parent operation or raises an exception if the operation has no parent.
static nanobind::object create(std::string_view name, std::optional< std::vector< PyType * >> results, llvm::ArrayRef< MlirValue > operands, std::optional< nanobind::dict > attributes, std::optional< std::vector< PyBlock * >> successors, int regions, PyLocation &location, const nanobind::object &ip, bool inferType)
Creates an operation. See corresponding python docstring.
nanobind::object createOpView()
Creates an OpView suitable for this operation.
PyBlock getBlock()
Gets the owning block or raises an exception if the operation has no owning block.
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.
void setInvalid()
Invalidate the operation.
Wrapper around an MlirRegion.
PyRegion(PyOperationRef parentOperation, MlirRegion region)
PyOperationRef & getParentOperation()
static constexpr GetTypeIDFunctionTy getTypeIdFunction
static constexpr IsAFunctionTy isaFunction
static constexpr const char * pyClassName
static void bindDerived(ClassTy &c)
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 walkSymbolTables(PyOperationBase &from, bool allSymUsesVisible, nanobind::object callback)
Walks all symbol tables under and including 'from'.
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)
~PySymbolTable()
Destroys the symbol table.
PyStringAttribute 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 PyStringAttribute getSymbolName(PyOperationBase &symbol)
Gets and sets the name of a symbol op.
static PyStringAttribute getVisibility(PyOperationBase &symbol)
Gets and sets the visibility of a symbol op.
nanobind::object dunderGetItem(const std::string &name)
Returns the symbol (opview) with the given name, throws if there is no such symbol in the table.
Tracks an entry in the thread context stack.
static PyThreadContextEntry * getTopOfStack()
Stack management.
static void popLocation(PyLocation &location)
static nanobind::object pushLocation(nanobind::object location)
PyLocation * getLocation()
static nanobind::object pushContext(nanobind::object context)
static PyLocation * getDefaultLocation()
Gets the top of stack location and returns nullptr if not defined.
static void popInsertionPoint(PyInsertionPoint &insertionPoint)
static nanobind::object pushInsertionPoint(nanobind::object insertionPoint)
static void popContext(PyMlirContext &context)
static PyInsertionPoint * getDefaultInsertionPoint()
Gets the top of stack insertion point and return nullptr if not defined.
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.
PyThreadContextEntry(FrameKind frameKind, nanobind::object context, nanobind::object insertionPoint, nanobind::object location)
PyInsertionPoint * getInsertionPoint()
Wrapper around MlirLlvmThreadPool Python object owns the C++ thread pool.
std::string _mlir_thread_pool_ptr() const
PyThreadPool(const PyThreadPool &)=delete
int getMaxConcurrency() const
PyThreadPool(PyThreadPool &&)=delete
A TypeID provides an efficient and unique identifier for a specific C++ type.
static PyTypeID createFromCapsule(nanobind::object capsule)
Creates a PyTypeID from the MlirTypeID wrapped by a capsule.
bool operator==(const PyTypeID &other) const
nanobind::object getCapsule()
Gets a capsule wrapping the void* within the MlirTypeID.
PyTypeID(MlirTypeID typeID)
Wrapper around the generic MlirType.
PyType(PyMlirContextRef contextRef, MlirType type)
nanobind::object getCapsule()
Gets a capsule wrapping the void* within the MlirType.
static PyType createFromCapsule(nanobind::object capsule)
Creates a PyType from the MlirType wrapped by a capsule.
nanobind::object maybeDownCast()
bool operator==(const PyType &other) const
Wrapper around the generic MlirValue.
PyValue(PyOperationRef parentOperation, MlirValue value)
static PyValue createFromCapsule(nanobind::object capsule)
Creates a PyValue from the MlirValue wrapped by a capsule.
nanobind::object maybeDownCast()
nanobind::object getCapsule()
Gets a capsule wrapping the void* within the MlirValue.
virtual ~PyValue()=default
PyOperationRef & getParentOperation()
MlirDiagnosticSeverity
Severity of a diagnostic.
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.
MlirDiagnostic wrap(mlir::Diagnostic &diagnostic)
MLIR_CAPI_EXPORTED MlirTypeID mlirStringAttrGetTypeID(void)
Returns the typeID of a String attribute.
MLIR_CAPI_EXPORTED bool mlirAttributeIsAString(MlirAttribute attr)
Checks whether the given attribute is a string attribute.
MlirWalkOrder
Traversal order for operation walk.
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags)
Use local scope when printing the operation.
MLIR_CAPI_EXPORTED void mlirDialectRegistryDestroy(MlirDialectRegistry registry)
Takes a dialect registry owned by the caller and destroys it.
MLIR_CAPI_EXPORTED MlirType mlirAttributeGetType(MlirAttribute attribute)
Gets the type of this attribute.
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 mlirAttributePrint(MlirAttribute attr, MlirStringCallback callback, void *userData)
Prints an attribute by sending chunks of the string representation and forwarding userData tocallback...
MlirWalkResult
Operation walk result.
MLIR_CAPI_EXPORTED MlirAsmState mlirAsmStateCreateForOperation(MlirOperation op, MlirOpPrintingFlags flags)
Creates new AsmState, as with AsmState the IR should not be mutated in-between using this state.
static bool mlirBlockIsNull(MlirBlock block)
Checks whether a block is null.
MLIR_CAPI_EXPORTED void mlirSymbolTableDestroy(MlirSymbolTable symbolTable)
Destroys the symbol table created with mlirSymbolTableCreate.
static bool mlirDialectRegistryIsNull(MlirDialectRegistry registry)
Checks if the dialect registry is null.
static bool mlirRegionIsNull(MlirRegion region)
Checks whether a region is null.
MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsDestroy(MlirOpPrintingFlags flags)
Destroys printing flags created with mlirOpPrintingFlagsCreate.
MLIR_CAPI_EXPORTED MlirDialectRegistry mlirDialectRegistryCreate(void)
Creates a dialect registry and transfers its ownership to the caller.
MLIR_CAPI_EXPORTED void mlirOperationRemoveFromParent(MlirOperation op)
Removes the given operation from its parent block.
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.
PyObjectRef< PyMlirContext > PyMlirContextRef
Wrapper around MlirContext.
void populateIRAttributes(nanobind::module_ &m)
void populateIRInterfaces(nb::module_ &m)
PyObjectRef< PyModule > PyModuleRef
void populateIRAffine(nanobind::module_ &m)
void populateIRTypes(nanobind::module_ &m)
void populateIRCore(nanobind::module_ &m)
PyObjectRef< PyOperation > PyOperationRef
Include the generated interface declarations.
An opaque reference to a diagnostic, always owned by the diagnostics engine (context).
A logical result value, essentially a boolean with named states.
Accumulates into a python string from a method that accepts an MlirStringCallback.
MlirStringCallback getCallback()
Custom exception that allows access to error diagnostic information.
MLIRError(llvm::Twine message, std::vector< PyDiagnostic::DiagnosticInfo > &&errorDiagnostics={})
std::vector< PyDiagnostic::DiagnosticInfo > errorDiagnostics
Materialized diagnostic information.
MlirDiagnosticSeverity severity
std::vector< DiagnosticInfo > notes
RAII object that captures any error diagnostics emitted to the provided context.
std::vector< PyDiagnostic::DiagnosticInfo > take()
ErrorCapture(PyMlirContextRef ctx)