mlir.dialects._llvm_ops_gen

Attributes

Classes

_Dialect

ACosOp

ACosOpAdaptor

AShrOp

AShrOpAdaptor

ASinOp

ASinOpAdaptor

ATan2Op

ATan2OpAdaptor

ATanOp

ATanOpAdaptor

AbsOp

AbsOpAdaptor

AddOp

AddOpAdaptor

AddrSpaceCastOp

AddrSpaceCastOpAdaptor

AddressOfOp

Creates an SSA value containing a pointer to a global value (function,

AddressOfOpAdaptor

AliasOp

llvm.mlir.alias is a top level operation that defines a global alias for

AliasOpAdaptor

AllocaOp

AllocaOpAdaptor

AndOp

AndOpAdaptor

Annotation

AnnotationAdaptor

AssumeOp

AssumeOpAdaptor

AtomicCmpXchgOp

AtomicCmpXchgOpAdaptor

AtomicRMWOp

AtomicRMWOpAdaptor

BitReverseOp

BitReverseOpAdaptor

BitcastOp

BitcastOpAdaptor

BlockAddressOp

Creates an SSA value containing a pointer to a basic block. The block

BlockAddressOpAdaptor

BlockTagOp

This operation uses a tag to uniquely identify an MLIR block in a

BlockTagOpAdaptor

BrOp

BrOpAdaptor

ByteSwapOp

ByteSwapOpAdaptor

CallIntrinsicOp

Call the specified llvm intrinsic. If the intrinsic is overloaded, use

CallIntrinsicOpAdaptor

CallOp

In LLVM IR, functions may return either 0 or 1 value. LLVM IR dialect

CallOpAdaptor

ComdatOp

Provides access to object file COMDAT section/group functionality.

ComdatOpAdaptor

ComdatSelectorOp

Provides access to object file COMDAT section/group functionality.

ComdatSelectorOpAdaptor

CondBrOp

CondBrOpAdaptor

ConstantOp

Unlike LLVM IR, MLIR does not have first-class constant values. Therefore,

ConstantOpAdaptor

ConstrainedFPExtIntr

ConstrainedFPExtIntrAdaptor

ConstrainedFPTruncIntr

ConstrainedFPTruncIntrAdaptor

ConstrainedSIToFP

ConstrainedSIToFPAdaptor

ConstrainedUIToFP

ConstrainedUIToFPAdaptor

CopySignOp

CopySignOpAdaptor

CoroAlignOp

CoroAlignOpAdaptor

CoroBeginOp

CoroBeginOpAdaptor

CoroEndOp

CoroEndOpAdaptor

CoroFreeOp

CoroFreeOpAdaptor

CoroIdOp

CoroIdOpAdaptor

CoroPromiseOp

CoroPromiseOpAdaptor

CoroResumeOp

CoroResumeOpAdaptor

CoroSaveOp

CoroSaveOpAdaptor

CoroSizeOp

CoroSizeOpAdaptor

CoroSuspendOp

CoroSuspendOpAdaptor

CosOp

CosOpAdaptor

CoshOp

CoshOpAdaptor

CountLeadingZerosOp

CountLeadingZerosOpAdaptor

CountTrailingZerosOp

CountTrailingZerosOpAdaptor

CtPopOp

CtPopOpAdaptor

DSOLocalEquivalentOp

Creates an SSA value containing a pointer to a global value (function or

DSOLocalEquivalentOpAdaptor

DbgDeclareOp

DbgDeclareOpAdaptor

DbgLabelOp

DbgLabelOpAdaptor

DbgValueOp

DbgValueOpAdaptor

DebugTrap

DebugTrapAdaptor

EhTypeidForOp

EhTypeidForOpAdaptor

Exp2Op

Exp2OpAdaptor

Exp10Op

Exp10OpAdaptor

ExpOp

ExpOpAdaptor

ExpectOp

ExpectOpAdaptor

ExpectWithProbabilityOp

ExpectWithProbabilityOpAdaptor

ExtractElementOp

ExtractElementOpAdaptor

ExtractValueOp

ExtractValueOpAdaptor

FAbsOp

FAbsOpAdaptor

FAddOp

FAddOpAdaptor

FCeilOp

FCeilOpAdaptor

FCmpOp

FCmpOpAdaptor

FDivOp

FDivOpAdaptor

FFloorOp

FFloorOpAdaptor

FMAOp

FMAOpAdaptor

FMulAddOp

FMulAddOpAdaptor

FMulOp

FMulOpAdaptor

FNegOp

FNegOpAdaptor

FPExtOp

FPExtOpAdaptor

FPToSIOp

FPToSIOpAdaptor

FPToUIOp

FPToUIOpAdaptor

FPTruncOp

FPTruncOpAdaptor

FRemOp

FRemOpAdaptor

FSubOp

FSubOpAdaptor

FTruncOp

FTruncOpAdaptor

FenceOp

FenceOpAdaptor

FractionExpOp

FractionExpOpAdaptor

FreezeOp

FreezeOpAdaptor

FshlOp

FshlOpAdaptor

FshrOp

FshrOpAdaptor

GEPOp

This operation mirrors LLVM IRs 'getelementptr' operation that is used to

GEPOpAdaptor

GetActiveLaneMaskOp

GetActiveLaneMaskOpAdaptor

GlobalCtorsOp

Specifies a list of constructor functions, priorities, and associated data.

GlobalCtorsOpAdaptor

GlobalDtorsOp

Specifies a list of destructor functions and priorities. The functions

GlobalDtorsOpAdaptor

GlobalOp

Since MLIR allows for arbitrary operations to be present at the top level,

GlobalOpAdaptor

ICmpOp

ICmpOpAdaptor

IFuncOp

llvm.mlir.ifunc is a top level operation that defines a global ifunc.

IFuncOpAdaptor

IndirectBrOp

Transfer control flow to address in $addr. A list of possible target

IndirectBrOpAdaptor

InlineAsmOp

The InlineAsmOp mirrors the underlying LLVM semantics with a notable

InlineAsmOpAdaptor

InsertElementOp

InsertElementOpAdaptor

InsertValueOp

InsertValueOpAdaptor

IntToPtrOp

IntToPtrOpAdaptor

InvariantEndOp

InvariantEndOpAdaptor

InvariantStartOp

InvariantStartOpAdaptor

InvokeOp

InvokeOpAdaptor

IsConstantOp

IsConstantOpAdaptor

IsFPClass

IsFPClassAdaptor

LLVMFuncOp

MLIR functions are defined by an operation that is not built into the IR

LLVMFuncOpAdaptor

LShrOp

LShrOpAdaptor

LandingpadOp

LandingpadOpAdaptor

LaunderInvariantGroupOp

LaunderInvariantGroupOpAdaptor

LifetimeEndOp

LifetimeEndOpAdaptor

LifetimeStartOp

LifetimeStartOpAdaptor

LinkerOptionsOp

Pass the given options to the linker when the resulting object file is linked.

LinkerOptionsOpAdaptor

LlrintOp

LlrintOpAdaptor

LlroundOp

LlroundOpAdaptor

LoadExpOp

LoadExpOpAdaptor

LoadOp

The load operation is used to read from memory. A load may be marked as

LoadOpAdaptor

Log2Op

Log2OpAdaptor

Log10Op

Log10OpAdaptor

LogOp

LogOpAdaptor

LrintOp

LrintOpAdaptor

LroundOp

LroundOpAdaptor

MaskedLoadOp

MaskedLoadOpAdaptor

MaskedStoreOp

MaskedStoreOpAdaptor

MatrixColumnMajorLoadOp

MatrixColumnMajorLoadOpAdaptor

MatrixColumnMajorStoreOp

MatrixColumnMajorStoreOpAdaptor

MatrixMultiplyOp

MatrixMultiplyOpAdaptor

MatrixTransposeOp

MatrixTransposeOpAdaptor

MaxNumOp

MaxNumOpAdaptor

MaximumOp

MaximumOpAdaptor

MemcpyInlineOp

MemcpyInlineOpAdaptor

MemcpyOp

MemcpyOpAdaptor

MemmoveOp

MemmoveOpAdaptor

MemsetInlineOp

MemsetInlineOpAdaptor

MemsetOp

MemsetOpAdaptor

MinNumOp

MinNumOpAdaptor

MinimumOp

MinimumOpAdaptor

ModuleFlagsOp

Represents the equivalent in MLIR for LLVM's llvm.module.flags metadata,

ModuleFlagsOpAdaptor

MulOp

MulOpAdaptor

NearbyintOp

NearbyintOpAdaptor

NoAliasScopeDeclOp

NoAliasScopeDeclOpAdaptor

NoneTokenOp

Unlike LLVM IR, MLIR does not have first-class token values. They must be

NoneTokenOpAdaptor

OrOp

OrOpAdaptor

PoisonOp

Unlike LLVM IR, MLIR does not have first-class poison values. Such values

PoisonOpAdaptor

PowIOp

PowIOpAdaptor

PowOp

PowOpAdaptor

Prefetch

PrefetchAdaptor

PtrAnnotation

PtrAnnotationAdaptor

PtrMaskOp

PtrMaskOpAdaptor

PtrToIntOp

PtrToIntOpAdaptor

ResumeOp

ResumeOpAdaptor

ReturnOp

ReturnOpAdaptor

RintOp

RintOpAdaptor

RoundEvenOp

RoundEvenOpAdaptor

RoundOp

RoundOpAdaptor

SAddSat

SAddSatAdaptor

SAddWithOverflowOp

SAddWithOverflowOpAdaptor

SCmpOp

SCmpOpAdaptor

SDivOp

SDivOpAdaptor

SExtOp

SExtOpAdaptor

SIToFPOp

SIToFPOpAdaptor

SMaxOp

SMaxOpAdaptor

SMinOp

SMinOpAdaptor

SMulWithOverflowOp

SMulWithOverflowOpAdaptor

SRemOp

SRemOpAdaptor

SSACopyOp

SSACopyOpAdaptor

SSHLSat

SSHLSatAdaptor

SSubSat

SSubSatAdaptor

SSubWithOverflowOp

SSubWithOverflowOpAdaptor

SelectOp

SelectOpAdaptor

ShlOp

ShlOpAdaptor

ShuffleVectorOp

ShuffleVectorOpAdaptor

SinOp

SinOpAdaptor

SincosOp

SincosOpAdaptor

SinhOp

SinhOpAdaptor

SqrtOp

SqrtOpAdaptor

StackRestoreOp

StackRestoreOpAdaptor

StackSaveOp

StackSaveOpAdaptor

StepVectorOp

StepVectorOpAdaptor

StoreOp

The store operation is used to write to memory. A store may be marked as

StoreOpAdaptor

StripInvariantGroupOp

StripInvariantGroupOpAdaptor

SubOp

SubOpAdaptor

SwitchOp

SwitchOpAdaptor

TanOp

TanOpAdaptor

TanhOp

TanhOpAdaptor

ThreadlocalAddressOp

ThreadlocalAddressOpAdaptor

Trap

TrapAdaptor

TruncOp

TruncOpAdaptor

UAddSat

UAddSatAdaptor

UAddWithOverflowOp

UAddWithOverflowOpAdaptor

UBSanTrap

UBSanTrapAdaptor

UCmpOp

UCmpOpAdaptor

UDivOp

UDivOpAdaptor

UIToFPOp

UIToFPOpAdaptor

UMaxOp

UMaxOpAdaptor

UMinOp

UMinOpAdaptor

UMulWithOverflowOp

UMulWithOverflowOpAdaptor

URemOp

URemOpAdaptor

USHLSat

USHLSatAdaptor

USubSat

USubSatAdaptor

USubWithOverflowOp

USubWithOverflowOpAdaptor

UndefOp

Unlike LLVM IR, MLIR does not have first-class undefined values. Such values

UndefOpAdaptor

UnreachableOp

UnreachableOpAdaptor

VPAShrOp

VPAShrOpAdaptor

VPAddOp

VPAddOpAdaptor

VPAndOp

VPAndOpAdaptor

VPFAddOp

VPFAddOpAdaptor

VPFDivOp

VPFDivOpAdaptor

VPFMulAddOp

VPFMulAddOpAdaptor

VPFMulOp

VPFMulOpAdaptor

VPFNegOp

VPFNegOpAdaptor

VPFPExtOp

VPFPExtOpAdaptor

VPFPToSIOp

VPFPToSIOpAdaptor

VPFPToUIOp

VPFPToUIOpAdaptor

VPFPTruncOp

VPFPTruncOpAdaptor

VPFRemOp

VPFRemOpAdaptor

VPFSubOp

VPFSubOpAdaptor

VPFmaOp

VPFmaOpAdaptor

VPIntToPtrOp

VPIntToPtrOpAdaptor

VPLShrOp

VPLShrOpAdaptor

VPLoadOp

VPLoadOpAdaptor

VPMergeMinOp

VPMergeMinOpAdaptor

VPMulOp

VPMulOpAdaptor

VPOrOp

VPOrOpAdaptor

VPPtrToIntOp

VPPtrToIntOpAdaptor

VPReduceAddOp

VPReduceAddOpAdaptor

VPReduceAndOp

VPReduceAndOpAdaptor

VPReduceFAddOp

VPReduceFAddOpAdaptor

VPReduceFMaxOp

VPReduceFMaxOpAdaptor

VPReduceFMinOp

VPReduceFMinOpAdaptor

VPReduceFMulOp

VPReduceFMulOpAdaptor

VPReduceMulOp

VPReduceMulOpAdaptor

VPReduceOrOp

VPReduceOrOpAdaptor

VPReduceSMaxOp

VPReduceSMaxOpAdaptor

VPReduceSMinOp

VPReduceSMinOpAdaptor

VPReduceUMaxOp

VPReduceUMaxOpAdaptor

VPReduceUMinOp

VPReduceUMinOpAdaptor

VPReduceXorOp

VPReduceXorOpAdaptor

VPSDivOp

VPSDivOpAdaptor

VPSExtOp

VPSExtOpAdaptor

VPSIToFPOp

VPSIToFPOpAdaptor

VPSMaxOp

VPSMaxOpAdaptor

VPSMinOp

VPSMinOpAdaptor

VPSRemOp

VPSRemOpAdaptor

VPSelectMinOp

VPSelectMinOpAdaptor

VPShlOp

VPShlOpAdaptor

VPStoreOp

VPStoreOpAdaptor

VPStridedLoadOp

VPStridedLoadOpAdaptor

VPStridedStoreOp

VPStridedStoreOpAdaptor

VPSubOp

VPSubOpAdaptor

VPTruncOp

VPTruncOpAdaptor

VPUDivOp

VPUDivOpAdaptor

VPUIToFPOp

VPUIToFPOpAdaptor

VPUMaxOp

VPUMaxOpAdaptor

VPUMinOp

VPUMinOpAdaptor

VPURemOp

VPURemOpAdaptor

VPXorOp

VPXorOpAdaptor

VPZExtOp

VPZExtOpAdaptor

VaArgOp

VaArgOpAdaptor

VaCopyOp

VaCopyOpAdaptor

VaEndOp

VaEndOpAdaptor

VaStartOp

VaStartOpAdaptor

VarAnnotation

VarAnnotationAdaptor

XOrOp

XOrOpAdaptor

ZExtOp

ZExtOpAdaptor

ZeroOp

Unlike LLVM IR, MLIR does not have first-class zero-initialized values.

ZeroOpAdaptor

masked_compressstore

masked_compressstoreAdaptor

masked_expandload

masked_expandloadAdaptor

masked_gather

masked_gatherAdaptor

masked_scatter

masked_scatterAdaptor

vector_deinterleave2

vector_deinterleave2Adaptor

vector_extract

vector_extractAdaptor

vector_insert

vector_insertAdaptor

vector_interleave2

vector_interleave2Adaptor

vector_reduce_add

vector_reduce_addAdaptor

vector_reduce_and

vector_reduce_andAdaptor

vector_reduce_fadd

vector_reduce_faddAdaptor

vector_reduce_fmax

vector_reduce_fmaxAdaptor

vector_reduce_fmaximum

vector_reduce_fmaximumAdaptor

vector_reduce_fmin

vector_reduce_fminAdaptor

vector_reduce_fminimum

vector_reduce_fminimumAdaptor

vector_reduce_fmul

vector_reduce_fmulAdaptor

vector_reduce_mul

vector_reduce_mulAdaptor

vector_reduce_or

vector_reduce_orAdaptor

vector_reduce_smax

vector_reduce_smaxAdaptor

vector_reduce_smin

vector_reduce_sminAdaptor

vector_reduce_umax

vector_reduce_umaxAdaptor

vector_reduce_umin

vector_reduce_uminAdaptor

vector_reduce_xor

vector_reduce_xorAdaptor

vscale

vscaleAdaptor

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)

intr_scmp(→ _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)

intr_ucmp(→ _ods_ir)

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
class mlir.dialects._llvm_ops_gen.ACosOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ACosOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.acos'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.AShrOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.AShrOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.ashr'
lhs() _ods_ir
rhs() _ods_ir
isExact() bool
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
class mlir.dialects._llvm_ops_gen.ASinOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ASinOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.asin'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.ATan2OpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ATan2OpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.atan2'
a() _ods_ir
b() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.ATanOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ATanOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.atan'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.AbsOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.AbsOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.abs'
in_() _ods_ir
is_int_min_poison() _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
class mlir.dialects._llvm_ops_gen.AddOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.AddOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.add'
lhs() _ods_ir
rhs() _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
class mlir.dialects._llvm_ops_gen.AddrSpaceCastOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.AddrSpaceCastOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.addrspacecast'
arg() _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
class mlir.dialects._llvm_ops_gen.AddressOfOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.AddressOfOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.mlir.addressof'
global_name() _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
class mlir.dialects._llvm_ops_gen.AliasOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.AliasOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.mlir.alias'
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
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[_ods_ir]
alignment() _ods_ir | None
elem_type() _ods_ir
inalloca() bool
res() _ods_ir
class mlir.dialects._llvm_ops_gen.AllocaOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.AllocaOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.alloca'
arraySize() _ods_ir[_ods_ir]
alignment() _ods_ir | None
elem_type() _ods_ir
inalloca() bool
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
class mlir.dialects._llvm_ops_gen.AndOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.AndOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.and'
lhs() _ods_ir
rhs() _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[_ods_ir]
annotation() _ods_ir
fileName() _ods_ir
line() _ods_ir[_ods_ir]
res() _ods_ir[_ods_ir]
class mlir.dialects._llvm_ops_gen.AnnotationAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.AnnotationAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.annotation'
integer() _ods_ir[_ods_ir]
annotation() _ods_ir
fileName() _ods_ir
line() _ods_ir[_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[_ods_ir]
op_bundle_operands() _ods_ir
op_bundle_sizes() _ods_ir
op_bundle_tags() _ods_ir | None
class mlir.dialects._llvm_ops_gen.AssumeOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.AssumeOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.assume'
cond() _ods_ir[_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
class mlir.dialects._llvm_ops_gen.AtomicCmpXchgOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.AtomicCmpXchgOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.cmpxchg'
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
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
class mlir.dialects._llvm_ops_gen.AtomicRMWOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.AtomicRMWOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.atomicrmw'
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
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
class mlir.dialects._llvm_ops_gen.BitReverseOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.BitReverseOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.bitreverse'
in_() _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
class mlir.dialects._llvm_ops_gen.BitcastOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.BitcastOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.bitcast'
arg() _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
class mlir.dialects._llvm_ops_gen.BlockAddressOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.BlockAddressOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.blockaddress'
block_addr() _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
class mlir.dialects._llvm_ops_gen.BlockTagOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.BlockTagOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.blocktag'
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
class mlir.dialects._llvm_ops_gen.BrOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.BrOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.br'
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
class mlir.dialects._llvm_ops_gen.ByteSwapOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ByteSwapOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.bswap'
in_() _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
class mlir.dialects._llvm_ops_gen.CallIntrinsicOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CallIntrinsicOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.call_intrinsic'
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
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, noreturn=None, returns_twice=None, hot=None, cold=None, noduplicate=None, no_caller_saved_registers=None, nocallback=None, modular_format=None, nobuiltins=None, allocsize=None, optsize=None, minsize=None, nobuiltin=None, save_reg_params=None, zero_call_used_regs=None, trap_func_name=None, default_func_attrs=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
noreturn() bool
returns_twice() bool
hot() bool
cold() bool
noduplicate() bool
no_caller_saved_registers() bool
nocallback() bool
modular_format() _ods_ir | None
nobuiltins() _ods_ir | None
allocsize() _ods_ir | None
optsize() bool
minsize() bool
nobuiltin() bool
save_reg_params() bool
zero_call_used_regs() _ods_ir | None
trap_func_name() _ods_ir | None
default_func_attrs() _ods_ir | None
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).

class mlir.dialects._llvm_ops_gen.CallOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CallOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.call'
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
noreturn() bool
returns_twice() bool
hot() bool
cold() bool
noduplicate() bool
no_caller_saved_registers() bool
nocallback() bool
modular_format() _ods_ir | None
nobuiltins() _ods_ir | None
allocsize() _ods_ir | None
optsize() bool
minsize() bool
nobuiltin() bool
save_reg_params() bool
zero_call_used_regs() _ods_ir | None
trap_func_name() _ods_ir | None
default_func_attrs() _ods_ir | None
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
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, noreturn=None, returns_twice=None, hot=None, cold=None, noduplicate=None, no_caller_saved_registers=None, nocallback=None, modular_format=None, nobuiltins=None, allocsize=None, optsize=None, minsize=None, nobuiltin=None, save_reg_params=None, zero_call_used_regs=None, trap_func_name=None, default_func_attrs=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
class mlir.dialects._llvm_ops_gen.ComdatOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ComdatOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.comdat'
sym_name() _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
class mlir.dialects._llvm_ops_gen.ComdatSelectorOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ComdatSelectorOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.comdat_selector'
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[_ods_ir]
trueDestOperands() _ods_ir
falseDestOperands() _ods_ir
branch_weights() _ods_ir | None
loop_annotation() _ods_ir | None
class mlir.dialects._llvm_ops_gen.CondBrOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CondBrOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.cond_br'
condition() _ods_ir[_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
class mlir.dialects._llvm_ops_gen.ConstantOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ConstantOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.mlir.constant'
value() _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
class mlir.dialects._llvm_ops_gen.ConstrainedFPExtIntrAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ConstrainedFPExtIntrAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.experimental.constrained.fpext'
arg_0() _ods_ir
fpExceptionBehavior() _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
class mlir.dialects._llvm_ops_gen.ConstrainedFPTruncIntrAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ConstrainedFPTruncIntrAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.experimental.constrained.fptrunc'
arg_0() _ods_ir
roundingmode() _ods_ir
fpExceptionBehavior() _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
class mlir.dialects._llvm_ops_gen.ConstrainedSIToFPAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ConstrainedSIToFPAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.experimental.constrained.sitofp'
arg_0() _ods_ir
roundingmode() _ods_ir
fpExceptionBehavior() _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
class mlir.dialects._llvm_ops_gen.ConstrainedUIToFPAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ConstrainedUIToFPAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.experimental.constrained.uitofp'
arg_0() _ods_ir
roundingmode() _ods_ir
fpExceptionBehavior() _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
class mlir.dialects._llvm_ops_gen.CopySignOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CopySignOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.copysign'
a() _ods_ir
b() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.CoroAlignOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CoroAlignOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.align'
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
class mlir.dialects._llvm_ops_gen.CoroBeginOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CoroBeginOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.begin'
token() _ods_ir
mem() _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[_ods_ir]
retvals() _ods_ir
res() _ods_ir
class mlir.dialects._llvm_ops_gen.CoroEndOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CoroEndOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.end'
handle() _ods_ir
unwind() _ods_ir[_ods_ir]
retvals() _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
class mlir.dialects._llvm_ops_gen.CoroFreeOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CoroFreeOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.free'
id() _ods_ir
handle() _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[_ods_ir]
promise() _ods_ir
coroaddr() _ods_ir
fnaddrs() _ods_ir
res() _ods_ir
class mlir.dialects._llvm_ops_gen.CoroIdOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CoroIdOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.id'
align() _ods_ir[_ods_ir]
promise() _ods_ir
coroaddr() _ods_ir
fnaddrs() _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[_ods_ir]
from_() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.CoroPromiseOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CoroPromiseOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.promise'
handle() _ods_ir
align() _ods_ir[_ods_ir]
from_() _ods_ir[_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
class mlir.dialects._llvm_ops_gen.CoroResumeOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CoroResumeOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.resume'
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
class mlir.dialects._llvm_ops_gen.CoroSaveOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CoroSaveOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.save'
handle() _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
class mlir.dialects._llvm_ops_gen.CoroSizeOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CoroSizeOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.size'
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[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.CoroSuspendOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CoroSuspendOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.coro.suspend'
save() _ods_ir
final() _ods_ir[_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
class mlir.dialects._llvm_ops_gen.CosOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CosOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.cos'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.CoshOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CoshOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.cosh'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.CountLeadingZerosOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CountLeadingZerosOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ctlz'
in_() _ods_ir
is_zero_poison() _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
class mlir.dialects._llvm_ops_gen.CountTrailingZerosOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CountTrailingZerosOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.cttz'
in_() _ods_ir
is_zero_poison() _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
class mlir.dialects._llvm_ops_gen.CtPopOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.CtPopOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ctpop'
in_() _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
class mlir.dialects._llvm_ops_gen.DSOLocalEquivalentOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.DSOLocalEquivalentOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.dso_local_equivalent'
function_name() _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
class mlir.dialects._llvm_ops_gen.DbgDeclareOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.DbgDeclareOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.dbg.declare'
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
class mlir.dialects._llvm_ops_gen.DbgLabelOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.DbgLabelOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.dbg.label'
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
class mlir.dialects._llvm_ops_gen.DbgValueOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.DbgValueOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.dbg.value'
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)
class mlir.dialects._llvm_ops_gen.DebugTrapAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.DebugTrapAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.debugtrap'
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
class mlir.dialects._llvm_ops_gen.EhTypeidForOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.EhTypeidForOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.eh.typeid.for'
type_info() _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
class mlir.dialects._llvm_ops_gen.Exp2OpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.Exp2OpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.exp2'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.Exp10OpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.Exp10OpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.exp10'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.ExpOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ExpOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.exp'
in_() _ods_ir
fastmathFlags() _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[_ods_ir]
expected() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.ExpectOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ExpectOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.expect'
val() _ods_ir[_ods_ir]
expected() _ods_ir[_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[_ods_ir]
expected() _ods_ir[_ods_ir]
prob() _ods_ir
res() _ods_ir
class mlir.dialects._llvm_ops_gen.ExpectWithProbabilityOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ExpectWithProbabilityOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.expect.with.probability'
val() _ods_ir[_ods_ir]
expected() _ods_ir[_ods_ir]
prob() _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[_ods_ir]
position() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.ExtractElementOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ExtractElementOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.extractelement'
vector() _ods_ir[_ods_ir]
position() _ods_ir[_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
class mlir.dialects._llvm_ops_gen.ExtractValueOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ExtractValueOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.extractvalue'
container() _ods_ir
position() _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
class mlir.dialects._llvm_ops_gen.FAbsOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FAbsOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.fabs'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.FAddOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FAddOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.fadd'
lhs() _ods_ir
rhs() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.FCeilOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FCeilOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ceil'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.FCmpOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FCmpOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.fcmp'
lhs() _ods_ir
rhs() _ods_ir
predicate() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.FDivOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FDivOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.fdiv'
lhs() _ods_ir
rhs() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.FFloorOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FFloorOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.floor'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.FMAOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FMAOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.fma'
a() _ods_ir
b() _ods_ir
c() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.FMulAddOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FMulAddOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.fmuladd'
a() _ods_ir
b() _ods_ir
c() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.FMulOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FMulOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.fmul'
lhs() _ods_ir
rhs() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.FNegOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FNegOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.fneg'
operand() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.FPExtOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FPExtOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.fpext'
arg() _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
class mlir.dialects._llvm_ops_gen.FPToSIOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FPToSIOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.fptosi'
arg() _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
class mlir.dialects._llvm_ops_gen.FPToUIOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FPToUIOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.fptoui'
arg() _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
class mlir.dialects._llvm_ops_gen.FPTruncOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FPTruncOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.fptrunc'
arg() _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
class mlir.dialects._llvm_ops_gen.FRemOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FRemOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.frem'
lhs() _ods_ir
rhs() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.FSubOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FSubOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.fsub'
lhs() _ods_ir
rhs() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.FTruncOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FTruncOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.trunc'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.FenceOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FenceOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.fence'
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
class mlir.dialects._llvm_ops_gen.FractionExpOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FractionExpOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.frexp'
val() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.FreezeOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FreezeOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.freeze'
val() _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
class mlir.dialects._llvm_ops_gen.FshlOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FshlOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.fshl'
a() _ods_ir
b() _ods_ir
c() _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
class mlir.dialects._llvm_ops_gen.FshrOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.FshrOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.fshr'
a() _ods_ir
b() _ods_ir
c() _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
class mlir.dialects._llvm_ops_gen.GEPOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.GEPOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.getelementptr'
base() _ods_ir
dynamicIndices() _ods_ir
rawConstantIndices() _ods_ir
elem_type() _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[_ods_ir]
n() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.GetActiveLaneMaskOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.GetActiveLaneMaskOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.get.active.lane.mask'
base() _ods_ir[_ods_ir]
n() _ods_ir[_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
class mlir.dialects._llvm_ops_gen.GlobalCtorsOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.GlobalCtorsOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.mlir.global_ctors'
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
class mlir.dialects._llvm_ops_gen.GlobalDtorsOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.GlobalDtorsOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.mlir.global_dtors'
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
class mlir.dialects._llvm_ops_gen.GlobalOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.GlobalOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.mlir.global'
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
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
class mlir.dialects._llvm_ops_gen.ICmpOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ICmpOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.icmp'
lhs() _ods_ir
rhs() _ods_ir
predicate() _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
class mlir.dialects._llvm_ops_gen.IFuncOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.IFuncOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.mlir.ifunc'
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
class mlir.dialects._llvm_ops_gen.IndirectBrOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.IndirectBrOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.indirectbr'
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
class mlir.dialects._llvm_ops_gen.InlineAsmOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.InlineAsmOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.inline_asm'
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
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[_ods_ir]
value() _ods_ir
position() _ods_ir[_ods_ir]
res() _ods_ir[_ods_ir]
class mlir.dialects._llvm_ops_gen.InsertElementOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.InsertElementOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.insertelement'
vector() _ods_ir[_ods_ir]
value() _ods_ir
position() _ods_ir[_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
class mlir.dialects._llvm_ops_gen.InsertValueOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.InsertValueOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.insertvalue'
container() _ods_ir
value() _ods_ir
position() _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
class mlir.dialects._llvm_ops_gen.IntToPtrOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.IntToPtrOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.inttoptr'
arg() _ods_ir
dereferenceable() _ods_ir | None
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
class mlir.dialects._llvm_ops_gen.InvariantEndOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.InvariantEndOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.invariant.end'
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
class mlir.dialects._llvm_ops_gen.InvariantStartOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.InvariantStartOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.invariant.start'
ptr() _ods_ir
size() _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).

class mlir.dialects._llvm_ops_gen.InvokeOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.InvokeOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.invoke'
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
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[_ods_ir]
class mlir.dialects._llvm_ops_gen.IsConstantOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.IsConstantOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.is.constant'
val() _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
class mlir.dialects._llvm_ops_gen.IsFPClassAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.IsFPClassAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.is.fpclass'
in_() _ods_ir
bit() _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_fpenv=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, noreturn=None, optimize_none=None, returns_twice=None, hot=None, cold=None, noduplicate=None, no_caller_saved_registers=None, nocallback=None, modular_format=None, nobuiltins=None, allocsize=None, optsize=None, minsize=None, save_reg_params=None, zero_call_used_regs=None, default_func_attrs=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_fpenv() _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
noreturn() bool
optimize_none() bool
returns_twice() bool
hot() bool
cold() bool
noduplicate() bool
no_caller_saved_registers() bool
nocallback() bool
modular_format() _ods_ir | None
nobuiltins() _ods_ir | None
allocsize() _ods_ir | None
optsize() bool
minsize() bool
save_reg_params() bool
zero_call_used_regs() _ods_ir | None
default_func_attrs() _ods_ir | None
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
class mlir.dialects._llvm_ops_gen.LLVMFuncOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.LLVMFuncOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.func'
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_fpenv() _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
noreturn() bool
optimize_none() bool
returns_twice() bool
hot() bool
cold() bool
noduplicate() bool
no_caller_saved_registers() bool
nocallback() bool
modular_format() _ods_ir | None
nobuiltins() _ods_ir | None
allocsize() _ods_ir | None
optsize() bool
minsize() bool
save_reg_params() bool
zero_call_used_regs() _ods_ir | None
default_func_attrs() _ods_ir | None
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
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_fpenv=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, noreturn=None, optimize_none=None, returns_twice=None, hot=None, cold=None, noduplicate=None, no_caller_saved_registers=None, nocallback=None, modular_format=None, nobuiltins=None, allocsize=None, optsize=None, minsize=None, save_reg_params=None, zero_call_used_regs=None, default_func_attrs=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
class mlir.dialects._llvm_ops_gen.LShrOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.LShrOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.lshr'
lhs() _ods_ir
rhs() _ods_ir
isExact() bool
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
class mlir.dialects._llvm_ops_gen.LandingpadOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.LandingpadOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.landingpad'
cleanup() bool
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
class mlir.dialects._llvm_ops_gen.LaunderInvariantGroupOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.LaunderInvariantGroupOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.launder.invariant.group'
ptr() _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
class mlir.dialects._llvm_ops_gen.LifetimeEndOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.LifetimeEndOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.lifetime.end'
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
class mlir.dialects._llvm_ops_gen.LifetimeStartOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.LifetimeStartOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.lifetime.start'
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
class mlir.dialects._llvm_ops_gen.LinkerOptionsOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.LinkerOptionsOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.linker_options'
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
class mlir.dialects._llvm_ops_gen.LlrintOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.LlrintOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.llrint'
val() _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
class mlir.dialects._llvm_ops_gen.LlroundOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.LlroundOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.llround'
val() _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[_ods_ir]
fastmathFlags() _ods_ir
res() _ods_ir
class mlir.dialects._llvm_ops_gen.LoadExpOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.LoadExpOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ldexp'
val() _ods_ir
power() _ods_ir[_ods_ir]
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.LoadOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.LoadOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.load'
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
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
class mlir.dialects._llvm_ops_gen.Log2OpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.Log2OpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.log2'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.Log10OpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.Log10OpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.log10'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.LogOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.LogOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.log'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.LrintOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.LrintOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.lrint'
val() _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
class mlir.dialects._llvm_ops_gen.LroundOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.LroundOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.lround'
val() _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[_ods_ir]
pass_thru() _ods_ir[_ods_ir] | None
alignment() _ods_ir
nontemporal() bool
res() _ods_ir[_ods_ir]
class mlir.dialects._llvm_ops_gen.MaskedLoadOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.MaskedLoadOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.masked.load'
data() _ods_ir
mask() _ods_ir[_ods_ir]
pass_thru() _ods_ir[_ods_ir] | None
alignment() _ods_ir
nontemporal() bool
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[_ods_ir]
data() _ods_ir
mask() _ods_ir[_ods_ir]
alignment() _ods_ir
class mlir.dialects._llvm_ops_gen.MaskedStoreOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.MaskedStoreOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.masked.store'
value() _ods_ir[_ods_ir]
data() _ods_ir
mask() _ods_ir[_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[_ods_ir]
isVolatile() _ods_ir
rows() _ods_ir
columns() _ods_ir
res() _ods_ir[_ods_ir]
class mlir.dialects._llvm_ops_gen.MatrixColumnMajorLoadOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.MatrixColumnMajorLoadOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.matrix.column.major.load'
data() _ods_ir
stride() _ods_ir[_ods_ir]
isVolatile() _ods_ir
rows() _ods_ir
columns() _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[_ods_ir]
data() _ods_ir
stride() _ods_ir[_ods_ir]
isVolatile() _ods_ir
rows() _ods_ir
columns() _ods_ir
class mlir.dialects._llvm_ops_gen.MatrixColumnMajorStoreOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.MatrixColumnMajorStoreOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.matrix.column.major.store'
matrix() _ods_ir[_ods_ir]
data() _ods_ir
stride() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
lhs_rows() _ods_ir
lhs_columns() _ods_ir
rhs_columns() _ods_ir
res() _ods_ir[_ods_ir]
class mlir.dialects._llvm_ops_gen.MatrixMultiplyOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.MatrixMultiplyOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.matrix.multiply'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
lhs_rows() _ods_ir
lhs_columns() _ods_ir
rhs_columns() _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[_ods_ir]
rows() _ods_ir
columns() _ods_ir
res() _ods_ir[_ods_ir]
class mlir.dialects._llvm_ops_gen.MatrixTransposeOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.MatrixTransposeOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.matrix.transpose'
matrix() _ods_ir[_ods_ir]
rows() _ods_ir
columns() _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
class mlir.dialects._llvm_ops_gen.MaxNumOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.MaxNumOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.maxnum'
a() _ods_ir
b() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.MaximumOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.MaximumOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.maximum'
a() _ods_ir
b() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.MemcpyInlineOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.MemcpyInlineOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.memcpy.inline'
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[_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
class mlir.dialects._llvm_ops_gen.MemcpyOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.MemcpyOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.memcpy'
dst() _ods_ir
src() _ods_ir
len() _ods_ir[_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[_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
class mlir.dialects._llvm_ops_gen.MemmoveOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.MemmoveOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.memmove'
dst() _ods_ir
src() _ods_ir
len() _ods_ir[_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[_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
class mlir.dialects._llvm_ops_gen.MemsetInlineOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.MemsetInlineOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.memset.inline'
dst() _ods_ir
val() _ods_ir[_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[_ods_ir]
len() _ods_ir[_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
class mlir.dialects._llvm_ops_gen.MemsetOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.MemsetOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.memset'
dst() _ods_ir
val() _ods_ir[_ods_ir]
len() _ods_ir[_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
class mlir.dialects._llvm_ops_gen.MinNumOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.MinNumOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.minnum'
a() _ods_ir
b() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.MinimumOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.MinimumOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.minimum'
a() _ods_ir
b() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.ModuleFlagsOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ModuleFlagsOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.module_flags'
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
class mlir.dialects._llvm_ops_gen.MulOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.MulOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.mul'
lhs() _ods_ir
rhs() _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
class mlir.dialects._llvm_ops_gen.NearbyintOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.NearbyintOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.nearbyint'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.NoAliasScopeDeclOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.NoAliasScopeDeclOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.experimental.noalias.scope.decl'
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
class mlir.dialects._llvm_ops_gen.NoneTokenOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.NoneTokenOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.mlir.none'
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
class mlir.dialects._llvm_ops_gen.OrOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.OrOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.or'
lhs() _ods_ir
rhs() _ods_ir
isDisjoint() bool
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
class mlir.dialects._llvm_ops_gen.PoisonOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.PoisonOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.mlir.poison'
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[_ods_ir]
fastmathFlags() _ods_ir
res() _ods_ir
class mlir.dialects._llvm_ops_gen.PowIOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.PowIOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.powi'
val() _ods_ir
power() _ods_ir[_ods_ir]
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.PowOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.PowOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.pow'
a() _ods_ir
b() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.PrefetchAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.PrefetchAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.prefetch'
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[_ods_ir]
attr() _ods_ir
res() _ods_ir
class mlir.dialects._llvm_ops_gen.PtrAnnotationAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.PtrAnnotationAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ptr.annotation'
ptr() _ods_ir
annotation() _ods_ir
fileName() _ods_ir
line() _ods_ir[_ods_ir]
attr() _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
class mlir.dialects._llvm_ops_gen.PtrMaskOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.PtrMaskOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ptrmask'
ptr() _ods_ir
mask() _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
class mlir.dialects._llvm_ops_gen.PtrToIntOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.PtrToIntOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.ptrtoint'
arg() _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
class mlir.dialects._llvm_ops_gen.ResumeOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ResumeOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.resume'
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
class mlir.dialects._llvm_ops_gen.ReturnOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ReturnOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.return'
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
class mlir.dialects._llvm_ops_gen.RintOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.RintOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.rint'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.RoundEvenOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.RoundEvenOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.roundeven'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.RoundOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.RoundOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.round'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.SAddSatAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SAddSatAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.sadd.sat'
a() _ods_ir
b() _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
class mlir.dialects._llvm_ops_gen.SAddWithOverflowOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SAddWithOverflowOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.sadd.with.overflow'
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.SCmpOp(res, a, b, *, loc=None, ip=None)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.scmp'
_ODS_REGIONS = (0, True)
a() _ods_ir
b() _ods_ir
res() _ods_ir
class mlir.dialects._llvm_ops_gen.SCmpOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SCmpOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.scmp'
a() _ods_ir
b() _ods_ir
mlir.dialects._llvm_ops_gen.intr_scmp(res, a, b, *, 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
class mlir.dialects._llvm_ops_gen.SDivOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SDivOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.sdiv'
lhs() _ods_ir
rhs() _ods_ir
isExact() bool
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
class mlir.dialects._llvm_ops_gen.SExtOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SExtOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.sext'
arg() _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
class mlir.dialects._llvm_ops_gen.SIToFPOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SIToFPOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.sitofp'
arg() _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
class mlir.dialects._llvm_ops_gen.SMaxOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SMaxOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.smax'
a() _ods_ir
b() _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
class mlir.dialects._llvm_ops_gen.SMinOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SMinOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.smin'
a() _ods_ir
b() _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
class mlir.dialects._llvm_ops_gen.SMulWithOverflowOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SMulWithOverflowOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.smul.with.overflow'
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
class mlir.dialects._llvm_ops_gen.SRemOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SRemOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.srem'
lhs() _ods_ir
rhs() _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
class mlir.dialects._llvm_ops_gen.SSACopyOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SSACopyOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ssa.copy'
operand() _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
class mlir.dialects._llvm_ops_gen.SSHLSatAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SSHLSatAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.sshl.sat'
a() _ods_ir
b() _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
class mlir.dialects._llvm_ops_gen.SSubSatAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SSubSatAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ssub.sat'
a() _ods_ir
b() _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
class mlir.dialects._llvm_ops_gen.SSubWithOverflowOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SSubWithOverflowOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ssub.with.overflow'
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
class mlir.dialects._llvm_ops_gen.SelectOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SelectOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.select'
condition() _ods_ir
trueValue() _ods_ir
falseValue() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.ShlOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ShlOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.shl'
lhs() _ods_ir
rhs() _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[_ods_ir]
v2() _ods_ir[_ods_ir]
mask() _ods_ir
res() _ods_ir[_ods_ir]
class mlir.dialects._llvm_ops_gen.ShuffleVectorOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ShuffleVectorOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.shufflevector'
v1() _ods_ir[_ods_ir]
v2() _ods_ir[_ods_ir]
mask() _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
class mlir.dialects._llvm_ops_gen.SinOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SinOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.sin'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.SincosOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SincosOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.sincos'
val() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.SinhOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SinhOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.sinh'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.SqrtOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SqrtOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.sqrt'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.StackRestoreOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.StackRestoreOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.stackrestore'
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
class mlir.dialects._llvm_ops_gen.StackSaveOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.StackSaveOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.stacksave'
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[_ods_ir]
class mlir.dialects._llvm_ops_gen.StepVectorOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.StepVectorOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.stepvector'
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
class mlir.dialects._llvm_ops_gen.StoreOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.StoreOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.store'
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
class mlir.dialects._llvm_ops_gen.StripInvariantGroupOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.StripInvariantGroupOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.strip.invariant.group'
ptr() _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
class mlir.dialects._llvm_ops_gen.SubOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SubOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.sub'
lhs() _ods_ir
rhs() _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[_ods_ir]
defaultOperands() _ods_ir
caseOperands() _ods_ir
case_values() _ods_ir | None
case_operand_segments() _ods_ir
branch_weights() _ods_ir | None
class mlir.dialects._llvm_ops_gen.SwitchOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.SwitchOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.switch'
value() _ods_ir[_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
class mlir.dialects._llvm_ops_gen.TanOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.TanOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.tan'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.TanhOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.TanhOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.tanh'
in_() _ods_ir
fastmathFlags() _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
class mlir.dialects._llvm_ops_gen.ThreadlocalAddressOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ThreadlocalAddressOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.threadlocal.address'
global_() _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)
class mlir.dialects._llvm_ops_gen.TrapAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.TrapAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.trap'
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
class mlir.dialects._llvm_ops_gen.TruncOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.TruncOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.trunc'
arg() _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
class mlir.dialects._llvm_ops_gen.UAddSatAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.UAddSatAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.uadd.sat'
a() _ods_ir
b() _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
class mlir.dialects._llvm_ops_gen.UAddWithOverflowOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.UAddWithOverflowOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.uadd.with.overflow'
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
class mlir.dialects._llvm_ops_gen.UBSanTrapAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.UBSanTrapAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ubsantrap'
failureKind() _ods_ir
mlir.dialects._llvm_ops_gen.intr_ubsantrap(failure_kind, *, loc=None, ip=None) UBSanTrap
class mlir.dialects._llvm_ops_gen.UCmpOp(res, a, b, *, loc=None, ip=None)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ucmp'
_ODS_REGIONS = (0, True)
a() _ods_ir
b() _ods_ir
res() _ods_ir
class mlir.dialects._llvm_ops_gen.UCmpOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.UCmpOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ucmp'
a() _ods_ir
b() _ods_ir
mlir.dialects._llvm_ops_gen.intr_ucmp(res, a, b, *, loc=None, ip=None) _ods_ir
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
class mlir.dialects._llvm_ops_gen.UDivOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.UDivOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.udiv'
lhs() _ods_ir
rhs() _ods_ir
isExact() bool
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
class mlir.dialects._llvm_ops_gen.UIToFPOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.UIToFPOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.uitofp'
arg() _ods_ir
nonNeg() bool
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
class mlir.dialects._llvm_ops_gen.UMaxOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.UMaxOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.umax'
a() _ods_ir
b() _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
class mlir.dialects._llvm_ops_gen.UMinOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.UMinOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.umin'
a() _ods_ir
b() _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
class mlir.dialects._llvm_ops_gen.UMulWithOverflowOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.UMulWithOverflowOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.umul.with.overflow'
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
class mlir.dialects._llvm_ops_gen.URemOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.URemOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.urem'
lhs() _ods_ir
rhs() _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
class mlir.dialects._llvm_ops_gen.USHLSatAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.USHLSatAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.ushl.sat'
a() _ods_ir
b() _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
class mlir.dialects._llvm_ops_gen.USubSatAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.USubSatAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.usub.sat'
a() _ods_ir
b() _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
class mlir.dialects._llvm_ops_gen.USubWithOverflowOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.USubWithOverflowOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.usub.with.overflow'
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
class mlir.dialects._llvm_ops_gen.UndefOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.UndefOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.mlir.undef'
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)
class mlir.dialects._llvm_ops_gen.UnreachableOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.UnreachableOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.unreachable'
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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPAShrOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPAShrOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.ashr'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPAddOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPAddOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.add'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPAndOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPAndOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.and'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPFAddOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPFAddOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fadd'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPFDivOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPFDivOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fdiv'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
op2() _ods_ir[_ods_ir]
op3() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPFMulAddOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPFMulAddOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fmuladd'
op1() _ods_ir[_ods_ir]
op2() _ods_ir[_ods_ir]
op3() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPFMulOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPFMulOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fmul'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPFNegOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPFNegOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fneg'
op() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPFPExtOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPFPExtOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fpext'
src() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPFPToSIOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPFPToSIOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fptosi'
src() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPFPToUIOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPFPToUIOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fptoui'
src() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPFPTruncOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPFPTruncOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fptrunc'
src() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPFRemOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPFRemOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.frem'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPFSubOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPFSubOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fsub'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
op2() _ods_ir[_ods_ir]
op3() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPFmaOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPFmaOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.fma'
op1() _ods_ir[_ods_ir]
op2() _ods_ir[_ods_ir]
op3() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPIntToPtrOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPIntToPtrOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.inttoptr'
src() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPLShrOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPLShrOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.lshr'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPLoadOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPLoadOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.load'
ptr() _ods_ir
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
true_val() _ods_ir[_ods_ir]
false_val() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPMergeMinOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPMergeMinOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.merge'
cond() _ods_ir[_ods_ir]
true_val() _ods_ir[_ods_ir]
false_val() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPMulOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPMulOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.mul'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPOrOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPOrOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.or'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPPtrToIntOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPPtrToIntOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.ptrtoint'
src() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPReduceAddOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPReduceAddOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.add'
satrt_value() _ods_ir[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPReduceAndOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPReduceAndOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.and'
satrt_value() _ods_ir[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPReduceFAddOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPReduceFAddOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.fadd'
satrt_value() _ods_ir[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPReduceFMaxOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPReduceFMaxOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.fmax'
satrt_value() _ods_ir[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPReduceFMinOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPReduceFMinOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.fmin'
satrt_value() _ods_ir[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPReduceFMulOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPReduceFMulOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.fmul'
satrt_value() _ods_ir[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPReduceMulOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPReduceMulOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.mul'
satrt_value() _ods_ir[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPReduceOrOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPReduceOrOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.or'
satrt_value() _ods_ir[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPReduceSMaxOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPReduceSMaxOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.smax'
satrt_value() _ods_ir[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPReduceSMinOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPReduceSMinOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.smin'
satrt_value() _ods_ir[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPReduceUMaxOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPReduceUMaxOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.umax'
satrt_value() _ods_ir[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPReduceUMinOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPReduceUMinOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.umin'
satrt_value() _ods_ir[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPReduceXorOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPReduceXorOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.reduce.xor'
satrt_value() _ods_ir[_ods_ir]
val() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPSDivOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPSDivOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.sdiv'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPSExtOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPSExtOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.sext'
src() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPSIToFPOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPSIToFPOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.sitofp'
src() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPSMaxOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPSMaxOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.smax'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPSMinOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPSMinOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.smin'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPSRemOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPSRemOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.srem'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
true_val() _ods_ir[_ods_ir]
false_val() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPSelectMinOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPSelectMinOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.select'
cond() _ods_ir[_ods_ir]
true_val() _ods_ir[_ods_ir]
false_val() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPShlOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPShlOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.shl'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
ptr() _ods_ir
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
class mlir.dialects._llvm_ops_gen.VPStoreOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPStoreOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.store'
val() _ods_ir[_ods_ir]
ptr() _ods_ir
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPStridedLoadOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPStridedLoadOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.experimental.vp.strided.load'
ptr() _ods_ir
stride() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
ptr() _ods_ir
stride() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
class mlir.dialects._llvm_ops_gen.VPStridedStoreOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPStridedStoreOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.experimental.vp.strided.store'
val() _ods_ir[_ods_ir]
ptr() _ods_ir
stride() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPSubOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPSubOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.sub'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPTruncOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPTruncOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.trunc'
src() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPUDivOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPUDivOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.udiv'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPUIToFPOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPUIToFPOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.uitofp'
src() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPUMaxOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPUMaxOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.umax'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPUMinOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPUMinOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.umin'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPURemOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPURemOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.urem'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPXorOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPXorOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.xor'
lhs() _ods_ir[_ods_ir]
rhs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.VPZExtOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VPZExtOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vp.zext'
src() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
evl() _ods_ir[_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
class mlir.dialects._llvm_ops_gen.VaArgOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VaArgOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.va_arg'
arg() _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
class mlir.dialects._llvm_ops_gen.VaCopyOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VaCopyOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vacopy'
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
class mlir.dialects._llvm_ops_gen.VaEndOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VaEndOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vaend'
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
class mlir.dialects._llvm_ops_gen.VaStartOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VaStartOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vastart'
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[_ods_ir]
attr() _ods_ir
class mlir.dialects._llvm_ops_gen.VarAnnotationAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.VarAnnotationAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.var.annotation'
val() _ods_ir
annotation() _ods_ir
fileName() _ods_ir
line() _ods_ir[_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
class mlir.dialects._llvm_ops_gen.XOrOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.XOrOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.xor'
lhs() _ods_ir
rhs() _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
class mlir.dialects._llvm_ops_gen.ZExtOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ZExtOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.zext'
arg() _ods_ir
nonNeg() bool
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
class mlir.dialects._llvm_ops_gen.ZeroOpAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.ZeroOpAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.mlir.zero'
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[_ods_ir]
ptr() _ods_ir
mask() _ods_ir[_ods_ir]
arg_attrs() _ods_ir | None
res_attrs() _ods_ir | None
class mlir.dialects._llvm_ops_gen.masked_compressstoreAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.masked_compressstoreAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.masked.compressstore'
value() _ods_ir[_ods_ir]
ptr() _ods_ir
mask() _ods_ir[_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[_ods_ir]
passthru() _ods_ir[_ods_ir]
arg_attrs() _ods_ir | None
res_attrs() _ods_ir | None
res() _ods_ir
class mlir.dialects._llvm_ops_gen.masked_expandloadAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.masked_expandloadAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.masked.expandload'
ptr() _ods_ir
mask() _ods_ir[_ods_ir]
passthru() _ods_ir[_ods_ir]
arg_attrs() _ods_ir | None
res_attrs() _ods_ir | None
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[_ods_ir]
mask() _ods_ir[_ods_ir]
pass_thru() _ods_ir
alignment() _ods_ir
res() _ods_ir[_ods_ir]
class mlir.dialects._llvm_ops_gen.masked_gatherAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.masked_gatherAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.masked.gather'
ptrs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
pass_thru() _ods_ir
alignment() _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[_ods_ir]
ptrs() _ods_ir[_ods_ir]
mask() _ods_ir[_ods_ir]
alignment() _ods_ir
class mlir.dialects._llvm_ops_gen.masked_scatterAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.masked_scatterAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.masked.scatter'
value() _ods_ir[_ods_ir]
ptrs() _ods_ir[_ods_ir]
mask() _ods_ir[_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[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.vector_deinterleave2Adaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_deinterleave2Adaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.deinterleave2'
vec() _ods_ir[_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[_ods_ir]
pos() _ods_ir
res() _ods_ir[_ods_ir]
class mlir.dialects._llvm_ops_gen.vector_extractAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_extractAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.extract'
srcvec() _ods_ir[_ods_ir]
pos() _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[_ods_ir]
srcvec() _ods_ir[_ods_ir]
pos() _ods_ir
res() _ods_ir[_ods_ir]
class mlir.dialects._llvm_ops_gen.vector_insertAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_insertAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.insert'
dstvec() _ods_ir[_ods_ir]
srcvec() _ods_ir[_ods_ir]
pos() _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[_ods_ir]
vec2() _ods_ir[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.vector_interleave2Adaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_interleave2Adaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.interleave2'
vec1() _ods_ir[_ods_ir]
vec2() _ods_ir[_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[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.vector_reduce_addAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_reduce_addAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.add'
in_() _ods_ir[_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[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.vector_reduce_andAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_reduce_andAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.and'
in_() _ods_ir[_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[_ods_ir]
input() _ods_ir[_ods_ir]
fastmathFlags() _ods_ir
res() _ods_ir
class mlir.dialects._llvm_ops_gen.vector_reduce_faddAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_reduce_faddAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.fadd'
start_value() _ods_ir[_ods_ir]
input() _ods_ir[_ods_ir]
fastmathFlags() _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[_ods_ir]
fastmathFlags() _ods_ir
res() _ods_ir
class mlir.dialects._llvm_ops_gen.vector_reduce_fmaxAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_reduce_fmaxAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.fmax'
in_() _ods_ir[_ods_ir]
fastmathFlags() _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[_ods_ir]
fastmathFlags() _ods_ir
res() _ods_ir
class mlir.dialects._llvm_ops_gen.vector_reduce_fmaximumAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_reduce_fmaximumAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.fmaximum'
in_() _ods_ir[_ods_ir]
fastmathFlags() _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[_ods_ir]
fastmathFlags() _ods_ir
res() _ods_ir
class mlir.dialects._llvm_ops_gen.vector_reduce_fminAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_reduce_fminAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.fmin'
in_() _ods_ir[_ods_ir]
fastmathFlags() _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[_ods_ir]
fastmathFlags() _ods_ir
res() _ods_ir
class mlir.dialects._llvm_ops_gen.vector_reduce_fminimumAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_reduce_fminimumAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.fminimum'
in_() _ods_ir[_ods_ir]
fastmathFlags() _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[_ods_ir]
input() _ods_ir[_ods_ir]
fastmathFlags() _ods_ir
res() _ods_ir
class mlir.dialects._llvm_ops_gen.vector_reduce_fmulAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_reduce_fmulAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.fmul'
start_value() _ods_ir[_ods_ir]
input() _ods_ir[_ods_ir]
fastmathFlags() _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[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.vector_reduce_mulAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_reduce_mulAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.mul'
in_() _ods_ir[_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[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.vector_reduce_orAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_reduce_orAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.or'
in_() _ods_ir[_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[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.vector_reduce_smaxAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_reduce_smaxAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.smax'
in_() _ods_ir[_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[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.vector_reduce_sminAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_reduce_sminAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.smin'
in_() _ods_ir[_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[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.vector_reduce_umaxAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_reduce_umaxAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.umax'
in_() _ods_ir[_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[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.vector_reduce_uminAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_reduce_uminAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.umin'
in_() _ods_ir[_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[_ods_ir]
res() _ods_ir
class mlir.dialects._llvm_ops_gen.vector_reduce_xorAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vector_reduce_xorAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vector.reduce.xor'
in_() _ods_ir[_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
class mlir.dialects._llvm_ops_gen.vscaleAdaptor(operands: list, attributes: OpAttributeMap)
class mlir.dialects._llvm_ops_gen.vscaleAdaptor(operands: list, opview: OpView)

Bases: _ods_ir

OPERATION_NAME = 'llvm.intr.vscale'
mlir.dialects._llvm_ops_gen.intr_vscale(res, *, loc=None, ip=None) _ods_ir