mlir.dialects._llvm_ops_gen¶

Attributes¶

_ods_ir

Classes¶

`_Dialect`
`ACosOp`
`AShrOp`
`ASinOp`
`ATan2Op`
`ATanOp`
`AbsOp`
`AddOp`
`AddrSpaceCastOp`
`AddressOfOp`	Creates an SSA value containing a pointer to a global value (function,
`AliasOp`	`llvm.mlir.alias` is a top level operation that defines a global alias for
`AllocaOp`
`AndOp`
`Annotation`
`AssumeOp`
`AtomicCmpXchgOp`
`AtomicRMWOp`
`BitReverseOp`
`BitcastOp`
`BlockAddressOp`	Creates an SSA value containing a pointer to a basic block. The block
`BlockTagOp`	This operation uses a `tag` to uniquely identify an MLIR block in a
`BrOp`
`ByteSwapOp`
`CallIntrinsicOp`	Call the specified llvm intrinsic. If the intrinsic is overloaded, use
`CallOp`	In LLVM IR, functions may return either 0 or 1 value. LLVM IR dialect
`ComdatOp`	Provides access to object file COMDAT section/group functionality.
`ComdatSelectorOp`	Provides access to object file COMDAT section/group functionality.
`CondBrOp`
`ConstantOp`	Unlike LLVM IR, MLIR does not have first-class constant values. Therefore,
`ConstrainedFPExtIntr`
`ConstrainedFPTruncIntr`
`ConstrainedSIToFP`
`ConstrainedUIToFP`
`CopySignOp`
`CoroAlignOp`
`CoroBeginOp`
`CoroEndOp`
`CoroFreeOp`
`CoroIdOp`
`CoroPromiseOp`
`CoroResumeOp`
`CoroSaveOp`
`CoroSizeOp`
`CoroSuspendOp`
`CosOp`
`CoshOp`
`CountLeadingZerosOp`
`CountTrailingZerosOp`
`CtPopOp`
`DSOLocalEquivalentOp`	Creates an SSA value containing a pointer to a global value (function or
`DbgDeclareOp`
`DbgLabelOp`
`DbgValueOp`
`DebugTrap`
`EhTypeidForOp`
`Exp2Op`
`Exp10Op`
`ExpOp`
`ExpectOp`
`ExpectWithProbabilityOp`
`ExtractElementOp`
`ExtractValueOp`
`FAbsOp`
`FAddOp`
`FCeilOp`
`FCmpOp`
`FDivOp`
`FFloorOp`
`FMAOp`
`FMulAddOp`
`FMulOp`
`FNegOp`
`FPExtOp`
`FPToSIOp`
`FPToUIOp`
`FPTruncOp`
`FRemOp`
`FSubOp`
`FTruncOp`
`FenceOp`
`FractionExpOp`
`FreezeOp`
`FshlOp`
`FshrOp`
`GEPOp`	This operation mirrors LLVM IRs 'getelementptr' operation that is used to
`GetActiveLaneMaskOp`
`GlobalCtorsOp`	Specifies a list of constructor functions, priorities, and associated data.
`GlobalDtorsOp`	Specifies a list of destructor functions and priorities. The functions
`GlobalOp`	Since MLIR allows for arbitrary operations to be present at the top level,
`ICmpOp`
`IFuncOp`	`llvm.mlir.ifunc` is a top level operation that defines a global ifunc.
`IndirectBrOp`	Transfer control flow to address in `$addr`. A list of possible target
`InlineAsmOp`	The InlineAsmOp mirrors the underlying LLVM semantics with a notable
`InsertElementOp`
`InsertValueOp`
`IntToPtrOp`
`InvariantEndOp`
`InvariantStartOp`
`InvokeOp`
`IsConstantOp`
`IsFPClass`
`LLVMFuncOp`	MLIR functions are defined by an operation that is not built into the IR
`LShrOp`
`LandingpadOp`
`LaunderInvariantGroupOp`
`LifetimeEndOp`
`LifetimeStartOp`
`LinkerOptionsOp`	Pass the given options to the linker when the resulting object file is linked.
`LlrintOp`
`LlroundOp`
`LoadExpOp`
`LoadOp`	The `load` operation is used to read from memory. A load may be marked as
`Log2Op`
`Log10Op`
`LogOp`
`LrintOp`
`LroundOp`
`MaskedLoadOp`
`MaskedStoreOp`
`MatrixColumnMajorLoadOp`
`MatrixColumnMajorStoreOp`
`MatrixMultiplyOp`
`MatrixTransposeOp`
`MaxNumOp`
`MaximumOp`
`MemcpyInlineOp`
`MemcpyOp`
`MemmoveOp`
`MemsetInlineOp`
`MemsetOp`
`MinNumOp`
`MinimumOp`
`ModuleFlagsOp`	Represents the equivalent in MLIR for LLVM's `llvm.module.flags` metadata,
`MulOp`
`NearbyintOp`
`NoAliasScopeDeclOp`
`NoneTokenOp`	Unlike LLVM IR, MLIR does not have first-class token values. They must be
`OrOp`
`PoisonOp`	Unlike LLVM IR, MLIR does not have first-class poison values. Such values
`PowIOp`
`PowOp`
`Prefetch`
`PtrAnnotation`
`PtrMaskOp`
`PtrToIntOp`
`ResumeOp`
`ReturnOp`
`RintOp`
`RoundEvenOp`
`RoundOp`
`SAddSat`
`SAddWithOverflowOp`
`SDivOp`
`SExtOp`
`SIToFPOp`
`SMaxOp`
`SMinOp`
`SMulWithOverflowOp`
`SRemOp`
`SSACopyOp`
`SSHLSat`
`SSubSat`
`SSubWithOverflowOp`
`SelectOp`
`ShlOp`
`ShuffleVectorOp`
`SinOp`
`SincosOp`
`SinhOp`
`SqrtOp`
`StackRestoreOp`
`StackSaveOp`
`StepVectorOp`
`StoreOp`	The `store` operation is used to write to memory. A store may be marked as
`StripInvariantGroupOp`
`SubOp`
`SwitchOp`
`TanOp`
`TanhOp`
`ThreadlocalAddressOp`
`Trap`
`TruncOp`
`UAddSat`
`UAddWithOverflowOp`
`UBSanTrap`
`UDivOp`
`UIToFPOp`
`UMaxOp`
`UMinOp`
`UMulWithOverflowOp`
`URemOp`
`USHLSat`
`USubSat`
`USubWithOverflowOp`
`UndefOp`	Unlike LLVM IR, MLIR does not have first-class undefined values. Such values
`UnreachableOp`
`VPAShrOp`
`VPAddOp`
`VPAndOp`
`VPFAddOp`
`VPFDivOp`
`VPFMulAddOp`
`VPFMulOp`
`VPFNegOp`
`VPFPExtOp`
`VPFPToSIOp`
`VPFPToUIOp`
`VPFPTruncOp`
`VPFRemOp`
`VPFSubOp`
`VPFmaOp`
`VPIntToPtrOp`
`VPLShrOp`
`VPLoadOp`
`VPMergeMinOp`
`VPMulOp`
`VPOrOp`
`VPPtrToIntOp`
`VPReduceAddOp`
`VPReduceAndOp`
`VPReduceFAddOp`
`VPReduceFMaxOp`
`VPReduceFMinOp`
`VPReduceFMulOp`
`VPReduceMulOp`
`VPReduceOrOp`
`VPReduceSMaxOp`
`VPReduceSMinOp`
`VPReduceUMaxOp`
`VPReduceUMinOp`
`VPReduceXorOp`
`VPSDivOp`
`VPSExtOp`
`VPSIToFPOp`
`VPSMaxOp`
`VPSMinOp`
`VPSRemOp`
`VPSelectMinOp`
`VPShlOp`
`VPStoreOp`
`VPStridedLoadOp`
`VPStridedStoreOp`
`VPSubOp`
`VPTruncOp`
`VPUDivOp`
`VPUIToFPOp`
`VPUMaxOp`
`VPUMinOp`
`VPURemOp`
`VPXorOp`
`VPZExtOp`
`VaArgOp`
`VaCopyOp`
`VaEndOp`
`VaStartOp`
`VarAnnotation`
`XOrOp`
`ZExtOp`
`ZeroOp`	Unlike LLVM IR, MLIR does not have first-class zero-initialized values.
`masked_compressstore`
`masked_expandload`
`masked_gather`
`masked_scatter`
`vector_deinterleave2`
`vector_extract`
`vector_insert`
`vector_interleave2`
`vector_reduce_add`
`vector_reduce_and`
`vector_reduce_fadd`
`vector_reduce_fmax`
`vector_reduce_fmaximum`
`vector_reduce_fmin`
`vector_reduce_fminimum`
`vector_reduce_fmul`
`vector_reduce_mul`
`vector_reduce_or`
`vector_reduce_smax`
`vector_reduce_smin`
`vector_reduce_umax`
`vector_reduce_umin`
`vector_reduce_xor`
`vscale`

Functions¶

`intr_acos`(→ _ods_ir)
`ashr`(→ _ods_ir)
`intr_asin`(→ _ods_ir)
`intr_atan2`(→ _ods_ir)
`intr_atan`(→ _ods_ir)
`intr_abs`(→ _ods_ir)
`add`(→ _ods_ir)
`addrspacecast`(→ _ods_ir)
`mlir_addressof`(→ _ods_ir)
`mlir_alias`(→ AliasOp)
`alloca`(→ _ods_ir)
`and_`(→ _ods_ir)
`intr_annotation`(→ _ods_ir)
`intr_assume`(→ AssumeOp)
`cmpxchg`(→ _ods_ir)
`atomicrmw`(→ _ods_ir)
`intr_bitreverse`(→ _ods_ir)
`bitcast`(→ _ods_ir)
`blockaddress`(→ _ods_ir)
`blocktag`(→ BlockTagOp)
`br`(→ BrOp)
`intr_bswap`(→ _ods_ir)
`call_intrinsic`(→ Union[_ods_ir, _ods_ir, CallIntrinsicOp])
`call`(→ Union[_ods_ir, _ods_ir, CallOp])
`comdat`(→ ComdatOp)
`comdat_selector`(→ ComdatSelectorOp)
`cond_br`(→ CondBrOp)
`mlir_constant`(→ _ods_ir)
`intr_experimental_constrained_fpext`(→ _ods_ir)
`intr_experimental_constrained_fptrunc`(→ _ods_ir)
`intr_experimental_constrained_sitofp`(→ _ods_ir)
`intr_experimental_constrained_uitofp`(→ _ods_ir)
`intr_copysign`(→ _ods_ir)
`intr_coro_align`(→ _ods_ir)
`intr_coro_begin`(→ _ods_ir)
`intr_coro_end`(→ _ods_ir)
`intr_coro_free`(→ _ods_ir)
`intr_coro_id`(→ _ods_ir)
`intr_coro_promise`(→ _ods_ir)
`intr_coro_resume`(→ CoroResumeOp)
`intr_coro_save`(→ _ods_ir)
`intr_coro_size`(→ _ods_ir)
`intr_coro_suspend`(→ _ods_ir)
`intr_cos`(→ _ods_ir)
`intr_cosh`(→ _ods_ir)
`intr_ctlz`(→ _ods_ir)
`intr_cttz`(→ _ods_ir)
`intr_ctpop`(→ _ods_ir)
`dso_local_equivalent`(→ _ods_ir)
`intr_dbg_declare`(→ DbgDeclareOp)
`intr_dbg_label`(→ DbgLabelOp)
`intr_dbg_value`(→ DbgValueOp)
`intr_debugtrap`(→ DebugTrap)
`intr_eh_typeid_for`(→ _ods_ir)
`intr_exp2`(→ _ods_ir)
`intr_exp10`(→ _ods_ir)
`intr_exp`(→ _ods_ir)
`intr_expect`(→ _ods_ir)
`intr_expect_with_probability`(→ _ods_ir)
`extractelement`(→ _ods_ir)
`extractvalue`(→ _ods_ir)
`intr_fabs`(→ _ods_ir)
`fadd`(→ _ods_ir)
`intr_ceil`(→ _ods_ir)
`fcmp`(→ _ods_ir)
`fdiv`(→ _ods_ir)
`intr_floor`(→ _ods_ir)
`intr_fma`(→ _ods_ir)
`intr_fmuladd`(→ _ods_ir)
`fmul`(→ _ods_ir)
`fneg`(→ _ods_ir)
`fpext`(→ _ods_ir)
`fptosi`(→ _ods_ir)
`fptoui`(→ _ods_ir)
`fptrunc`(→ _ods_ir)
`frem`(→ _ods_ir)
`fsub`(→ _ods_ir)
`intr_trunc`(→ _ods_ir)
`fence`(→ FenceOp)
`intr_frexp`(→ _ods_ir)
`freeze`(→ _ods_ir)
`intr_fshl`(→ _ods_ir)
`intr_fshr`(→ _ods_ir)
`getelementptr`(→ _ods_ir)
`intr_get_active_lane_mask`(→ _ods_ir)
`mlir_global_ctors`(→ GlobalCtorsOp)
`mlir_global_dtors`(→ GlobalDtorsOp)
`mlir_global`(→ GlobalOp)
`icmp`(→ _ods_ir)
`mlir_ifunc`(→ IFuncOp)
`indirectbr`(→ IndirectBrOp)
`inline_asm`(→ Union[_ods_ir, _ods_ir, InlineAsmOp])
`insertelement`(→ _ods_ir)
`insertvalue`(→ _ods_ir)
`inttoptr`(→ _ods_ir)
`intr_invariant_end`(→ InvariantEndOp)
`intr_invariant_start`(→ _ods_ir)
`invoke`(→ Union[_ods_ir, _ods_ir, InvokeOp])
`intr_is_constant`(→ _ods_ir)
`intr_is_fpclass`(→ _ods_ir)
`func`(→ LLVMFuncOp)
`lshr`(→ _ods_ir)
`landingpad`(→ _ods_ir)
`intr_launder_invariant_group`(→ _ods_ir)
`intr_lifetime_end`(→ LifetimeEndOp)
`intr_lifetime_start`(→ LifetimeStartOp)
`linker_options`(→ LinkerOptionsOp)
`intr_llrint`(→ _ods_ir)
`intr_llround`(→ _ods_ir)
`intr_ldexp`(→ _ods_ir)
`load`(→ _ods_ir)
`intr_log2`(→ _ods_ir)
`intr_log10`(→ _ods_ir)
`intr_log`(→ _ods_ir)
`intr_lrint`(→ _ods_ir)
`intr_lround`(→ _ods_ir)
`intr_masked_load`(→ _ods_ir)
`intr_masked_store`(→ MaskedStoreOp)
`intr_matrix_column_major_load`(→ _ods_ir)
`intr_matrix_column_major_store`(→ MatrixColumnMajorStoreOp)
`intr_matrix_multiply`(→ _ods_ir)
`intr_matrix_transpose`(→ _ods_ir)
`intr_maxnum`(→ _ods_ir)
`intr_maximum`(→ _ods_ir)
`intr_memcpy_inline`(→ MemcpyInlineOp)
`intr_memcpy`(→ MemcpyOp)
`intr_memmove`(→ MemmoveOp)
`intr_memset_inline`(→ MemsetInlineOp)
`intr_memset`(→ MemsetOp)
`intr_minnum`(→ _ods_ir)
`intr_minimum`(→ _ods_ir)
`module_flags`(→ ModuleFlagsOp)
`mul`(→ _ods_ir)
`intr_nearbyint`(→ _ods_ir)
`intr_experimental_noalias_scope_decl`(→ NoAliasScopeDeclOp)
`mlir_none`(→ _ods_ir)
`or_`(→ _ods_ir)
`mlir_poison`(→ _ods_ir)
`intr_powi`(→ _ods_ir)
`intr_pow`(→ _ods_ir)
`intr_prefetch`(→ Prefetch)
`intr_ptr_annotation`(→ _ods_ir)
`intr_ptrmask`(→ _ods_ir)
`ptrtoint`(→ _ods_ir)
`resume`(→ ResumeOp)
`return_`(→ ReturnOp)
`intr_rint`(→ _ods_ir)
`intr_roundeven`(→ _ods_ir)
`intr_round`(→ _ods_ir)
`intr_sadd_sat`(→ _ods_ir)
`intr_sadd_with_overflow`(→ _ods_ir)
`sdiv`(→ _ods_ir)
`sext`(→ _ods_ir)
`sitofp`(→ _ods_ir)
`intr_smax`(→ _ods_ir)
`intr_smin`(→ _ods_ir)
`intr_smul_with_overflow`(→ _ods_ir)
`srem`(→ _ods_ir)
`intr_ssa_copy`(→ _ods_ir)
`intr_sshl_sat`(→ _ods_ir)
`intr_ssub_sat`(→ _ods_ir)
`intr_ssub_with_overflow`(→ _ods_ir)
`select`(→ _ods_ir)
`shl`(→ _ods_ir)
`shufflevector`(→ _ods_ir)
`intr_sin`(→ _ods_ir)
`intr_sincos`(→ _ods_ir)
`intr_sinh`(→ _ods_ir)
`intr_sqrt`(→ _ods_ir)
`intr_stackrestore`(→ StackRestoreOp)
`intr_stacksave`(→ _ods_ir)
`intr_stepvector`(→ _ods_ir)
`store`(→ StoreOp)
`intr_strip_invariant_group`(→ _ods_ir)
`sub`(→ _ods_ir)
`switch`(→ SwitchOp)
`intr_tan`(→ _ods_ir)
`intr_tanh`(→ _ods_ir)
`intr_threadlocal_address`(→ _ods_ir)
`intr_trap`(→ Trap)
`trunc`(→ _ods_ir)
`intr_uadd_sat`(→ _ods_ir)
`intr_uadd_with_overflow`(→ _ods_ir)
`intr_ubsantrap`(→ UBSanTrap)
`udiv`(→ _ods_ir)
`uitofp`(→ _ods_ir)
`intr_umax`(→ _ods_ir)
`intr_umin`(→ _ods_ir)
`intr_umul_with_overflow`(→ _ods_ir)
`urem`(→ _ods_ir)
`intr_ushl_sat`(→ _ods_ir)
`intr_usub_sat`(→ _ods_ir)
`intr_usub_with_overflow`(→ _ods_ir)
`mlir_undef`(→ _ods_ir)
`unreachable`(→ UnreachableOp)
`intr_vp_ashr`(→ _ods_ir)
`intr_vp_add`(→ _ods_ir)
`intr_vp_and`(→ _ods_ir)
`intr_vp_fadd`(→ _ods_ir)
`intr_vp_fdiv`(→ _ods_ir)
`intr_vp_fmuladd`(→ _ods_ir)
`intr_vp_fmul`(→ _ods_ir)
`intr_vp_fneg`(→ _ods_ir)
`intr_vp_fpext`(→ _ods_ir)
`intr_vp_fptosi`(→ _ods_ir)
`intr_vp_fptoui`(→ _ods_ir)
`intr_vp_fptrunc`(→ _ods_ir)
`intr_vp_frem`(→ _ods_ir)
`intr_vp_fsub`(→ _ods_ir)
`intr_vp_fma`(→ _ods_ir)
`intr_vp_inttoptr`(→ _ods_ir)
`intr_vp_lshr`(→ _ods_ir)
`intr_vp_load`(→ _ods_ir)
`intr_vp_merge`(→ _ods_ir)
`intr_vp_mul`(→ _ods_ir)
`intr_vp_or`(→ _ods_ir)
`intr_vp_ptrtoint`(→ _ods_ir)
`intr_vp_reduce_add`(→ _ods_ir)
`intr_vp_reduce_and`(→ _ods_ir)
`intr_vp_reduce_fadd`(→ _ods_ir)
`intr_vp_reduce_fmax`(→ _ods_ir)
`intr_vp_reduce_fmin`(→ _ods_ir)
`intr_vp_reduce_fmul`(→ _ods_ir)
`intr_vp_reduce_mul`(→ _ods_ir)
`intr_vp_reduce_or`(→ _ods_ir)
`intr_vp_reduce_smax`(→ _ods_ir)
`intr_vp_reduce_smin`(→ _ods_ir)
`intr_vp_reduce_umax`(→ _ods_ir)
`intr_vp_reduce_umin`(→ _ods_ir)
`intr_vp_reduce_xor`(→ _ods_ir)
`intr_vp_sdiv`(→ _ods_ir)
`intr_vp_sext`(→ _ods_ir)
`intr_vp_sitofp`(→ _ods_ir)
`intr_vp_smax`(→ _ods_ir)
`intr_vp_smin`(→ _ods_ir)
`intr_vp_srem`(→ _ods_ir)
`intr_vp_select`(→ _ods_ir)
`intr_vp_shl`(→ _ods_ir)
`intr_vp_store`(→ VPStoreOp)
`intr_experimental_vp_strided_load`(→ _ods_ir)
`intr_experimental_vp_strided_store`(→ VPStridedStoreOp)
`intr_vp_sub`(→ _ods_ir)
`intr_vp_trunc`(→ _ods_ir)
`intr_vp_udiv`(→ _ods_ir)
`intr_vp_uitofp`(→ _ods_ir)
`intr_vp_umax`(→ _ods_ir)
`intr_vp_umin`(→ _ods_ir)
`intr_vp_urem`(→ _ods_ir)
`intr_vp_xor`(→ _ods_ir)
`intr_vp_zext`(→ _ods_ir)
`va_arg`(→ _ods_ir)
`intr_vacopy`(→ VaCopyOp)
`intr_vaend`(→ VaEndOp)
`intr_vastart`(→ VaStartOp)
`intr_var_annotation`(→ VarAnnotation)
`xor`(→ _ods_ir)
`zext`(→ _ods_ir)
`mlir_zero`(→ _ods_ir)
`intr_masked_compressstore`(→ masked_compressstore)
`intr_masked_expandload`(→ _ods_ir)
`intr_masked_gather`(→ _ods_ir)
`intr_masked_scatter`(→ masked_scatter)
`intr_vector_deinterleave2`(→ _ods_ir)
`intr_vector_extract`(→ _ods_ir)
`intr_vector_insert`(→ _ods_ir)
`intr_vector_interleave2`(→ _ods_ir)
`intr_vector_reduce_add`(→ _ods_ir)
`intr_vector_reduce_and`(→ _ods_ir)
`intr_vector_reduce_fadd`(→ _ods_ir)
`intr_vector_reduce_fmax`(→ _ods_ir)
`intr_vector_reduce_fmaximum`(→ _ods_ir)
`intr_vector_reduce_fmin`(→ _ods_ir)
`intr_vector_reduce_fminimum`(→ _ods_ir)
`intr_vector_reduce_fmul`(→ _ods_ir)
`intr_vector_reduce_mul`(→ _ods_ir)
`intr_vector_reduce_or`(→ _ods_ir)
`intr_vector_reduce_smax`(→ _ods_ir)
`intr_vector_reduce_smin`(→ _ods_ir)
`intr_vector_reduce_umax`(→ _ods_ir)
`intr_vector_reduce_umin`(→ _ods_ir)
`intr_vector_reduce_xor`(→ _ods_ir)
`intr_vscale`(→ _ods_ir)

Module Contents¶

mlir.dialects._llvm_ops_gen._ods_ir¶

class mlir.dialects._llvm_ops_gen._Dialect(descriptor: object)¶

Bases: _ods_ir

DIALECT_NAMESPACE = 'llvm'¶

class mlir.dialects._llvm_ops_gen.ACosOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.acos'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_acos(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.AShrOp(lhs, rhs, *, isExact=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.ashr'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

isExact() → bool¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.ashr(lhs, rhs, *, is_exact=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ASinOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.asin'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_asin(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ATan2Op(a, b, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.atan2'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_atan2(a, b, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ATanOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.atan'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_atan(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.AbsOp(res, in_, is_int_min_poison, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.abs'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

is_int_min_poison() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_abs(res, in_, is_int_min_poison, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.AddOp(lhs, rhs, overflowFlags, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.add'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.add(lhs, rhs, overflow_flags, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.AddrSpaceCastOp(res, arg, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.addrspacecast'¶

_ODS_REGIONS = (0, True)¶

arg() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.addrspacecast(res, arg, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.AddressOfOp(res, global_name, *, loc=None, ip=None)¶

Bases: _ods_ir

Creates an SSA value containing a pointer to a global value (function, variable or alias). The global value can be defined after its first referenced. If the global value is a constant, storing into it is not allowed.

Examples:

func @foo() {
  // Get the address of a global variable.
  %0 = llvm.mlir.addressof @const : !llvm.ptr

  // Use it as a regular pointer.
  %1 = llvm.load %0 : !llvm.ptr -> i32

  // Get the address of a function.
  %2 = llvm.mlir.addressof @foo : !llvm.ptr

  // The function address can be used for indirect calls.
  llvm.call %2() : !llvm.ptr, () -> ()

  // Get the address of an aliased global.
  %3 = llvm.mlir.addressof @const_alias : !llvm.ptr
}

// Define the global.
llvm.mlir.global @const(42 : i32) : i32

// Define an alias.
llvm.mlir.alias @const_alias : i32 {
  %0 = llvm.mlir.addressof @const : !llvm.ptr
  llvm.return %0 : !llvm.ptr
}

OPERATION_NAME = 'llvm.mlir.addressof'¶

_ODS_REGIONS = (0, True)¶

global_name() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.mlir_addressof(res, global_name, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.AliasOp(alias_type, sym_name, linkage, *, dso_local=None, thread_local_=None, unnamed_addr=None, visibility_=None, loc=None, ip=None)¶

Bases: _ods_ir

llvm.mlir.alias is a top level operation that defines a global alias for global variables and functions. The operation is always initialized by using a initializer region which could be a direct map to another global value or contain some address computation on top of it.

It uses a symbol for its value, which will be uniqued by the module with respect to other symbols in it.

Similarly to functions and globals, they can also have a linkage attribute. This attribute is placed between llvm.mlir.alias and the symbol name. If the attribute is omitted, external linkage is assumed by default.

Examples:

// Global alias use @-identifiers.
llvm.mlir.alias external @foo_alias {addr_space = 0 : i32} : !llvm.ptr {
  %0 = llvm.mlir.addressof @some_function : !llvm.ptr
  llvm.return %0 : !llvm.ptr
}

// More complex initialization.
llvm.mlir.alias linkonce_odr hidden @glob
{addr_space = 0 : i32, dso_local} : !llvm.array<32 x i32> {
  %0 = llvm.mlir.constant(1234 : i64) : i64
  %1 = llvm.mlir.addressof @glob.private : !llvm.ptr
  %2 = llvm.ptrtoint %1 : !llvm.ptr to i64
  %3 = llvm.add %2, %0 : i64
  %4 = llvm.inttoptr %3 : i64 to !llvm.ptr
  llvm.return %4 : !llvm.ptr
}

OPERATION_NAME = 'llvm.mlir.alias'¶

_ODS_REGIONS = (1, True)¶

alias_type() → _ods_ir¶

sym_name() → _ods_ir¶

linkage() → _ods_ir¶

dso_local() → bool¶

thread_local_() → bool¶

unnamed_addr() → _ods_ir | None¶

visibility_() → _ods_ir¶

initializer() → _ods_ir¶

mlir.dialects._llvm_ops_gen.mlir_alias(alias_type, sym_name, linkage, *, dso_local=None, thread_local_=None, unnamed_addr=None, visibility_=None, loc=None, ip=None) → AliasOp¶

class mlir.dialects._llvm_ops_gen.AllocaOp(res, arraySize, elem_type, *, alignment=None, inalloca=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.alloca'¶

_ODS_REGIONS = (0, True)¶

arraySize() → _ods_ir¶

alignment() → _ods_ir | None¶

elem_type() → _ods_ir¶

inalloca() → bool¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.alloca(res, array_size, elem_type, *, alignment=None, inalloca=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.AndOp(lhs, rhs, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.and'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.and_(lhs, rhs, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.Annotation(integer, annotation, fileName, line, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.annotation'¶

_ODS_REGIONS = (0, True)¶

integer() → _ods_ir¶

annotation() → _ods_ir¶

fileName() → _ods_ir¶

line() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_annotation(integer, annotation, file_name, line, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.AssumeOp(cond, op_bundle_operands, op_bundle_sizes, *, op_bundle_tags=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.assume'¶

_ODS_REGIONS = (0, True)¶

cond() → _ods_ir¶

op_bundle_operands() → _ods_ir¶

op_bundle_sizes() → _ods_ir¶

op_bundle_tags() → _ods_ir | None¶

mlir.dialects._llvm_ops_gen.intr_assume(cond, op_bundle_operands, op_bundle_sizes, *, op_bundle_tags=None, loc=None, ip=None) → AssumeOp¶

class mlir.dialects._llvm_ops_gen.AtomicCmpXchgOp(ptr, cmp, val, success_ordering, failure_ordering, *, syncscope=None, alignment=None, weak=None, volatile_=None, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.cmpxchg'¶

_ODS_REGIONS = (0, True)¶

ptr() → _ods_ir¶

cmp() → _ods_ir¶

val() → _ods_ir¶

success_ordering() → _ods_ir¶

failure_ordering() → _ods_ir¶

syncscope() → _ods_ir | None¶

alignment() → _ods_ir | None¶

weak() → bool¶

volatile_() → bool¶

access_groups() → _ods_ir | None¶

alias_scopes() → _ods_ir | None¶

noalias_scopes() → _ods_ir | None¶

tbaa() → _ods_ir | None¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.cmpxchg(ptr, cmp, val, success_ordering, failure_ordering, *, syncscope=None, alignment=None, weak=None, volatile_=None, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.AtomicRMWOp(bin_op, ptr, val, ordering, *, syncscope=None, alignment=None, volatile_=None, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.atomicrmw'¶

_ODS_REGIONS = (0, True)¶

ptr() → _ods_ir¶

val() → _ods_ir¶

bin_op() → _ods_ir¶

ordering() → _ods_ir¶

syncscope() → _ods_ir | None¶

alignment() → _ods_ir | None¶

volatile_() → bool¶

access_groups() → _ods_ir | None¶

alias_scopes() → _ods_ir | None¶

noalias_scopes() → _ods_ir | None¶

tbaa() → _ods_ir | None¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.atomicrmw(bin_op, ptr, val, ordering, *, syncscope=None, alignment=None, volatile_=None, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.BitReverseOp(in_, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.bitreverse'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_bitreverse(in_, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.BitcastOp(res, arg, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.bitcast'¶

_ODS_REGIONS = (0, True)¶

arg() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.bitcast(res, arg, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.BlockAddressOp(res, block_addr, *, loc=None, ip=None)¶

Bases: _ods_ir

Creates an SSA value containing a pointer to a basic block. The block address information (function and block) is given by the BlockAddressAttr attribute. This operation assumes an existing llvm.blocktag operation identifying an existing MLIR block within a function. Example:

llvm.mlir.global private @g() : !llvm.ptr {
  %0 = llvm.blockaddress <function = @fn, tag = <id = 0>> : !llvm.ptr
  llvm.return %0 : !llvm.ptr
}

llvm.func @fn() {
  llvm.br ^bb1
^bb1:  // pred: ^bb0
  llvm.blocktag <id = 0>
  llvm.return
}

OPERATION_NAME = 'llvm.blockaddress'¶

_ODS_REGIONS = (0, True)¶

block_addr() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.blockaddress(res, block_addr, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.BlockTagOp(tag, *, loc=None, ip=None)¶

Bases: _ods_ir

This operation uses a tag to uniquely identify an MLIR block in a function. The same tag is used by llvm.blockaddress in order to compute the target address.

A given function should have at most one llvm.blocktag operation with a given tag. This operation cannot be used as a terminator.

Example:

llvm.func @f() -> !llvm.ptr {
  %addr = llvm.blockaddress <function = @f, tag = <id = 1>> : !llvm.ptr
  llvm.br ^bb1
^bb1:
  llvm.blocktag <id = 1>
  llvm.return %addr : !llvm.ptr
}

OPERATION_NAME = 'llvm.blocktag'¶

_ODS_REGIONS = (0, True)¶

tag() → _ods_ir¶

mlir.dialects._llvm_ops_gen.blocktag(tag, *, loc=None, ip=None) → BlockTagOp¶

class mlir.dialects._llvm_ops_gen.BrOp(destOperands, dest, *, loop_annotation=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.br'¶

_ODS_REGIONS = (0, True)¶

destOperands() → _ods_ir¶

loop_annotation() → _ods_ir | None¶

mlir.dialects._llvm_ops_gen.br(dest_operands, dest, *, loop_annotation=None, loc=None, ip=None) → BrOp¶

class mlir.dialects._llvm_ops_gen.ByteSwapOp(in_, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.bswap'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_bswap(in_, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.CallIntrinsicOp(results_, intrin, args, op_bundle_operands, op_bundle_sizes, *, fastmathFlags=None, op_bundle_tags=None, arg_attrs=None, res_attrs=None, loc=None, ip=None)¶

Bases: _ods_ir

Call the specified llvm intrinsic. If the intrinsic is overloaded, use the MLIR function type of this op to determine which intrinsic to call.

OPERATION_NAME = 'llvm.call_intrinsic'¶

_ODS_OPERAND_SEGMENTS¶

_ODS_REGIONS = (0, True)¶

args() → _ods_ir¶

op_bundle_operands() → _ods_ir¶

intrin() → _ods_ir¶

fastmathFlags() → _ods_ir¶

op_bundle_sizes() → _ods_ir¶

op_bundle_tags() → _ods_ir | None¶

arg_attrs() → _ods_ir | None¶

res_attrs() → _ods_ir | None¶

results_() → _ods_ir | None¶

mlir.dialects._llvm_ops_gen.call_intrinsic(results_, intrin, args, op_bundle_operands, op_bundle_sizes, *, fastmath_flags=None, op_bundle_tags=None, arg_attrs=None, res_attrs=None, loc=None, ip=None) → _ods_ir | _ods_ir | CallIntrinsicOp¶

class mlir.dialects._llvm_ops_gen.CallOp(result, callee_operands, op_bundle_operands, op_bundle_sizes, *, var_callee_type=None, callee=None, fastmathFlags=None, CConv=None, TailCallKind=None, memory_effects=None, convergent=None, no_unwind=None, will_return=None, op_bundle_tags=None, arg_attrs=None, res_attrs=None, no_inline=None, always_inline=None, inline_hint=None, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, loc=None, ip=None)¶

Bases: _ods_ir

In LLVM IR, functions may return either 0 or 1 value. LLVM IR dialect implements this behavior by providing a variadic call operation for 0- and 1-result functions. Even though MLIR supports multi-result functions, LLVM IR dialect disallows them.

The call instruction supports both direct and indirect calls. Direct calls start with a function name (@-prefixed) and indirect calls start with an SSA value (%-prefixed). The direct callee, if present, is stored as a function attribute callee. For indirect calls, the callee is of !llvm.ptr type and is stored as the first value in callee_operands. If and only if the callee is a variadic function, the var_callee_type attribute must carry the variadic LLVM function type. The trailing type list contains the optional indirect callee type and the MLIR function type, which differs from the LLVM function type that uses an explicit void type to model functions that do not return a value.

If this operatin has the no_inline attribute, then this specific function call will never be inlined. The opposite behavior will occur if the call has always_inline attribute. The inline_hint attribute indicates that it is desirable to inline this function call.

Examples:

// Direct call without arguments and with one result.
%0 = llvm.call @foo() : () -> (f32)

// Direct call with arguments and without a result.
llvm.call @bar(%0) : (f32) -> ()

// Indirect call with an argument and without a result.
%1 = llvm.mlir.addressof @foo : !llvm.ptr
llvm.call %1(%0) : !llvm.ptr, (f32) -> ()

// Direct variadic call.
llvm.call @printf(%0, %1) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, i32) -> i32

// Indirect variadic call
llvm.call %1(%0) vararg(!llvm.func<void (...)>) : !llvm.ptr, (i32) -> ()

OPERATION_NAME = 'llvm.call'¶

_ODS_OPERAND_SEGMENTS¶

_ODS_REGIONS = (0, True)¶

callee_operands() → _ods_ir¶

op_bundle_operands() → _ods_ir¶

var_callee_type() → _ods_ir | None¶

callee() → _ods_ir | None¶

fastmathFlags() → _ods_ir¶

CConv() → _ods_ir¶

TailCallKind() → _ods_ir¶

memory_effects() → _ods_ir | None¶

convergent() → bool¶

no_unwind() → bool¶

will_return() → bool¶

op_bundle_sizes() → _ods_ir¶

op_bundle_tags() → _ods_ir | None¶

arg_attrs() → _ods_ir | None¶

res_attrs() → _ods_ir | None¶

no_inline() → bool¶

always_inline() → bool¶

inline_hint() → bool¶

access_groups() → _ods_ir | None¶

alias_scopes() → _ods_ir | None¶

noalias_scopes() → _ods_ir | None¶

tbaa() → _ods_ir | None¶

result() → _ods_ir | None¶: Shortcut to get an op result if it has only one (throws an error otherwise).

mlir.dialects._llvm_ops_gen.call(result, callee_operands, op_bundle_operands, op_bundle_sizes, *, var_callee_type=None, callee=None, fastmath_flags=None, c_conv=None, tail_call_kind=None, memory_effects=None, convergent=None, no_unwind=None, will_return=None, op_bundle_tags=None, arg_attrs=None, res_attrs=None, no_inline=None, always_inline=None, inline_hint=None, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, loc=None, ip=None) → _ods_ir | _ods_ir | CallOp¶

class mlir.dialects._llvm_ops_gen.ComdatOp(sym_name, *, loc=None, ip=None)¶

Bases: _ods_ir

Provides access to object file COMDAT section/group functionality.

Examples:

llvm.comdat @__llvm_comdat {
  llvm.comdat_selector @any any
}
llvm.mlir.global internal constant @has_any_comdat(1 : i64) comdat(@__llvm_comdat::@any) : i64

OPERATION_NAME = 'llvm.comdat'¶

_ODS_REGIONS = (1, True)¶

sym_name() → _ods_ir¶

body() → _ods_ir¶

mlir.dialects._llvm_ops_gen.comdat(sym_name, *, loc=None, ip=None) → ComdatOp¶

class mlir.dialects._llvm_ops_gen.ComdatSelectorOp(sym_name, comdat, *, loc=None, ip=None)¶

Bases: _ods_ir

Provides access to object file COMDAT section/group functionality.

Examples:

llvm.comdat @__llvm_comdat {
  llvm.comdat_selector @any any
}
llvm.mlir.global internal constant @has_any_comdat(1 : i64) comdat(@__llvm_comdat::@any) : i64

OPERATION_NAME = 'llvm.comdat_selector'¶

_ODS_REGIONS = (0, True)¶

sym_name() → _ods_ir¶

comdat() → _ods_ir¶

mlir.dialects._llvm_ops_gen.comdat_selector(sym_name, comdat, *, loc=None, ip=None) → ComdatSelectorOp¶

class mlir.dialects._llvm_ops_gen.CondBrOp(condition, trueDestOperands, falseDestOperands, trueDest, falseDest, *, branch_weights=None, loop_annotation=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.cond_br'¶

_ODS_OPERAND_SEGMENTS¶

_ODS_REGIONS = (0, True)¶

condition() → _ods_ir¶

trueDestOperands() → _ods_ir¶

falseDestOperands() → _ods_ir¶

branch_weights() → _ods_ir | None¶

loop_annotation() → _ods_ir | None¶

mlir.dialects._llvm_ops_gen.cond_br(condition, true_dest_operands, false_dest_operands, true_dest, false_dest, *, branch_weights=None, loop_annotation=None, loc=None, ip=None) → CondBrOp¶

class mlir.dialects._llvm_ops_gen.ConstantOp(res, value, *, loc=None, ip=None)¶

Bases: _ods_ir

Unlike LLVM IR, MLIR does not have first-class constant values. Therefore, all constants must be created as SSA values before being used in other operations. llvm.mlir.constant creates such values for scalars, vectors, strings, structs, and array of structs. It has a mandatory value attribute whose type depends on the type of the constant value. The type of the constant value must correspond to the attribute type converted to LLVM IR type.

When creating constant scalars, the value attribute must be either an integer attribute or a floating point attribute. The type of the attribute may be omitted for i64 and f64 types that are implied.

When creating constant vectors, the value attribute must be either an array attribute, a dense attribute, or a sparse attribute that contains integers or floats. The number of elements in the result vector must match the number of elements in the attribute.

When creating constant strings, the value attribute must be a string attribute. The type of the constant must be an LLVM array of ``i8``s, and the length of the array must match the length of the attribute.

When creating constant structs, the value attribute must be an array attribute that contains integers or floats. The type of the constant must be an LLVM struct type. The number of fields in the struct must match the number of elements in the attribute, and the type of each LLVM struct field must correspond to the type of the corresponding attribute element converted to LLVM IR.

When creating an array of structs, the value attribute must be an array attribute, itself containing zero, or undef, or array attributes for each potential nested array type, and the elements of the leaf array attributes for must match the struct element types or be zero or undef attributes.

Examples:

// Integer constant, internal i32 is mandatory
%0 = llvm.mlir.constant(42 : i32) : i32

// It's okay to omit i64.
%1 = llvm.mlir.constant(42) : i64

// Floating point constant.
%2 = llvm.mlir.constant(42.0 : f32) : f32

// Splat dense vector constant.
%3 = llvm.mlir.constant(dense<1.0> : vector<4xf32>) : vector<4xf32>

OPERATION_NAME = 'llvm.mlir.constant'¶

_ODS_REGIONS = (0, True)¶

value() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.mlir_constant(res, value, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ConstrainedFPExtIntr(res, arg_0, fpExceptionBehavior, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.experimental.constrained.fpext'¶

_ODS_REGIONS = (0, True)¶

arg_0() → _ods_ir¶

fpExceptionBehavior() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_experimental_constrained_fpext(res, arg_0, fp_exception_behavior, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ConstrainedFPTruncIntr(res, arg_0, roundingmode, fpExceptionBehavior, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.experimental.constrained.fptrunc'¶

_ODS_REGIONS = (0, True)¶

arg_0() → _ods_ir¶

roundingmode() → _ods_ir¶

fpExceptionBehavior() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_experimental_constrained_fptrunc(res, arg_0, roundingmode, fp_exception_behavior, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ConstrainedSIToFP(res, arg_0, roundingmode, fpExceptionBehavior, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.experimental.constrained.sitofp'¶

_ODS_REGIONS = (0, True)¶

arg_0() → _ods_ir¶

roundingmode() → _ods_ir¶

fpExceptionBehavior() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_experimental_constrained_sitofp(res, arg_0, roundingmode, fp_exception_behavior, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ConstrainedUIToFP(res, arg_0, roundingmode, fpExceptionBehavior, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.experimental.constrained.uitofp'¶

_ODS_REGIONS = (0, True)¶

arg_0() → _ods_ir¶

roundingmode() → _ods_ir¶

fpExceptionBehavior() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_experimental_constrained_uitofp(res, arg_0, roundingmode, fp_exception_behavior, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.CopySignOp(a, b, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.copysign'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_copysign(a, b, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.CoroAlignOp(res, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.align'¶

_ODS_REGIONS = (0, True)¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_coro_align(res, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.CoroBeginOp(res, token, mem, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.begin'¶

_ODS_REGIONS = (0, True)¶

token() → _ods_ir¶

mem() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_coro_begin(res, token, mem, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.CoroEndOp(res, handle, unwind, retvals, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.end'¶

_ODS_REGIONS = (0, True)¶

handle() → _ods_ir¶

unwind() → _ods_ir¶

retvals() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_coro_end(res, handle, unwind, retvals, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.CoroFreeOp(res, id, handle, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.free'¶

_ODS_REGIONS = (0, True)¶

id() → _ods_ir¶

handle() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_coro_free(res, id, handle, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.CoroIdOp(res, align, promise, coroaddr, fnaddrs, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.id'¶

_ODS_REGIONS = (0, True)¶

align() → _ods_ir¶

promise() → _ods_ir¶

coroaddr() → _ods_ir¶

fnaddrs() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_coro_id(res, align, promise, coroaddr, fnaddrs, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.CoroPromiseOp(res, handle, align, from_, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.promise'¶

_ODS_REGIONS = (0, True)¶

handle() → _ods_ir¶

align() → _ods_ir¶

from_() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_coro_promise(res, handle, align, from_, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.CoroResumeOp(handle, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.resume'¶

_ODS_REGIONS = (0, True)¶

handle() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_coro_resume(handle, *, loc=None, ip=None) → CoroResumeOp¶

class mlir.dialects._llvm_ops_gen.CoroSaveOp(res, handle, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.save'¶

_ODS_REGIONS = (0, True)¶

handle() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_coro_save(res, handle, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.CoroSizeOp(res, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.size'¶

_ODS_REGIONS = (0, True)¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_coro_size(res, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.CoroSuspendOp(res, save, final, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.suspend'¶

_ODS_REGIONS = (0, True)¶

save() → _ods_ir¶

final() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_coro_suspend(res, save, final, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.CosOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.cos'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_cos(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.CoshOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.cosh'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_cosh(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.CountLeadingZerosOp(in_, is_zero_poison, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ctlz'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

is_zero_poison() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_ctlz(in_, is_zero_poison, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.CountTrailingZerosOp(in_, is_zero_poison, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.cttz'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

is_zero_poison() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_cttz(in_, is_zero_poison, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.CtPopOp(in_, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ctpop'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_ctpop(in_, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.DSOLocalEquivalentOp(res, function_name, *, loc=None, ip=None)¶

Bases: _ods_ir

Creates an SSA value containing a pointer to a global value (function or alias to function). It represents a function which is functionally equivalent to a given function, but is always defined in the current linkage unit. The target function may not have extern_weak linkage.

Examples:

llvm.mlir.global external constant @const() : i64 {
  %0 = llvm.mlir.addressof @const : !llvm.ptr
  %1 = llvm.ptrtoint %0 : !llvm.ptr to i64
  %2 = llvm.dso_local_equivalent @func : !llvm.ptr
  %4 = llvm.ptrtoint %2 : !llvm.ptr to i64
  llvm.return %4 : i64
}

OPERATION_NAME = 'llvm.dso_local_equivalent'¶

_ODS_REGIONS = (0, True)¶

function_name() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.dso_local_equivalent(res, function_name, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.DbgDeclareOp(addr, varInfo, *, locationExpr=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.dbg.declare'¶

_ODS_REGIONS = (0, True)¶

addr() → _ods_ir¶

varInfo() → _ods_ir¶

locationExpr() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_dbg_declare(addr, var_info, *, location_expr=None, loc=None, ip=None) → DbgDeclareOp¶

class mlir.dialects._llvm_ops_gen.DbgLabelOp(label, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.dbg.label'¶

_ODS_REGIONS = (0, True)¶

label() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_dbg_label(label, *, loc=None, ip=None) → DbgLabelOp¶

class mlir.dialects._llvm_ops_gen.DbgValueOp(value, varInfo, *, locationExpr=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.dbg.value'¶

_ODS_REGIONS = (0, True)¶

value() → _ods_ir¶

varInfo() → _ods_ir¶

locationExpr() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_dbg_value(value, var_info, *, location_expr=None, loc=None, ip=None) → DbgValueOp¶

class mlir.dialects._llvm_ops_gen.DebugTrap(*, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.debugtrap'¶

_ODS_REGIONS = (0, True)¶

mlir.dialects._llvm_ops_gen.intr_debugtrap(*, loc=None, ip=None) → DebugTrap¶

class mlir.dialects._llvm_ops_gen.EhTypeidForOp(res, type_info, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.eh.typeid.for'¶

_ODS_REGIONS = (0, True)¶

type_info() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_eh_typeid_for(res, type_info, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.Exp2Op(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.exp2'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_exp2(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.Exp10Op(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.exp10'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_exp10(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ExpOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.exp'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_exp(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ExpectOp(val, expected, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.expect'¶

_ODS_REGIONS = (0, True)¶

val() → _ods_ir¶

expected() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_expect(val, expected, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ExpectWithProbabilityOp(val, expected, prob, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.expect.with.probability'¶

_ODS_REGIONS = (0, True)¶

val() → _ods_ir¶

expected() → _ods_ir¶

prob() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_expect_with_probability(val, expected, prob, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ExtractElementOp(vector, position, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.extractelement'¶

_ODS_REGIONS = (0, True)¶

vector() → _ods_ir¶

position() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.extractelement(vector, position, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ExtractValueOp(res, container, position, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.extractvalue'¶

_ODS_REGIONS = (0, True)¶

container() → _ods_ir¶

position() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.extractvalue(res, container, position, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FAbsOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.fabs'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_fabs(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FAddOp(lhs, rhs, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.fadd'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.fadd(lhs, rhs, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FCeilOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ceil'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_ceil(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FCmpOp(predicate, lhs, rhs, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.fcmp'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

predicate() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.fcmp(predicate, lhs, rhs, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FDivOp(lhs, rhs, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.fdiv'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.fdiv(lhs, rhs, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FFloorOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.floor'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_floor(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FMAOp(a, b, c, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.fma'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

c() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_fma(a, b, c, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FMulAddOp(a, b, c, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.fmuladd'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

c() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_fmuladd(a, b, c, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FMulOp(lhs, rhs, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.fmul'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.fmul(lhs, rhs, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FNegOp(operand, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.fneg'¶

_ODS_REGIONS = (0, True)¶

operand() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.fneg(operand, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FPExtOp(res, arg, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.fpext'¶

_ODS_REGIONS = (0, True)¶

arg() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.fpext(res, arg, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FPToSIOp(res, arg, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.fptosi'¶

_ODS_REGIONS = (0, True)¶

arg() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.fptosi(res, arg, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FPToUIOp(res, arg, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.fptoui'¶

_ODS_REGIONS = (0, True)¶

arg() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.fptoui(res, arg, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FPTruncOp(res, arg, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.fptrunc'¶

_ODS_REGIONS = (0, True)¶

arg() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.fptrunc(res, arg, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FRemOp(lhs, rhs, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.frem'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.frem(lhs, rhs, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FSubOp(lhs, rhs, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.fsub'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.fsub(lhs, rhs, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FTruncOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.trunc'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_trunc(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FenceOp(ordering, *, syncscope=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.fence'¶

_ODS_REGIONS = (0, True)¶

ordering() → _ods_ir¶

syncscope() → _ods_ir | None¶

mlir.dialects._llvm_ops_gen.fence(ordering, *, syncscope=None, loc=None, ip=None) → FenceOp¶

class mlir.dialects._llvm_ops_gen.FractionExpOp(res, val, *, fastmathFlags=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.frexp'¶

_ODS_REGIONS = (0, True)¶

val() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_frexp(res, val, *, fastmath_flags=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FreezeOp(val, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.freeze'¶

_ODS_REGIONS = (0, True)¶

val() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.freeze(val, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FshlOp(a, b, c, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.fshl'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

c() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_fshl(a, b, c, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.FshrOp(a, b, c, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.fshr'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

c() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_fshr(a, b, c, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.GEPOp(res, base, dynamicIndices, rawConstantIndices, elem_type, noWrapFlags, *, loc=None, ip=None)¶

Bases: _ods_ir

This operation mirrors LLVM IRs ‘getelementptr’ operation that is used to perform pointer arithmetic.

Like in LLVM IR, it is possible to use both constants as well as SSA values as indices. In the case of indexing within a structure, it is required to either use constant indices directly, or supply a constant SSA value.

The no-wrap flags can be used to specify the low-level pointer arithmetic overflow behavior that LLVM uses after lowering the operation to LLVM IR. Valid options include ‘inbounds’ (pointer arithmetic must be within object bounds), ‘nusw’ (no unsigned signed wrap), and ‘nuw’ (no unsigned wrap). Note that ‘inbounds’ implies ‘nusw’ which is ensured by the enum definition. The flags can be set individually or in combination.

Examples:

// GEP with an SSA value offset
%0 = llvm.getelementptr %1[%2] : (!llvm.ptr, i64) -> !llvm.ptr, f32

// GEP with a constant offset and the inbounds attribute set
%0 = llvm.getelementptr inbounds %1[3] : (!llvm.ptr) -> !llvm.ptr, f32

// GEP with constant offsets into a structure
%0 = llvm.getelementptr %1[0, 1]
   : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, f32)>

OPERATION_NAME = 'llvm.getelementptr'¶

_ODS_REGIONS = (0, True)¶

base() → _ods_ir¶

dynamicIndices() → _ods_ir¶

rawConstantIndices() → _ods_ir¶

elem_type() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.getelementptr(res, base, dynamic_indices, raw_constant_indices, elem_type, no_wrap_flags, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.GetActiveLaneMaskOp(res, base, n, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.get.active.lane.mask'¶

_ODS_REGIONS = (0, True)¶

base() → _ods_ir¶

n() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_get_active_lane_mask(res, base, n, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.GlobalCtorsOp(ctors, priorities, data, *, loc=None, ip=None)¶

Bases: _ods_ir

Specifies a list of constructor functions, priorities, and associated data. The functions referenced by this array will be called in ascending order of priority (i.e. lowest first) when the module is loaded. The order of functions with the same priority is not defined. This operation is translated to LLVM’s global_ctors global variable. The initializer functions are run at load time. However, if the associated data is not #llvm.zero, functions only run if the data is not discarded.

Examples:

llvm.func @ctor() {
  ...
  llvm.return
}
llvm.mlir.global_ctors ctors = [@ctor], priorities = [0],
                               data = [#llvm.zero]

OPERATION_NAME = 'llvm.mlir.global_ctors'¶

_ODS_REGIONS = (0, True)¶

ctors() → _ods_ir¶

priorities() → _ods_ir¶

data() → _ods_ir¶

mlir.dialects._llvm_ops_gen.mlir_global_ctors(ctors, priorities, data, *, loc=None, ip=None) → GlobalCtorsOp¶

class mlir.dialects._llvm_ops_gen.GlobalDtorsOp(dtors, priorities, data, *, loc=None, ip=None)¶

Bases: _ods_ir

Specifies a list of destructor functions and priorities. The functions referenced by this array will be called in descending order of priority (i.e. highest first) when the module is unloaded. The order of functions with the same priority is not defined. This operation is translated to LLVM’s global_dtors global variable. The destruction functions are run at load time. However, if the associated data is not #llvm.zero, functions only run if the data is not discarded.

Examples:

llvm.func @dtor() {
  llvm.return
}
llvm.mlir.global_dtors dtors = [@dtor], priorities = [0],
                               data = [#llvm.zero]

OPERATION_NAME = 'llvm.mlir.global_dtors'¶

_ODS_REGIONS = (0, True)¶

dtors() → _ods_ir¶

priorities() → _ods_ir¶

data() → _ods_ir¶

mlir.dialects._llvm_ops_gen.mlir_global_dtors(dtors, priorities, data, *, loc=None, ip=None) → GlobalDtorsOp¶

class mlir.dialects._llvm_ops_gen.GlobalOp(global_type, sym_name, linkage, *, constant=None, dso_local=None, thread_local_=None, externally_initialized=None, value=None, alignment=None, addr_space=None, unnamed_addr=None, section=None, comdat=None, dbg_exprs=None, visibility_=None, target_specific_attrs=None, loc=None, ip=None)¶

Bases: _ods_ir

Since MLIR allows for arbitrary operations to be present at the top level, global variables are defined using the llvm.mlir.global operation. Both global constants and variables can be defined, and the value may also be initialized in both cases.

There are two forms of initialization syntax. Simple constants that can be represented as MLIR attributes can be given in-line:

llvm.mlir.global @variable(32.0 : f32) : f32

This initialization and type syntax is similar to llvm.mlir.constant and may use two types: one for MLIR attribute and another for the LLVM value. These types must be compatible.

More complex constants that cannot be represented as MLIR attributes can be given in an initializer region:

// This global is initialized with the equivalent of:
//   i32* getelementptr (i32* @g2, i32 2)
llvm.mlir.global constant @int_gep() : !llvm.ptr {
  %0 = llvm.mlir.addressof @g2 : !llvm.ptr
  %1 = llvm.mlir.constant(2 : i32) : i32
  %2 = llvm.getelementptr %0[%1]
     : (!llvm.ptr, i32) -> !llvm.ptr, i32
  // The initializer region must end with `llvm.return`.
  llvm.return %2 : !llvm.ptr
}

Only one of the initializer attribute or initializer region may be provided.

llvm.mlir.global must appear at top-level of the enclosing module. It uses an @-identifier for its value, which will be uniqued by the module with respect to other @-identifiers in it.

Examples:

// Global values use @-identifiers.
llvm.mlir.global constant @cst(42 : i32) : i32

// Non-constant values must also be initialized.
llvm.mlir.global @variable(32.0 : f32) : f32

// Strings are expected to be of wrapped LLVM i8 array type and do not
// automatically include the trailing zero.
llvm.mlir.global @string("abc") : !llvm.array<3 x i8>

// For strings globals, the trailing type may be omitted.
llvm.mlir.global constant @no_trailing_type("foo bar")

// A complex initializer is constructed with an initializer region.
llvm.mlir.global constant @int_gep() : !llvm.ptr {
  %0 = llvm.mlir.addressof @g2 : !llvm.ptr
  %1 = llvm.mlir.constant(2 : i32) : i32
  %2 = llvm.getelementptr %0[%1]
     : (!llvm.ptr, i32) -> !llvm.ptr, i32
  llvm.return %2 : !llvm.ptr
}

Similarly to functions, globals have a linkage attribute. In the custom syntax, this attribute is placed between llvm.mlir.global and the optional constant keyword. If the attribute is omitted, external linkage is assumed by default.

Examples:

// A constant with internal linkage will not participate in linking.
llvm.mlir.global internal constant @cst(42 : i32) : i32

// By default, "external" linkage is assumed and the global participates in
// symbol resolution at link-time.
llvm.mlir.global @glob(0 : f32) : f32

// Alignment is optional
llvm.mlir.global private constant @y(dense<1.0> : tensor<8xf32>) : !llvm.array<8 x f32>

Like global variables in LLVM IR, globals can have an (optional) alignment attribute using keyword alignment. The integer value of the alignment must be a positive integer that is a power of 2.

Examples:

// Alignment is optional
llvm.mlir.global private constant @y(dense<1.0> : tensor<8xf32>) { alignment = 32 : i64 } : !llvm.array<8 x f32>

The target_specific_attrs attribute provides a mechanism to preserve target-specific LLVM IR attributes that are not explicitly modeled in the LLVM dialect.

The attribute is an array containing either string attributes or two-element array attributes of strings. The value of a standalone string attribute is interpreted as the name of an LLVM IR attribute on the global. A two-element array is interpreted as a key-value pair.

Example:

llvm.mlir.global external @example() {
  target_specific_attrs = ["value-less-attr", ["int-attr", "4"], ["string-attr", "string"]]} : f64

OPERATION_NAME = 'llvm.mlir.global'¶

_ODS_REGIONS = (1, True)¶

global_type() → _ods_ir¶

constant() → bool¶

sym_name() → _ods_ir¶

linkage() → _ods_ir¶

dso_local() → bool¶

thread_local_() → bool¶

externally_initialized() → bool¶

value() → _ods_ir | None¶

alignment() → _ods_ir | None¶

addr_space() → _ods_ir¶

unnamed_addr() → _ods_ir | None¶

section() → _ods_ir | None¶

comdat() → _ods_ir | None¶

dbg_exprs() → _ods_ir | None¶

visibility_() → _ods_ir¶

target_specific_attrs() → _ods_ir | None¶

initializer() → _ods_ir¶

mlir.dialects._llvm_ops_gen.mlir_global(global_type, sym_name, linkage, *, constant=None, dso_local=None, thread_local_=None, externally_initialized=None, value=None, alignment=None, addr_space=None, unnamed_addr=None, section=None, comdat=None, dbg_exprs=None, visibility_=None, target_specific_attrs=None, loc=None, ip=None) → GlobalOp¶

class mlir.dialects._llvm_ops_gen.ICmpOp(predicate, lhs, rhs, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.icmp'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

predicate() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.icmp(predicate, lhs, rhs, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.IFuncOp(sym_name, i_func_type, resolver, resolver_type, linkage, *, dso_local=None, address_space=None, unnamed_addr=None, visibility_=None, loc=None, ip=None)¶

Bases: _ods_ir

llvm.mlir.ifunc is a top level operation that defines a global ifunc. It defines a new symbol and takes a symbol refering to a resolver function. IFuncs can be called as regular functions. The function type is the same as the IFuncType. The symbol is resolved at runtime by calling a resolver function.

Examples:

// IFuncs resolve a symbol at runtime using a resovler function.
llvm.mlir.ifunc external @foo: !llvm.func<f32 (i64)>, !llvm.ptr @resolver

llvm.func @foo_1(i64) -> f32
llvm.func @foo_2(i64) -> f32

llvm.func @resolve_foo() -> !llvm.ptr attributes {
  %0 = llvm.mlir.addressof @foo_2 : !llvm.ptr
  %1 = llvm.mlir.addressof @foo_1 : !llvm.ptr

  // ... Logic selecting from foo_{1, 2}

  // Return function pointer to the selected function
  llvm.return %7 : !llvm.ptr
}

llvm.func @use_foo() {
  // IFuncs are called as regular functions
  %res = llvm.call @foo(%value) : i64 -> f32
}

OPERATION_NAME = 'llvm.mlir.ifunc'¶

_ODS_REGIONS = (0, True)¶

sym_name() → _ods_ir¶

i_func_type() → _ods_ir¶

resolver() → _ods_ir¶

resolver_type() → _ods_ir¶

linkage() → _ods_ir¶

dso_local() → bool¶

address_space() → _ods_ir¶

unnamed_addr() → _ods_ir¶

visibility_() → _ods_ir¶

mlir.dialects._llvm_ops_gen.mlir_ifunc(sym_name, i_func_type, resolver, resolver_type, linkage, *, dso_local=None, address_space=None, unnamed_addr=None, visibility_=None, loc=None, ip=None) → IFuncOp¶

class mlir.dialects._llvm_ops_gen.IndirectBrOp(addr, succOperands, indbr_operand_segments, successors, *, loc=None, ip=None)¶

Bases: _ods_ir

Transfer control flow to address in $addr. A list of possible target blocks in $successors can be provided and maybe used as a hint in LLVM:

...
llvm.func @g(...
  %dest = llvm.blockaddress <function = @g, tag = <id = 0>> : !llvm.ptr
  llvm.indirectbr %dest : !llvm.ptr, [
    ^head
  ]
^head:
  llvm.blocktag <id = 0>
  llvm.return %arg0 : i32
  ...

It also supports a list of operands that can be passed to a target block:

  llvm.indirectbr %dest : !llvm.ptr, [
    ^head(%arg0 : i32),
    ^tail(%arg1, %arg0 : i32, i32)
  ]
^head(%r0 : i32):
  llvm.return %r0 : i32
^tail(%r1 : i32, %r2 : i32):
  ...

OPERATION_NAME = 'llvm.indirectbr'¶

_ODS_REGIONS = (0, True)¶

addr() → _ods_ir¶

succOperands() → _ods_ir¶

indbr_operand_segments() → _ods_ir¶

mlir.dialects._llvm_ops_gen.indirectbr(addr, succ_operands, indbr_operand_segments, successors, *, loc=None, ip=None) → IndirectBrOp¶

class mlir.dialects._llvm_ops_gen.InlineAsmOp(res, operands_, asm_string, constraints, *, has_side_effects=None, is_align_stack=None, tail_call_kind=None, asm_dialect=None, operand_attrs=None, loc=None, ip=None)¶

Bases: _ods_ir

The InlineAsmOp mirrors the underlying LLVM semantics with a notable exception: the embedded asm_string is not allowed to define or reference any symbol or any global variable: only the operands of the op may be read, written, or referenced. Attempting to define or reference any symbol or any global behavior is considered undefined behavior at this time. If tail_call_kind is used, the operation behaves like the specified tail call kind. The musttail kind it’s not available for this operation, since it isn’t supported by LLVM’s inline asm.

OPERATION_NAME = 'llvm.inline_asm'¶

_ODS_REGIONS = (0, True)¶

operands_() → _ods_ir¶

asm_string() → _ods_ir¶

constraints() → _ods_ir¶

has_side_effects() → bool¶

is_align_stack() → bool¶

tail_call_kind() → _ods_ir¶

asm_dialect() → _ods_ir | None¶

operand_attrs() → _ods_ir | None¶

res() → _ods_ir | None¶

mlir.dialects._llvm_ops_gen.inline_asm(res, operands_, asm_string, constraints, *, has_side_effects=None, is_align_stack=None, tail_call_kind=None, asm_dialect=None, operand_attrs=None, loc=None, ip=None) → _ods_ir | _ods_ir | InlineAsmOp¶

class mlir.dialects._llvm_ops_gen.InsertElementOp(vector, value, position, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.insertelement'¶

_ODS_REGIONS = (0, True)¶

vector() → _ods_ir¶

value() → _ods_ir¶

position() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.insertelement(vector, value, position, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.InsertValueOp(container, value, position, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.insertvalue'¶

_ODS_REGIONS = (0, True)¶

container() → _ods_ir¶

value() → _ods_ir¶

position() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.insertvalue(container, value, position, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.IntToPtrOp(res, arg, *, dereferenceable=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.inttoptr'¶

_ODS_REGIONS = (0, True)¶

arg() → _ods_ir¶

dereferenceable() → _ods_ir | None¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.inttoptr(res, arg, *, dereferenceable=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.InvariantEndOp(start, size, ptr, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.invariant.end'¶

_ODS_REGIONS = (0, True)¶

start() → _ods_ir¶

ptr() → _ods_ir¶

size() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_invariant_end(start, size, ptr, *, loc=None, ip=None) → InvariantEndOp¶

class mlir.dialects._llvm_ops_gen.InvariantStartOp(size, ptr, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.invariant.start'¶

_ODS_REGIONS = (0, True)¶

ptr() → _ods_ir¶

size() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_invariant_start(size, ptr, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.InvokeOp(result, callee_operands, normalDestOperands, unwindDestOperands, op_bundle_operands, op_bundle_sizes, normalDest, unwindDest, *, var_callee_type=None, callee=None, arg_attrs=None, res_attrs=None, branch_weights=None, CConv=None, op_bundle_tags=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.invoke'¶

_ODS_OPERAND_SEGMENTS¶

_ODS_REGIONS = (0, True)¶

callee_operands() → _ods_ir¶

normalDestOperands() → _ods_ir¶

unwindDestOperands() → _ods_ir¶

op_bundle_operands() → _ods_ir¶

var_callee_type() → _ods_ir | None¶

callee() → _ods_ir | None¶

arg_attrs() → _ods_ir | None¶

res_attrs() → _ods_ir | None¶

branch_weights() → _ods_ir | None¶

CConv() → _ods_ir¶

op_bundle_sizes() → _ods_ir¶

op_bundle_tags() → _ods_ir | None¶

result() → _ods_ir | None¶: Shortcut to get an op result if it has only one (throws an error otherwise).

mlir.dialects._llvm_ops_gen.invoke(result, callee_operands, normal_dest_operands, unwind_dest_operands, op_bundle_operands, op_bundle_sizes, normal_dest, unwind_dest, *, var_callee_type=None, callee=None, arg_attrs=None, res_attrs=None, branch_weights=None, c_conv=None, op_bundle_tags=None, loc=None, ip=None) → _ods_ir | _ods_ir | InvokeOp¶

class mlir.dialects._llvm_ops_gen.IsConstantOp(val, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.is.constant'¶

_ODS_REGIONS = (0, True)¶

val() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_is_constant(val, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.IsFPClass(res, in_, bit, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.is.fpclass'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

bit() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_is_fpclass(res, in_, bit, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.LLVMFuncOp(sym_name, function_type, *, sym_visibility=None, linkage=None, dso_local=None, CConv=None, comdat=None, convergent=None, personality=None, garbageCollector=None, passthrough=None, arg_attrs=None, res_attrs=None, function_entry_count=None, memory_effects=None, visibility_=None, arm_streaming=None, arm_locally_streaming=None, arm_streaming_compatible=None, arm_new_za=None, arm_in_za=None, arm_out_za=None, arm_inout_za=None, arm_preserves_za=None, section=None, unnamed_addr=None, alignment=None, vscale_range=None, frame_pointer=None, target_cpu=None, tune_cpu=None, reciprocal_estimates=None, prefer_vector_width=None, target_features=None, no_infs_fp_math=None, no_nans_fp_math=None, no_signed_zeros_fp_math=None, denormal_fp_math=None, denormal_fp_math_f32=None, fp_contract=None, instrument_function_entry=None, instrument_function_exit=None, no_inline=None, always_inline=None, inline_hint=None, no_unwind=None, will_return=None, optimize_none=None, vec_type_hint=None, work_group_size_hint=None, reqd_work_group_size=None, intel_reqd_sub_group_size=None, uwtable_kind=None, loc=None, ip=None)¶

Bases: _ods_ir

MLIR functions are defined by an operation that is not built into the IR itself. The LLVM dialect provides an llvm.func operation to define functions compatible with LLVM IR. These functions have LLVM dialect function type but use MLIR syntax to express it. They are required to have exactly one result type. LLVM function operation is intended to capture additional properties of LLVM functions, such as linkage and calling convention, that may be modeled differently by the built-in MLIR function.

// The type of @bar is !llvm<"i64 (i64)">
llvm.func @bar(%arg0: i64) -> i64 {
  llvm.return %arg0 : i64
}

// Type type of @foo is !llvm<"void (i64)">
// !llvm.void type is omitted
llvm.func @foo(%arg0: i64) {
  llvm.return
}

// A function with `internal` linkage.
llvm.func internal @internal_func() {
  llvm.return
}

OPERATION_NAME = 'llvm.func'¶

_ODS_REGIONS = (1, True)¶

sym_name() → _ods_ir¶

sym_visibility() → _ods_ir | None¶

function_type() → _ods_ir¶

linkage() → _ods_ir¶

dso_local() → bool¶

CConv() → _ods_ir¶

comdat() → _ods_ir | None¶

convergent() → bool¶

personality() → _ods_ir | None¶

garbageCollector() → _ods_ir | None¶

passthrough() → _ods_ir | None¶

arg_attrs() → _ods_ir | None¶

res_attrs() → _ods_ir | None¶

function_entry_count() → _ods_ir | None¶

memory_effects() → _ods_ir | None¶

visibility_() → _ods_ir¶

arm_streaming() → bool¶

arm_locally_streaming() → bool¶

arm_streaming_compatible() → bool¶

arm_new_za() → bool¶

arm_in_za() → bool¶

arm_out_za() → bool¶

arm_inout_za() → bool¶

arm_preserves_za() → bool¶

section() → _ods_ir | None¶

unnamed_addr() → _ods_ir | None¶

alignment() → _ods_ir | None¶

vscale_range() → _ods_ir | None¶

frame_pointer() → _ods_ir | None¶

target_cpu() → _ods_ir | None¶

tune_cpu() → _ods_ir | None¶

reciprocal_estimates() → _ods_ir | None¶

prefer_vector_width() → _ods_ir | None¶

target_features() → _ods_ir | None¶

no_infs_fp_math() → _ods_ir | None¶

no_nans_fp_math() → _ods_ir | None¶

no_signed_zeros_fp_math() → _ods_ir | None¶

denormal_fp_math() → _ods_ir | None¶

denormal_fp_math_f32() → _ods_ir | None¶

fp_contract() → _ods_ir | None¶

instrument_function_entry() → _ods_ir | None¶

instrument_function_exit() → _ods_ir | None¶

no_inline() → bool¶

always_inline() → bool¶

inline_hint() → bool¶

no_unwind() → bool¶

will_return() → bool¶

optimize_none() → bool¶

vec_type_hint() → _ods_ir | None¶

work_group_size_hint() → _ods_ir | None¶

reqd_work_group_size() → _ods_ir | None¶

intel_reqd_sub_group_size() → _ods_ir | None¶

uwtable_kind() → _ods_ir | None¶

body() → _ods_ir¶

mlir.dialects._llvm_ops_gen.func(sym_name, function_type, *, sym_visibility=None, linkage=None, dso_local=None, c_conv=None, comdat=None, convergent=None, personality=None, garbage_collector=None, passthrough=None, arg_attrs=None, res_attrs=None, function_entry_count=None, memory_effects=None, visibility_=None, arm_streaming=None, arm_locally_streaming=None, arm_streaming_compatible=None, arm_new_za=None, arm_in_za=None, arm_out_za=None, arm_inout_za=None, arm_preserves_za=None, section=None, unnamed_addr=None, alignment=None, vscale_range=None, frame_pointer=None, target_cpu=None, tune_cpu=None, reciprocal_estimates=None, prefer_vector_width=None, target_features=None, no_infs_fp_math=None, no_nans_fp_math=None, no_signed_zeros_fp_math=None, denormal_fp_math=None, denormal_fp_math_f32=None, fp_contract=None, instrument_function_entry=None, instrument_function_exit=None, no_inline=None, always_inline=None, inline_hint=None, no_unwind=None, will_return=None, optimize_none=None, vec_type_hint=None, work_group_size_hint=None, reqd_work_group_size=None, intel_reqd_sub_group_size=None, uwtable_kind=None, loc=None, ip=None) → LLVMFuncOp¶

class mlir.dialects._llvm_ops_gen.LShrOp(lhs, rhs, *, isExact=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.lshr'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

isExact() → bool¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.lshr(lhs, rhs, *, is_exact=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.LandingpadOp(res, _gen_arg_1, *, cleanup=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.landingpad'¶

_ODS_REGIONS = (0, True)¶

cleanup() → bool¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.landingpad(res, _gen_arg_1, *, cleanup=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.LaunderInvariantGroupOp(ptr, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.launder.invariant.group'¶

_ODS_REGIONS = (0, True)¶

ptr() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_launder_invariant_group(ptr, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.LifetimeEndOp(ptr, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.lifetime.end'¶

_ODS_REGIONS = (0, True)¶

ptr() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_lifetime_end(ptr, *, loc=None, ip=None) → LifetimeEndOp¶

class mlir.dialects._llvm_ops_gen.LifetimeStartOp(ptr, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.lifetime.start'¶

_ODS_REGIONS = (0, True)¶

ptr() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_lifetime_start(ptr, *, loc=None, ip=None) → LifetimeStartOp¶

class mlir.dialects._llvm_ops_gen.LinkerOptionsOp(options, *, loc=None, ip=None)¶

Bases: _ods_ir

Pass the given options to the linker when the resulting object file is linked. This is used extensively on Windows to determine the C runtime that the object files should link against.

Examples:

// Link against the MSVC static threaded CRT.
llvm.linker_options ["/DEFAULTLIB:", "libcmt"]

// Link against aarch64 compiler-rt builtins
llvm.linker_options ["-l", "clang_rt.builtins-aarch64"]

OPERATION_NAME = 'llvm.linker_options'¶

_ODS_REGIONS = (0, True)¶

options() → _ods_ir¶

mlir.dialects._llvm_ops_gen.linker_options(options, *, loc=None, ip=None) → LinkerOptionsOp¶

class mlir.dialects._llvm_ops_gen.LlrintOp(res, val, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.llrint'¶

_ODS_REGIONS = (0, True)¶

val() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_llrint(res, val, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.LlroundOp(res, val, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.llround'¶

_ODS_REGIONS = (0, True)¶

val() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_llround(res, val, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.LoadExpOp(res, val, power, *, fastmathFlags=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ldexp'¶

_ODS_REGIONS = (0, True)¶

val() → _ods_ir¶

power() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_ldexp(res, val, power, *, fastmath_flags=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.LoadOp(res, addr, *, alignment=None, volatile_=None, nontemporal=None, invariant=None, invariantGroup=None, ordering=None, syncscope=None, dereferenceable=None, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, loc=None, ip=None)¶

Bases: _ods_ir

The load operation is used to read from memory. A load may be marked as atomic, volatile, and/or nontemporal, and takes a number of optional attributes that specify aliasing information.

An atomic load only supports a limited set of pointer, integer, and floating point types, and requires an explicit alignment.

Examples:

// A volatile load of a float variable.
%0 = llvm.load volatile %ptr : !llvm.ptr -> f32

// A nontemporal load of a float variable.
%0 = llvm.load %ptr {nontemporal} : !llvm.ptr -> f32

// An atomic load of an integer variable.
%0 = llvm.load %ptr atomic monotonic {alignment = 8 : i64}
    : !llvm.ptr -> i64

See the following link for more details: https://llvm.org/docs/LangRef.html#load-instruction

OPERATION_NAME = 'llvm.load'¶

_ODS_REGIONS = (0, True)¶

addr() → _ods_ir¶

alignment() → _ods_ir | None¶

volatile_() → bool¶

nontemporal() → bool¶

invariant() → bool¶

invariantGroup() → bool¶

ordering() → _ods_ir¶

syncscope() → _ods_ir | None¶

dereferenceable() → _ods_ir | None¶

access_groups() → _ods_ir | None¶

alias_scopes() → _ods_ir | None¶

noalias_scopes() → _ods_ir | None¶

tbaa() → _ods_ir | None¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.load(res, addr, *, alignment=None, volatile_=None, nontemporal=None, invariant=None, invariant_group=None, ordering=None, syncscope=None, dereferenceable=None, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.Log2Op(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.log2'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_log2(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.Log10Op(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.log10'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_log10(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.LogOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.log'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_log(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.LrintOp(res, val, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.lrint'¶

_ODS_REGIONS = (0, True)¶

val() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_lrint(res, val, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.LroundOp(res, val, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.lround'¶

_ODS_REGIONS = (0, True)¶

val() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_lround(res, val, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.MaskedLoadOp(res, data, mask, alignment, *, pass_thru=None, nontemporal=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.masked.load'¶

_ODS_REGIONS = (0, True)¶

data() → _ods_ir¶

mask() → _ods_ir¶

pass_thru() → _ods_ir | None¶

alignment() → _ods_ir¶

nontemporal() → bool¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_masked_load(res, data, mask, alignment, *, pass_thru=None, nontemporal=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.MaskedStoreOp(value, data, mask, alignment, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.masked.store'¶

_ODS_REGIONS = (0, True)¶

value() → _ods_ir¶

data() → _ods_ir¶

mask() → _ods_ir¶

alignment() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_masked_store(value, data, mask, alignment, *, loc=None, ip=None) → MaskedStoreOp¶

class mlir.dialects._llvm_ops_gen.MatrixColumnMajorLoadOp(res, data, stride, isVolatile, rows, columns, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.matrix.column.major.load'¶

_ODS_REGIONS = (0, True)¶

data() → _ods_ir¶

stride() → _ods_ir¶

isVolatile() → _ods_ir¶

rows() → _ods_ir¶

columns() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_matrix_column_major_load(res, data, stride, is_volatile, rows, columns, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.MatrixColumnMajorStoreOp(matrix, data, stride, isVolatile, rows, columns, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.matrix.column.major.store'¶

_ODS_REGIONS = (0, True)¶

matrix() → _ods_ir¶

data() → _ods_ir¶

stride() → _ods_ir¶

isVolatile() → _ods_ir¶

rows() → _ods_ir¶

columns() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_matrix_column_major_store(matrix, data, stride, is_volatile, rows, columns, *, loc=None, ip=None) → MatrixColumnMajorStoreOp¶

class mlir.dialects._llvm_ops_gen.MatrixMultiplyOp(res, lhs, rhs, lhs_rows, lhs_columns, rhs_columns, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.matrix.multiply'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

lhs_rows() → _ods_ir¶

lhs_columns() → _ods_ir¶

rhs_columns() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_matrix_multiply(res, lhs, rhs, lhs_rows, lhs_columns, rhs_columns, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.MatrixTransposeOp(res, matrix, rows, columns, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.matrix.transpose'¶

_ODS_REGIONS = (0, True)¶

matrix() → _ods_ir¶

rows() → _ods_ir¶

columns() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_matrix_transpose(res, matrix, rows, columns, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.MaxNumOp(a, b, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.maxnum'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_maxnum(a, b, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.MaximumOp(a, b, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.maximum'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_maximum(a, b, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.MemcpyInlineOp(dst, src, len, isVolatile, *, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, arg_attrs=None, res_attrs=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.memcpy.inline'¶

_ODS_REGIONS = (0, True)¶

dst() → _ods_ir¶

src() → _ods_ir¶

len() → _ods_ir¶

isVolatile() → _ods_ir¶

access_groups() → _ods_ir | None¶

alias_scopes() → _ods_ir | None¶

noalias_scopes() → _ods_ir | None¶

tbaa() → _ods_ir | None¶

arg_attrs() → _ods_ir | None¶

res_attrs() → _ods_ir | None¶

mlir.dialects._llvm_ops_gen.intr_memcpy_inline(dst, src, len, is_volatile, *, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, arg_attrs=None, res_attrs=None, loc=None, ip=None) → MemcpyInlineOp¶

class mlir.dialects._llvm_ops_gen.MemcpyOp(dst, src, len, isVolatile, *, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, arg_attrs=None, res_attrs=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.memcpy'¶

_ODS_REGIONS = (0, True)¶

dst() → _ods_ir¶

src() → _ods_ir¶

len() → _ods_ir¶

isVolatile() → _ods_ir¶

access_groups() → _ods_ir | None¶

alias_scopes() → _ods_ir | None¶

noalias_scopes() → _ods_ir | None¶

tbaa() → _ods_ir | None¶

arg_attrs() → _ods_ir | None¶

res_attrs() → _ods_ir | None¶

mlir.dialects._llvm_ops_gen.intr_memcpy(dst, src, len, is_volatile, *, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, arg_attrs=None, res_attrs=None, loc=None, ip=None) → MemcpyOp¶

class mlir.dialects._llvm_ops_gen.MemmoveOp(dst, src, len, isVolatile, *, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, arg_attrs=None, res_attrs=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.memmove'¶

_ODS_REGIONS = (0, True)¶

dst() → _ods_ir¶

src() → _ods_ir¶

len() → _ods_ir¶

isVolatile() → _ods_ir¶

access_groups() → _ods_ir | None¶

alias_scopes() → _ods_ir | None¶

noalias_scopes() → _ods_ir | None¶

tbaa() → _ods_ir | None¶

arg_attrs() → _ods_ir | None¶

res_attrs() → _ods_ir | None¶

mlir.dialects._llvm_ops_gen.intr_memmove(dst, src, len, is_volatile, *, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, arg_attrs=None, res_attrs=None, loc=None, ip=None) → MemmoveOp¶

class mlir.dialects._llvm_ops_gen.MemsetInlineOp(dst, val, len, isVolatile, *, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, arg_attrs=None, res_attrs=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.memset.inline'¶

_ODS_REGIONS = (0, True)¶

dst() → _ods_ir¶

val() → _ods_ir¶

len() → _ods_ir¶

isVolatile() → _ods_ir¶

access_groups() → _ods_ir | None¶

alias_scopes() → _ods_ir | None¶

noalias_scopes() → _ods_ir | None¶

tbaa() → _ods_ir | None¶

arg_attrs() → _ods_ir | None¶

res_attrs() → _ods_ir | None¶

mlir.dialects._llvm_ops_gen.intr_memset_inline(dst, val, len, is_volatile, *, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, arg_attrs=None, res_attrs=None, loc=None, ip=None) → MemsetInlineOp¶

class mlir.dialects._llvm_ops_gen.MemsetOp(dst, val, len, isVolatile, *, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, arg_attrs=None, res_attrs=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.memset'¶

_ODS_REGIONS = (0, True)¶

dst() → _ods_ir¶

val() → _ods_ir¶

len() → _ods_ir¶

isVolatile() → _ods_ir¶

access_groups() → _ods_ir | None¶

alias_scopes() → _ods_ir | None¶

noalias_scopes() → _ods_ir | None¶

tbaa() → _ods_ir | None¶

arg_attrs() → _ods_ir | None¶

res_attrs() → _ods_ir | None¶

mlir.dialects._llvm_ops_gen.intr_memset(dst, val, len, is_volatile, *, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, arg_attrs=None, res_attrs=None, loc=None, ip=None) → MemsetOp¶

class mlir.dialects._llvm_ops_gen.MinNumOp(a, b, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.minnum'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_minnum(a, b, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.MinimumOp(a, b, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.minimum'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_minimum(a, b, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ModuleFlagsOp(flags, *, loc=None, ip=None)¶

Bases: _ods_ir

Represents the equivalent in MLIR for LLVM’s llvm.module.flags metadata, which requires a list of metadata triplets. Each triplet entry is described by a ModuleFlagAttr.

Example:

llvm.module.flags [
  #llvm.mlir.module_flag<error, "wchar_size", 4>,
  #llvm.mlir.module_flag<max, "PIC Level", 2>
]

OPERATION_NAME = 'llvm.module_flags'¶

_ODS_REGIONS = (0, True)¶

flags() → _ods_ir¶

mlir.dialects._llvm_ops_gen.module_flags(flags, *, loc=None, ip=None) → ModuleFlagsOp¶

class mlir.dialects._llvm_ops_gen.MulOp(lhs, rhs, overflowFlags, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.mul'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.mul(lhs, rhs, overflow_flags, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.NearbyintOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.nearbyint'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_nearbyint(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.NoAliasScopeDeclOp(scope, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.experimental.noalias.scope.decl'¶

_ODS_REGIONS = (0, True)¶

scope() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_experimental_noalias_scope_decl(scope, *, loc=None, ip=None) → NoAliasScopeDeclOp¶

class mlir.dialects._llvm_ops_gen.NoneTokenOp(*, results=None, loc=None, ip=None)¶

Bases: _ods_ir

Unlike LLVM IR, MLIR does not have first-class token values. They must be explicitly created as SSA values using llvm.mlir.none. This operation has no operands or attributes, and returns a none token value of a wrapped LLVM IR pointer type.

Examples:

%0 = llvm.mlir.none : !llvm.token

OPERATION_NAME = 'llvm.mlir.none'¶

_ODS_REGIONS = (0, True)¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.mlir_none(*, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.OrOp(lhs, rhs, *, isDisjoint=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.or'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

isDisjoint() → bool¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.or_(lhs, rhs, *, is_disjoint=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.PoisonOp(res, *, loc=None, ip=None)¶

Bases: _ods_ir

Unlike LLVM IR, MLIR does not have first-class poison values. Such values must be created as SSA values using llvm.mlir.poison. This operation has no operands or attributes. It creates a poison value of the specified LLVM IR dialect type.

Example:

// Create a poison value for a structure with a 32-bit integer followed
// by a float.
%0 = llvm.mlir.poison : !llvm.struct<(i32, f32)>

OPERATION_NAME = 'llvm.mlir.poison'¶

_ODS_REGIONS = (0, True)¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.mlir_poison(res, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.PowIOp(res, val, power, *, fastmathFlags=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.powi'¶

_ODS_REGIONS = (0, True)¶

val() → _ods_ir¶

power() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_powi(res, val, power, *, fastmath_flags=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.PowOp(a, b, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.pow'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_pow(a, b, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.Prefetch(addr, rw, hint, cache, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.prefetch'¶

_ODS_REGIONS = (0, True)¶

addr() → _ods_ir¶

rw() → _ods_ir¶

hint() → _ods_ir¶

cache() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_prefetch(addr, rw, hint, cache, *, loc=None, ip=None) → Prefetch¶

class mlir.dialects._llvm_ops_gen.PtrAnnotation(ptr, annotation, fileName, line, attr, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ptr.annotation'¶

_ODS_REGIONS = (0, True)¶

ptr() → _ods_ir¶

annotation() → _ods_ir¶

fileName() → _ods_ir¶

line() → _ods_ir¶

attr() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_ptr_annotation(ptr, annotation, file_name, line, attr, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.PtrMaskOp(ptr, mask, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ptrmask'¶

_ODS_REGIONS = (0, True)¶

ptr() → _ods_ir¶

mask() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_ptrmask(ptr, mask, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.PtrToIntOp(res, arg, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.ptrtoint'¶

_ODS_REGIONS = (0, True)¶

arg() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.ptrtoint(res, arg, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ResumeOp(value, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.resume'¶

_ODS_REGIONS = (0, True)¶

value() → _ods_ir¶

mlir.dialects._llvm_ops_gen.resume(value, *, loc=None, ip=None) → ResumeOp¶

class mlir.dialects._llvm_ops_gen.ReturnOp(*, arg=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.return'¶

_ODS_REGIONS = (0, True)¶

arg() → _ods_ir | None¶

mlir.dialects._llvm_ops_gen.return_(*, arg=None, loc=None, ip=None) → ReturnOp¶

class mlir.dialects._llvm_ops_gen.RintOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.rint'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_rint(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.RoundEvenOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.roundeven'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_roundeven(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.RoundOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.round'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_round(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SAddSat(a, b, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.sadd.sat'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_sadd_sat(a, b, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SAddWithOverflowOp(res, _gen_arg_0, _gen_arg_1, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.sadd.with.overflow'¶

_ODS_REGIONS = (0, True)¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_sadd_with_overflow(res, _gen_arg_0, _gen_arg_1, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SDivOp(lhs, rhs, *, isExact=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.sdiv'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

isExact() → bool¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.sdiv(lhs, rhs, *, is_exact=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SExtOp(res, arg, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.sext'¶

_ODS_REGIONS = (0, True)¶

arg() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.sext(res, arg, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SIToFPOp(res, arg, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.sitofp'¶

_ODS_REGIONS = (0, True)¶

arg() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.sitofp(res, arg, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SMaxOp(a, b, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.smax'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_smax(a, b, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SMinOp(a, b, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.smin'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_smin(a, b, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SMulWithOverflowOp(res, _gen_arg_0, _gen_arg_1, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.smul.with.overflow'¶

_ODS_REGIONS = (0, True)¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_smul_with_overflow(res, _gen_arg_0, _gen_arg_1, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SRemOp(lhs, rhs, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.srem'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.srem(lhs, rhs, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SSACopyOp(operand, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ssa.copy'¶

_ODS_REGIONS = (0, True)¶

operand() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_ssa_copy(operand, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SSHLSat(a, b, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.sshl.sat'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_sshl_sat(a, b, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SSubSat(a, b, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ssub.sat'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_ssub_sat(a, b, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SSubWithOverflowOp(res, _gen_arg_0, _gen_arg_1, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ssub.with.overflow'¶

_ODS_REGIONS = (0, True)¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_ssub_with_overflow(res, _gen_arg_0, _gen_arg_1, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SelectOp(condition, trueValue, falseValue, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.select'¶

_ODS_REGIONS = (0, True)¶

condition() → _ods_ir¶

trueValue() → _ods_ir¶

falseValue() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.select(condition, true_value, false_value, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ShlOp(lhs, rhs, overflowFlags, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.shl'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.shl(lhs, rhs, overflow_flags, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ShuffleVectorOp(res, v1, v2, mask, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.shufflevector'¶

_ODS_REGIONS = (0, True)¶

v1() → _ods_ir¶

v2() → _ods_ir¶

mask() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.shufflevector(res, v1, v2, mask, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SinOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.sin'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_sin(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SincosOp(res, val, *, fastmathFlags=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.sincos'¶

_ODS_REGIONS = (0, True)¶

val() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_sincos(res, val, *, fastmath_flags=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SinhOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.sinh'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_sinh(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SqrtOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.sqrt'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_sqrt(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.StackRestoreOp(ptr, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.stackrestore'¶

_ODS_REGIONS = (0, True)¶

ptr() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_stackrestore(ptr, *, loc=None, ip=None) → StackRestoreOp¶

class mlir.dialects._llvm_ops_gen.StackSaveOp(res, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.stacksave'¶

_ODS_REGIONS = (0, True)¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_stacksave(res, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.StepVectorOp(res, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.stepvector'¶

_ODS_REGIONS = (0, True)¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_stepvector(res, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.StoreOp(value, addr, *, alignment=None, volatile_=None, nontemporal=None, invariantGroup=None, ordering=None, syncscope=None, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, loc=None, ip=None)¶

Bases: _ods_ir

The store operation is used to write to memory. A store may be marked as atomic, volatile, and/or nontemporal, and takes a number of optional attributes that specify aliasing information.

An atomic store only supports a limited set of pointer, integer, and floating point types, and requires an explicit alignment.

Examples:

// A volatile store of a float variable.
llvm.store volatile %val, %ptr : f32, !llvm.ptr

// A nontemporal store of a float variable.
llvm.store %val, %ptr {nontemporal} : f32, !llvm.ptr

// An atomic store of an integer variable.
llvm.store %val, %ptr atomic monotonic {alignment = 8 : i64}
    : i64, !llvm.ptr

See the following link for more details: https://llvm.org/docs/LangRef.html#store-instruction

OPERATION_NAME = 'llvm.store'¶

_ODS_REGIONS = (0, True)¶

value() → _ods_ir¶

addr() → _ods_ir¶

alignment() → _ods_ir | None¶

volatile_() → bool¶

nontemporal() → bool¶

invariantGroup() → bool¶

ordering() → _ods_ir¶

syncscope() → _ods_ir | None¶

access_groups() → _ods_ir | None¶

alias_scopes() → _ods_ir | None¶

noalias_scopes() → _ods_ir | None¶

tbaa() → _ods_ir | None¶

mlir.dialects._llvm_ops_gen.store(value, addr, *, alignment=None, volatile_=None, nontemporal=None, invariant_group=None, ordering=None, syncscope=None, access_groups=None, alias_scopes=None, noalias_scopes=None, tbaa=None, loc=None, ip=None) → StoreOp¶

class mlir.dialects._llvm_ops_gen.StripInvariantGroupOp(ptr, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.strip.invariant.group'¶

_ODS_REGIONS = (0, True)¶

ptr() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_strip_invariant_group(ptr, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SubOp(lhs, rhs, overflowFlags, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.sub'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.sub(lhs, rhs, overflow_flags, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.SwitchOp(value, defaultOperands, caseOperands, case_operand_segments, defaultDestination, caseDestinations, *, case_values=None, branch_weights=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.switch'¶

_ODS_OPERAND_SEGMENTS¶

_ODS_REGIONS = (0, True)¶

value() → _ods_ir¶

defaultOperands() → _ods_ir¶

caseOperands() → _ods_ir¶

case_values() → _ods_ir | None¶

case_operand_segments() → _ods_ir¶

branch_weights() → _ods_ir | None¶

mlir.dialects._llvm_ops_gen.switch(value, default_operands, case_operands, case_operand_segments, default_destination, case_destinations, *, case_values=None, branch_weights=None, loc=None, ip=None) → SwitchOp¶

class mlir.dialects._llvm_ops_gen.TanOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.tan'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_tan(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.TanhOp(in_, *, fastmathFlags=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.tanh'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_tanh(in_, *, fastmath_flags=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ThreadlocalAddressOp(res, global_, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.threadlocal.address'¶

_ODS_REGIONS = (0, True)¶

global_() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_threadlocal_address(res, global_, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.Trap(*, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.trap'¶

_ODS_REGIONS = (0, True)¶

mlir.dialects._llvm_ops_gen.intr_trap(*, loc=None, ip=None) → Trap¶

class mlir.dialects._llvm_ops_gen.TruncOp(res, arg, overflowFlags, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.trunc'¶

_ODS_REGIONS = (0, True)¶

arg() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.trunc(res, arg, overflow_flags, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.UAddSat(a, b, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.uadd.sat'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_uadd_sat(a, b, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.UAddWithOverflowOp(res, _gen_arg_0, _gen_arg_1, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.uadd.with.overflow'¶

_ODS_REGIONS = (0, True)¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_uadd_with_overflow(res, _gen_arg_0, _gen_arg_1, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.UBSanTrap(failureKind, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ubsantrap'¶

_ODS_REGIONS = (0, True)¶

failureKind() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_ubsantrap(failure_kind, *, loc=None, ip=None) → UBSanTrap¶

class mlir.dialects._llvm_ops_gen.UDivOp(lhs, rhs, *, isExact=None, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.udiv'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

isExact() → bool¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.udiv(lhs, rhs, *, is_exact=None, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.UIToFPOp(res, arg, *, nonNeg=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.uitofp'¶

_ODS_REGIONS = (0, True)¶

arg() → _ods_ir¶

nonNeg() → bool¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.uitofp(res, arg, *, non_neg=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.UMaxOp(a, b, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.umax'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_umax(a, b, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.UMinOp(a, b, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.umin'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_umin(a, b, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.UMulWithOverflowOp(res, _gen_arg_0, _gen_arg_1, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.umul.with.overflow'¶

_ODS_REGIONS = (0, True)¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_umul_with_overflow(res, _gen_arg_0, _gen_arg_1, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.URemOp(lhs, rhs, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.urem'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.urem(lhs, rhs, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.USHLSat(a, b, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ushl.sat'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_ushl_sat(a, b, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.USubSat(a, b, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.usub.sat'¶

_ODS_REGIONS = (0, True)¶

a() → _ods_ir¶

b() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_usub_sat(a, b, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.USubWithOverflowOp(res, _gen_arg_0, _gen_arg_1, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.usub.with.overflow'¶

_ODS_REGIONS = (0, True)¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_usub_with_overflow(res, _gen_arg_0, _gen_arg_1, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.UndefOp(res, *, loc=None, ip=None)¶

Bases: _ods_ir

Unlike LLVM IR, MLIR does not have first-class undefined values. Such values must be created as SSA values using llvm.mlir.undef. This operation has no operands or attributes. It creates an undefined value of the specified LLVM IR dialect type.

Example:

// Create a structure with a 32-bit integer followed by a float.
%0 = llvm.mlir.undef : !llvm.struct<(i32, f32)>

OPERATION_NAME = 'llvm.mlir.undef'¶

_ODS_REGIONS = (0, True)¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.mlir_undef(res, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.UnreachableOp(*, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.unreachable'¶

_ODS_REGIONS = (0, True)¶

mlir.dialects._llvm_ops_gen.unreachable(*, loc=None, ip=None) → UnreachableOp¶

class mlir.dialects._llvm_ops_gen.VPAShrOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.ashr'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_ashr(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPAddOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.add'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_add(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPAndOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.and'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_and(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPFAddOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fadd'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_fadd(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPFDivOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fdiv'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_fdiv(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPFMulAddOp(res, op1, op2, op3, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fmuladd'¶

_ODS_REGIONS = (0, True)¶

op1() → _ods_ir¶

op2() → _ods_ir¶

op3() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_fmuladd(res, op1, op2, op3, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPFMulOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fmul'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_fmul(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPFNegOp(res, op, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fneg'¶

_ODS_REGIONS = (0, True)¶

op() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_fneg(res, op, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPFPExtOp(res, src, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fpext'¶

_ODS_REGIONS = (0, True)¶

src() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_fpext(res, src, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPFPToSIOp(res, src, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fptosi'¶

_ODS_REGIONS = (0, True)¶

src() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_fptosi(res, src, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPFPToUIOp(res, src, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fptoui'¶

_ODS_REGIONS = (0, True)¶

src() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_fptoui(res, src, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPFPTruncOp(res, src, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fptrunc'¶

_ODS_REGIONS = (0, True)¶

src() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_fptrunc(res, src, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPFRemOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.frem'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_frem(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPFSubOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fsub'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_fsub(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPFmaOp(res, op1, op2, op3, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fma'¶

_ODS_REGIONS = (0, True)¶

op1() → _ods_ir¶

op2() → _ods_ir¶

op3() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_fma(res, op1, op2, op3, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPIntToPtrOp(res, src, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.inttoptr'¶

_ODS_REGIONS = (0, True)¶

src() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_inttoptr(res, src, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPLShrOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.lshr'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_lshr(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPLoadOp(res, ptr, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.load'¶

_ODS_REGIONS = (0, True)¶

ptr() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_load(res, ptr, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPMergeMinOp(res, cond, true_val, false_val, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.merge'¶

_ODS_REGIONS = (0, True)¶

cond() → _ods_ir¶

true_val() → _ods_ir¶

false_val() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_merge(res, cond, true_val, false_val, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPMulOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.mul'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_mul(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPOrOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.or'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_or(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPPtrToIntOp(res, src, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.ptrtoint'¶

_ODS_REGIONS = (0, True)¶

src() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_ptrtoint(res, src, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPReduceAddOp(res, satrt_value, val, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.add'¶

_ODS_REGIONS = (0, True)¶

satrt_value() → _ods_ir¶

val() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_reduce_add(res, satrt_value, val, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPReduceAndOp(res, satrt_value, val, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.and'¶

_ODS_REGIONS = (0, True)¶

satrt_value() → _ods_ir¶

val() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_reduce_and(res, satrt_value, val, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPReduceFAddOp(res, satrt_value, val, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.fadd'¶

_ODS_REGIONS = (0, True)¶

satrt_value() → _ods_ir¶

val() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_reduce_fadd(res, satrt_value, val, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPReduceFMaxOp(res, satrt_value, val, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.fmax'¶

_ODS_REGIONS = (0, True)¶

satrt_value() → _ods_ir¶

val() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_reduce_fmax(res, satrt_value, val, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPReduceFMinOp(res, satrt_value, val, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.fmin'¶

_ODS_REGIONS = (0, True)¶

satrt_value() → _ods_ir¶

val() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_reduce_fmin(res, satrt_value, val, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPReduceFMulOp(res, satrt_value, val, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.fmul'¶

_ODS_REGIONS = (0, True)¶

satrt_value() → _ods_ir¶

val() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_reduce_fmul(res, satrt_value, val, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPReduceMulOp(res, satrt_value, val, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.mul'¶

_ODS_REGIONS = (0, True)¶

satrt_value() → _ods_ir¶

val() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_reduce_mul(res, satrt_value, val, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPReduceOrOp(res, satrt_value, val, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.or'¶

_ODS_REGIONS = (0, True)¶

satrt_value() → _ods_ir¶

val() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_reduce_or(res, satrt_value, val, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPReduceSMaxOp(res, satrt_value, val, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.smax'¶

_ODS_REGIONS = (0, True)¶

satrt_value() → _ods_ir¶

val() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_reduce_smax(res, satrt_value, val, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPReduceSMinOp(res, satrt_value, val, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.smin'¶

_ODS_REGIONS = (0, True)¶

satrt_value() → _ods_ir¶

val() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_reduce_smin(res, satrt_value, val, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPReduceUMaxOp(res, satrt_value, val, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.umax'¶

_ODS_REGIONS = (0, True)¶

satrt_value() → _ods_ir¶

val() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_reduce_umax(res, satrt_value, val, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPReduceUMinOp(res, satrt_value, val, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.umin'¶

_ODS_REGIONS = (0, True)¶

satrt_value() → _ods_ir¶

val() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_reduce_umin(res, satrt_value, val, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPReduceXorOp(res, satrt_value, val, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.xor'¶

_ODS_REGIONS = (0, True)¶

satrt_value() → _ods_ir¶

val() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_reduce_xor(res, satrt_value, val, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPSDivOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.sdiv'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_sdiv(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPSExtOp(res, src, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.sext'¶

_ODS_REGIONS = (0, True)¶

src() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_sext(res, src, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPSIToFPOp(res, src, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.sitofp'¶

_ODS_REGIONS = (0, True)¶

src() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_sitofp(res, src, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPSMaxOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.smax'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_smax(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPSMinOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.smin'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_smin(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPSRemOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.srem'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_srem(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPSelectMinOp(res, cond, true_val, false_val, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.select'¶

_ODS_REGIONS = (0, True)¶

cond() → _ods_ir¶

true_val() → _ods_ir¶

false_val() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_select(res, cond, true_val, false_val, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPShlOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.shl'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_shl(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPStoreOp(val, ptr, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.store'¶

_ODS_REGIONS = (0, True)¶

val() → _ods_ir¶

ptr() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_store(val, ptr, mask, evl, *, loc=None, ip=None) → VPStoreOp¶

class mlir.dialects._llvm_ops_gen.VPStridedLoadOp(res, ptr, stride, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.experimental.vp.strided.load'¶

_ODS_REGIONS = (0, True)¶

ptr() → _ods_ir¶

stride() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_experimental_vp_strided_load(res, ptr, stride, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPStridedStoreOp(val, ptr, stride, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.experimental.vp.strided.store'¶

_ODS_REGIONS = (0, True)¶

val() → _ods_ir¶

ptr() → _ods_ir¶

stride() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_experimental_vp_strided_store(val, ptr, stride, mask, evl, *, loc=None, ip=None) → VPStridedStoreOp¶

class mlir.dialects._llvm_ops_gen.VPSubOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.sub'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_sub(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPTruncOp(res, src, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.trunc'¶

_ODS_REGIONS = (0, True)¶

src() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_trunc(res, src, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPUDivOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.udiv'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_udiv(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPUIToFPOp(res, src, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.uitofp'¶

_ODS_REGIONS = (0, True)¶

src() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_uitofp(res, src, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPUMaxOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.umax'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_umax(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPUMinOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.umin'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_umin(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPURemOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.urem'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_urem(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPXorOp(res, lhs, rhs, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.xor'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_xor(res, lhs, rhs, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VPZExtOp(res, src, mask, evl, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.zext'¶

_ODS_REGIONS = (0, True)¶

src() → _ods_ir¶

mask() → _ods_ir¶

evl() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vp_zext(res, src, mask, evl, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VaArgOp(res, arg, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.va_arg'¶

_ODS_REGIONS = (0, True)¶

arg() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.va_arg(res, arg, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.VaCopyOp(dest_list, src_list, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vacopy'¶

_ODS_REGIONS = (0, True)¶

dest_list() → _ods_ir¶

src_list() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vacopy(dest_list, src_list, *, loc=None, ip=None) → VaCopyOp¶

class mlir.dialects._llvm_ops_gen.VaEndOp(arg_list, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vaend'¶

_ODS_REGIONS = (0, True)¶

arg_list() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vaend(arg_list, *, loc=None, ip=None) → VaEndOp¶

class mlir.dialects._llvm_ops_gen.VaStartOp(arg_list, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vastart'¶

_ODS_REGIONS = (0, True)¶

arg_list() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vastart(arg_list, *, loc=None, ip=None) → VaStartOp¶

class mlir.dialects._llvm_ops_gen.VarAnnotation(val, annotation, fileName, line, attr, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.var.annotation'¶

_ODS_REGIONS = (0, True)¶

val() → _ods_ir¶

annotation() → _ods_ir¶

fileName() → _ods_ir¶

line() → _ods_ir¶

attr() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_var_annotation(val, annotation, file_name, line, attr, *, loc=None, ip=None) → VarAnnotation¶

class mlir.dialects._llvm_ops_gen.XOrOp(lhs, rhs, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.xor'¶

_ODS_REGIONS = (0, True)¶

lhs() → _ods_ir¶

rhs() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.xor(lhs, rhs, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ZExtOp(res, arg, *, nonNeg=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.zext'¶

_ODS_REGIONS = (0, True)¶

arg() → _ods_ir¶

nonNeg() → bool¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.zext(res, arg, *, non_neg=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.ZeroOp(res, *, loc=None, ip=None)¶

Bases: _ods_ir

Unlike LLVM IR, MLIR does not have first-class zero-initialized values. Such values must be created as SSA values using llvm.mlir.zero. This operation has no operands or attributes. It creates a zero-initialized value of the specified LLVM IR dialect type.

Example:

// Create a zero-initialized value for a structure with a 32-bit integer
// followed by a float.
%0 = llvm.mlir.zero : !llvm.struct<(i32, f32)>

OPERATION_NAME = 'llvm.mlir.zero'¶

_ODS_REGIONS = (0, True)¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.mlir_zero(res, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.masked_compressstore(value, ptr, mask, *, arg_attrs=None, res_attrs=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.masked.compressstore'¶

_ODS_REGIONS = (0, True)¶

value() → _ods_ir¶

ptr() → _ods_ir¶

mask() → _ods_ir¶

arg_attrs() → _ods_ir | None¶

res_attrs() → _ods_ir | None¶

mlir.dialects._llvm_ops_gen.intr_masked_compressstore(value, ptr, mask, *, arg_attrs=None, res_attrs=None, loc=None, ip=None) → masked_compressstore¶

class mlir.dialects._llvm_ops_gen.masked_expandload(res, ptr, mask, passthru, *, arg_attrs=None, res_attrs=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.masked.expandload'¶

_ODS_REGIONS = (0, True)¶

ptr() → _ods_ir¶

mask() → _ods_ir¶

passthru() → _ods_ir¶

arg_attrs() → _ods_ir | None¶

res_attrs() → _ods_ir | None¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_masked_expandload(res, ptr, mask, passthru, *, arg_attrs=None, res_attrs=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.masked_gather(res, ptrs, mask, pass_thru, alignment, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.masked.gather'¶

_ODS_REGIONS = (0, True)¶

ptrs() → _ods_ir¶

mask() → _ods_ir¶

pass_thru() → _ods_ir¶

alignment() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_masked_gather(res, ptrs, mask, pass_thru, alignment, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.masked_scatter(value, ptrs, mask, alignment, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.masked.scatter'¶

_ODS_REGIONS = (0, True)¶

value() → _ods_ir¶

ptrs() → _ods_ir¶

mask() → _ods_ir¶

alignment() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_masked_scatter(value, ptrs, mask, alignment, *, loc=None, ip=None) → masked_scatter¶

class mlir.dialects._llvm_ops_gen.vector_deinterleave2(res, vec, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.deinterleave2'¶

_ODS_REGIONS = (0, True)¶

vec() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_deinterleave2(res, vec, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_extract(res, srcvec, pos, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.extract'¶

_ODS_REGIONS = (0, True)¶

srcvec() → _ods_ir¶

pos() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_extract(res, srcvec, pos, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_insert(dstvec, srcvec, pos, *, results=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.insert'¶

_ODS_REGIONS = (0, True)¶

dstvec() → _ods_ir¶

srcvec() → _ods_ir¶

pos() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_insert(dstvec, srcvec, pos, *, results=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_interleave2(res, vec1, vec2, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.interleave2'¶

_ODS_REGIONS = (0, True)¶

vec1() → _ods_ir¶

vec2() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_interleave2(res, vec1, vec2, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_reduce_add(res, in_, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.add'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_reduce_add(res, in_, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_reduce_and(res, in_, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.and'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_reduce_and(res, in_, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_reduce_fadd(res, start_value, input, *, fastmathFlags=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.fadd'¶

_ODS_REGIONS = (0, True)¶

start_value() → _ods_ir¶

input() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_reduce_fadd(res, start_value, input, *, fastmath_flags=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_reduce_fmax(res, in_, *, fastmathFlags=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.fmax'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_reduce_fmax(res, in_, *, fastmath_flags=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_reduce_fmaximum(res, in_, *, fastmathFlags=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.fmaximum'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_reduce_fmaximum(res, in_, *, fastmath_flags=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_reduce_fmin(res, in_, *, fastmathFlags=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.fmin'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_reduce_fmin(res, in_, *, fastmath_flags=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_reduce_fminimum(res, in_, *, fastmathFlags=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.fminimum'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_reduce_fminimum(res, in_, *, fastmath_flags=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_reduce_fmul(res, start_value, input, *, fastmathFlags=None, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.fmul'¶

_ODS_REGIONS = (0, True)¶

start_value() → _ods_ir¶

input() → _ods_ir¶

fastmathFlags() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_reduce_fmul(res, start_value, input, *, fastmath_flags=None, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_reduce_mul(res, in_, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.mul'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_reduce_mul(res, in_, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_reduce_or(res, in_, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.or'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_reduce_or(res, in_, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_reduce_smax(res, in_, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.smax'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_reduce_smax(res, in_, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_reduce_smin(res, in_, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.smin'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_reduce_smin(res, in_, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_reduce_umax(res, in_, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.umax'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_reduce_umax(res, in_, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_reduce_umin(res, in_, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.umin'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_reduce_umin(res, in_, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vector_reduce_xor(res, in_, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.xor'¶

_ODS_REGIONS = (0, True)¶

in_() → _ods_ir¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vector_reduce_xor(res, in_, *, loc=None, ip=None) → _ods_ir¶

class mlir.dialects._llvm_ops_gen.vscale(res, *, loc=None, ip=None)¶

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vscale'¶

_ODS_REGIONS = (0, True)¶

res() → _ods_ir¶

mlir.dialects._llvm_ops_gen.intr_vscale(res, *, loc=None, ip=None) → _ods_ir¶