mlir.dialects._index_ops_gen ============================ .. py:module:: mlir.dialects._index_ops_gen Attributes ---------- .. autoapisummary:: mlir.dialects._index_ops_gen._ods_ir mlir.dialects._index_ops_gen._Buffer Classes ------- .. autoapisummary:: mlir.dialects._index_ops_gen._Dialect mlir.dialects._index_ops_gen.AddOp mlir.dialects._index_ops_gen.AddOpAdaptor mlir.dialects._index_ops_gen.AndOp mlir.dialects._index_ops_gen.AndOpAdaptor mlir.dialects._index_ops_gen.BoolConstantOp mlir.dialects._index_ops_gen.BoolConstantOpAdaptor mlir.dialects._index_ops_gen.CastSOp mlir.dialects._index_ops_gen.CastSOpAdaptor mlir.dialects._index_ops_gen.CastUOp mlir.dialects._index_ops_gen.CastUOpAdaptor mlir.dialects._index_ops_gen.CeilDivSOp mlir.dialects._index_ops_gen.CeilDivSOpAdaptor mlir.dialects._index_ops_gen.CeilDivUOp mlir.dialects._index_ops_gen.CeilDivUOpAdaptor mlir.dialects._index_ops_gen.CmpOp mlir.dialects._index_ops_gen.CmpOpAdaptor mlir.dialects._index_ops_gen.ConstantOp mlir.dialects._index_ops_gen.ConstantOpAdaptor mlir.dialects._index_ops_gen.DivSOp mlir.dialects._index_ops_gen.DivSOpAdaptor mlir.dialects._index_ops_gen.DivUOp mlir.dialects._index_ops_gen.DivUOpAdaptor mlir.dialects._index_ops_gen.FloorDivSOp mlir.dialects._index_ops_gen.FloorDivSOpAdaptor mlir.dialects._index_ops_gen.MaxSOp mlir.dialects._index_ops_gen.MaxSOpAdaptor mlir.dialects._index_ops_gen.MaxUOp mlir.dialects._index_ops_gen.MaxUOpAdaptor mlir.dialects._index_ops_gen.MinSOp mlir.dialects._index_ops_gen.MinSOpAdaptor mlir.dialects._index_ops_gen.MinUOp mlir.dialects._index_ops_gen.MinUOpAdaptor mlir.dialects._index_ops_gen.MulOp mlir.dialects._index_ops_gen.MulOpAdaptor mlir.dialects._index_ops_gen.OrOp mlir.dialects._index_ops_gen.OrOpAdaptor mlir.dialects._index_ops_gen.RemSOp mlir.dialects._index_ops_gen.RemSOpAdaptor mlir.dialects._index_ops_gen.RemUOp mlir.dialects._index_ops_gen.RemUOpAdaptor mlir.dialects._index_ops_gen.ShlOp mlir.dialects._index_ops_gen.ShlOpAdaptor mlir.dialects._index_ops_gen.ShrSOp mlir.dialects._index_ops_gen.ShrSOpAdaptor mlir.dialects._index_ops_gen.ShrUOp mlir.dialects._index_ops_gen.ShrUOpAdaptor mlir.dialects._index_ops_gen.SizeOfOp mlir.dialects._index_ops_gen.SizeOfOpAdaptor mlir.dialects._index_ops_gen.SubOp mlir.dialects._index_ops_gen.SubOpAdaptor mlir.dialects._index_ops_gen.XOrOp mlir.dialects._index_ops_gen.XOrOpAdaptor Functions --------- .. autoapisummary:: mlir.dialects._index_ops_gen.add mlir.dialects._index_ops_gen.and_ mlir.dialects._index_ops_gen.bool_constant mlir.dialects._index_ops_gen.casts mlir.dialects._index_ops_gen.castu mlir.dialects._index_ops_gen.ceildivs mlir.dialects._index_ops_gen.ceildivu mlir.dialects._index_ops_gen.cmp mlir.dialects._index_ops_gen.constant mlir.dialects._index_ops_gen.divs mlir.dialects._index_ops_gen.divu mlir.dialects._index_ops_gen.floordivs mlir.dialects._index_ops_gen.maxs mlir.dialects._index_ops_gen.maxu mlir.dialects._index_ops_gen.mins mlir.dialects._index_ops_gen.minu mlir.dialects._index_ops_gen.mul mlir.dialects._index_ops_gen.or_ mlir.dialects._index_ops_gen.rems mlir.dialects._index_ops_gen.remu mlir.dialects._index_ops_gen.shl mlir.dialects._index_ops_gen.shrs mlir.dialects._index_ops_gen.shru mlir.dialects._index_ops_gen.sizeof mlir.dialects._index_ops_gen.sub mlir.dialects._index_ops_gen.xor Module Contents --------------- .. py:data:: _ods_ir .. py:data:: _Buffer .. py:class:: _Dialect(descriptor: object) Bases: :py:obj:`_ods_ir` .. py:attribute:: DIALECT_NAMESPACE :value: 'index' .. py:class:: AddOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.add`` operation takes two index values and computes their sum. Example: .. code:: mlir // c = a + b %c = index.add %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.add' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: AddOpAdaptor(operands: list[Value], attributes: OpAttributeMap) AddOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.add' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: add(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: AndOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.and`` operation takes two index values and computes their bitwise and. Example: .. code:: mlir // c = a & b %c = index.and %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.and' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: AndOpAdaptor(operands: list[Value], attributes: OpAttributeMap) AndOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.and' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: and_(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: BoolConstantOp(value: Union[bool, _ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.bool.constant`` operation produces an bool-typed SSA value equal to either ``true`` or ``false``. This operation is used to materialize bool constants that arise when folding ``index.cmp``. Example: .. code:: mlir %0 = index.bool.constant true .. py:attribute:: OPERATION_NAME :value: 'index.bool.constant' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: value() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: BoolConstantOpAdaptor(operands: list[Value], attributes: OpAttributeMap) BoolConstantOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.bool.constant' .. py:method:: value() -> _ods_ir .. py:function:: bool_constant(value: Union[bool, _ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: CastSOp(output: _ods_ir, input: _ods_ir, *, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.casts`` operation enables conversions between values of index type and concrete fixed-width integer types. If casting to a wider integer, the value is sign-extended. If casting to a narrower integer, the value is truncated. Example: .. code:: mlir // Cast to i32 %0 = index.casts %a : index to i32 // Cast from i64 %1 = index.casts %b : i64 to index .. py:attribute:: OPERATION_NAME :value: 'index.casts' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: input() -> _ods_ir .. py:method:: output() -> _ods_ir .. py:class:: CastSOpAdaptor(operands: list[Value], attributes: OpAttributeMap) CastSOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.casts' .. py:method:: input() -> _ods_ir .. py:function:: casts(output: _ods_ir, input: _ods_ir, *, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir .. py:class:: CastUOp(output: _ods_ir, input: _ods_ir, *, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.castu`` operation enables conversions between values of index type and concrete fixed-width integer types. If casting to a wider integer, the value is zero-extended. If casting to a narrower integer, the value is truncated. Example: .. code:: mlir // Cast to i32 %0 = index.castu %a : index to i32 // Cast from i64 %1 = index.castu %b : i64 to index .. py:attribute:: OPERATION_NAME :value: 'index.castu' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: input() -> _ods_ir .. py:method:: output() -> _ods_ir .. py:class:: CastUOpAdaptor(operands: list[Value], attributes: OpAttributeMap) CastUOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.castu' .. py:method:: input() -> _ods_ir .. py:function:: castu(output: _ods_ir, input: _ods_ir, *, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir .. py:class:: CeilDivSOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.ceildivs`` operation takes two index values and computes their signed quotient. Treats the leading bit as the sign and rounds towards positive infinity, i.e. ``7 / -2 = -3``. Note: division by zero and signed division overflow are undefined behaviour. Example: .. code:: mlir // c = ceil(a / b) %c = index.ceildivs %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.ceildivs' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: CeilDivSOpAdaptor(operands: list[Value], attributes: OpAttributeMap) CeilDivSOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.ceildivs' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: ceildivs(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: CeilDivUOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.ceildivu`` operation takes two index values and computes their unsigned quotient. Treats the leading bit as the most significant and rounds towards positive infinity, i.e. ``6 / -2 = 1``. Note: division by zero is undefined behaviour. Example: .. code:: mlir // c = ceil(a / b) %c = index.ceildivu %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.ceildivu' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: CeilDivUOpAdaptor(operands: list[Value], attributes: OpAttributeMap) CeilDivUOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.ceildivu' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: ceildivu(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: CmpOp(pred: Union[Any, _ods_ir], lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.cmp`` operation takes two index values and compares them according to the comparison predicate and returns an ``i1``. The following comparisons are supported: * ``eq``: equal * ``ne``: not equal * ``slt``: signed less than * ``sle``: signed less than or equal * ``sgt``: signed greater than * ``sge``: signed greater than or equal * ``ult``: unsigned less than * ``ule``: unsigned less than or equal * ``ugt``: unsigned greater than * ``uge``: unsigned greater than or equal The result is ``1`` if the comparison is true and ``0`` otherwise. Example: .. code:: mlir // Signed less than comparison. %0 = index.cmp slt(%a, %b) // Unsigned greater than or equal comparison. %1 = index.cmp uge(%a, %b) // Not equal comparison. %2 = index.cmp ne(%a, %b) .. py:attribute:: OPERATION_NAME :value: 'index.cmp' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: pred() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: CmpOpAdaptor(operands: list[Value], attributes: OpAttributeMap) CmpOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.cmp' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: pred() -> _ods_ir .. py:function:: cmp(pred: Union[Any, _ods_ir], lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: ConstantOp(value: Union[int, _ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.constant`` operation produces an index-typed SSA value equal to some index-typed integer constant. Example: .. code:: mlir %0 = index.constant 42 .. py:attribute:: OPERATION_NAME :value: 'index.constant' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: value() -> _ods_ir .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: ConstantOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ConstantOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.constant' .. py:method:: value() -> _ods_ir .. py:function:: constant(value: Union[int, _ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: DivSOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.divs`` operation takes two index values and computes their signed quotient. Treats the leading bit as the sign and rounds towards zero, i.e. ``6 / -2 = -3``. Note: division by zero and signed division overflow are undefined behaviour. Example: .. code:: mlir // c = a / b %c = index.divs %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.divs' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: DivSOpAdaptor(operands: list[Value], attributes: OpAttributeMap) DivSOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.divs' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: divs(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: DivUOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.divu`` operation takes two index values and computes their unsigned quotient. Treats the leading bit as the most significant and rounds towards zero, i.e. ``6 / -2 = 0``. Note: division by zero is undefined behaviour. Example: .. code:: mlir // c = a / b %c = index.divu %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.divu' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: DivUOpAdaptor(operands: list[Value], attributes: OpAttributeMap) DivUOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.divu' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: divu(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: FloorDivSOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.floordivs`` operation takes two index values and computes their signed quotient. Treats the leading bit as the sign and rounds towards negative infinity, i.e. ``5 / -2 = -3``. Note: division by zero and signed division overflow are undefined behaviour. Example: .. code:: mlir // c = floor(a / b) %c = index.floordivs %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.floordivs' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: FloorDivSOpAdaptor(operands: list[Value], attributes: OpAttributeMap) FloorDivSOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.floordivs' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: floordivs(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: MaxSOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.maxs`` operation takes two index values and computes their signed maximum value. Treats the leading bit as the sign, i.e. ``max(-2, 6) = 6``. Example: .. code:: mlir // c = max(a, b) %c = index.maxs %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.maxs' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: MaxSOpAdaptor(operands: list[Value], attributes: OpAttributeMap) MaxSOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.maxs' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: maxs(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: MaxUOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.maxu`` operation takes two index values and computes their unsigned maximum value. Treats the leading bit as the most significant, i.e. ``max(15, 6) = 15`` or ``max(-2, 6) = -2``. Example: .. code:: mlir // c = max(a, b) %c = index.maxu %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.maxu' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: MaxUOpAdaptor(operands: list[Value], attributes: OpAttributeMap) MaxUOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.maxu' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: maxu(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: MinSOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.mins`` operation takes two index values and computes their signed minimum value. Treats the leading bit as the sign, i.e. ``min(-2, 6) = -2``. Example: .. code:: mlir // c = min(a, b) %c = index.mins %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.mins' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: MinSOpAdaptor(operands: list[Value], attributes: OpAttributeMap) MinSOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.mins' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: mins(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: MinUOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.minu`` operation takes two index values and computes their unsigned minimum value. Treats the leading bit as the most significant, i.e. ``min(15, 6) = 6`` or ``min(-2, 6) = 6``. Example: .. code:: mlir // c = min(a, b) %c = index.minu %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.minu' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: MinUOpAdaptor(operands: list[Value], attributes: OpAttributeMap) MinUOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.minu' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: minu(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: MulOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.mul`` operation takes two index values and computes their product. Example: .. code:: mlir // c = a * b %c = index.mul %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.mul' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: MulOpAdaptor(operands: list[Value], attributes: OpAttributeMap) MulOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.mul' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: mul(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: OrOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.or`` operation takes two index values and computes their bitwise or. Example: .. code:: mlir // c = a | b %c = index.or %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.or' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: OrOpAdaptor(operands: list[Value], attributes: OpAttributeMap) OrOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.or' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: or_(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: RemSOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.rems`` operation takes two index values and computes their signed remainder. Treats the leading bit as the sign, i.e. ``6 % -2 = 0``. Example: .. code:: mlir // c = a % b %c = index.rems %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.rems' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: RemSOpAdaptor(operands: list[Value], attributes: OpAttributeMap) RemSOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.rems' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: rems(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: RemUOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.remu`` operation takes two index values and computes their unsigned remainder. Treats the leading bit as the most significant, i.e. ``6 % -2 = 6``. Example: .. code:: mlir // c = a % b %c = index.remu %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.remu' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: RemUOpAdaptor(operands: list[Value], attributes: OpAttributeMap) RemUOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.remu' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: remu(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: ShlOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.shl`` operation shifts an index value to the left by a variable amount. The low order bits are filled with zeroes. The RHS operand is always treated as unsigned. If the RHS operand is equal to or greater than the index bitwidth, the result is a poison value. Example: .. code:: mlir // c = a << b %c = index.shl %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.shl' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: ShlOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ShlOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.shl' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: shl(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: ShrSOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.shrs`` operation shifts an index value to the right by a variable amount. The LHS operand is treated as signed. The high order bits are filled with copies of the most significant bit. If the RHS operand is equal to or greater than the index bitwidth, the result is a poison value. Example: .. code:: mlir // c = a >> b %c = index.shrs %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.shrs' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: ShrSOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ShrSOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.shrs' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: shrs(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: ShrUOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.shru`` operation shifts an index value to the right by a variable amount. The LHS operand is treated as unsigned. The high order bits are filled with zeroes. If the RHS operand is equal to or greater than the index bitwidth, the result is a poison value. Example: .. code:: mlir // c = a >> b %c = index.shru %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.shru' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: ShrUOpAdaptor(operands: list[Value], attributes: OpAttributeMap) ShrUOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.shru' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: shru(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: SizeOfOp(*, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.sizeof`` operation produces an index-typed SSA value equal to the size in bits of the ``index`` type. For example, on 32-bit systems, the result is ``32 : index``, and on 64-bit systems, the result is ``64 : index``. Example: .. code:: mlir %0 = index.sizeof .. py:attribute:: OPERATION_NAME :value: 'index.sizeof' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: SizeOfOpAdaptor(operands: list[Value], attributes: OpAttributeMap) SizeOfOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.sizeof' .. py:function:: sizeof(*, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: SubOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.sub`` operation takes two index values and computes the difference of the first from the second operand. Example: .. code:: mlir // c = a - b %c = index.sub %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.sub' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: SubOpAdaptor(operands: list[Value], attributes: OpAttributeMap) SubOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.sub' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: sub(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir] .. py:class:: XOrOp(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) Bases: :py:obj:`_ods_ir` The ``index.xor`` operation takes two index values and computes their bitwise xor. Example: .. code:: mlir // c = a ^ b %c = index.xor %a, %b .. py:attribute:: OPERATION_NAME :value: 'index.xor' .. py:attribute:: _ODS_REGIONS :value: (0, True) .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:method:: result() -> _ods_ir[_ods_ir] Shortcut to get an op result if it has only one (throws an error otherwise). .. py:class:: XOrOpAdaptor(operands: list[Value], attributes: OpAttributeMap) XOrOpAdaptor(operands: list[Value], opview: OpView) Bases: :py:obj:`_ods_ir` .. py:attribute:: OPERATION_NAME :value: 'index.xor' .. py:method:: lhs() -> _ods_ir[_ods_ir] .. py:method:: rhs() -> _ods_ir[_ods_ir] .. py:function:: xor(lhs: _ods_ir[_ods_ir], rhs: _ods_ir[_ods_ir], *, results: Optional[Sequence[_ods_ir]] = None, loc: Optional[_ods_ir] = None, ip: Optional[_ods_ir] = None) -> _ods_ir[_ods_ir]