9 #ifndef MLIR_BINDINGS_PYTHON_IRMODULES_H
10 #define MLIR_BINDINGS_PYTHON_IRMODULES_H
23 #include "llvm/ADT/DenseMap.h"
30 class PyDiagnosticHandler;
31 class PyInsertionPoint;
33 class DefaultingPyLocation;
35 class DefaultingPyMlirContext;
48 : referrent(referrent), object(std::move(object)) {
49 assert(this->referrent &&
50 "cannot construct PyObjectRef with null referrent");
51 assert(this->
object &&
"cannot construct PyObjectRef with null object");
54 : referrent(other.referrent), object(std::move(other.object)) {
55 other.referrent =
nullptr;
56 assert(!other.object);
59 : referrent(other.referrent), object(other.object ) {}
65 return object.ref_count();
72 assert(referrent &&
object);
74 auto stolen = std::move(
object);
78 T *
get() {
return referrent; }
80 assert(referrent &&
object);
84 assert(referrent &&
object);
87 operator bool()
const {
return referrent && object; }
91 pybind11::object object;
111 pybind11::object insertionPoint,
112 pybind11::object location)
113 : context(std::move(context)), insertionPoint(std::move(insertionPoint)),
114 location(std::move(location)), frameKind(frameKind) {}
140 static std::vector<PyThreadContextEntry> &
getStack();
143 static void push(
FrameKind frameKind, pybind11::object context,
144 pybind11::object insertionPoint, pybind11::object location);
147 pybind11::object context;
149 pybind11::object insertionPoint;
151 pybind11::object location;
180 MlirContext
get() {
return context; }
217 const pybind11::object &excVal,
218 const pybind11::object &excTb);
238 static LiveContextMap &getLiveContexts();
244 using LiveModuleMap =
246 LiveModuleMap liveModules;
252 using LiveOperationMap =
254 LiveOperationMap liveOperations;
256 bool emitErrorDiagnostics =
false;
266 :
public Defaulting<DefaultingPyMlirContext, PyMlirContext> {
280 assert(this->contextRef &&
281 "context object constructed with null context ref");
297 operator MlirLocation()
const {
return loc; }
298 MlirLocation
get()
const {
return loc; }
303 const pybind11::object &excVal,
304 const pybind11::object &excTb);
350 std::optional<pybind11::tuple> materializedNotes;
386 const pybind11::object &excVal,
387 const pybind11::object &excTb) {
393 pybind11::object callback;
394 std::optional<MlirDiagnosticHandlerID> registeredID;
395 bool hadError =
false;
404 ctx->
get(), handler, this,
408 assert(errors.empty() &&
"unhandled captured errors");
411 std::vector<PyDiagnostic::DiagnosticInfo>
take() {
412 return std::move(errors);
418 std::vector<PyDiagnostic::DiagnosticInfo> errors;
433 MlirDialect
get() {
return dialect; }
454 PyDialect(pybind11::object descriptor) : descriptor(std::move(descriptor)) {}
459 pybind11::object descriptor;
475 other.registry = {
nullptr};
478 operator MlirDialectRegistry()
const {
return registry; }
479 MlirDialectRegistry
get()
const {
return registry; }
485 MlirDialectRegistry registry;
491 :
public Defaulting<DefaultingPyLocation, PyLocation> {
497 operator MlirLocation()
const {
return *
get(); }
514 MlirModule
get() {
return module; }
519 pybind11::reinterpret_borrow<pybind11::object>(handle));
537 pybind11::handle handle;
546 void print(pybind11::object fileObject,
bool binary,
547 std::optional<int64_t> largeElementsLimit,
bool enableDebugInfo,
548 bool prettyDebugInfo,
bool printGenericOpForm,
bool useLocalScope,
549 bool assumeVerified);
550 pybind11::object
getAsm(
bool binary,
551 std::optional<int64_t> largeElementsLimit,
552 bool enableDebugInfo,
bool prettyDebugInfo,
553 bool printGenericOpForm,
bool useLocalScope,
554 bool assumeVerified);
588 pybind11::object parentKeepAlive = pybind11::object());
594 pybind11::object parentKeepAlive = pybind11::object());
599 const std::string &sourceStr,
600 const std::string &sourceName);
607 parentKeepAlive = pybind11::object();
611 operator MlirOperation()
const {
return get(); }
612 MlirOperation
get()
const {
619 this, pybind11::reinterpret_borrow<pybind11::object>(handle));
623 void setAttached(
const pybind11::object &parent = pybind11::object()) {
624 assert(!attached &&
"operation already attached");
628 assert(attached &&
"operation already detached");
650 static pybind11::object
651 create(
const std::string &name, std::optional<std::vector<PyType *>> results,
652 std::optional<std::vector<PyValue *>> operands,
653 std::optional<pybind11::dict> attributes,
654 std::optional<std::vector<PyBlock *>> successors,
int regions,
668 pybind11::object
clone(
const pybind11::object &ip);
673 MlirOperation operation,
674 pybind11::object parentKeepAlive);
676 MlirOperation operation;
677 pybind11::handle handle;
684 pybind11::object parentKeepAlive;
685 bool attached =
true;
699 PyOpView(
const pybind11::object &operationObject);
704 static pybind11::object
705 buildGeneric(
const pybind11::object &cls, pybind11::list resultTypeList,
706 pybind11::list operandList,
707 std::optional<pybind11::dict> attributes,
708 std::optional<std::vector<PyBlock *>> successors,
710 const pybind11::object &maybeIp);
724 pybind11::object operationObject;
733 : parentOperation(std::move(parentOperation)), region(region) {
736 operator MlirRegion()
const {
return region; }
738 MlirRegion
get() {
return region; }
754 : parentOperation(std::move(parentOperation)), block(block) {
758 MlirBlock
get() {
return block; }
791 const pybind11::object &excVal,
792 const pybind11::object &excTb);
800 : refOperation(std::move(refOperation)), block(std::move(block)) {}
802 std::optional<PyOperationRef> refOperation;
812 operator MlirType()
const {
return type; }
813 MlirType
get()
const {
return type; }
833 template <
typename DerivedTy,
typename BaseTy = PyType>
839 using ClassTy = pybind11::class_<DerivedTy, BaseTy>;
844 : BaseTy(std::move(contextRef), t) {}
849 if (!DerivedTy::isaFunction(orig)) {
850 auto origRepr = pybind11::repr(pybind11::cast(orig)).cast<std::string>();
851 throw SetPyError(PyExc_ValueError, llvm::Twine(
"Cannot cast type to ") +
852 DerivedTy::pyClassName +
853 " (from " + origRepr +
")");
858 static void bind(pybind11::module &m) {
859 auto cls =
ClassTy(m, DerivedTy::pyClassName, pybind11::module_local());
860 cls.def(pybind11::init<PyType &>(), pybind11::keep_alive<0, 1>(),
861 pybind11::arg(
"cast_from_type"));
864 [](
PyType &otherType) ->
bool {
865 return DerivedTy::isaFunction(otherType);
867 pybind11::arg(
"other"));
868 DerivedTy::bindDerived(cls);
882 operator MlirAttribute()
const {
return attr; }
883 MlirAttribute
get()
const {
return attr; }
918 std::unique_ptr<std::string> ownedName;
926 template <
typename DerivedTy,
typename BaseTy = PyAttribute>
932 using ClassTy = pybind11::class_<DerivedTy, BaseTy>;
937 : BaseTy(std::move(contextRef), attr) {}
942 if (!DerivedTy::isaFunction(orig)) {
943 auto origRepr = pybind11::repr(pybind11::cast(orig)).cast<std::string>();
945 llvm::Twine(
"Cannot cast attribute to ") +
946 DerivedTy::pyClassName +
" (from " + origRepr +
")");
951 static void bind(pybind11::module &m) {
952 auto cls =
ClassTy(m, DerivedTy::pyClassName, pybind11::buffer_protocol(),
953 pybind11::module_local());
954 cls.def(pybind11::init<PyAttribute &>(), pybind11::keep_alive<0, 1>(),
955 pybind11::arg(
"cast_from_attr"));
959 return DerivedTy::isaFunction(otherAttr);
961 pybind11::arg(
"other"));
962 cls.def_property_readonly(
"type", [](
PyAttribute &attr) {
965 DerivedTy::bindDerived(cls);
981 : parentOperation(std::move(parentOperation)), value(value) {}
982 operator MlirValue()
const {
return value; }
984 MlirValue
get() {
return value; }
1007 operator MlirAffineExpr()
const {
return affineExpr; }
1008 MlirAffineExpr
get()
const {
return affineExpr; }
1026 MlirAffineExpr affineExpr;
1034 operator MlirAffineMap()
const {
return affineMap; }
1035 MlirAffineMap
get()
const {
return affineMap; }
1047 MlirAffineMap affineMap;
1055 operator MlirIntegerSet()
const {
return integerSet; }
1056 MlirIntegerSet
get()
const {
return integerSet; }
1067 MlirIntegerSet integerSet;
1088 void dunderDel(
const std::string &name);
1101 const std::string &visibility);
1106 const std::string &newSymbol,
1111 pybind11::object callback);
1114 operator MlirSymbolTable() {
return symbolTable; }
1118 MlirSymbolTable symbolTable;
1144 struct type_caster<
mlir::python::DefaultingPyMlirContext>
1147 struct type_caster<
mlir::python::DefaultingPyLocation>
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.
static PyAffineExpr createFromCapsule(pybind11::object capsule)
Creates a PyAffineExpr from the MlirAffineExpr wrapped by a capsule.
pybind11::object getCapsule()
Gets a capsule wrapping the void* within the MlirAffineExpr.
PyAffineExpr(PyMlirContextRef contextRef, MlirAffineExpr affineExpr)
PyAffineExpr ceilDiv(const PyAffineExpr &other) const
PyAffineExpr mul(const PyAffineExpr &other) const
bool operator==(const PyAffineExpr &other)
PyAffineExpr mod(const PyAffineExpr &other) const
PyAffineExpr floorDiv(const PyAffineExpr &other) const
PyAffineExpr add(const PyAffineExpr &other) const
MlirAffineExpr get() const
bool operator==(const PyAffineMap &other)
pybind11::object getCapsule()
Gets a capsule wrapping the void* within the MlirAffineMap.
PyAffineMap(PyMlirContextRef contextRef, MlirAffineMap affineMap)
MlirAffineMap get() const
static PyAffineMap createFromCapsule(pybind11::object capsule)
Creates a PyAffineMap from the MlirAffineMap wrapped by a capsule.
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.
bool operator==(const PyAttribute &other)
pybind11::object getCapsule()
Gets a capsule wrapping the void* within the MlirAttribute.
MlirAttribute get() const
Wrapper around an MlirBlock.
PyOperationRef & getParentOperation()
PyBlock(PyOperationRef parentOperation, MlirBlock block)
CRTP base classes for Python attributes that subclass Attribute and should be castable from it (i....
pybind11::class_< DerivedTy, BaseTy > ClassTy
static MlirAttribute castFrom(PyAttribute &orig)
static void bind(pybind11::module &m)
PyConcreteAttribute()=default
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....
static void bind(pybind11::module &m)
pybind11::class_< DerivedTy, BaseTy > ClassTy
PyConcreteType(PyType &orig)
bool(*)(MlirType) IsAFunctionTy
static void bindDerived(ClassTy &m)
Implemented by derived classes to add methods to the Python subclass.
PyConcreteType(PyMlirContextRef contextRef, MlirType t)
static MlirType castFrom(PyType &orig)
Represents a diagnostic handler attached to the context.
void contextExit(const pybind11::object &excType, const pybind11::object &excVal, const pybind11::object &excTb)
void detach()
Detaches the handler. Does nothing if not attached.
PyDiagnosticHandler(MlirContext context, pybind11::object callback)
pybind11::object contextEnter()
Python class mirroring the C MlirDiagnostic struct.
pybind11::str getMessage()
PyDiagnostic(MlirDiagnostic diagnostic)
MlirDiagnosticSeverity getSeverity()
pybind11::tuple getNotes()
Wrapper around an MlirDialect.
PyDialectDescriptor(PyMlirContextRef contextRef, MlirDialect dialect)
Wrapper around an MlirDialectRegistry.
PyDialectRegistry(PyDialectRegistry &)=delete
static PyDialectRegistry createFromCapsule(pybind11::object capsule)
MlirDialectRegistry get() const
pybind11::object getCapsule()
PyDialectRegistry(MlirDialectRegistry registry)
PyDialectRegistry(PyDialectRegistry &&other)
User-level dialect object.
PyDialect(pybind11::object descriptor)
pybind11::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)
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.
static PyIntegerSet createFromCapsule(pybind11::object capsule)
Creates a PyIntegerSet from the MlirAffineMap wrapped by a capsule.
bool operator==(const PyIntegerSet &other)
MlirIntegerSet get() const
pybind11::object getCapsule()
Gets a capsule wrapping the void* within the MlirIntegerSet.
PyIntegerSet(PyMlirContextRef contextRef, MlirIntegerSet integerSet)
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...
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 pybind11::object createFromCapsule(pybind11::object capsule)
Creates a PyMlirContext from the MlirContext wrapped by a capsule.
static size_t getLiveCount()
Gets the count of live context objects. Used for testing.
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.
void contextExit(const pybind11::object &excType, const pybind11::object &excVal, const pybind11::object &excTb)
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.
void setEmitErrorDiagnostics(bool value)
Controls whether error diagnostics should be propagated to diagnostic handlers, instead of being capt...
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.
PyModuleRef getRef()
Gets a strong reference to this module.
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...
PyObjectRef(T *referrent, pybind11::object object)
pybind11::object getObject()
pybind11::object releaseObject()
Releases the object held by this instance, returning it.
PyObjectRef(PyObjectRef &&other)
PyObjectRef(const PyObjectRef &other)
A PyOpView is equivalent to the C++ "Op" wrappers: these are the basis for providing more instance-sp...
PyOpView(const pybind11::object &operationObject)
pybind11::object getOperationObject()
static pybind11::object constructDerived(const pybind11::object &cls, const PyOperation &operation)
Construct an instance of a class deriving from OpView, bypassing its __init__ method.
static pybind11::object buildGeneric(const pybind11::object &cls, 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)
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...
virtual PyOperation & getOperation()=0
Each must provide access to the raw Operation.
pybind11::object getAsm(bool binary, std::optional< int64_t > largeElementsLimit, bool enableDebugInfo, bool prettyDebugInfo, bool printGenericOpForm, bool useLocalScope, bool assumeVerified)
virtual ~PyOperationBase()=default
void print(pybind11::object fileObject, bool binary, std::optional< int64_t > largeElementsLimit, bool enableDebugInfo, bool prettyDebugInfo, bool printGenericOpForm, bool useLocalScope, bool assumeVerified)
Implements the bound 'print' method and helps with others.
void moveAfter(PyOperationBase &other)
Moves the operation before or after the other operation.
void moveBefore(PyOperationBase &other)
bool verify()
Verify the operation.
void writeBytecode(const pybind11::object &fileObject)
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.
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)
Creates an operation. See corresponding python docstring.
MlirOperation get() const
void setAttached(const pybind11::object &parent=pybind11::object())
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.
void setInvalid()
Invalidate the operation.
Wrapper around an MlirRegion.
PyRegion(PyOperationRef parentOperation, MlirRegion region)
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 ...
PyAttribute insert(PyOperationBase &symbol)
Inserts the given operation into the symbol table.
static PyAttribute getSymbolName(PyOperationBase &symbol)
Gets and sets the name of a symbol op.
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.
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.
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 void walkSymbolTables(PyOperationBase &from, bool allSymUsesVisible, pybind11::object callback)
Walks all symbol tables under and including 'from'.
static PyAttribute getVisibility(PyOperationBase &symbol)
Gets and sets the visibility of a symbol op.
Tracks an entry in the thread context stack.
static PyThreadContextEntry * getTopOfStack()
Stack management.
static void popLocation(PyLocation &location)
PyLocation * getLocation()
PyThreadContextEntry(FrameKind frameKind, pybind11::object context, pybind11::object insertionPoint, pybind11::object location)
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()
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.
bool operator==(const PyType &other)
PyType(PyMlirContextRef contextRef, MlirType type)
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.
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.
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.
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 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.
void populateIRAttributes(pybind11::module &m)
void populateIRTypes(pybind11::module &m)
PyObjectRef< PyMlirContext > PyMlirContextRef
Wrapper around MlirContext.
void populateIRAffine(pybind11::module &m)
PyObjectRef< PyModule > PyModuleRef
pybind11::error_already_set SetPyError(PyObject *excClass, const llvm::Twine &message)
void populateIRCore(pybind11::module &m)
PyObjectRef< PyOperation > PyOperationRef
void populateIRInterfaces(py::module &m)
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.
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)