CINXE.COM

<!doctype html><html lang=en-us><head><meta charset=utf-8><meta http-equiv=x-ua-compatible content="IE=edge"><meta name=viewport content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no"><title>'llvm' Dialect - MLIR</title><meta name=description content="Multi-Level IR Compiler Framework"><meta name=generator content="Hugo 0.119.0"><link href=https://mlir.llvm.org/index.xml rel=alternate type=application/rss+xml><link rel=canonical href=https://mlir.llvm.org/docs/Dialects/LLVM/><link rel=stylesheet href=https://mlir.llvm.org/css/theme.css><script src=https://use.fontawesome.com/releases/v5.0.6/js/all.js></script> <link rel=stylesheet href=https://mlir.llvm.org/css/chroma.min.css><script src=https://cdn.jsdelivr.net/npm/jquery@3.3.1/dist/jquery.min.js></script> <script src=https://cdn.jsdelivr.net/npm/jquery.easing@1.4.1/jquery.easing.min.js></script> <script src=https://mlir.llvm.org/js/bundle.js></script> <script type=text/javascript src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script> <script type=text/x-mathjax-config> MathJax.Hub.Config({ tex2jax: { inlineMath: [['$', '$'] ], displayMath: [ ['$$','$$'], ["\\[","\\]"] ] } }); </script><link rel=apple-touch-icon sizes=180x180 href="/apple-touch-icon.png?v=1"><link rel=icon type=image/png sizes=32x32 href="/favicon-32x32.png?v=1"><link rel=icon type=image/png sizes=16x16 href="/favicon-16x16.png?v=1"><link rel=manifest href="/site.webmanifest?v=1"><link rel=mask-icon href="/safari-pinned-tab.svg?v=1" color=#3775e0><link rel="shortcut icon" href="/favicon.ico?v=1"><meta name=msapplication-TileColor content="#2d89ef"><meta name=theme-color content="#ffffff"><link rel=icon href=/favicon.svg type=image/svg+xml sizes=any><style>:root{}</style></head><body><div class=container><header><h1><div><img src=https://mlir.llvm.org//mlir-logo.png width=40px align=absmiddle> MLIR</div></h1><p class=description>Multi-Level IR Compiler Framework</p></header><div class=global-menu><nav><ul><li class=parent><a href>Community<i class="fas fa-angle-right"></i></a><ul class=sub-menu><li class=child><a href=https://llvm.discourse.group/c/mlir/31>Forums</a></li><li class=child><a href=https://discord.gg/xS7Z362>Chat</a></li></ul></li><li><a href=/getting_started/Debugging/>Debugging Tips</a></li><li><a href=/getting_started/Faq/>FAQ</a></li><li class=parent><a href=https://github.com/llvm/llvm-project/tree/main/mlir>Source<i class="fas fa-angle-right"></i></a><ul class=sub-menu><li class=child><a href=/doxygen/>Doxygen</a></li><li class=child><a href=https://github.com/llvm/llvm-project/tree/main/mlir>GitHub</a></li></ul></li><li><a href="https://bugs.llvm.org/buglist.cgi?bug_status=__open__&list_id=177877&order=changeddate%20DESC%2Cpriority%2Cbug_severity&product=MLIR&query_format=specific">Bugs</a></li><li><a href=https://github.com/llvm/mlir-www/tree/main/website/static/LogoAssets>Logo Assets</a></li><li><a href=https://www.youtube.com/MLIRCompiler>Youtube Channel</a></li></ul></nav></div><div class=content-container><main><h1>'llvm' Dialect</h1><p>This dialect maps <a href=https://llvm.org/docs/LangRef.html>LLVM IR</a> into MLIR by defining the corresponding operations and types. LLVM IR metadata is usually represented as MLIR attributes, which offer additional structure verification.</p><p>We use “LLVM IR” to designate the <a href=https://llvm.org/docs/LangRef.html>intermediate representation of LLVM</a> and “LLVM <em>dialect</em>” or “LLVM IR <em>dialect</em>” to refer to this MLIR dialect.</p><p>Unless explicitly stated otherwise, the semantics of the LLVM dialect operations must correspond to the semantics of LLVM IR instructions and any divergence is considered a bug. The dialect also contains auxiliary operations that smoothen the differences in the IR structure, e.g., MLIR does not have <code>phi</code> operations and LLVM IR does not have a <code>constant</code> operation. These auxiliary operations are systematically prefixed with <code>mlir</code>, e.g. <code>llvm.mlir.constant</code> where <code>llvm.</code> is the dialect namespace prefix.</p><p><nav id=TableOfContents><ul><li><a href=#dependency-on-llvm-ir>Dependency on LLVM IR</a></li><li><a href=#module-structure>Module Structure</a><ul><li><a href=#data-layout-and-triple>Data Layout and Triple</a></li><li><a href=#functions>Functions</a></li><li><a href=#phi-nodes-and-block-arguments>PHI Nodes and Block Arguments</a></li><li><a href=#context-level-values>Context-Level Values</a></li><li><a href=#globals>Globals</a></li><li><a href=#linkage>Linkage</a></li><li><a href=#attribute-pass-through>Attribute Pass-Through</a></li></ul></li><li><a href=#types>Types</a><ul><li><a href=#built-in-type-compatibility>Built-in Type Compatibility</a></li><li><a href=#additional-simple-types>Additional Simple Types</a></li><li><a href=#additional-parametric-types>Additional Parametric Types</a></li><li><a href=#vector-types>Vector Types</a></li><li><a href=#structure-types>Structure Types</a></li><li><a href=#unsupported-types>Unsupported Types</a></li></ul></li><li><a href=#operations>Operations</a><ul><li><a href=#llvmashr-llvmashrop><code>llvm.ashr</code> (LLVM::AShrOp)</a></li><li><a href=#llvmadd-llvmaddop><code>llvm.add</code> (LLVM::AddOp)</a></li><li><a href=#llvmaddrspacecast-llvmaddrspacecastop><code>llvm.addrspacecast</code> (LLVM::AddrSpaceCastOp)</a></li><li><a href=#llvmmliraddressof-llvmaddressofop><code>llvm.mlir.addressof</code> (LLVM::AddressOfOp)</a></li><li><a href=#llvmalloca-llvmallocaop><code>llvm.alloca</code> (LLVM::AllocaOp)</a></li><li><a href=#llvmand-llvmandop><code>llvm.and</code> (LLVM::AndOp)</a></li><li><a href=#llvmcmpxchg-llvmatomiccmpxchgop><code>llvm.cmpxchg</code> (LLVM::AtomicCmpXchgOp)</a></li><li><a href=#llvmatomicrmw-llvmatomicrmwop><code>llvm.atomicrmw</code> (LLVM::AtomicRMWOp)</a></li><li><a href=#llvmbitcast-llvmbitcastop><code>llvm.bitcast</code> (LLVM::BitcastOp)</a></li><li><a href=#llvmbr-llvmbrop><code>llvm.br</code> (LLVM::BrOp)</a></li><li><a href=#llvmcall_intrinsic-llvmcallintrinsicop><code>llvm.call_intrinsic</code> (LLVM::CallIntrinsicOp)</a></li><li><a href=#llvmcall-llvmcallop><code>llvm.call</code> (LLVM::CallOp)</a></li><li><a href=#llvmcomdat-llvmcomdatop><code>llvm.comdat</code> (LLVM::ComdatOp)</a></li><li><a href=#llvmcomdat_selector-llvmcomdatselectorop><code>llvm.comdat_selector</code> (LLVM::ComdatSelectorOp)</a></li><li><a href=#llvmcond_br-llvmcondbrop><code>llvm.cond_br</code> (LLVM::CondBrOp)</a></li><li><a href=#llvmmlirconstant-llvmconstantop><code>llvm.mlir.constant</code> (LLVM::ConstantOp)</a></li><li><a href=#llvmextractelement-llvmextractelementop><code>llvm.extractelement</code> (LLVM::ExtractElementOp)</a></li><li><a href=#llvmextractvalue-llvmextractvalueop><code>llvm.extractvalue</code> (LLVM::ExtractValueOp)</a></li><li><a href=#llvmfadd-llvmfaddop><code>llvm.fadd</code> (LLVM::FAddOp)</a></li><li><a href=#llvmfcmp-llvmfcmpop><code>llvm.fcmp</code> (LLVM::FCmpOp)</a></li><li><a href=#llvmfdiv-llvmfdivop><code>llvm.fdiv</code> (LLVM::FDivOp)</a></li><li><a href=#llvmfmul-llvmfmulop><code>llvm.fmul</code> (LLVM::FMulOp)</a></li><li><a href=#llvmfneg-llvmfnegop><code>llvm.fneg</code> (LLVM::FNegOp)</a></li><li><a href=#llvmfpext-llvmfpextop><code>llvm.fpext</code> (LLVM::FPExtOp)</a></li><li><a href=#llvmfptosi-llvmfptosiop><code>llvm.fptosi</code> (LLVM::FPToSIOp)</a></li><li><a href=#llvmfptoui-llvmfptouiop><code>llvm.fptoui</code> (LLVM::FPToUIOp)</a></li><li><a href=#llvmfptrunc-llvmfptruncop><code>llvm.fptrunc</code> (LLVM::FPTruncOp)</a></li><li><a href=#llvmfrem-llvmfremop><code>llvm.frem</code> (LLVM::FRemOp)</a></li><li><a href=#llvmfsub-llvmfsubop><code>llvm.fsub</code> (LLVM::FSubOp)</a></li><li><a href=#llvmfence-llvmfenceop><code>llvm.fence</code> (LLVM::FenceOp)</a></li><li><a href=#llvmfreeze-llvmfreezeop><code>llvm.freeze</code> (LLVM::FreezeOp)</a></li><li><a href=#llvmgetelementptr-llvmgepop><code>llvm.getelementptr</code> (LLVM::GEPOp)</a></li><li><a href=#llvmmlirglobal_ctors-llvmglobalctorsop><code>llvm.mlir.global_ctors</code> (LLVM::GlobalCtorsOp)</a></li><li><a href=#llvmmlirglobal_dtors-llvmglobaldtorsop><code>llvm.mlir.global_dtors</code> (LLVM::GlobalDtorsOp)</a></li><li><a href=#llvmmlirglobal-llvmglobalop><code>llvm.mlir.global</code> (LLVM::GlobalOp)</a></li><li><a href=#llvmicmp-llvmicmpop><code>llvm.icmp</code> (LLVM::ICmpOp)</a></li><li><a href=#llvminline_asm-llvminlineasmop><code>llvm.inline_asm</code> (LLVM::InlineAsmOp)</a></li><li><a href=#llvminsertelement-llvminsertelementop><code>llvm.insertelement</code> (LLVM::InsertElementOp)</a></li><li><a href=#llvminsertvalue-llvminsertvalueop><code>llvm.insertvalue</code> (LLVM::InsertValueOp)</a></li><li><a href=#llvminttoptr-llvminttoptrop><code>llvm.inttoptr</code> (LLVM::IntToPtrOp)</a></li><li><a href=#llvminvoke-llvminvokeop><code>llvm.invoke</code> (LLVM::InvokeOp)</a></li><li><a href=#llvmfunc-llvmllvmfuncop><code>llvm.func</code> (LLVM::LLVMFuncOp)</a></li><li><a href=#llvmlshr-llvmlshrop><code>llvm.lshr</code> (LLVM::LShrOp)</a></li><li><a href=#llvmlandingpad-llvmlandingpadop><code>llvm.landingpad</code> (LLVM::LandingpadOp)</a></li><li><a href=#llvmlinker_options-llvmlinkeroptionsop><code>llvm.linker_options</code> (LLVM::LinkerOptionsOp)</a></li><li><a href=#llvmload-llvmloadop><code>llvm.load</code> (LLVM::LoadOp)</a></li><li><a href=#llvmmul-llvmmulop><code>llvm.mul</code> (LLVM::MulOp)</a></li><li><a href=#llvmmlirnone-llvmnonetokenop><code>llvm.mlir.none</code> (LLVM::NoneTokenOp)</a></li><li><a href=#llvmor-llvmorop><code>llvm.or</code> (LLVM::OrOp)</a></li><li><a href=#llvmmlirpoison-llvmpoisonop><code>llvm.mlir.poison</code> (LLVM::PoisonOp)</a></li><li><a href=#llvmptrtoint-llvmptrtointop><code>llvm.ptrtoint</code> (LLVM::PtrToIntOp)</a></li><li><a href=#llvmresume-llvmresumeop><code>llvm.resume</code> (LLVM::ResumeOp)</a></li><li><a href=#llvmreturn-llvmreturnop><code>llvm.return</code> (LLVM::ReturnOp)</a></li><li><a href=#llvmsdiv-llvmsdivop><code>llvm.sdiv</code> (LLVM::SDivOp)</a></li><li><a href=#llvmsext-llvmsextop><code>llvm.sext</code> (LLVM::SExtOp)</a></li><li><a href=#llvmsitofp-llvmsitofpop><code>llvm.sitofp</code> (LLVM::SIToFPOp)</a></li><li><a href=#llvmsrem-llvmsremop><code>llvm.srem</code> (LLVM::SRemOp)</a></li><li><a href=#llvmselect-llvmselectop><code>llvm.select</code> (LLVM::SelectOp)</a></li><li><a href=#llvmshl-llvmshlop><code>llvm.shl</code> (LLVM::ShlOp)</a></li><li><a href=#llvmshufflevector-llvmshufflevectorop><code>llvm.shufflevector</code> (LLVM::ShuffleVectorOp)</a></li><li><a href=#llvmstore-llvmstoreop><code>llvm.store</code> (LLVM::StoreOp)</a></li><li><a href=#llvmsub-llvmsubop><code>llvm.sub</code> (LLVM::SubOp)</a></li><li><a href=#llvmswitch-llvmswitchop><code>llvm.switch</code> (LLVM::SwitchOp)</a></li><li><a href=#llvmtrunc-llvmtruncop><code>llvm.trunc</code> (LLVM::TruncOp)</a></li><li><a href=#llvmudiv-llvmudivop><code>llvm.udiv</code> (LLVM::UDivOp)</a></li><li><a href=#llvmuitofp-llvmuitofpop><code>llvm.uitofp</code> (LLVM::UIToFPOp)</a></li><li><a href=#llvmurem-llvmuremop><code>llvm.urem</code> (LLVM::URemOp)</a></li><li><a href=#llvmmlirundef-llvmundefop><code>llvm.mlir.undef</code> (LLVM::UndefOp)</a></li><li><a href=#llvmunreachable-llvmunreachableop><code>llvm.unreachable</code> (LLVM::UnreachableOp)</a></li><li><a href=#llvmva_arg-llvmvaargop><code>llvm.va_arg</code> (LLVM::VaArgOp)</a></li><li><a href=#llvmxor-llvmxorop><code>llvm.xor</code> (LLVM::XOrOp)</a></li><li><a href=#llvmzext-llvmzextop><code>llvm.zext</code> (LLVM::ZExtOp)</a></li><li><a href=#llvmmlirzero-llvmzeroop><code>llvm.mlir.zero</code> (LLVM::ZeroOp)</a></li></ul></li><li><a href=#operations-for-llvm-ir-intrinsics>Operations for LLVM IR Intrinsics</a><ul><li><a href=#llvmintrabs-llvmabsop><code>llvm.intr.abs</code> (LLVM::AbsOp)</a></li><li><a href=#llvmintrannotation-llvmannotation><code>llvm.intr.annotation</code> (LLVM::Annotation)</a></li><li><a href=#llvmintrassume-llvmassumeop><code>llvm.intr.assume</code> (LLVM::AssumeOp)</a></li><li><a href=#llvmintrbitreverse-llvmbitreverseop><code>llvm.intr.bitreverse</code> (LLVM::BitReverseOp)</a></li><li><a href=#llvmintrbswap-llvmbyteswapop><code>llvm.intr.bswap</code> (LLVM::ByteSwapOp)</a></li><li><a href=#llvmintrexperimentalconstrainedfptrunc-llvmconstrainedfptruncintr><code>llvm.intr.experimental.constrained.fptrunc</code> (LLVM::ConstrainedFPTruncIntr)</a></li><li><a href=#llvmintrcopysign-llvmcopysignop><code>llvm.intr.copysign</code> (LLVM::CopySignOp)</a></li><li><a href=#llvmintrcoroalign-llvmcoroalignop><code>llvm.intr.coro.align</code> (LLVM::CoroAlignOp)</a></li><li><a href=#llvmintrcorobegin-llvmcorobeginop><code>llvm.intr.coro.begin</code> (LLVM::CoroBeginOp)</a></li><li><a href=#llvmintrcoroend-llvmcoroendop><code>llvm.intr.coro.end</code> (LLVM::CoroEndOp)</a></li><li><a href=#llvmintrcorofree-llvmcorofreeop><code>llvm.intr.coro.free</code> (LLVM::CoroFreeOp)</a></li><li><a href=#llvmintrcoroid-llvmcoroidop><code>llvm.intr.coro.id</code> (LLVM::CoroIdOp)</a></li><li><a href=#llvmintrcoropromise-llvmcoropromiseop><code>llvm.intr.coro.promise</code> (LLVM::CoroPromiseOp)</a></li><li><a href=#llvmintrcororesume-llvmcororesumeop><code>llvm.intr.coro.resume</code> (LLVM::CoroResumeOp)</a></li><li><a href=#llvmintrcorosave-llvmcorosaveop><code>llvm.intr.coro.save</code> (LLVM::CoroSaveOp)</a></li><li><a href=#llvmintrcorosize-llvmcorosizeop><code>llvm.intr.coro.size</code> (LLVM::CoroSizeOp)</a></li><li><a href=#llvmintrcorosuspend-llvmcorosuspendop><code>llvm.intr.coro.suspend</code> (LLVM::CoroSuspendOp)</a></li><li><a href=#llvmintrcos-llvmcosop><code>llvm.intr.cos</code> (LLVM::CosOp)</a></li><li><a href=#llvmintrcosh-llvmcoshop><code>llvm.intr.cosh</code> (LLVM::CoshOp)</a></li><li><a href=#llvmintrctlz-llvmcountleadingzerosop><code>llvm.intr.ctlz</code> (LLVM::CountLeadingZerosOp)</a></li><li><a href=#llvmintrcttz-llvmcounttrailingzerosop><code>llvm.intr.cttz</code> (LLVM::CountTrailingZerosOp)</a></li><li><a href=#llvmintrctpop-llvmctpopop><code>llvm.intr.ctpop</code> (LLVM::CtPopOp)</a></li><li><a href=#llvmintrdbgdeclare-llvmdbgdeclareop><code>llvm.intr.dbg.declare</code> (LLVM::DbgDeclareOp)</a></li><li><a href=#llvmintrdbglabel-llvmdbglabelop><code>llvm.intr.dbg.label</code> (LLVM::DbgLabelOp)</a></li><li><a href=#llvmintrdbgvalue-llvmdbgvalueop><code>llvm.intr.dbg.value</code> (LLVM::DbgValueOp)</a></li><li><a href=#llvmintrdebugtrap-llvmdebugtrap><code>llvm.intr.debugtrap</code> (LLVM::DebugTrap)</a></li><li><a href=#llvmintrehtypeidfor-llvmehtypeidforop><code>llvm.intr.eh.typeid.for</code> (LLVM::EhTypeidForOp)</a></li><li><a href=#llvmintrexp2-llvmexp2op><code>llvm.intr.exp2</code> (LLVM::Exp2Op)</a></li><li><a href=#llvmintrexp-llvmexpop><code>llvm.intr.exp</code> (LLVM::ExpOp)</a></li><li><a href=#llvmintrexpect-llvmexpectop><code>llvm.intr.expect</code> (LLVM::ExpectOp)</a></li><li><a href=#llvmintrexpectwithprobability-llvmexpectwithprobabilityop><code>llvm.intr.expect.with.probability</code> (LLVM::ExpectWithProbabilityOp)</a></li><li><a href=#llvmintrfabs-llvmfabsop><code>llvm.intr.fabs</code> (LLVM::FAbsOp)</a></li><li><a href=#llvmintrceil-llvmfceilop><code>llvm.intr.ceil</code> (LLVM::FCeilOp)</a></li><li><a href=#llvmintrfloor-llvmffloorop><code>llvm.intr.floor</code> (LLVM::FFloorOp)</a></li><li><a href=#llvmintrfma-llvmfmaop><code>llvm.intr.fma</code> (LLVM::FMAOp)</a></li><li><a href=#llvmintrfmuladd-llvmfmuladdop><code>llvm.intr.fmuladd</code> (LLVM::FMulAddOp)</a></li><li><a href=#llvmintrtrunc-llvmftruncop><code>llvm.intr.trunc</code> (LLVM::FTruncOp)</a></li><li><a href=#llvmintrfshl-llvmfshlop><code>llvm.intr.fshl</code> (LLVM::FshlOp)</a></li><li><a href=#llvmintrfshr-llvmfshrop><code>llvm.intr.fshr</code> (LLVM::FshrOp)</a></li><li><a href=#llvmintrgetactivelanemask-llvmgetactivelanemaskop><code>llvm.intr.get.active.lane.mask</code> (LLVM::GetActiveLaneMaskOp)</a></li><li><a href=#llvmintrinvariantend-llvminvariantendop><code>llvm.intr.invariant.end</code> (LLVM::InvariantEndOp)</a></li><li><a href=#llvmintrinvariantstart-llvminvariantstartop><code>llvm.intr.invariant.start</code> (LLVM::InvariantStartOp)</a></li><li><a href=#llvmintrisconstant-llvmisconstantop><code>llvm.intr.is.constant</code> (LLVM::IsConstantOp)</a></li><li><a href=#llvmintrisfpclass-llvmisfpclass><code>llvm.intr.is.fpclass</code> (LLVM::IsFPClass)</a></li><li><a href=#llvmintrlaunderinvariantgroup-llvmlaunderinvariantgroupop><code>llvm.intr.launder.invariant.group</code> (LLVM::LaunderInvariantGroupOp)</a></li><li><a href=#llvmintrlifetimeend-llvmlifetimeendop><code>llvm.intr.lifetime.end</code> (LLVM::LifetimeEndOp)</a></li><li><a href=#llvmintrlifetimestart-llvmlifetimestartop><code>llvm.intr.lifetime.start</code> (LLVM::LifetimeStartOp)</a></li><li><a href=#llvmintrllrint-llvmllrintop><code>llvm.intr.llrint</code> (LLVM::LlrintOp)</a></li><li><a href=#llvmintrllround-llvmllroundop><code>llvm.intr.llround</code> (LLVM::LlroundOp)</a></li><li><a href=#llvmintrlog10-llvmlog10op><code>llvm.intr.log10</code> (LLVM::Log10Op)</a></li><li><a href=#llvmintrlog2-llvmlog2op><code>llvm.intr.log2</code> (LLVM::Log2Op)</a></li><li><a href=#llvmintrlog-llvmlogop><code>llvm.intr.log</code> (LLVM::LogOp)</a></li><li><a href=#llvmintrlrint-llvmlrintop><code>llvm.intr.lrint</code> (LLVM::LrintOp)</a></li><li><a href=#llvmintrlround-llvmlroundop><code>llvm.intr.lround</code> (LLVM::LroundOp)</a></li><li><a href=#llvmintrmaskedload-llvmmaskedloadop><code>llvm.intr.masked.load</code> (LLVM::MaskedLoadOp)</a></li><li><a href=#llvmintrmaskedstore-llvmmaskedstoreop><code>llvm.intr.masked.store</code> (LLVM::MaskedStoreOp)</a></li><li><a href=#llvmintrmatrixcolumnmajorload-llvmmatrixcolumnmajorloadop><code>llvm.intr.matrix.column.major.load</code> (LLVM::MatrixColumnMajorLoadOp)</a></li><li><a href=#llvmintrmatrixcolumnmajorstore-llvmmatrixcolumnmajorstoreop><code>llvm.intr.matrix.column.major.store</code> (LLVM::MatrixColumnMajorStoreOp)</a></li><li><a href=#llvmintrmatrixmultiply-llvmmatrixmultiplyop><code>llvm.intr.matrix.multiply</code> (LLVM::MatrixMultiplyOp)</a></li><li><a href=#llvmintrmatrixtranspose-llvmmatrixtransposeop><code>llvm.intr.matrix.transpose</code> (LLVM::MatrixTransposeOp)</a></li><li><a href=#llvmintrmaxnum-llvmmaxnumop><code>llvm.intr.maxnum</code> (LLVM::MaxNumOp)</a></li><li><a href=#llvmintrmaximum-llvmmaximumop><code>llvm.intr.maximum</code> (LLVM::MaximumOp)</a></li><li><a href=#llvmintrmemcpyinline-llvmmemcpyinlineop><code>llvm.intr.memcpy.inline</code> (LLVM::MemcpyInlineOp)</a></li><li><a href=#llvmintrmemcpy-llvmmemcpyop><code>llvm.intr.memcpy</code> (LLVM::MemcpyOp)</a></li><li><a href=#llvmintrmemmove-llvmmemmoveop><code>llvm.intr.memmove</code> (LLVM::MemmoveOp)</a></li><li><a href=#llvmintrmemsetinline-llvmmemsetinlineop><code>llvm.intr.memset.inline</code> (LLVM::MemsetInlineOp)</a></li><li><a href=#llvmintrmemset-llvmmemsetop><code>llvm.intr.memset</code> (LLVM::MemsetOp)</a></li><li><a href=#llvmintrminnum-llvmminnumop><code>llvm.intr.minnum</code> (LLVM::MinNumOp)</a></li><li><a href=#llvmintrminimum-llvmminimumop><code>llvm.intr.minimum</code> (LLVM::MinimumOp)</a></li><li><a href=#llvmintrnearbyint-llvmnearbyintop><code>llvm.intr.nearbyint</code> (LLVM::NearbyintOp)</a></li><li><a href=#llvmintrexperimentalnoaliasscopedecl-llvmnoaliasscopedeclop><code>llvm.intr.experimental.noalias.scope.decl</code> (LLVM::NoAliasScopeDeclOp)</a></li><li><a href=#llvmintrpowi-llvmpowiop><code>llvm.intr.powi</code> (LLVM::PowIOp)</a></li><li><a href=#llvmintrpow-llvmpowop><code>llvm.intr.pow</code> (LLVM::PowOp)</a></li><li><a href=#llvmintrprefetch-llvmprefetch><code>llvm.intr.prefetch</code> (LLVM::Prefetch)</a></li><li><a href=#llvmintrptrannotation-llvmptrannotation><code>llvm.intr.ptr.annotation</code> (LLVM::PtrAnnotation)</a></li><li><a href=#llvmintrrint-llvmrintop><code>llvm.intr.rint</code> (LLVM::RintOp)</a></li><li><a href=#llvmintrroundeven-llvmroundevenop><code>llvm.intr.roundeven</code> (LLVM::RoundEvenOp)</a></li><li><a href=#llvmintrround-llvmroundop><code>llvm.intr.round</code> (LLVM::RoundOp)</a></li><li><a href=#llvmintrsaddsat-llvmsaddsat><code>llvm.intr.sadd.sat</code> (LLVM::SAddSat)</a></li><li><a href=#llvmintrsaddwithoverflow-llvmsaddwithoverflowop><code>llvm.intr.sadd.with.overflow</code> (LLVM::SAddWithOverflowOp)</a></li><li><a href=#llvmintrsmax-llvmsmaxop><code>llvm.intr.smax</code> (LLVM::SMaxOp)</a></li><li><a href=#llvmintrsmin-llvmsminop><code>llvm.intr.smin</code> (LLVM::SMinOp)</a></li><li><a href=#llvmintrsmulwithoverflow-llvmsmulwithoverflowop><code>llvm.intr.smul.with.overflow</code> (LLVM::SMulWithOverflowOp)</a></li><li><a href=#llvmintrssacopy-llvmssacopyop><code>llvm.intr.ssa.copy</code> (LLVM::SSACopyOp)</a></li><li><a href=#llvmintrsshlsat-llvmsshlsat><code>llvm.intr.sshl.sat</code> (LLVM::SSHLSat)</a></li><li><a href=#llvmintrssubsat-llvmssubsat><code>llvm.intr.ssub.sat</code> (LLVM::SSubSat)</a></li><li><a href=#llvmintrssubwithoverflow-llvmssubwithoverflowop><code>llvm.intr.ssub.with.overflow</code> (LLVM::SSubWithOverflowOp)</a></li><li><a href=#llvmintrsin-llvmsinop><code>llvm.intr.sin</code> (LLVM::SinOp)</a></li><li><a href=#llvmintrsinh-llvmsinhop><code>llvm.intr.sinh</code> (LLVM::SinhOp)</a></li><li><a href=#llvmintrsqrt-llvmsqrtop><code>llvm.intr.sqrt</code> (LLVM::SqrtOp)</a></li><li><a href=#llvmintrstackrestore-llvmstackrestoreop><code>llvm.intr.stackrestore</code> (LLVM::StackRestoreOp)</a></li><li><a href=#llvmintrstacksave-llvmstacksaveop><code>llvm.intr.stacksave</code> (LLVM::StackSaveOp)</a></li><li><a href=#llvmintrstepvector-llvmstepvectorop><code>llvm.intr.stepvector</code> (LLVM::StepVectorOp)</a></li><li><a href=#llvmintrstripinvariantgroup-llvmstripinvariantgroupop><code>llvm.intr.strip.invariant.group</code> (LLVM::StripInvariantGroupOp)</a></li><li><a href=#llvmintrtanh-llvmtanhop><code>llvm.intr.tanh</code> (LLVM::TanhOp)</a></li><li><a href=#llvmintrthreadlocaladdress-llvmthreadlocaladdressop><code>llvm.intr.threadlocal.address</code> (LLVM::ThreadlocalAddressOp)</a></li><li><a href=#llvmintrtrap-llvmtrap><code>llvm.intr.trap</code> (LLVM::Trap)</a></li><li><a href=#llvmintruaddsat-llvmuaddsat><code>llvm.intr.uadd.sat</code> (LLVM::UAddSat)</a></li><li><a href=#llvmintruaddwithoverflow-llvmuaddwithoverflowop><code>llvm.intr.uadd.with.overflow</code> (LLVM::UAddWithOverflowOp)</a></li><li><a href=#llvmintrubsantrap-llvmubsantrap><code>llvm.intr.ubsantrap</code> (LLVM::UBSanTrap)</a></li><li><a href=#llvmintrumax-llvmumaxop><code>llvm.intr.umax</code> (LLVM::UMaxOp)</a></li><li><a href=#llvmintrumin-llvmuminop><code>llvm.intr.umin</code> (LLVM::UMinOp)</a></li><li><a href=#llvmintrumulwithoverflow-llvmumulwithoverflowop><code>llvm.intr.umul.with.overflow</code> (LLVM::UMulWithOverflowOp)</a></li><li><a href=#llvmintrushlsat-llvmushlsat><code>llvm.intr.ushl.sat</code> (LLVM::USHLSat)</a></li><li><a href=#llvmintrusubsat-llvmusubsat><code>llvm.intr.usub.sat</code> (LLVM::USubSat)</a></li><li><a href=#llvmintrusubwithoverflow-llvmusubwithoverflowop><code>llvm.intr.usub.with.overflow</code> (LLVM::USubWithOverflowOp)</a></li><li><a href=#llvmintrvpashr-llvmvpashrop><code>llvm.intr.vp.ashr</code> (LLVM::VPAShrOp)</a></li><li><a href=#llvmintrvpadd-llvmvpaddop><code>llvm.intr.vp.add</code> (LLVM::VPAddOp)</a></li><li><a href=#llvmintrvpand-llvmvpandop><code>llvm.intr.vp.and</code> (LLVM::VPAndOp)</a></li><li><a href=#llvmintrvpfadd-llvmvpfaddop><code>llvm.intr.vp.fadd</code> (LLVM::VPFAddOp)</a></li><li><a href=#llvmintrvpfdiv-llvmvpfdivop><code>llvm.intr.vp.fdiv</code> (LLVM::VPFDivOp)</a></li><li><a href=#llvmintrvpfmuladd-llvmvpfmuladdop><code>llvm.intr.vp.fmuladd</code> (LLVM::VPFMulAddOp)</a></li><li><a href=#llvmintrvpfmul-llvmvpfmulop><code>llvm.intr.vp.fmul</code> (LLVM::VPFMulOp)</a></li><li><a href=#llvmintrvpfneg-llvmvpfnegop><code>llvm.intr.vp.fneg</code> (LLVM::VPFNegOp)</a></li><li><a href=#llvmintrvpfpext-llvmvpfpextop><code>llvm.intr.vp.fpext</code> (LLVM::VPFPExtOp)</a></li><li><a href=#llvmintrvpfptosi-llvmvpfptosiop><code>llvm.intr.vp.fptosi</code> (LLVM::VPFPToSIOp)</a></li><li><a href=#llvmintrvpfptoui-llvmvpfptouiop><code>llvm.intr.vp.fptoui</code> (LLVM::VPFPToUIOp)</a></li><li><a href=#llvmintrvpfptrunc-llvmvpfptruncop><code>llvm.intr.vp.fptrunc</code> (LLVM::VPFPTruncOp)</a></li><li><a href=#llvmintrvpfrem-llvmvpfremop><code>llvm.intr.vp.frem</code> (LLVM::VPFRemOp)</a></li><li><a href=#llvmintrvpfsub-llvmvpfsubop><code>llvm.intr.vp.fsub</code> (LLVM::VPFSubOp)</a></li><li><a href=#llvmintrvpfma-llvmvpfmaop><code>llvm.intr.vp.fma</code> (LLVM::VPFmaOp)</a></li><li><a href=#llvmintrvpinttoptr-llvmvpinttoptrop><code>llvm.intr.vp.inttoptr</code> (LLVM::VPIntToPtrOp)</a></li><li><a href=#llvmintrvplshr-llvmvplshrop><code>llvm.intr.vp.lshr</code> (LLVM::VPLShrOp)</a></li><li><a href=#llvmintrvpload-llvmvploadop><code>llvm.intr.vp.load</code> (LLVM::VPLoadOp)</a></li><li><a href=#llvmintrvpmerge-llvmvpmergeminop><code>llvm.intr.vp.merge</code> (LLVM::VPMergeMinOp)</a></li><li><a href=#llvmintrvpmul-llvmvpmulop><code>llvm.intr.vp.mul</code> (LLVM::VPMulOp)</a></li><li><a href=#llvmintrvpor-llvmvporop><code>llvm.intr.vp.or</code> (LLVM::VPOrOp)</a></li><li><a href=#llvmintrvpptrtoint-llvmvpptrtointop><code>llvm.intr.vp.ptrtoint</code> (LLVM::VPPtrToIntOp)</a></li><li><a href=#llvmintrvpreduceadd-llvmvpreduceaddop><code>llvm.intr.vp.reduce.add</code> (LLVM::VPReduceAddOp)</a></li><li><a href=#llvmintrvpreduceand-llvmvpreduceandop><code>llvm.intr.vp.reduce.and</code> (LLVM::VPReduceAndOp)</a></li><li><a href=#llvmintrvpreducefadd-llvmvpreducefaddop><code>llvm.intr.vp.reduce.fadd</code> (LLVM::VPReduceFAddOp)</a></li><li><a href=#llvmintrvpreducefmax-llvmvpreducefmaxop><code>llvm.intr.vp.reduce.fmax</code> (LLVM::VPReduceFMaxOp)</a></li><li><a href=#llvmintrvpreducefmin-llvmvpreducefminop><code>llvm.intr.vp.reduce.fmin</code> (LLVM::VPReduceFMinOp)</a></li><li><a href=#llvmintrvpreducefmul-llvmvpreducefmulop><code>llvm.intr.vp.reduce.fmul</code> (LLVM::VPReduceFMulOp)</a></li><li><a href=#llvmintrvpreducemul-llvmvpreducemulop><code>llvm.intr.vp.reduce.mul</code> (LLVM::VPReduceMulOp)</a></li><li><a href=#llvmintrvpreduceor-llvmvpreduceorop><code>llvm.intr.vp.reduce.or</code> (LLVM::VPReduceOrOp)</a></li><li><a href=#llvmintrvpreducesmax-llvmvpreducesmaxop><code>llvm.intr.vp.reduce.smax</code> (LLVM::VPReduceSMaxOp)</a></li><li><a href=#llvmintrvpreducesmin-llvmvpreducesminop><code>llvm.intr.vp.reduce.smin</code> (LLVM::VPReduceSMinOp)</a></li><li><a href=#llvmintrvpreduceumax-llvmvpreduceumaxop><code>llvm.intr.vp.reduce.umax</code> (LLVM::VPReduceUMaxOp)</a></li><li><a href=#llvmintrvpreduceumin-llvmvpreduceuminop><code>llvm.intr.vp.reduce.umin</code> (LLVM::VPReduceUMinOp)</a></li><li><a href=#llvmintrvpreducexor-llvmvpreducexorop><code>llvm.intr.vp.reduce.xor</code> (LLVM::VPReduceXorOp)</a></li><li><a href=#llvmintrvpsdiv-llvmvpsdivop><code>llvm.intr.vp.sdiv</code> (LLVM::VPSDivOp)</a></li><li><a href=#llvmintrvpsext-llvmvpsextop><code>llvm.intr.vp.sext</code> (LLVM::VPSExtOp)</a></li><li><a href=#llvmintrvpsitofp-llvmvpsitofpop><code>llvm.intr.vp.sitofp</code> (LLVM::VPSIToFPOp)</a></li><li><a href=#llvmintrvpsmax-llvmvpsmaxop><code>llvm.intr.vp.smax</code> (LLVM::VPSMaxOp)</a></li><li><a href=#llvmintrvpsmin-llvmvpsminop><code>llvm.intr.vp.smin</code> (LLVM::VPSMinOp)</a></li><li><a href=#llvmintrvpsrem-llvmvpsremop><code>llvm.intr.vp.srem</code> (LLVM::VPSRemOp)</a></li><li><a href=#llvmintrvpselect-llvmvpselectminop><code>llvm.intr.vp.select</code> (LLVM::VPSelectMinOp)</a></li><li><a href=#llvmintrvpshl-llvmvpshlop><code>llvm.intr.vp.shl</code> (LLVM::VPShlOp)</a></li><li><a href=#llvmintrvpstore-llvmvpstoreop><code>llvm.intr.vp.store</code> (LLVM::VPStoreOp)</a></li><li><a href=#llvmintrexperimentalvpstridedload-llvmvpstridedloadop><code>llvm.intr.experimental.vp.strided.load</code> (LLVM::VPStridedLoadOp)</a></li><li><a href=#llvmintrexperimentalvpstridedstore-llvmvpstridedstoreop><code>llvm.intr.experimental.vp.strided.store</code> (LLVM::VPStridedStoreOp)</a></li><li><a href=#llvmintrvpsub-llvmvpsubop><code>llvm.intr.vp.sub</code> (LLVM::VPSubOp)</a></li><li><a href=#llvmintrvptrunc-llvmvptruncop><code>llvm.intr.vp.trunc</code> (LLVM::VPTruncOp)</a></li><li><a href=#llvmintrvpudiv-llvmvpudivop><code>llvm.intr.vp.udiv</code> (LLVM::VPUDivOp)</a></li><li><a href=#llvmintrvpuitofp-llvmvpuitofpop><code>llvm.intr.vp.uitofp</code> (LLVM::VPUIToFPOp)</a></li><li><a href=#llvmintrvpumax-llvmvpumaxop><code>llvm.intr.vp.umax</code> (LLVM::VPUMaxOp)</a></li><li><a href=#llvmintrvpumin-llvmvpuminop><code>llvm.intr.vp.umin</code> (LLVM::VPUMinOp)</a></li><li><a href=#llvmintrvpurem-llvmvpuremop><code>llvm.intr.vp.urem</code> (LLVM::VPURemOp)</a></li><li><a href=#llvmintrvpxor-llvmvpxorop><code>llvm.intr.vp.xor</code> (LLVM::VPXorOp)</a></li><li><a href=#llvmintrvpzext-llvmvpzextop><code>llvm.intr.vp.zext</code> (LLVM::VPZExtOp)</a></li><li><a href=#llvmintrvacopy-llvmvacopyop><code>llvm.intr.vacopy</code> (LLVM::VaCopyOp)</a></li><li><a href=#llvmintrvaend-llvmvaendop><code>llvm.intr.vaend</code> (LLVM::VaEndOp)</a></li><li><a href=#llvmintrvastart-llvmvastartop><code>llvm.intr.vastart</code> (LLVM::VaStartOp)</a></li><li><a href=#llvmintrvarannotation-llvmvarannotation><code>llvm.intr.var.annotation</code> (LLVM::VarAnnotation)</a></li><li><a href=#llvmintrmaskedcompressstore-llvmmasked_compressstore><code>llvm.intr.masked.compressstore</code> (LLVM::masked_compressstore)</a></li><li><a href=#llvmintrmaskedexpandload-llvmmasked_expandload><code>llvm.intr.masked.expandload</code> (LLVM::masked_expandload)</a></li><li><a href=#llvmintrmaskedgather-llvmmasked_gather><code>llvm.intr.masked.gather</code> (LLVM::masked_gather)</a></li><li><a href=#llvmintrmaskedscatter-llvmmasked_scatter><code>llvm.intr.masked.scatter</code> (LLVM::masked_scatter)</a></li><li><a href=#llvmintrvectordeinterleave2-llvmvector_deinterleave2><code>llvm.intr.vector.deinterleave2</code> (LLVM::vector_deinterleave2)</a></li><li><a href=#llvmintrvectorextract-llvmvector_extract><code>llvm.intr.vector.extract</code> (LLVM::vector_extract)</a></li><li><a href=#llvmintrvectorinsert-llvmvector_insert><code>llvm.intr.vector.insert</code> (LLVM::vector_insert)</a></li><li><a href=#llvmintrvectorinterleave2-llvmvector_interleave2><code>llvm.intr.vector.interleave2</code> (LLVM::vector_interleave2)</a></li><li><a href=#llvmintrvectorreduceadd-llvmvector_reduce_add><code>llvm.intr.vector.reduce.add</code> (LLVM::vector_reduce_add)</a></li><li><a href=#llvmintrvectorreduceand-llvmvector_reduce_and><code>llvm.intr.vector.reduce.and</code> (LLVM::vector_reduce_and)</a></li><li><a href=#llvmintrvectorreducefadd-llvmvector_reduce_fadd><code>llvm.intr.vector.reduce.fadd</code> (LLVM::vector_reduce_fadd)</a></li><li><a href=#llvmintrvectorreducefmax-llvmvector_reduce_fmax><code>llvm.intr.vector.reduce.fmax</code> (LLVM::vector_reduce_fmax)</a></li><li><a href=#llvmintrvectorreducefmaximum-llvmvector_reduce_fmaximum><code>llvm.intr.vector.reduce.fmaximum</code> (LLVM::vector_reduce_fmaximum)</a></li><li><a href=#llvmintrvectorreducefmin-llvmvector_reduce_fmin><code>llvm.intr.vector.reduce.fmin</code> (LLVM::vector_reduce_fmin)</a></li><li><a href=#llvmintrvectorreducefminimum-llvmvector_reduce_fminimum><code>llvm.intr.vector.reduce.fminimum</code> (LLVM::vector_reduce_fminimum)</a></li><li><a href=#llvmintrvectorreducefmul-llvmvector_reduce_fmul><code>llvm.intr.vector.reduce.fmul</code> (LLVM::vector_reduce_fmul)</a></li><li><a href=#llvmintrvectorreducemul-llvmvector_reduce_mul><code>llvm.intr.vector.reduce.mul</code> (LLVM::vector_reduce_mul)</a></li><li><a href=#llvmintrvectorreduceor-llvmvector_reduce_or><code>llvm.intr.vector.reduce.or</code> (LLVM::vector_reduce_or)</a></li><li><a href=#llvmintrvectorreducesmax-llvmvector_reduce_smax><code>llvm.intr.vector.reduce.smax</code> (LLVM::vector_reduce_smax)</a></li><li><a href=#llvmintrvectorreducesmin-llvmvector_reduce_smin><code>llvm.intr.vector.reduce.smin</code> (LLVM::vector_reduce_smin)</a></li><li><a href=#llvmintrvectorreduceumax-llvmvector_reduce_umax><code>llvm.intr.vector.reduce.umax</code> (LLVM::vector_reduce_umax)</a></li><li><a href=#llvmintrvectorreduceumin-llvmvector_reduce_umin><code>llvm.intr.vector.reduce.umin</code> (LLVM::vector_reduce_umin)</a></li><li><a href=#llvmintrvectorreducexor-llvmvector_reduce_xor><code>llvm.intr.vector.reduce.xor</code> (LLVM::vector_reduce_xor)</a></li><li><a href=#llvmintrvscale-llvmvscale><code>llvm.intr.vscale</code> (LLVM::vscale)</a></li><li><a href=#debug-info>Debug Info</a></li></ul></li></ul></nav><h2 id=dependency-on-llvm-ir>Dependency on LLVM IR <a class=headline-hash href=#dependency-on-llvm-ir>¶</a></h2><p>LLVM dialect is not expected to depend on any object that requires an <code>LLVMContext</code>, such as an LLVM IR instruction or type. Instead, MLIR provides thread-safe alternatives compatible with the rest of the infrastructure. The dialect is allowed to depend on the LLVM IR objects that don’t require a context, such as data layout and triple description.</p><h2 id=module-structure>Module Structure <a class=headline-hash href=#module-structure>¶</a></h2><p>IR modules use the built-in MLIR <code>ModuleOp</code> and support all its features. In particular, modules can be named, nested and are subject to symbol visibility. Modules can contain any operations, including LLVM functions and globals.</p><h3 id=data-layout-and-triple>Data Layout and Triple <a class=headline-hash href=#data-layout-and-triple>¶</a></h3><p>An IR module may have an optional data layout and triple information attached using MLIR attributes <code>llvm.data_layout</code> and <code>llvm.triple</code>, respectively. Both are string attributes with the <a href=https://llvm.org/docs/LangRef.html#data-layout>same syntax</a> as in LLVM IR and are verified to be correct. They can be defined as follows.</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl>module attributes <span class=p>{</span><span class=nl>llvm.data_layout =</span> <span class=s>"e"</span><span class=p>,</span> </span></span><span class=line><span class=cl> <span class=nl>llvm.target_triple =</span> <span class=s>"aarch64-linux-android"</span><span class=p>}</span> <span class=p>{</span> </span></span><span class=line><span class=cl> <span class=c>// module contents </span></span></span><span class=line><span class=cl><span class=c></span><span class=p>}</span> </span></span></code></pre></div><h3 id=functions>Functions <a class=headline-hash href=#functions>¶</a></h3><p>LLVM functions are represented by a special operation, <code>llvm.func</code>, that has syntax similar to that of the built-in function operation but supports LLVM-related features such as linkage and variadic argument lists. See detailed description in the operation list <a href=#llvmfunc-llvmllvmfuncop>below</a>.</p><h3 id=phi-nodes-and-block-arguments>PHI Nodes and Block Arguments <a class=headline-hash href=#phi-nodes-and-block-arguments>¶</a></h3><p>MLIR uses block arguments instead of PHI nodes to communicate values between blocks. Therefore, the LLVM dialect has no operation directly equivalent to <code>phi</code> in LLVM IR. Instead, all terminators can pass values as successor operands as these values will be forwarded as block arguments when the control flow is transferred.</p><p>For example:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=nl>^bb1</span><span class=p>:</span> </span></span><span class=line><span class=cl> <span class=nv>%0</span> <span class=p>=</span> llvm<span class=p>.</span>addi <span class=nv>%arg0</span><span class=p>,</span> <span class=nv>%cst</span> <span class=p>:</span> <span class=k>i32</span> </span></span><span class=line><span class=cl> llvm<span class=p>.</span>br <span class=nl>^bb2</span><span class=p>[</span><span class=nv>%0</span><span class=p>:</span> <span class=k>i32</span><span class=p>]</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// If the control flow comes from ^bb1, %arg1 == %0. </span></span></span><span class=line><span class=cl><span class=c></span><span class=nl>^bb2</span><span class=p>(</span><span class=nv>%arg1</span><span class=p>:</span> <span class=k>i32</span><span class=p>)</span> </span></span><span class=line><span class=cl> <span class=c>// ... </span></span></span></code></pre></div><p>is equivalent to LLVM IR</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-llvm data-lang=llvm><span class=line><span class=cl><span class=n>%0</span><span class=err>:</span> </span></span><span class=line><span class=cl> <span class=n>%1</span> <span class=p>=</span> <span class=k>add</span> <span class=k>i32</span> <span class=nv>%arg0</span><span class=p>,</span> <span class=nv>%cst</span> </span></span><span class=line><span class=cl> <span class=k>br</span> <span class=n>%3</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=n>%3</span><span class=err>:</span> </span></span><span class=line><span class=cl> <span class=nv>%arg1</span> <span class=p>=</span> <span class=k>phi</span> <span class=p>[</span><span class=n>%1</span><span class=p>,</span> <span class=n>%0</span><span class=p>],</span> <span class=err>//</span><span class=p>...</span> </span></span></code></pre></div><p>Since there is no need to use the block identifier to differentiate the source of different values, the LLVM dialect supports terminators that transfer the control flow to the same block with different arguments. For example:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=nl>^bb1</span><span class=p>:</span> </span></span><span class=line><span class=cl> llvm<span class=p>.</span>cond_br <span class=nv>%cond</span><span class=p>,</span> <span class=nl>^bb2</span><span class=p>[</span><span class=nv>%0</span><span class=p>:</span> <span class=k>i32</span><span class=p>],</span> <span class=nl>^bb2</span><span class=p>[</span><span class=nv>%1</span><span class=p>:</span> <span class=k>i32</span><span class=p>]</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=nl>^bb2</span><span class=p>(</span><span class=nv>%arg0</span><span class=p>:</span> <span class=k>i32</span><span class=p>):</span> </span></span><span class=line><span class=cl> <span class=c>// ... </span></span></span></code></pre></div><h3 id=context-level-values>Context-Level Values <a class=headline-hash href=#context-level-values>¶</a></h3><p>Some value kinds in LLVM IR, such as constants and undefs, are uniqued in context and used directly in relevant operations. MLIR does not support such values for thread-safety and concept parsimony reasons. Instead, regular values are produced by dedicated operations that have the corresponding semantics: <a href=#llvmmlirconstant-llvmconstantop><code>llvm.mlir.constant</code></a>, <a href=#llvmmlirundef-llvmundefop><code>llvm.mlir.undef</code></a>, <a href=#llvmmlirpoison-llvmpoisonop><code>llvm.mlir.poison</code></a>, <a href=#llvmmlirzero-llvmzeroop><code>llvm.mlir.zero</code></a>. Note how these operations are prefixed with <code>mlir.</code> to indicate that they don’t belong to LLVM IR but are only necessary to model it in MLIR. The values produced by these operations are usable just like any other value.</p><p>Examples:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=c>// Create an undefined value of structure type with a 32-bit integer followed </span></span></span><span class=line><span class=cl><span class=c>// by a float. </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%0</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span>undef <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>struct<span class=p><(</span><span class=k>i32</span><span class=p>,</span> <span class=k>f32</span><span class=p>)></span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// Null pointer. </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%1</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span>zero <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// Create an zero initialized value of structure type with a 32-bit integer </span></span></span><span class=line><span class=cl><span class=c>// followed by a float. </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%2</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span>zero <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>struct<span class=p><(</span><span class=k>i32</span><span class=p>,</span> <span class=k>f32</span><span class=p>)></span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// Constant 42 as i32. </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%3</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span><span class=kt>constant</span><span class=p>(</span><span class=m>42</span> <span class=p>:</span> <span class=k>i32</span><span class=p>)</span> <span class=p>:</span> <span class=k>i32</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// Splat dense vector constant. </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%3</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span><span class=kt>constant</span><span class=p>(</span>dense<span class=p><</span><span class=m>1.0</span><span class=p>></span> <span class=p>:</span> <span class=kt>vector</span><span class=p><</span><span class=m>4x</span><span class=k>f32</span><span class=p>>)</span> <span class=p>:</span> <span class=kt>vector</span><span class=p><</span><span class=m>4x</span><span class=k>f32</span><span class=p>></span> </span></span></code></pre></div><p>Note that constants list the type twice. This is an artifact of the LLVM dialect not using built-in types, which are used for typed MLIR attributes. The syntax will be reevaluated after considering composite constants.</p><h3 id=globals>Globals <a class=headline-hash href=#globals>¶</a></h3><p>Global variables are also defined using a special operation, <a href=#llvmmlirglobal-llvmglobalop><code>llvm.mlir.global</code></a>, located at the module level. Globals are MLIR symbols and are identified by their name.</p><p>Since functions need to be isolated-from-above, i.e. values defined outside the function cannot be directly used inside the function, an additional operation, <a href=#llvmmliraddressof-llvmaddressofop><code>llvm.mlir.addressof</code></a>, is provided to locally define a value containing the <em>address</em> of a global. The actual value can then be loaded from that pointer, or a new value can be stored into it if the global is not declared constant. This is similar to LLVM IR where globals are accessed through name and have a pointer type.</p><h3 id=linkage>Linkage <a class=headline-hash href=#linkage>¶</a></h3><p>Module-level named objects in the LLVM dialect, namely functions and globals, have an optional <em>linkage</em> attribute derived from LLVM IR <a href=https://llvm.org/docs/LangRef.html#linkage-types>linkage types</a>. Linkage is specified by the same keyword as in LLVM IR and is located between the operation name (<code>llvm.func</code> or <code>llvm.global</code>) and the symbol name. If no linkage keyword is present, <code>external</code> linkage is assumed by default. Linkage is <em>distinct</em> from MLIR symbol visibility.</p><h3 id=attribute-pass-through>Attribute Pass-Through <a class=headline-hash href=#attribute-pass-through>¶</a></h3><p><strong>WARNING:</strong> this feature MUST NOT be used for any real workload. It is exclusively intended for quick prototyping. After that, attributes must be introduced as proper first-class concepts in the dialect.</p><p>The LLVM dialect provides a mechanism to forward function-level attributes to LLVM IR using the <code>passthrough</code> attribute. This is an array attribute containing either string attributes or array attributes. In the former case, the value of the string is interpreted as the name of LLVM IR function attribute. In the latter case, the array is expected to contain exactly two string attributes, the first corresponding to the name of LLVM IR function attribute, and the second corresponding to its value. Note that even integer LLVM IR function attributes have their value represented in the string form.</p><p>Example:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl>llvm<span class=p>.</span><span class=kt>func</span> <span class=nf>@func</span><span class=p>()</span> attributes <span class=p>{</span> </span></span><span class=line><span class=cl> <span class=nl>passthrough =</span> <span class=p>[</span><span class=s>"readonly"</span><span class=p>,</span> <span class=c>// value-less attribute </span></span></span><span class=line><span class=cl><span class=c></span> <span class=p>[</span><span class=s>"alignstack"</span><span class=p>,</span> <span class=s>"4"</span><span class=p>],</span> <span class=c>// integer attribute with value </span></span></span><span class=line><span class=cl><span class=c></span> <span class=p>[</span><span class=s>"other"</span><span class=p>,</span> <span class=s>"attr"</span><span class=p>]]</span> <span class=c>// attribute unknown to LLVM </span></span></span><span class=line><span class=cl><span class=c></span><span class=p>}</span> <span class=p>{</span> </span></span><span class=line><span class=cl> llvm<span class=p>.</span><span class=kt>return</span> </span></span><span class=line><span class=cl><span class=p>}</span> </span></span></code></pre></div><p>If the attribute is not known to LLVM IR, it will be attached as a string attribute.</p><h2 id=types>Types <a class=headline-hash href=#types>¶</a></h2><p>LLVM dialect uses built-in types whenever possible and defines a set of complementary types, which correspond to the LLVM IR types that cannot be directly represented with built-in types. Similarly to other MLIR context-owned objects, the creation and manipulation of LLVM dialect types is thread-safe.</p><p>MLIR does not support module-scoped named type declarations, e.g. <code>%s = type {i32, i32}</code> in LLVM IR. Instead, types must be fully specified at each use, except for recursive types where only the first reference to a named type needs to be fully specified. MLIR <a href=/docs/LangRef/#type-aliases>type aliases</a> can be used to achieve more compact syntax.</p><p>The general syntax of LLVM dialect types is <code>!llvm.</code>, followed by a type kind identifier (e.g., <code>ptr</code> for pointer or <code>struct</code> for structure) and by an optional list of type parameters in angle brackets. The dialect follows MLIR style for types with nested angle brackets and keyword specifiers rather than using different bracket styles to differentiate types. Types inside the angle brackets may omit the <code>!llvm.</code> prefix for brevity: the parser first attempts to find a type (starting with <code>!</code> or a built-in type) and falls back to accepting a keyword. For example, <code>!llvm.struct<(!llvm.ptr, f32)></code> and <code>!llvm.struct<(ptr, f32)></code> are equivalent, with the latter being the canonical form, and denote a struct containing a pointer and a float.</p><h3 id=built-in-type-compatibility>Built-in Type Compatibility <a class=headline-hash href=#built-in-type-compatibility>¶</a></h3><p>LLVM dialect accepts a subset of built-in types that are referred to as <em>LLVM dialect-compatible types</em>. The following types are compatible:</p><ul><li>Signless integers - <code>iN</code> (<code>IntegerType</code>).</li><li>Floating point types - <code>bfloat</code>, <code>half</code>, <code>float</code>, <code>double</code> , <code>f80</code>, <code>f128</code> (<code>FloatType</code>).</li><li>1D vectors of signless integers or floating point types - <code>vector<NxT></code> (<code>VectorType</code>).</li></ul><p>Note that only a subset of types that can be represented by a given class is compatible. For example, signed and unsigned integers are not compatible. LLVM provides a function, <code>bool LLVM::isCompatibleType(Type)</code>, that can be used as a compatibility check.</p><p>Each LLVM IR type corresponds to <em>exactly one</em> MLIR type, either built-in or LLVM dialect type. For example, because <code>i32</code> is LLVM-compatible, there is no <code>!llvm.i32</code> type. However, <code>!llvm.struct<(T, ...)></code> is defined in the LLVM dialect as there is no corresponding built-in type.</p><h3 id=additional-simple-types>Additional Simple Types <a class=headline-hash href=#additional-simple-types>¶</a></h3><p>The following non-parametric types derived from the LLVM IR are available in the LLVM dialect:</p><ul><li><code>!llvm.ppc_fp128</code> (<code>LLVMPPCFP128Type</code>) - 128-bit floating-point value (two 64 bits).</li><li><code>!llvm.token</code> (<code>LLVMTokenType</code>) - a non-inspectable value associated with an operation.</li><li><code>!llvm.metadata</code> (<code>LLVMMetadataType</code>) - LLVM IR metadata, to be used only if the metadata cannot be represented as structured MLIR attributes.</li><li><code>!llvm.void</code> (<code>LLVMVoidType</code>) - does not represent any value; can only appear in function results.</li></ul><p>These types represent a single value (or an absence thereof in case of <code>void</code>) and correspond to their LLVM IR counterparts.</p><h3 id=additional-parametric-types>Additional Parametric Types <a class=headline-hash href=#additional-parametric-types>¶</a></h3><p>These types are parameterized by the types they contain, e.g., the pointee or the element type, which can be either compatible built-in or LLVM dialect types.</p><h4 id=pointer-types>Pointer Types <a class=headline-hash href=#pointer-types>¶</a></h4><p>Pointer types specify an address in memory.</p><p>Pointers are <a href=https://llvm.org/docs/OpaquePointers.html>opaque</a>, i.e., do not indicate the type of the data pointed to, and are intended to simplify LLVM IR by encoding behavior relevant to the pointee type into operations rather than into types. Pointers can optionally be parametrized with an address space. The address space is an integer, but this choice may be reconsidered if MLIR implements named address spaces. The syntax of pointer types is as follows:</p><pre tabindex=0><code> llvm-ptr-type ::= `!llvm.ptr` (`<` integer-literal `>`)? </code></pre><p>where the optional group containing the integer literal corresponds to the address space. All cases are represented by <code>LLVMPointerType</code> internally.</p><h4 id=array-types>Array Types <a class=headline-hash href=#array-types>¶</a></h4><p>Array types represent sequences of elements in memory. Array elements can be addressed with a value unknown at compile time, and can be nested. Only 1D arrays are allowed though.</p><p>Array types are parameterized by the fixed size and the element type. Syntactically, their representation is the following:</p><pre tabindex=0><code> llvm-array-type ::= `!llvm.array<` integer-literal `x` type `>` </code></pre><p>and they are internally represented as <code>LLVMArrayType</code>.</p><h4 id=function-types>Function Types <a class=headline-hash href=#function-types>¶</a></h4><p>Function types represent the type of a function, i.e. its signature.</p><p>Function types are parameterized by the result type, the list of argument types and by an optional “variadic” flag. Unlike built-in <code>FunctionType</code>, LLVM dialect functions (<code>LLVMFunctionType</code>) always have single result, which may be <code>!llvm.void</code> if the function does not return anything. The syntax is as follows:</p><pre tabindex=0><code> llvm-func-type ::= `!llvm.func<` type `(` type-list (`,` `...`)? `)` `>` </code></pre><p>For example,</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=p>!</span>llvm<span class=p>.</span><span class=kt>func</span><span class=p><</span>void <span class=p>()></span> <span class=c>// a function with no arguments; </span></span></span><span class=line><span class=cl><span class=c></span><span class=p>!</span>llvm<span class=p>.</span><span class=kt>func</span><span class=p><</span><span class=k>i32</span> <span class=p>(</span><span class=k>f32</span><span class=p>,</span> <span class=k>i32</span><span class=p>)></span> <span class=c>// a function with two arguments and a result; </span></span></span><span class=line><span class=cl><span class=c></span><span class=p>!</span>llvm<span class=p>.</span><span class=kt>func</span><span class=p><</span>void <span class=p>(</span><span class=k>i32</span><span class=p>,</span> <span class=p>...)></span> <span class=c>// a variadic function with at least one argument. </span></span></span></code></pre></div><p>In the LLVM dialect, functions are not first-class objects and one cannot have a value of function type. Instead, one can take the address of a function and operate on pointers to functions.</p><h3 id=vector-types>Vector Types <a class=headline-hash href=#vector-types>¶</a></h3><p>Vector types represent sequences of elements, typically when multiple data elements are processed by a single instruction (SIMD). Vectors are thought of as stored in registers and therefore vector elements can only be addressed through constant indices.</p><p>Vector types are parameterized by the size, which may be either <em>fixed</em> or a multiple of some fixed size in case of <em>scalable</em> vectors, and the element type. Vectors cannot be nested and only 1D vectors are supported. Scalable vectors are still considered 1D.</p><p>LLVM dialect uses built-in vector types for <em>fixed</em>-size vectors of built-in types, and provides additional types for fixed-sized vectors of LLVM dialect types (<code>LLVMFixedVectorType</code>) and scalable vectors of any types (<code>LLVMScalableVectorType</code>). These two additional types share the following syntax:</p><pre tabindex=0><code> llvm-vec-type ::= `!llvm.vec<` (`?` `x`)? integer-literal `x` type `>` </code></pre><p>Note that the sets of element types supported by built-in and LLVM dialect vector types are mutually exclusive, e.g., the built-in vector type does not accept <code>!llvm.ptr</code> and the LLVM dialect fixed-width vector type does not accept <code>i32</code>.</p><p>The following functions are provided to operate on any kind of the vector types compatible with the LLVM dialect:</p><ul><li><code>bool LLVM::isCompatibleVectorType(Type)</code> - checks whether a type is a vector type compatible with the LLVM dialect;</li><li><code>Type LLVM::getVectorElementType(Type)</code> - returns the element type of any vector type compatible with the LLVM dialect;</li><li><code>llvm::ElementCount LLVM::getVectorNumElements(Type)</code> - returns the number of elements in any vector type compatible with the LLVM dialect;</li><li><code>Type LLVM::getFixedVectorType(Type, unsigned)</code> - gets a fixed vector type with the given element type and size; the resulting type is either a built-in or an LLVM dialect vector type depending on which one supports the given element type.</li></ul><h4 id=examples-of-compatible-vector-types>Examples of Compatible Vector Types <a class=headline-hash href=#examples-of-compatible-vector-types>¶</a></h4><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=kt>vector</span><span class=p><</span><span class=m>42 x</span> <span class=k>i32</span><span class=p>></span> <span class=c>// Vector of 42 32-bit integers. </span></span></span><span class=line><span class=cl><span class=c></span><span class=p>!</span>llvm<span class=p>.</span>vec<span class=p><</span><span class=m>42 x</span> ptr<span class=p>></span> <span class=c>// Vector of 42 pointers. </span></span></span><span class=line><span class=cl><span class=c></span><span class=p>!</span>llvm<span class=p>.</span>vec<span class=p><</span><span class=m>? x</span> <span class=m>4 x</span> <span class=k>i32</span><span class=p>></span> <span class=c>// Scalable vector of 32-bit integers with </span></span></span><span class=line><span class=cl><span class=c></span> <span class=c>// size divisible by 4. </span></span></span><span class=line><span class=cl><span class=c></span><span class=p>!</span>llvm<span class=p>.</span>array<span class=p><</span><span class=m>2 x</span> <span class=kt>vector</span><span class=p><</span><span class=m>2 x</span> <span class=k>i32</span><span class=p>>></span> <span class=c>// Array of 2 vectors of 2 32-bit integers. </span></span></span><span class=line><span class=cl><span class=c></span><span class=p>!</span>llvm<span class=p>.</span>array<span class=p><</span><span class=m>2 x</span> vec<span class=p><</span><span class=m>2 x</span> ptr<span class=p>>></span> <span class=c>// Array of 2 vectors of 2 pointers. </span></span></span></code></pre></div><h3 id=structure-types>Structure Types <a class=headline-hash href=#structure-types>¶</a></h3><p>The structure type is used to represent a collection of data members together in memory. The elements of a structure may be any type that has a size.</p><p>Structure types are represented in a single dedicated class mlir::LLVM::LLVMStructType. Internally, the struct type stores a (potentially empty) name, a (potentially empty) list of contained types and a bitmask indicating whether the struct is named, opaque, packed or uninitialized. Structure types that don’t have a name are referred to as <em>literal</em> structs. Such structures are uniquely identified by their contents. <em>Identified</em> structs on the other hand are uniquely identified by the name.</p><h4 id=identified-structure-types>Identified Structure Types <a class=headline-hash href=#identified-structure-types>¶</a></h4><p>Identified structure types are uniqued using their name in a given context. Attempting to construct an identified structure with the same name a structure that already exists in the context <em>will result in the existing structure being returned</em>. <strong>MLIR does not auto-rename identified structs in case of name conflicts</strong> because there is no naming scope equivalent to a module in LLVM IR since MLIR modules can be arbitrarily nested.</p><p>Programmatically, identified structures can be constructed in an <em>uninitialized</em> state. In this case, they are given a name but the body must be set up by a later call, using MLIR’s type mutation mechanism. Such uninitialized types can be used in type construction, but must be eventually initialized for IR to be valid. This mechanism allows for constructing <em>recursive</em> or mutually referring structure types: an uninitialized type can be used in its own initialization.</p><p>Once the type is initialized, its body cannot be changed anymore. Any further attempts to modify the body will fail and return failure to the caller <em>unless the type is initialized with the exact same body</em>. Type initialization is thread-safe; however, if a concurrent thread initializes the type before the current thread, the initialization may return failure.</p><p>The syntax for identified structure types is as follows.</p><pre tabindex=0><code>llvm-ident-struct-type ::= `!llvm.struct<` string-literal, `opaque` `>` | `!llvm.struct<` string-literal, `packed`? `(` type-or-ref-list `)` `>` type-or-ref-list ::= <maybe empty comma-separated list of type-or-ref> type-or-ref ::= <any compatible type with optional !llvm.> | `!llvm.`? `struct<` string-literal `>` </code></pre><h4 id=literal-structure-types>Literal Structure Types <a class=headline-hash href=#literal-structure-types>¶</a></h4><p>Literal structures are uniqued according to the list of elements they contain, and can optionally be packed. The syntax for such structs is as follows.</p><pre tabindex=0><code>llvm-literal-struct-type ::= `!llvm.struct<` `packed`? `(` type-list `)` `>` type-list ::= <maybe empty comma-separated list of types with optional !llvm.> </code></pre><p>Literal structs cannot be recursive, but can contain other structs. Therefore, they must be constructed in a single step with the entire list of contained elements provided.</p><h4 id=examples-of-structure-types>Examples of Structure Types <a class=headline-hash href=#examples-of-structure-types>¶</a></h4><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=p>!</span>llvm<span class=p>.</span>struct<span class=p><></span> <span class=c>// NOT allowed </span></span></span><span class=line><span class=cl><span class=c></span><span class=p>!</span>llvm<span class=p>.</span>struct<span class=p><()></span> <span class=c>// empty, literal </span></span></span><span class=line><span class=cl><span class=c></span><span class=p>!</span>llvm<span class=p>.</span>struct<span class=p><(</span><span class=k>i32</span><span class=p>)></span> <span class=c>// literal </span></span></span><span class=line><span class=cl><span class=c></span><span class=p>!</span>llvm<span class=p>.</span>struct<span class=p><(</span>struct<span class=p><(</span><span class=k>i32</span><span class=p>)>)></span> <span class=c>// struct containing a struct </span></span></span><span class=line><span class=cl><span class=c></span><span class=p>!</span>llvm<span class=p>.</span>struct<span class=p><</span>packed <span class=p>(</span><span class=k>i8</span><span class=p>,</span> <span class=k>i32</span><span class=p>)></span> <span class=c>// packed struct </span></span></span><span class=line><span class=cl><span class=c></span><span class=p>!</span>llvm<span class=p>.</span>struct<span class=p><</span><span class=s>"a"</span><span class=p>></span> <span class=c>// recursive reference, only allowed within </span></span></span><span class=line><span class=cl><span class=c></span> <span class=c>// another struct, NOT allowed at top level </span></span></span><span class=line><span class=cl><span class=c></span><span class=p>!</span>llvm<span class=p>.</span>struct<span class=p><</span><span class=s>"a"</span><span class=p>,</span> <span class=p>()></span> <span class=c>// empty, named (necessary to differentiate from </span></span></span><span class=line><span class=cl><span class=c></span> <span class=c>// recursive reference) </span></span></span><span class=line><span class=cl><span class=c></span><span class=p>!</span>llvm<span class=p>.</span>struct<span class=p><</span><span class=s>"a"</span><span class=p>,</span> opaque<span class=p>></span> <span class=c>// opaque, named </span></span></span><span class=line><span class=cl><span class=c></span><span class=p>!</span>llvm<span class=p>.</span>struct<span class=p><</span><span class=s>"a"</span><span class=p>,</span> <span class=p>(</span><span class=k>i32</span><span class=p>,</span> ptr<span class=p>)></span> <span class=c>// named </span></span></span><span class=line><span class=cl><span class=c></span><span class=p>!</span>llvm<span class=p>.</span>struct<span class=p><</span><span class=s>"a"</span><span class=p>,</span> packed <span class=p>(</span><span class=k>i8</span><span class=p>,</span> <span class=k>i32</span><span class=p>)></span> <span class=c>// named, packed </span></span></span></code></pre></div><h3 id=unsupported-types>Unsupported Types <a class=headline-hash href=#unsupported-types>¶</a></h3><p>LLVM IR <code>label</code> type does not have a counterpart in the LLVM dialect since, in MLIR, blocks are not values and don’t need a type.</p><h2 id=operations>Operations <a class=headline-hash href=#operations>¶</a></h2><p>All operations in the LLVM IR dialect have a custom form in MLIR. The mnemonic of an operation is that used in LLVM IR prefixed with “<code>llvm.</code>”.</p><p><a href=https://github.com/llvm/llvm-project/blob/main/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td>source</a></p><h3 id=llvmashr-llvmashrop><code>llvm.ashr</code> (LLVM::AShrOp) <a class=headline-hash href=#llvmashr-llvmashrop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.ashr` (`exact` $isExact^)? $lhs `,` $rhs attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>ExactFlagInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes>Attributes: <a class=headline-hash href=#attributes>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>isExact</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr></table><h4 id=operands>Operands: <a class=headline-hash href=#operands>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results>Results: <a class=headline-hash href=#results>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmadd-llvmaddop><code>llvm.add</code> (LLVM::AddOp) <a class=headline-hash href=#llvmadd-llvmaddop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.add` $lhs `,` $rhs `` custom<OverflowFlags>($overflowFlags) attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>Commutative</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>IntegerOverflowFlagsInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-1>Operands: <a class=headline-hash href=#operands-1>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-1>Results: <a class=headline-hash href=#results-1>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmaddrspacecast-llvmaddrspacecastop><code>llvm.addrspacecast</code> (LLVM::AddrSpaceCastOp) <a class=headline-hash href=#llvmaddrspacecast-llvmaddrspacecastop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.addrspacecast` $arg attr-dict `:` type($arg) `to` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code>, <code>PromotableOpInterface</code>, <code>ViewLikeOpInterface</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-2>Operands: <a class=headline-hash href=#operands-2>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg</code></td><td>LLVM pointer type or LLVM dialect-compatible vector of LLVM pointer type</td></tr></tbody></table><h4 id=results-2>Results: <a class=headline-hash href=#results-2>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM pointer type or LLVM dialect-compatible vector of LLVM pointer type</td></tr></tbody></table><h3 id=llvmmliraddressof-llvmaddressofop><code>llvm.mlir.addressof</code> (LLVM::AddressOfOp) <a class=headline-hash href=#llvmmliraddressof-llvmaddressofop>¶</a></h3><p><em>Creates a pointer pointing to a global or a function</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.mlir.addressof` $global_name attr-dict `:` qualified(type($res)) </code></pre><p>Creates an SSA value containing a pointer to a global variable or constant defined by <code>llvm.mlir.global</code>. The global value can be defined after its first referenced. If the global value is a constant, storing into it is not allowed.</p><p>Examples:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=kt>func</span> <span class=nf>@foo</span><span class=p>()</span> <span class=p>{</span> </span></span><span class=line><span class=cl> <span class=c>// Get the address of a global variable. </span></span></span><span class=line><span class=cl><span class=c></span> <span class=nv>%0</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span>addressof <span class=nf>@const</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl> <span class=c>// Use it as a regular pointer. </span></span></span><span class=line><span class=cl><span class=c></span> <span class=nv>%1</span> <span class=p>=</span> llvm<span class=p>.</span>load <span class=nv>%0</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr <span class=p>-></span> <span class=k>i32</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl> <span class=c>// Get the address of a function. </span></span></span><span class=line><span class=cl><span class=c></span> <span class=nv>%2</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span>addressof <span class=nf>@foo</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl> <span class=c>// The function address can be used for indirect calls. </span></span></span><span class=line><span class=cl><span class=c></span> llvm<span class=p>.</span>call <span class=nv>%2</span><span class=p>()</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr<span class=p>,</span> <span class=p>()</span> <span class=p>-></span> <span class=p>()</span> </span></span><span class=line><span class=cl><span class=p>}</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// Define the global. </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>mlir<span class=p>.</span>global <span class=nf>@const</span><span class=p>(</span><span class=m>42</span> <span class=p>:</span> <span class=k>i32</span><span class=p>)</span> <span class=p>:</span> <span class=k>i32</span> </span></span></code></pre></div><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>ConstantLike</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code>, <code>SymbolUserOpInterface</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-1>Attributes: <a class=headline-hash href=#attributes-1>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>global_name</code></td><td>::mlir::FlatSymbolRefAttr</td><td>flat symbol reference attribute</td></tr></table><h4 id=results-3>Results: <a class=headline-hash href=#results-3>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmalloca-llvmallocaop><code>llvm.alloca</code> (LLVM::AllocaOp) <a class=headline-hash href=#llvmalloca-llvmallocaop>¶</a></h3><p>Interfaces: <code>DestructurableAllocationOpInterface</code>, <code>PromotableAllocationOpInterface</code></p><h4 id=attributes-2>Attributes: <a class=headline-hash href=#attributes-2>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>alignment</code></td><td>::mlir::IntegerAttr</td><td>64-bit signless integer attribute</td></tr><tr><td><code>elem_type</code></td><td>::mlir::TypeAttr</td><td>any type attribute</td></tr><tr><td><code>inalloca</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr></table><h4 id=operands-3>Operands: <a class=headline-hash href=#operands-3>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arraySize</code></td><td>signless integer</td></tr></tbody></table><h4 id=results-4>Results: <a class=headline-hash href=#results-4>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmand-llvmandop><code>llvm.and</code> (LLVM::AndOp) <a class=headline-hash href=#llvmand-llvmandop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.and` $lhs `,` $rhs attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-4>Operands: <a class=headline-hash href=#operands-4>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-5>Results: <a class=headline-hash href=#results-5>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmcmpxchg-llvmatomiccmpxchgop><code>llvm.cmpxchg</code> (LLVM::AtomicCmpXchgOp) <a class=headline-hash href=#llvmcmpxchg-llvmatomiccmpxchgop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.cmpxchg` (`weak` $weak^)? (`volatile` $volatile_^)? $ptr `,` $cmp `,` $val (`syncscope` `(` $syncscope^ `)`)? $success_ordering $failure_ordering attr-dict `:` qualified(type($ptr)) `,` type($val) </code></pre><p>Interfaces: <code>AccessGroupOpInterface</code>, <code>AliasAnalysisOpInterface</code>, <code>InferTypeOpInterface</code></p><h4 id=attributes-3>Attributes: <a class=headline-hash href=#attributes-3>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>success_ordering</code></td><td>::mlir::LLVM::AtomicOrderingAttr</td><td><details><summary>Atomic ordering for LLVM's memory model</summary><p>Enum cases:</p><ul><li>not_atomic (<code>not_atomic</code>)</li><li>unordered (<code>unordered</code>)</li><li>monotonic (<code>monotonic</code>)</li><li>acquire (<code>acquire</code>)</li><li>release (<code>release</code>)</li><li>acq_rel (<code>acq_rel</code>)</li><li>seq_cst (<code>seq_cst</code>)</li></ul></details></td></tr><tr><td><code>failure_ordering</code></td><td>::mlir::LLVM::AtomicOrderingAttr</td><td><details><summary>Atomic ordering for LLVM's memory model</summary><p>Enum cases:</p><ul><li>not_atomic (<code>not_atomic</code>)</li><li>unordered (<code>unordered</code>)</li><li>monotonic (<code>monotonic</code>)</li><li>acquire (<code>acquire</code>)</li><li>release (<code>release</code>)</li><li>acq_rel (<code>acq_rel</code>)</li><li>seq_cst (<code>seq_cst</code>)</li></ul></details></td></tr><tr><td><code>syncscope</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>alignment</code></td><td>::mlir::IntegerAttr</td><td>64-bit signless integer attribute</td></tr><tr><td><code>weak</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>volatile_</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>access_groups</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect access group metadata array</td></tr><tr><td><code>alias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>noalias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>tbaa</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect TBAA tag metadata array</td></tr></table><h4 id=operands-5>Operands: <a class=headline-hash href=#operands-5>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>ptr</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>cmp</code></td><td>signless integer or LLVM pointer type</td></tr><tr><td style=text-align:center><code>val</code></td><td>signless integer or LLVM pointer type</td></tr></tbody></table><h4 id=results-6>Results: <a class=headline-hash href=#results-6>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM structure type</td></tr></tbody></table><h3 id=llvmatomicrmw-llvmatomicrmwop><code>llvm.atomicrmw</code> (LLVM::AtomicRMWOp) <a class=headline-hash href=#llvmatomicrmw-llvmatomicrmwop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.atomicrmw` (`volatile` $volatile_^)? $bin_op $ptr `,` $val (`syncscope` `(` $syncscope^ `)`)? $ordering attr-dict `:` qualified(type($ptr)) `,` type($val) </code></pre><p>Interfaces: <code>AccessGroupOpInterface</code>, <code>AliasAnalysisOpInterface</code>, <code>InferTypeOpInterface</code></p><h4 id=attributes-4>Attributes: <a class=headline-hash href=#attributes-4>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>bin_op</code></td><td>::mlir::LLVM::AtomicBinOpAttr</td><td><details><summary>llvm.atomicrmw binary operations</summary><p>Enum cases:</p><ul><li>xchg (<code>xchg</code>)</li><li>add (<code>add</code>)</li><li>sub (<code>sub</code>)</li><li>_and (<code>_and</code>)</li><li>nand (<code>nand</code>)</li><li>_or (<code>_or</code>)</li><li>_xor (<code>_xor</code>)</li><li>max (<code>max</code>)</li><li>min (<code>min</code>)</li><li>umax (<code>umax</code>)</li><li>umin (<code>umin</code>)</li><li>fadd (<code>fadd</code>)</li><li>fsub (<code>fsub</code>)</li><li>fmax (<code>fmax</code>)</li><li>fmin (<code>fmin</code>)</li><li>uinc_wrap (<code>uinc_wrap</code>)</li><li>udec_wrap (<code>udec_wrap</code>)</li><li>usub_cond (<code>usub_cond</code>)</li><li>usub_sat (<code>usub_sat</code>)</li></ul></details></td></tr><tr><td><code>ordering</code></td><td>::mlir::LLVM::AtomicOrderingAttr</td><td><details><summary>Atomic ordering for LLVM's memory model</summary><p>Enum cases:</p><ul><li>not_atomic (<code>not_atomic</code>)</li><li>unordered (<code>unordered</code>)</li><li>monotonic (<code>monotonic</code>)</li><li>acquire (<code>acquire</code>)</li><li>release (<code>release</code>)</li><li>acq_rel (<code>acq_rel</code>)</li><li>seq_cst (<code>seq_cst</code>)</li></ul></details></td></tr><tr><td><code>syncscope</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>alignment</code></td><td>::mlir::IntegerAttr</td><td>64-bit signless integer attribute</td></tr><tr><td><code>volatile_</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>access_groups</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect access group metadata array</td></tr><tr><td><code>alias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>noalias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>tbaa</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect TBAA tag metadata array</td></tr></table><h4 id=operands-6>Operands: <a class=headline-hash href=#operands-6>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>ptr</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>val</code></td><td>floating point LLVM type or LLVM pointer type or signless integer or LLVM dialect-compatible fixed-length vector type</td></tr></tbody></table><h4 id=results-7>Results: <a class=headline-hash href=#results-7>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>floating point LLVM type or LLVM pointer type or signless integer or LLVM dialect-compatible fixed-length vector type</td></tr></tbody></table><h3 id=llvmbitcast-llvmbitcastop><code>llvm.bitcast</code> (LLVM::BitcastOp) <a class=headline-hash href=#llvmbitcast-llvmbitcastop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.bitcast` $arg attr-dict `:` type($arg) `to` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code>, <code>PromotableOpInterface</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-7>Operands: <a class=headline-hash href=#operands-7>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg</code></td><td>LLVM-compatible non-aggregate type</td></tr></tbody></table><h4 id=results-8>Results: <a class=headline-hash href=#results-8>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM-compatible non-aggregate type</td></tr></tbody></table><h3 id=llvmbr-llvmbrop><code>llvm.br</code> (LLVM::BrOp) <a class=headline-hash href=#llvmbr-llvmbrop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.br` $dest (`(` $destOperands^ `:` type($destOperands) `)`)? attr-dict </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>Terminator</code></p><p>Interfaces: <code>BranchOpInterface</code>, <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-5>Attributes: <a class=headline-hash href=#attributes-5>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>loop_annotation</code></td><td>::mlir::LLVM::LoopAnnotationAttr</td><td><details><summary></summary><pre><code>This attributes encapsulates "loop metadata". It is meant to decorate branches that are "latches" (loop backedges) and maps to the `!llvm.loop` metadatas: https://llvm.org/docs/LangRef.html#llvm-loop It stores annotations in attribute parameters and groups related options in nested attributes to provide structured access. </code></pre></details></td></tr></table><h4 id=operands-8>Operands: <a class=headline-hash href=#operands-8>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>destOperands</code></td><td>variadic of LLVM dialect-compatible type</td></tr></tbody></table><h4 id=successors>Successors: <a class=headline-hash href=#successors>¶</a></h4><table><thead><tr><th style=text-align:center>Successor</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>dest</code></td><td>any successor</td></tr></tbody></table><h3 id=llvmcall_intrinsic-llvmcallintrinsicop><code>llvm.call_intrinsic</code> (LLVM::CallIntrinsicOp) <a class=headline-hash href=#llvmcall_intrinsic-llvmcallintrinsicop>¶</a></h3><p><em>Call to an LLVM intrinsic function.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.call_intrinsic` $intrin `(` $args `)` ( custom<OpBundles>($op_bundle_operands, type($op_bundle_operands), $op_bundle_tags)^ )? `:` functional-type($args, $results) attr-dict </code></pre><p>Call the specified llvm intrinsic. If the intrinsic is overloaded, use the MLIR function type of this op to determine which intrinsic to call.</p><p>Traits: <code>AttrSizedOperandSegments</code></p><p>Interfaces: <code>FastmathFlagsInterface</code></p><h4 id=attributes-6>Attributes: <a class=headline-hash href=#attributes-6>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>intrin</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr><tr><td><code>op_bundle_sizes</code></td><td>::mlir::DenseI32ArrayAttr</td><td>i32 dense array attribute</td></tr><tr><td><code>op_bundle_tags</code></td><td>::mlir::ArrayAttr</td><td>array attribute</td></tr></table><h4 id=operands-9>Operands: <a class=headline-hash href=#operands-9>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>args</code></td><td>variadic of LLVM dialect-compatible type</td></tr><tr><td style=text-align:center><code>op_bundle_operands</code></td><td>variadic of LLVM dialect-compatible type</td></tr></tbody></table><h4 id=results-9>Results: <a class=headline-hash href=#results-9>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>results</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmcall-llvmcallop><code>llvm.call</code> (LLVM::CallOp) <a class=headline-hash href=#llvmcall-llvmcallop>¶</a></h3><p><em>Call to an LLVM function.</em></p><p>In LLVM IR, functions may return either 0 or 1 value. LLVM IR dialect implements this behavior by providing a variadic <code>call</code> operation for 0- and 1-result functions. Even though MLIR supports multi-result functions, LLVM IR dialect disallows them.</p><p>The <code>call</code> instruction supports both direct and indirect calls. Direct calls start with a function name (<code>@</code>-prefixed) and indirect calls start with an SSA value (<code>%</code>-prefixed). The direct callee, if present, is stored as a function attribute <code>callee</code>. For indirect calls, the callee is of <code>!llvm.ptr</code> type and is stored as the first value in <code>callee_operands</code>. If and only if the callee is a variadic function, the <code>var_callee_type</code> 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.</p><p>Examples:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=c>// Direct call without arguments and with one result. </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%0</span> <span class=p>=</span> llvm<span class=p>.</span>call <span class=nf>@foo</span><span class=p>()</span> <span class=p>:</span> <span class=p>()</span> <span class=p>-></span> <span class=p>(</span><span class=k>f32</span><span class=p>)</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// Direct call with arguments and without a result. </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>call <span class=nf>@bar</span><span class=p>(</span><span class=nv>%0</span><span class=p>)</span> <span class=p>:</span> <span class=p>(</span><span class=k>f32</span><span class=p>)</span> <span class=p>-></span> <span class=p>()</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// Indirect call with an argument and without a result. </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%1</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span>addressof <span class=nf>@foo</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr </span></span><span class=line><span class=cl>llvm<span class=p>.</span>call <span class=nv>%1</span><span class=p>(</span><span class=nv>%0</span><span class=p>)</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr<span class=p>,</span> <span class=p>(</span><span class=k>f32</span><span class=p>)</span> <span class=p>-></span> <span class=p>()</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// Direct variadic call. </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>call <span class=nf>@printf</span><span class=p>(</span><span class=nv>%0</span><span class=p>,</span> <span class=nv>%1</span><span class=p>)</span> vararg<span class=p>(!</span>llvm<span class=p>.</span><span class=kt>func</span><span class=p><</span><span class=k>i32</span> <span class=p>(</span>ptr<span class=p>,</span> <span class=p>...)>)</span> <span class=p>:</span> <span class=p>(!</span>llvm<span class=p>.</span>ptr<span class=p>,</span> <span class=k>i32</span><span class=p>)</span> <span class=p>-></span> <span class=k>i32</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// Indirect variadic call </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>call <span class=nv>%1</span><span class=p>(</span><span class=nv>%0</span><span class=p>)</span> vararg<span class=p>(!</span>llvm<span class=p>.</span><span class=kt>func</span><span class=p><</span>void <span class=p>(...)>)</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr<span class=p>,</span> <span class=p>(</span><span class=k>i32</span><span class=p>)</span> <span class=p>-></span> <span class=p>()</span> </span></span></code></pre></div><p>Traits: <code>AttrSizedOperandSegments</code></p><p>Interfaces: <code>AccessGroupOpInterface</code>, <code>AliasAnalysisOpInterface</code>, <code>BranchWeightOpInterface</code>, <code>CallOpInterface</code>, <code>FastmathFlagsInterface</code>, <code>SymbolUserOpInterface</code></p><h4 id=attributes-7>Attributes: <a class=headline-hash href=#attributes-7>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>var_callee_type</code></td><td>::mlir::TypeAttr</td><td>type attribute of LLVM function type</td></tr><tr><td><code>callee</code></td><td>::mlir::FlatSymbolRefAttr</td><td>flat symbol reference attribute</td></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr><tr><td><code>branch_weights</code></td><td>::mlir::DenseI32ArrayAttr</td><td>i32 dense array attribute</td></tr><tr><td><code>CConv</code></td><td>::mlir::LLVM::CConvAttr</td><td>LLVM Calling Convention specification</td></tr><tr><td><code>TailCallKind</code></td><td>::mlir::LLVM::TailCallKindAttr</td><td>LLVM Calling Convention specification</td></tr><tr><td><code>memory_effects</code></td><td>::mlir::LLVM::MemoryEffectsAttr</td><td></td></tr><tr><td><code>convergent</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>no_unwind</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>will_return</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>op_bundle_sizes</code></td><td>::mlir::DenseI32ArrayAttr</td><td>i32 dense array attribute</td></tr><tr><td><code>op_bundle_tags</code></td><td>::mlir::ArrayAttr</td><td>array attribute</td></tr><tr><td><code>access_groups</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect access group metadata array</td></tr><tr><td><code>alias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>noalias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>tbaa</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect TBAA tag metadata array</td></tr></table><h4 id=operands-10>Operands: <a class=headline-hash href=#operands-10>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>callee_operands</code></td><td>variadic of LLVM dialect-compatible type</td></tr><tr><td style=text-align:center><code>op_bundle_operands</code></td><td>variadic of LLVM dialect-compatible type</td></tr></tbody></table><h4 id=results-10>Results: <a class=headline-hash href=#results-10>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>result</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmcomdat-llvmcomdatop><code>llvm.comdat</code> (LLVM::ComdatOp) <a class=headline-hash href=#llvmcomdat-llvmcomdatop>¶</a></h3><p><em>LLVM dialect comdat region</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.comdat` $sym_name $body attr-dict </code></pre><p>Provides access to object file COMDAT section/group functionality.</p><p>Examples:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl>llvm<span class=p>.</span>comdat <span class=nf>@__llvm_comdat</span> <span class=p>{</span> </span></span><span class=line><span class=cl> llvm<span class=p>.</span>comdat_selector <span class=nf>@any</span> any </span></span><span class=line><span class=cl><span class=p>}</span> </span></span><span class=line><span class=cl>llvm<span class=p>.</span>mlir<span class=p>.</span>global internal <span class=kt>constant</span> <span class=nf>@has_any_comdat</span><span class=p>(</span><span class=m>1</span> <span class=p>:</span> <span class=k>i64</span><span class=p>)</span> comdat<span class=p>(</span><span class=nf>@__llvm_comdat</span><span class=p>::</span><span class=nf>@any</span><span class=p>)</span> <span class=p>:</span> <span class=k>i64</span> </span></span></code></pre></div><p>Traits: <code>NoRegionArguments</code>, <code>NoTerminator</code>, <code>SymbolTable</code></p><p>Interfaces: <code>Symbol</code></p><h4 id=attributes-8>Attributes: <a class=headline-hash href=#attributes-8>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>sym_name</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr></table><h3 id=llvmcomdat_selector-llvmcomdatselectorop><code>llvm.comdat_selector</code> (LLVM::ComdatSelectorOp) <a class=headline-hash href=#llvmcomdat_selector-llvmcomdatselectorop>¶</a></h3><p><em>LLVM dialect comdat selector declaration</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.comdat_selector` $sym_name $comdat attr-dict </code></pre><p>Provides access to object file COMDAT section/group functionality.</p><p>Examples:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl>llvm<span class=p>.</span>comdat <span class=nf>@__llvm_comdat</span> <span class=p>{</span> </span></span><span class=line><span class=cl> llvm<span class=p>.</span>comdat_selector <span class=nf>@any</span> any </span></span><span class=line><span class=cl><span class=p>}</span> </span></span><span class=line><span class=cl>llvm<span class=p>.</span>mlir<span class=p>.</span>global internal <span class=kt>constant</span> <span class=nf>@has_any_comdat</span><span class=p>(</span><span class=m>1</span> <span class=p>:</span> <span class=k>i64</span><span class=p>)</span> comdat<span class=p>(</span><span class=nf>@__llvm_comdat</span><span class=p>::</span><span class=nf>@any</span><span class=p>)</span> <span class=p>:</span> <span class=k>i64</span> </span></span></code></pre></div><p>Interfaces: <code>Symbol</code></p><h4 id=attributes-9>Attributes: <a class=headline-hash href=#attributes-9>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>sym_name</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>comdat</code></td><td>::mlir::LLVM::comdat::ComdatAttr</td><td><details><summary>LLVM Comdat Types</summary><p>Enum cases:</p><ul><li>any (<code>Any</code>)</li><li>exactmatch (<code>ExactMatch</code>)</li><li>largest (<code>Largest</code>)</li><li>nodeduplicate (<code>NoDeduplicate</code>)</li><li>samesize (<code>SameSize</code>)</li></ul></details></td></tr></table><h3 id=llvmcond_br-llvmcondbrop><code>llvm.cond_br</code> (LLVM::CondBrOp) <a class=headline-hash href=#llvmcond_br-llvmcondbrop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.cond_br` $condition ( `weights` `(` $branch_weights^ `)` )? `,` $trueDest (`(` $trueDestOperands^ `:` type($trueDestOperands) `)`)? `,` $falseDest (`(` $falseDestOperands^ `:` type($falseDestOperands) `)`)? attr-dict </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>AttrSizedOperandSegments</code>, <code>Terminator</code></p><p>Interfaces: <code>BranchOpInterface</code>, <code>BranchWeightOpInterface</code>, <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-10>Attributes: <a class=headline-hash href=#attributes-10>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>branch_weights</code></td><td>::mlir::DenseI32ArrayAttr</td><td>i32 dense array attribute</td></tr><tr><td><code>loop_annotation</code></td><td>::mlir::LLVM::LoopAnnotationAttr</td><td><details><summary></summary><pre><code>This attributes encapsulates "loop metadata". It is meant to decorate branches that are "latches" (loop backedges) and maps to the `!llvm.loop` metadatas: https://llvm.org/docs/LangRef.html#llvm-loop It stores annotations in attribute parameters and groups related options in nested attributes to provide structured access. </code></pre></details></td></tr></table><h4 id=operands-11>Operands: <a class=headline-hash href=#operands-11>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>condition</code></td><td>1-bit signless integer</td></tr><tr><td style=text-align:center><code>trueDestOperands</code></td><td>variadic of LLVM dialect-compatible type</td></tr><tr><td style=text-align:center><code>falseDestOperands</code></td><td>variadic of LLVM dialect-compatible type</td></tr></tbody></table><h4 id=successors-1>Successors: <a class=headline-hash href=#successors-1>¶</a></h4><table><thead><tr><th style=text-align:center>Successor</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>trueDest</code></td><td>any successor</td></tr><tr><td style=text-align:center><code>falseDest</code></td><td>any successor</td></tr></tbody></table><h3 id=llvmmlirconstant-llvmconstantop><code>llvm.mlir.constant</code> (LLVM::ConstantOp) <a class=headline-hash href=#llvmmlirconstant-llvmconstantop>¶</a></h3><p><em>Defines a constant of LLVM type.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.mlir.constant` `(` $value `)` attr-dict `:` type($res) </code></pre><p>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. <code>llvm.mlir.constant</code> creates such values for scalars, vectors, strings, and structs. It has a mandatory <code>value</code> 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.</p><p>When creating constant scalars, the <code>value</code> attribute must be either an integer attribute or a floating point attribute. The type of the attribute may be omitted for <code>i64</code> and <code>f64</code> types that are implied.</p><p>When creating constant vectors, the <code>value</code> 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.</p><p>When creating constant strings, the <code>value</code> attribute must be a string attribute. The type of the constant must be an LLVM array of <code>i8</code>s, and the length of the array must match the length of the attribute.</p><p>When creating constant structs, the <code>value</code> 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.</p><p>Examples:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=c>// Integer constant, internal i32 is mandatory </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%0</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span><span class=kt>constant</span><span class=p>(</span><span class=m>42</span> <span class=p>:</span> <span class=k>i32</span><span class=p>)</span> <span class=p>:</span> <span class=k>i32</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// It's okay to omit i64. </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%1</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span><span class=kt>constant</span><span class=p>(</span><span class=m>42</span><span class=p>)</span> <span class=p>:</span> <span class=k>i64</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// Floating point constant. </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%2</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span><span class=kt>constant</span><span class=p>(</span><span class=m>42.0</span> <span class=p>:</span> <span class=k>f32</span><span class=p>)</span> <span class=p>:</span> <span class=k>f32</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// Splat dense vector constant. </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%3</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span><span class=kt>constant</span><span class=p>(</span>dense<span class=p><</span><span class=m>1.0</span><span class=p>></span> <span class=p>:</span> <span class=kt>vector</span><span class=p><</span><span class=m>4x</span><span class=k>f32</span><span class=p>>)</span> <span class=p>:</span> <span class=kt>vector</span><span class=p><</span><span class=m>4x</span><span class=k>f32</span><span class=p>></span> </span></span></code></pre></div><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>ConstantLike</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-11>Attributes: <a class=headline-hash href=#attributes-11>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>value</code></td><td>::mlir::Attribute</td><td>any attribute</td></tr></table><h4 id=results-11>Results: <a class=headline-hash href=#results-11>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmextractelement-llvmextractelementop><code>llvm.extractelement</code> (LLVM::ExtractElementOp) <a class=headline-hash href=#llvmextractelement-llvmextractelementop>¶</a></h3><p><em>Extract an element from an LLVM vector.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.extractelement` $vector `[` $position `:` type($position) `]` attr-dict `:` type($vector) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-12>Operands: <a class=headline-hash href=#operands-12>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>vector</code></td><td>LLVM dialect-compatible vector type</td></tr><tr><td style=text-align:center><code>position</code></td><td>signless integer</td></tr></tbody></table><h4 id=results-12>Results: <a class=headline-hash href=#results-12>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmextractvalue-llvmextractvalueop><code>llvm.extractvalue</code> (LLVM::ExtractValueOp) <a class=headline-hash href=#llvmextractvalue-llvmextractvalueop>¶</a></h3><p><em>Extract a value from an LLVM struct.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.extractvalue` $container `` $position attr-dict `:` type($container) custom<InsertExtractValueElementType>(type($res), ref(type($container)), ref($position)) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-12>Attributes: <a class=headline-hash href=#attributes-12>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>position</code></td><td>::mlir::DenseI64ArrayAttr</td><td>i64 dense array attribute</td></tr></table><h4 id=operands-13>Operands: <a class=headline-hash href=#operands-13>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>container</code></td><td>LLVM aggregate type</td></tr></tbody></table><h4 id=results-13>Results: <a class=headline-hash href=#results-13>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmfadd-llvmfaddop><code>llvm.fadd</code> (LLVM::FAddOp) <a class=headline-hash href=#llvmfadd-llvmfaddop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.fadd` $lhs `,` $rhs attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-13>Attributes: <a class=headline-hash href=#attributes-13>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-14>Operands: <a class=headline-hash href=#operands-14>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-14>Results: <a class=headline-hash href=#results-14>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h3 id=llvmfcmp-llvmfcmpop><code>llvm.fcmp</code> (LLVM::FCmpOp) <a class=headline-hash href=#llvmfcmp-llvmfcmpop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameTypeOperands</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-14>Attributes: <a class=headline-hash href=#attributes-14>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>predicate</code></td><td>::mlir::LLVM::FCmpPredicateAttr</td><td><details><summary>llvm.fcmp comparison predicate</summary><p>Enum cases:</p><ul><li>_false (<code>_false</code>)</li><li>oeq (<code>oeq</code>)</li><li>ogt (<code>ogt</code>)</li><li>oge (<code>oge</code>)</li><li>olt (<code>olt</code>)</li><li>ole (<code>ole</code>)</li><li>one (<code>one</code>)</li><li>ord (<code>ord</code>)</li><li>ueq (<code>ueq</code>)</li><li>ugt (<code>ugt</code>)</li><li>uge (<code>uge</code>)</li><li>ult (<code>ult</code>)</li><li>ule (<code>ule</code>)</li><li>une (<code>une</code>)</li><li>uno (<code>uno</code>)</li><li>_true (<code>_true</code>)</li></ul></details></td></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-15>Operands: <a class=headline-hash href=#operands-15>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-15>Results: <a class=headline-hash href=#results-15>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>1-bit signless integer or LLVM dialect-compatible vector of 1-bit signless integer</td></tr></tbody></table><h3 id=llvmfdiv-llvmfdivop><code>llvm.fdiv</code> (LLVM::FDivOp) <a class=headline-hash href=#llvmfdiv-llvmfdivop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.fdiv` $lhs `,` $rhs attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-15>Attributes: <a class=headline-hash href=#attributes-15>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-16>Operands: <a class=headline-hash href=#operands-16>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-16>Results: <a class=headline-hash href=#results-16>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h3 id=llvmfmul-llvmfmulop><code>llvm.fmul</code> (LLVM::FMulOp) <a class=headline-hash href=#llvmfmul-llvmfmulop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.fmul` $lhs `,` $rhs attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-16>Attributes: <a class=headline-hash href=#attributes-16>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-17>Operands: <a class=headline-hash href=#operands-17>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-17>Results: <a class=headline-hash href=#results-17>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h3 id=llvmfneg-llvmfnegop><code>llvm.fneg</code> (LLVM::FNegOp) <a class=headline-hash href=#llvmfneg-llvmfnegop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.fneg` $operand attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-17>Attributes: <a class=headline-hash href=#attributes-17>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-18>Operands: <a class=headline-hash href=#operands-18>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>operand</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-18>Results: <a class=headline-hash href=#results-18>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h3 id=llvmfpext-llvmfpextop><code>llvm.fpext</code> (LLVM::FPExtOp) <a class=headline-hash href=#llvmfpext-llvmfpextop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.fpext` $arg attr-dict `:` type($arg) `to` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-19>Operands: <a class=headline-hash href=#operands-19>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-19>Results: <a class=headline-hash href=#results-19>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h3 id=llvmfptosi-llvmfptosiop><code>llvm.fptosi</code> (LLVM::FPToSIOp) <a class=headline-hash href=#llvmfptosi-llvmfptosiop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.fptosi` $arg attr-dict `:` type($arg) `to` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-20>Operands: <a class=headline-hash href=#operands-20>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-20>Results: <a class=headline-hash href=#results-20>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmfptoui-llvmfptouiop><code>llvm.fptoui</code> (LLVM::FPToUIOp) <a class=headline-hash href=#llvmfptoui-llvmfptouiop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.fptoui` $arg attr-dict `:` type($arg) `to` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-21>Operands: <a class=headline-hash href=#operands-21>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-21>Results: <a class=headline-hash href=#results-21>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmfptrunc-llvmfptruncop><code>llvm.fptrunc</code> (LLVM::FPTruncOp) <a class=headline-hash href=#llvmfptrunc-llvmfptruncop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.fptrunc` $arg attr-dict `:` type($arg) `to` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-22>Operands: <a class=headline-hash href=#operands-22>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-22>Results: <a class=headline-hash href=#results-22>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h3 id=llvmfrem-llvmfremop><code>llvm.frem</code> (LLVM::FRemOp) <a class=headline-hash href=#llvmfrem-llvmfremop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.frem` $lhs `,` $rhs attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-18>Attributes: <a class=headline-hash href=#attributes-18>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-23>Operands: <a class=headline-hash href=#operands-23>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-23>Results: <a class=headline-hash href=#results-23>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h3 id=llvmfsub-llvmfsubop><code>llvm.fsub</code> (LLVM::FSubOp) <a class=headline-hash href=#llvmfsub-llvmfsubop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.fsub` $lhs `,` $rhs attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-19>Attributes: <a class=headline-hash href=#attributes-19>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-24>Operands: <a class=headline-hash href=#operands-24>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-24>Results: <a class=headline-hash href=#results-24>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h3 id=llvmfence-llvmfenceop><code>llvm.fence</code> (LLVM::FenceOp) <a class=headline-hash href=#llvmfence-llvmfenceop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.fence` (`syncscope` `(` $syncscope^ `)`)? $ordering attr-dict </code></pre><h4 id=attributes-20>Attributes: <a class=headline-hash href=#attributes-20>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>ordering</code></td><td>::mlir::LLVM::AtomicOrderingAttr</td><td><details><summary>Atomic ordering for LLVM's memory model</summary><p>Enum cases:</p><ul><li>not_atomic (<code>not_atomic</code>)</li><li>unordered (<code>unordered</code>)</li><li>monotonic (<code>monotonic</code>)</li><li>acquire (<code>acquire</code>)</li><li>release (<code>release</code>)</li><li>acq_rel (<code>acq_rel</code>)</li><li>seq_cst (<code>seq_cst</code>)</li></ul></details></td></tr><tr><td><code>syncscope</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr></table><h3 id=llvmfreeze-llvmfreezeop><code>llvm.freeze</code> (LLVM::FreezeOp) <a class=headline-hash href=#llvmfreeze-llvmfreezeop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.freeze` $val attr-dict `:` type($val) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-25>Operands: <a class=headline-hash href=#operands-25>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>val</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h4 id=results-25>Results: <a class=headline-hash href=#results-25>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmgetelementptr-llvmgepop><code>llvm.getelementptr</code> (LLVM::GEPOp) <a class=headline-hash href=#llvmgetelementptr-llvmgepop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.getelementptr` (`inbounds` $inbounds^)? $base `[` custom<GEPIndices>($dynamicIndices, $rawConstantIndices) `]` attr-dict `:` functional-type(operands, results) `,` $elem_type </code></pre><p>This operation mirrors LLVM IRs ‘getelementptr’ operation that is used to perform pointer arithmetic.</p><p>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.</p><p>An optional ‘inbounds’ attribute specifies the low-level pointer arithmetic overflow behavior that LLVM uses after lowering the operation to LLVM IR.</p><p>Examples:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=c>// GEP with an SSA value offset </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%0</span> <span class=p>=</span> llvm<span class=p>.</span>getelementptr <span class=nv>%1</span><span class=p>[</span><span class=nv>%2</span><span class=p>]</span> <span class=p>:</span> <span class=p>(!</span>llvm<span class=p>.</span>ptr<span class=p>,</span> <span class=k>i64</span><span class=p>)</span> <span class=p>-></span> <span class=p>!</span>llvm<span class=p>.</span>ptr<span class=p>,</span> <span class=k>f32</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// GEP with a constant offset and the inbounds attribute set </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%0</span> <span class=p>=</span> llvm<span class=p>.</span>getelementptr inbounds <span class=nv>%1</span><span class=p>[</span><span class=m>3</span><span class=p>]</span> <span class=p>:</span> <span class=p>(!</span>llvm<span class=p>.</span>ptr<span class=p>)</span> <span class=p>-></span> <span class=p>!</span>llvm<span class=p>.</span>ptr<span class=p>,</span> <span class=k>f32</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// GEP with constant offsets into a structure </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%0</span> <span class=p>=</span> llvm<span class=p>.</span>getelementptr <span class=nv>%1</span><span class=p>[</span><span class=m>0</span><span class=p>,</span> <span class=m>1</span><span class=p>]</span> </span></span><span class=line><span class=cl> <span class=p>:</span> <span class=p>(!</span>llvm<span class=p>.</span>ptr<span class=p>)</span> <span class=p>-></span> <span class=p>!</span>llvm<span class=p>.</span>ptr<span class=p>,</span> <span class=p>!</span>llvm<span class=p>.</span>struct<span class=p><(</span><span class=k>i32</span><span class=p>,</span> <span class=k>f32</span><span class=p>)></span> </span></span></code></pre></div><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>DestructurableAccessorOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code>, <code>PromotableOpInterface</code>, <code>SafeMemorySlotAccessOpInterface</code>, <code>ViewLikeOpInterface</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-21>Attributes: <a class=headline-hash href=#attributes-21>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>rawConstantIndices</code></td><td>::mlir::DenseI32ArrayAttr</td><td>i32 dense array attribute</td></tr><tr><td><code>elem_type</code></td><td>::mlir::TypeAttr</td><td>any type attribute</td></tr><tr><td><code>inbounds</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr></table><h4 id=operands-26>Operands: <a class=headline-hash href=#operands-26>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>base</code></td><td>LLVM pointer type or LLVM dialect-compatible vector of LLVM pointer type</td></tr><tr><td style=text-align:center><code>dynamicIndices</code></td><td>variadic of signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-26>Results: <a class=headline-hash href=#results-26>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM pointer type or LLVM dialect-compatible vector of LLVM pointer type</td></tr></tbody></table><h3 id=llvmmlirglobal_ctors-llvmglobalctorsop><code>llvm.mlir.global_ctors</code> (LLVM::GlobalCtorsOp) <a class=headline-hash href=#llvmmlirglobal_ctors-llvmglobalctorsop>¶</a></h3><p><em>LLVM dialect global_ctors.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.mlir.global_ctors` attr-dict </code></pre><p>Specifies a list of constructor functions and priorities. 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. The <code>data</code> field present in LLVM’s global_ctors variable is not modeled here.</p><p>Examples:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl>llvm<span class=p>.</span>mlir<span class=p>.</span>global_ctors <span class=p>{</span><span class=nf>@ctor</span><span class=p>}</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl>llvm<span class=p>.</span><span class=kt>func</span> <span class=nf>@ctor</span><span class=p>()</span> <span class=p>{</span> </span></span><span class=line><span class=cl> <span class=p>...</span> </span></span><span class=line><span class=cl> llvm<span class=p>.</span><span class=kt>return</span> </span></span><span class=line><span class=cl><span class=p>}</span> </span></span></code></pre></div><p>Interfaces: <code>SymbolUserOpInterface</code></p><h4 id=attributes-22>Attributes: <a class=headline-hash href=#attributes-22>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>ctors</code></td><td>::mlir::ArrayAttr</td><td>flat symbol ref array attribute</td></tr><tr><td><code>priorities</code></td><td>::mlir::ArrayAttr</td><td>32-bit integer array attribute</td></tr></table><h3 id=llvmmlirglobal_dtors-llvmglobaldtorsop><code>llvm.mlir.global_dtors</code> (LLVM::GlobalDtorsOp) <a class=headline-hash href=#llvmmlirglobal_dtors-llvmglobaldtorsop>¶</a></h3><p><em>LLVM dialect global_dtors.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.mlir.global_dtors` attr-dict </code></pre><p>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 <code>data</code> field present in LLVM’s global_dtors variable is not modeled here.</p><p>Examples:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl>llvm<span class=p>.</span><span class=kt>func</span> <span class=nf>@dtor</span><span class=p>()</span> <span class=p>{</span> </span></span><span class=line><span class=cl> llvm<span class=p>.</span><span class=kt>return</span> </span></span><span class=line><span class=cl><span class=p>}</span> </span></span><span class=line><span class=cl>llvm<span class=p>.</span>mlir<span class=p>.</span>global_dtors <span class=p>{</span><span class=nf>@dtor</span><span class=p>}</span> </span></span></code></pre></div><p>Interfaces: <code>SymbolUserOpInterface</code></p><h4 id=attributes-23>Attributes: <a class=headline-hash href=#attributes-23>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>dtors</code></td><td>::mlir::ArrayAttr</td><td>flat symbol ref array attribute</td></tr><tr><td><code>priorities</code></td><td>::mlir::ArrayAttr</td><td>32-bit integer array attribute</td></tr></table><h3 id=llvmmlirglobal-llvmglobalop><code>llvm.mlir.global</code> (LLVM::GlobalOp) <a class=headline-hash href=#llvmmlirglobal-llvmglobalop>¶</a></h3><p><em>LLVM dialect global.</em></p><p>Since MLIR allows for arbitrary operations to be present at the top level, global variables are defined using the <code>llvm.mlir.global</code> operation. Both global constants and variables can be defined, and the value may also be initialized in both cases.</p><p>There are two forms of initialization syntax. Simple constants that can be represented as MLIR attributes can be given in-line:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl>llvm<span class=p>.</span>mlir<span class=p>.</span>global <span class=nf>@variable</span><span class=p>(</span><span class=m>32.0</span> <span class=p>:</span> <span class=k>f32</span><span class=p>)</span> <span class=p>:</span> <span class=k>f32</span> </span></span></code></pre></div><p>This initialization and type syntax is similar to <code>llvm.mlir.constant</code> and may use two types: one for MLIR attribute and another for the LLVM value. These types must be compatible.</p><p>More complex constants that cannot be represented as MLIR attributes can be given in an initializer region:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=c>// This global is initialized with the equivalent of: </span></span></span><span class=line><span class=cl><span class=c>// i32* getelementptr (i32* @g2, i32 2) </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>mlir<span class=p>.</span>global <span class=kt>constant</span> <span class=nf>@int_gep</span><span class=p>()</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr <span class=p>{</span> </span></span><span class=line><span class=cl> <span class=nv>%0</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span>addressof <span class=nf>@g2</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr </span></span><span class=line><span class=cl> <span class=nv>%1</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span><span class=kt>constant</span><span class=p>(</span><span class=m>2</span> <span class=p>:</span> <span class=k>i32</span><span class=p>)</span> <span class=p>:</span> <span class=k>i32</span> </span></span><span class=line><span class=cl> <span class=nv>%2</span> <span class=p>=</span> llvm<span class=p>.</span>getelementptr <span class=nv>%0</span><span class=p>[</span><span class=nv>%1</span><span class=p>]</span> </span></span><span class=line><span class=cl> <span class=p>:</span> <span class=p>(!</span>llvm<span class=p>.</span>ptr<span class=p>,</span> <span class=k>i32</span><span class=p>)</span> <span class=p>-></span> <span class=p>!</span>llvm<span class=p>.</span>ptr<span class=p>,</span> <span class=k>i32</span> </span></span><span class=line><span class=cl> <span class=c>// The initializer region must end with `llvm.return`. </span></span></span><span class=line><span class=cl><span class=c></span> llvm<span class=p>.</span><span class=kt>return</span> <span class=nv>%2</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr </span></span><span class=line><span class=cl><span class=p>}</span> </span></span></code></pre></div><p>Only one of the initializer attribute or initializer region may be provided.</p><p><code>llvm.mlir.global</code> 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.</p><p>Examples:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=c>// Global values use @-identifiers. </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>mlir<span class=p>.</span>global <span class=kt>constant</span> <span class=nf>@cst</span><span class=p>(</span><span class=m>42</span> <span class=p>:</span> <span class=k>i32</span><span class=p>)</span> <span class=p>:</span> <span class=k>i32</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// Non-constant values must also be initialized. </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>mlir<span class=p>.</span>global <span class=nf>@variable</span><span class=p>(</span><span class=m>32.0</span> <span class=p>:</span> <span class=k>f32</span><span class=p>)</span> <span class=p>:</span> <span class=k>f32</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// Strings are expected to be of wrapped LLVM i8 array type and do not </span></span></span><span class=line><span class=cl><span class=c>// automatically include the trailing zero. </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>mlir<span class=p>.</span>global <span class=nf>@string</span><span class=p>(</span><span class=s>"abc"</span><span class=p>)</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>array<span class=p><</span><span class=m>3 x</span> <span class=k>i8</span><span class=p>></span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// For strings globals, the trailing type may be omitted. </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>mlir<span class=p>.</span>global <span class=kt>constant</span> <span class=nf>@no_trailing_type</span><span class=p>(</span><span class=s>"foo bar"</span><span class=p>)</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// A complex initializer is constructed with an initializer region. </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>mlir<span class=p>.</span>global <span class=kt>constant</span> <span class=nf>@int_gep</span><span class=p>()</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr <span class=p>{</span> </span></span><span class=line><span class=cl> <span class=nv>%0</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span>addressof <span class=nf>@g2</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr </span></span><span class=line><span class=cl> <span class=nv>%1</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span><span class=kt>constant</span><span class=p>(</span><span class=m>2</span> <span class=p>:</span> <span class=k>i32</span><span class=p>)</span> <span class=p>:</span> <span class=k>i32</span> </span></span><span class=line><span class=cl> <span class=nv>%2</span> <span class=p>=</span> llvm<span class=p>.</span>getelementptr <span class=nv>%0</span><span class=p>[</span><span class=nv>%1</span><span class=p>]</span> </span></span><span class=line><span class=cl> <span class=p>:</span> <span class=p>(!</span>llvm<span class=p>.</span>ptr<span class=p>,</span> <span class=k>i32</span><span class=p>)</span> <span class=p>-></span> <span class=p>!</span>llvm<span class=p>.</span>ptr<span class=p>,</span> <span class=k>i32</span> </span></span><span class=line><span class=cl> llvm<span class=p>.</span><span class=kt>return</span> <span class=nv>%2</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr </span></span><span class=line><span class=cl><span class=p>}</span> </span></span></code></pre></div><p>Similarly to functions, globals have a linkage attribute. In the custom syntax, this attribute is placed between <code>llvm.mlir.global</code> and the optional <code>constant</code> keyword. If the attribute is omitted, <code>external</code> linkage is assumed by default.</p><p>Examples:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=c>// A constant with internal linkage will not participate in linking. </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>mlir<span class=p>.</span>global internal <span class=kt>constant</span> <span class=nf>@cst</span><span class=p>(</span><span class=m>42</span> <span class=p>:</span> <span class=k>i32</span><span class=p>)</span> <span class=p>:</span> <span class=k>i32</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// By default, "external" linkage is assumed and the global participates in </span></span></span><span class=line><span class=cl><span class=c>// symbol resolution at link-time. </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>mlir<span class=p>.</span>global <span class=nf>@glob</span><span class=p>(</span><span class=m>0</span> <span class=p>:</span> <span class=k>f32</span><span class=p>)</span> <span class=p>:</span> <span class=k>f32</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// Alignment is optional </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>mlir<span class=p>.</span>global private <span class=kt>constant</span> <span class=nf>@y</span><span class=p>(</span>dense<span class=p><</span><span class=m>1.0</span><span class=p>></span> <span class=p>:</span> <span class=kt>tensor</span><span class=p><</span><span class=m>8x</span><span class=k>f32</span><span class=p>>)</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>array<span class=p><</span><span class=m>8 x</span> <span class=k>f32</span><span class=p>></span> </span></span></code></pre></div><p>Like global variables in LLVM IR, globals can have an (optional) alignment attribute using keyword <code>alignment</code>. The integer value of the alignment must be a positive integer that is a power of 2.</p><p>Examples:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=c>// Alignment is optional </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>mlir<span class=p>.</span>global private <span class=kt>constant</span> <span class=nf>@y</span><span class=p>(</span>dense<span class=p><</span><span class=m>1.0</span><span class=p>></span> <span class=p>:</span> <span class=kt>tensor</span><span class=p><</span><span class=m>8x</span><span class=k>f32</span><span class=p>>)</span> <span class=p>{</span> <span class=nl>alignment =</span> <span class=m>32</span> <span class=p>:</span> <span class=k>i64</span> <span class=p>}</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>array<span class=p><</span><span class=m>8 x</span> <span class=k>f32</span><span class=p>></span> </span></span></code></pre></div><p>Traits: <code>IsolatedFromAbove</code>, <code>SingleBlockImplicitTerminator<ReturnOp></code>, <code>SingleBlock</code></p><p>Interfaces: <code>Symbol</code></p><h4 id=attributes-24>Attributes: <a class=headline-hash href=#attributes-24>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>global_type</code></td><td>::mlir::TypeAttr</td><td>any type attribute</td></tr><tr><td><code>constant</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>sym_name</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>linkage</code></td><td>::mlir::LLVM::LinkageAttr</td><td>LLVM Linkage specification</td></tr><tr><td><code>dso_local</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>thread_local_</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>externally_initialized</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>value</code></td><td>::mlir::Attribute</td><td>any attribute</td></tr><tr><td><code>alignment</code></td><td>::mlir::IntegerAttr</td><td>64-bit signless integer attribute</td></tr><tr><td><code>addr_space</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute whose value is non-negative</td></tr><tr><td><code>unnamed_addr</code></td><td>::mlir::LLVM::UnnamedAddrAttr</td><td><details><summary>LLVM GlobalValue UnnamedAddr</summary><p>Enum cases:</p><ul><li>(<code>None</code>)</li><li>local_unnamed_addr (<code>Local</code>)</li><li>unnamed_addr (<code>Global</code>)</li></ul></details></td></tr><tr><td><code>section</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>comdat</code></td><td>::mlir::SymbolRefAttr</td><td>symbol reference attribute</td></tr><tr><td><code>dbg_exprs</code></td><td>::mlir::ArrayAttr</td><td>an array of variable expressions</td></tr><tr><td><code>visibility_</code></td><td>::mlir::LLVM::VisibilityAttr</td><td><details><summary>LLVM GlobalValue Visibility</summary><p>Enum cases:</p><ul><li>(<code>Default</code>)</li><li>hidden (<code>Hidden</code>)</li><li>protected (<code>Protected</code>)</li></ul></details></td></tr></table><h3 id=llvmicmp-llvmicmpop><code>llvm.icmp</code> (LLVM::ICmpOp) <a class=headline-hash href=#llvmicmp-llvmicmpop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameTypeOperands</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-25>Attributes: <a class=headline-hash href=#attributes-25>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>predicate</code></td><td>::mlir::LLVM::ICmpPredicateAttr</td><td><details><summary>lvm.icmp comparison predicate</summary><p>Enum cases:</p><ul><li>eq (<code>eq</code>)</li><li>ne (<code>ne</code>)</li><li>slt (<code>slt</code>)</li><li>sle (<code>sle</code>)</li><li>sgt (<code>sgt</code>)</li><li>sge (<code>sge</code>)</li><li>ult (<code>ult</code>)</li><li>ule (<code>ule</code>)</li><li>ugt (<code>ugt</code>)</li><li>uge (<code>uge</code>)</li></ul></details></td></tr></table><h4 id=operands-27>Operands: <a class=headline-hash href=#operands-27>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer or LLVM pointer type or LLVM dialect-compatible vector of LLVM pointer type</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer or LLVM pointer type or LLVM dialect-compatible vector of LLVM pointer type</td></tr></tbody></table><h4 id=results-27>Results: <a class=headline-hash href=#results-27>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>1-bit signless integer or LLVM dialect-compatible vector of 1-bit signless integer</td></tr></tbody></table><h3 id=llvminline_asm-llvminlineasmop><code>llvm.inline_asm</code> (LLVM::InlineAsmOp) <a class=headline-hash href=#llvminline_asm-llvminlineasmop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.inline_asm` (`has_side_effects` $has_side_effects^)? (`is_align_stack` $is_align_stack^)? (`asm_dialect` `=` $asm_dialect^)? (`operand_attrs` `=` $operand_attrs^)? attr-dict $asm_string `,` $constraints operands `:` functional-type(operands, results) </code></pre><p>The InlineAsmOp mirrors the underlying LLVM semantics with a notable exception: the embedded <code>asm_string</code> 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.</p><p>Interfaces: <code>MemoryEffectOpInterface</code></p><h4 id=attributes-26>Attributes: <a class=headline-hash href=#attributes-26>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>asm_string</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>constraints</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>has_side_effects</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>is_align_stack</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>asm_dialect</code></td><td>::mlir::LLVM::AsmDialectAttr</td><td><details><summary>ATT (0) or Intel (1) asm dialect</summary><p>Enum cases:</p><ul><li>att (<code>AD_ATT</code>)</li><li>intel (<code>AD_Intel</code>)</li></ul></details></td></tr><tr><td><code>operand_attrs</code></td><td>::mlir::ArrayAttr</td><td>array attribute</td></tr></table><h4 id=operands-28>Operands: <a class=headline-hash href=#operands-28>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>operands</code></td><td>variadic of LLVM dialect-compatible type</td></tr></tbody></table><h4 id=results-28>Results: <a class=headline-hash href=#results-28>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvminsertelement-llvminsertelementop><code>llvm.insertelement</code> (LLVM::InsertElementOp) <a class=headline-hash href=#llvminsertelement-llvminsertelementop>¶</a></h3><p><em>Insert an element into an LLVM vector.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.insertelement` $value `,` $vector `[` $position `:` type($position) `]` attr-dict `:` type($vector) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-29>Operands: <a class=headline-hash href=#operands-29>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>vector</code></td><td>LLVM dialect-compatible vector type</td></tr><tr><td style=text-align:center><code>value</code></td><td>primitive LLVM type</td></tr><tr><td style=text-align:center><code>position</code></td><td>signless integer</td></tr></tbody></table><h4 id=results-29>Results: <a class=headline-hash href=#results-29>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible vector type</td></tr></tbody></table><h3 id=llvminsertvalue-llvminsertvalueop><code>llvm.insertvalue</code> (LLVM::InsertValueOp) <a class=headline-hash href=#llvminsertvalue-llvminsertvalueop>¶</a></h3><p><em>Insert a value into an LLVM struct.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.insertvalue` $value `,` $container `` $position attr-dict `:` type($container) custom<InsertExtractValueElementType>(type($value), ref(type($container)), ref($position)) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-27>Attributes: <a class=headline-hash href=#attributes-27>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>position</code></td><td>::mlir::DenseI64ArrayAttr</td><td>i64 dense array attribute</td></tr></table><h4 id=operands-30>Operands: <a class=headline-hash href=#operands-30>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>container</code></td><td>LLVM aggregate type</td></tr><tr><td style=text-align:center><code>value</code></td><td>primitive LLVM type</td></tr></tbody></table><h4 id=results-30>Results: <a class=headline-hash href=#results-30>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM aggregate type</td></tr></tbody></table><h3 id=llvminttoptr-llvminttoptrop><code>llvm.inttoptr</code> (LLVM::IntToPtrOp) <a class=headline-hash href=#llvminttoptr-llvminttoptrop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.inttoptr` $arg attr-dict `:` type($arg) `to` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-31>Operands: <a class=headline-hash href=#operands-31>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-31>Results: <a class=headline-hash href=#results-31>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM pointer type or LLVM dialect-compatible vector of LLVM pointer type</td></tr></tbody></table><h3 id=llvminvoke-llvminvokeop><code>llvm.invoke</code> (LLVM::InvokeOp) <a class=headline-hash href=#llvminvoke-llvminvokeop>¶</a></h3><p>Traits: <code>AttrSizedOperandSegments</code>, <code>Terminator</code></p><p>Interfaces: <code>BranchOpInterface</code>, <code>BranchWeightOpInterface</code>, <code>CallOpInterface</code></p><h4 id=attributes-28>Attributes: <a class=headline-hash href=#attributes-28>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>var_callee_type</code></td><td>::mlir::TypeAttr</td><td>type attribute of LLVM function type</td></tr><tr><td><code>callee</code></td><td>::mlir::FlatSymbolRefAttr</td><td>flat symbol reference attribute</td></tr><tr><td><code>branch_weights</code></td><td>::mlir::DenseI32ArrayAttr</td><td>i32 dense array attribute</td></tr><tr><td><code>CConv</code></td><td>::mlir::LLVM::CConvAttr</td><td>LLVM Calling Convention specification</td></tr><tr><td><code>op_bundle_sizes</code></td><td>::mlir::DenseI32ArrayAttr</td><td>i32 dense array attribute</td></tr><tr><td><code>op_bundle_tags</code></td><td>::mlir::ArrayAttr</td><td>array attribute</td></tr></table><h4 id=operands-32>Operands: <a class=headline-hash href=#operands-32>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>callee_operands</code></td><td>variadic of LLVM dialect-compatible type</td></tr><tr><td style=text-align:center><code>normalDestOperands</code></td><td>variadic of LLVM dialect-compatible type</td></tr><tr><td style=text-align:center><code>unwindDestOperands</code></td><td>variadic of LLVM dialect-compatible type</td></tr><tr><td style=text-align:center><code>op_bundle_operands</code></td><td>variadic of LLVM dialect-compatible type</td></tr></tbody></table><h4 id=results-32>Results: <a class=headline-hash href=#results-32>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>result</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h4 id=successors-2>Successors: <a class=headline-hash href=#successors-2>¶</a></h4><table><thead><tr><th style=text-align:center>Successor</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>normalDest</code></td><td>any successor</td></tr><tr><td style=text-align:center><code>unwindDest</code></td><td>any successor</td></tr></tbody></table><h3 id=llvmfunc-llvmllvmfuncop><code>llvm.func</code> (LLVM::LLVMFuncOp) <a class=headline-hash href=#llvmfunc-llvmllvmfuncop>¶</a></h3><p><em>LLVM dialect function.</em></p><p>MLIR functions are defined by an operation that is not built into the IR itself. The LLVM dialect provides an <code>llvm.func</code> 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.</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=c>// The type of @bar is !llvm<"i64 (i64)"> </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span><span class=kt>func</span> <span class=nf>@bar</span><span class=p>(</span><span class=nv>%arg0</span><span class=p>:</span> <span class=k>i64</span><span class=p>)</span> <span class=p>-></span> <span class=k>i64</span> <span class=p>{</span> </span></span><span class=line><span class=cl> llvm<span class=p>.</span><span class=kt>return</span> <span class=nv>%arg0</span> <span class=p>:</span> <span class=k>i64</span> </span></span><span class=line><span class=cl><span class=p>}</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// Type type of @foo is !llvm<"void (i64)"> </span></span></span><span class=line><span class=cl><span class=c>// !llvm.void type is omitted </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span><span class=kt>func</span> <span class=nf>@foo</span><span class=p>(</span><span class=nv>%arg0</span><span class=p>:</span> <span class=k>i64</span><span class=p>)</span> <span class=p>{</span> </span></span><span class=line><span class=cl> llvm<span class=p>.</span><span class=kt>return</span> </span></span><span class=line><span class=cl><span class=p>}</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// A function with `internal` linkage. </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span><span class=kt>func</span> internal <span class=nf>@internal_func</span><span class=p>()</span> <span class=p>{</span> </span></span><span class=line><span class=cl> llvm<span class=p>.</span><span class=kt>return</span> </span></span><span class=line><span class=cl><span class=p>}</span> </span></span></code></pre></div><p>Traits: <code>AutomaticAllocationScope</code>, <code>IsolatedFromAbove</code></p><p>Interfaces: <code>CallableOpInterface</code>, <code>FunctionOpInterface</code>, <code>Symbol</code></p><h4 id=attributes-29>Attributes: <a class=headline-hash href=#attributes-29>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>sym_name</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>sym_visibility</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>function_type</code></td><td>::mlir::TypeAttr</td><td>type attribute of LLVM function type</td></tr><tr><td><code>linkage</code></td><td>::mlir::LLVM::LinkageAttr</td><td>LLVM Linkage specification</td></tr><tr><td><code>dso_local</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>CConv</code></td><td>::mlir::LLVM::CConvAttr</td><td>LLVM Calling Convention specification</td></tr><tr><td><code>comdat</code></td><td>::mlir::SymbolRefAttr</td><td>symbol reference attribute</td></tr><tr><td><code>convergent</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>personality</code></td><td>::mlir::FlatSymbolRefAttr</td><td>flat symbol reference attribute</td></tr><tr><td><code>garbageCollector</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>passthrough</code></td><td>::mlir::ArrayAttr</td><td>array attribute</td></tr><tr><td><code>arg_attrs</code></td><td>::mlir::ArrayAttr</td><td>Array of dictionary attributes</td></tr><tr><td><code>res_attrs</code></td><td>::mlir::ArrayAttr</td><td>Array of dictionary attributes</td></tr><tr><td><code>function_entry_count</code></td><td>::mlir::IntegerAttr</td><td>64-bit signless integer attribute</td></tr><tr><td><code>memory_effects</code></td><td>::mlir::LLVM::MemoryEffectsAttr</td><td></td></tr><tr><td><code>visibility_</code></td><td>::mlir::LLVM::VisibilityAttr</td><td><details><summary>LLVM GlobalValue Visibility</summary><p>Enum cases:</p><ul><li>(<code>Default</code>)</li><li>hidden (<code>Hidden</code>)</li><li>protected (<code>Protected</code>)</li></ul></details></td></tr><tr><td><code>arm_streaming</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>arm_locally_streaming</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>arm_streaming_compatible</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>arm_new_za</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>arm_in_za</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>arm_out_za</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>arm_inout_za</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>arm_preserves_za</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>section</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>unnamed_addr</code></td><td>::mlir::LLVM::UnnamedAddrAttr</td><td><details><summary>LLVM GlobalValue UnnamedAddr</summary><p>Enum cases:</p><ul><li>(<code>None</code>)</li><li>local_unnamed_addr (<code>Local</code>)</li><li>unnamed_addr (<code>Global</code>)</li></ul></details></td></tr><tr><td><code>alignment</code></td><td>::mlir::IntegerAttr</td><td>64-bit signless integer attribute</td></tr><tr><td><code>vscale_range</code></td><td>::mlir::LLVM::VScaleRangeAttr</td><td></td></tr><tr><td><code>frame_pointer</code></td><td>::mlir::LLVM::FramePointerKindAttr</td><td></td></tr><tr><td><code>target_cpu</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>tune_cpu</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>target_features</code></td><td>::mlir::LLVM::TargetFeaturesAttr</td><td><details><summary>LLVM target features attribute</summary><pre><code>Represents the LLVM target features as a list that can be checked within passes/rewrites. <p>Example:</p> <div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=nv>#llvm.target_features</span><span class=err>&</span>lt<span class=err>;</span><span class=p>[</span><span class=err>&</span>quot<span class=err>;+</span>sme<span class=err>&</span>quot<span class=err>;</span><span class=p>,</span> <span class=err>&</span>quot<span class=err>;+</span>sve<span class=err>&</span>quot<span class=err>;</span><span class=p>,</span> <span class=err>&</span>quot<span class=err>;+</span>sme<span class=err>-</span><span class=k>f64f64</span><span class=err>&</span>quot<span class=err>;</span><span class=p>]</span><span class=err>&</span>gt<span class=err>;</span> </span></span></code></pre></div><p>Then within a pass or rewrite the features active at an op can be queried:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-c++ data-lang=c++><span class=line><span class=cl><span class=k>auto</span> <span class=n>targetFeatures</span> <span class=o>=</span> <span class=n>LLVM</span><span class=o>::</span><span class=n>TargetFeaturesAttr</span><span class=o>::</span><span class=n>featuresAt</span><span class=p>(</span><span class=n>op</span><span class=p>);</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=k>if</span> <span class=p>(</span><span class=o>!</span><span class=n>targetFeatures</span><span class=p>.</span><span class=n>contains</span><span class=p>(</span><span class=o>&</span><span class=n>quot</span><span class=p>;</span><span class=o>+</span><span class=n>sme</span><span class=o>-</span><span class=n>f64f64</span><span class=o>&</span><span class=n>quot</span><span class=p>;))</span> </span></span><span class=line><span class=cl> <span class=k>return</span> <span class=n>failure</span><span class=p>();</span> </span></span></code></pre></div><p></code></pre></p></details></td></tr><tr><td><code>unsafe_fp_math</code></td><td>::mlir::BoolAttr</td><td>bool attribute</td></tr><tr><td><code>no_infs_fp_math</code></td><td>::mlir::BoolAttr</td><td>bool attribute</td></tr><tr><td><code>no_nans_fp_math</code></td><td>::mlir::BoolAttr</td><td>bool attribute</td></tr><tr><td><code>approx_func_fp_math</code></td><td>::mlir::BoolAttr</td><td>bool attribute</td></tr><tr><td><code>no_signed_zeros_fp_math</code></td><td>::mlir::BoolAttr</td><td>bool attribute</td></tr><tr><td><code>denormal_fp_math</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>denormal_fp_math_f32</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>fp_contract</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>no_inline</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>always_inline</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>no_unwind</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>will_return</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>optimize_none</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>vec_type_hint</code></td><td>::mlir::LLVM::VecTypeHintAttr</td><td><details><summary>Explicit vectorization compiler hint</summary><pre><code>A hint to the compiler that indicates most operations used in the function are explictly vectorized using a particular vector type. `$hint` is the vector or scalar type in particular. `$is_signed` can be used with integer types to state whether the type is signed. </code></pre></details></td></tr><tr><td><code>work_group_size_hint</code></td><td>::mlir::DenseI32ArrayAttr</td><td>i32 dense array attribute</td></tr><tr><td><code>reqd_work_group_size</code></td><td>::mlir::DenseI32ArrayAttr</td><td>i32 dense array attribute</td></tr><tr><td><code>intel_reqd_sub_group_size</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr></table><h3 id=llvmlshr-llvmlshrop><code>llvm.lshr</code> (LLVM::LShrOp) <a class=headline-hash href=#llvmlshr-llvmlshrop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.lshr` (`exact` $isExact^)? $lhs `,` $rhs attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>ExactFlagInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-30>Attributes: <a class=headline-hash href=#attributes-30>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>isExact</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr></table><h4 id=operands-33>Operands: <a class=headline-hash href=#operands-33>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-33>Results: <a class=headline-hash href=#results-33>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmlandingpad-llvmlandingpadop><code>llvm.landingpad</code> (LLVM::LandingpadOp) <a class=headline-hash href=#llvmlandingpad-llvmlandingpadop>¶</a></h3><h4 id=attributes-31>Attributes: <a class=headline-hash href=#attributes-31>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>cleanup</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr></table><h4 id=operands-34>Operands: <a class=headline-hash href=#operands-34>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center>«unnamed»</td><td>variadic of LLVM dialect-compatible type</td></tr></tbody></table><h4 id=results-34>Results: <a class=headline-hash href=#results-34>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmlinker_options-llvmlinkeroptionsop><code>llvm.linker_options</code> (LLVM::LinkerOptionsOp) <a class=headline-hash href=#llvmlinker_options-llvmlinkeroptionsop>¶</a></h3><p><em>Options to pass to the linker when the object file is linked</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.linker_options` $options attr-dict </code></pre><p>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.</p><p>Examples:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=c>// Link against the MSVC static threaded CRT. </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>linker_options <span class=p>[</span><span class=s>"/DEFAULTLIB:"</span><span class=p>,</span> <span class=s>"libcmt"</span><span class=p>]</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// Link against aarch64 compiler-rt builtins </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>linker_options <span class=p>[</span><span class=s>"-l"</span><span class=p>,</span> <span class=s>"clang_rt.builtins-aarch64"</span><span class=p>]</span> </span></span></code></pre></div><h4 id=attributes-32>Attributes: <a class=headline-hash href=#attributes-32>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>options</code></td><td>::mlir::ArrayAttr</td><td>string array attribute</td></tr></table><h3 id=llvmload-llvmloadop><code>llvm.load</code> (LLVM::LoadOp) <a class=headline-hash href=#llvmload-llvmloadop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.load` (`volatile` $volatile_^)? $addr (`atomic` (`syncscope` `(` $syncscope^ `)`)? $ordering^)? (`invariant` $invariant^)? (`invariant_group` $invariantGroup^)? attr-dict `:` qualified(type($addr)) `->` type($res) </code></pre><p>The <code>load</code> 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.</p><p>An atomic load only supports a limited set of pointer, integer, and floating point types, and requires an explicit alignment.</p><p>Examples:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=c>// A volatile load of a float variable. </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%0</span> <span class=p>=</span> llvm<span class=p>.</span>load volatile <span class=nv>%ptr</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr <span class=p>-></span> <span class=k>f32</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// A nontemporal load of a float variable. </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%0</span> <span class=p>=</span> llvm<span class=p>.</span>load <span class=nv>%ptr</span> <span class=p>{</span>nontemporal<span class=p>}</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr <span class=p>-></span> <span class=k>f32</span> </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// An atomic load of an integer variable. </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%0</span> <span class=p>=</span> llvm<span class=p>.</span>load <span class=nv>%ptr</span> atomic monotonic <span class=p>{</span><span class=nl>alignment =</span> <span class=m>8</span> <span class=p>:</span> <span class=k>i64</span><span class=p>}</span> </span></span><span class=line><span class=cl> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr <span class=p>-></span> <span class=k>i64</span> </span></span></code></pre></div><p>See the following link for more details: <a href=https://llvm.org/docs/LangRef.html#load-instruction>https://llvm.org/docs/LangRef.html#load-instruction</a></p><p>Interfaces: <code>AccessGroupOpInterface</code>, <code>AliasAnalysisOpInterface</code>, <code>DestructurableAccessorOpInterface</code>, <code>MemoryEffectOpInterface</code>, <code>PromotableMemOpInterface</code>, <code>SafeMemorySlotAccessOpInterface</code></p><h4 id=attributes-33>Attributes: <a class=headline-hash href=#attributes-33>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>alignment</code></td><td>::mlir::IntegerAttr</td><td>64-bit signless integer attribute</td></tr><tr><td><code>volatile_</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>nontemporal</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>invariant</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>invariantGroup</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>ordering</code></td><td>::mlir::LLVM::AtomicOrderingAttr</td><td><details><summary>Atomic ordering for LLVM's memory model</summary><p>Enum cases:</p><ul><li>not_atomic (<code>not_atomic</code>)</li><li>unordered (<code>unordered</code>)</li><li>monotonic (<code>monotonic</code>)</li><li>acquire (<code>acquire</code>)</li><li>release (<code>release</code>)</li><li>acq_rel (<code>acq_rel</code>)</li><li>seq_cst (<code>seq_cst</code>)</li></ul></details></td></tr><tr><td><code>syncscope</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>access_groups</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect access group metadata array</td></tr><tr><td><code>alias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>noalias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>tbaa</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect TBAA tag metadata array</td></tr></table><h4 id=operands-35>Operands: <a class=headline-hash href=#operands-35>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>addr</code></td><td>LLVM pointer type</td></tr></tbody></table><h4 id=results-35>Results: <a class=headline-hash href=#results-35>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM type with size</td></tr></tbody></table><h3 id=llvmmul-llvmmulop><code>llvm.mul</code> (LLVM::MulOp) <a class=headline-hash href=#llvmmul-llvmmulop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.mul` $lhs `,` $rhs `` custom<OverflowFlags>($overflowFlags) attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>Commutative</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>IntegerOverflowFlagsInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-36>Operands: <a class=headline-hash href=#operands-36>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-36>Results: <a class=headline-hash href=#results-36>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmmlirnone-llvmnonetokenop><code>llvm.mlir.none</code> (LLVM::NoneTokenOp) <a class=headline-hash href=#llvmmlirnone-llvmnonetokenop>¶</a></h3><p><em>Defines a value containing an empty token to LLVM type.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.mlir.none` attr-dict `:` type($res) </code></pre><p>Unlike LLVM IR, MLIR does not have first-class token values. They must be explicitly created as SSA values using <code>llvm.mlir.none</code>. This operation has no operands or attributes, and returns a none token value of a wrapped LLVM IR pointer type.</p><p>Examples:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=nv>%0</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span>none <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>token </span></span></code></pre></div><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=results-37>Results: <a class=headline-hash href=#results-37>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM token type</td></tr></tbody></table><h3 id=llvmor-llvmorop><code>llvm.or</code> (LLVM::OrOp) <a class=headline-hash href=#llvmor-llvmorop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.or` (`disjoint` $isDisjoint^)? $lhs `,` $rhs attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>DisjointFlagInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-34>Attributes: <a class=headline-hash href=#attributes-34>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>isDisjoint</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr></table><h4 id=operands-37>Operands: <a class=headline-hash href=#operands-37>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-38>Results: <a class=headline-hash href=#results-38>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmmlirpoison-llvmpoisonop><code>llvm.mlir.poison</code> (LLVM::PoisonOp) <a class=headline-hash href=#llvmmlirpoison-llvmpoisonop>¶</a></h3><p><em>Creates a poison value of LLVM dialect type.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.mlir.poison` attr-dict `:` type($res) </code></pre><p>Unlike LLVM IR, MLIR does not have first-class poison values. Such values must be created as SSA values using <code>llvm.mlir.poison</code>. This operation has no operands or attributes. It creates a poison value of the specified LLVM IR dialect type.</p><p>Example:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=c>// Create a poison value for a structure with a 32-bit integer followed </span></span></span><span class=line><span class=cl><span class=c>// by a float. </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%0</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span>poison <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>struct<span class=p><(</span><span class=k>i32</span><span class=p>,</span> <span class=k>f32</span><span class=p>)></span> </span></span></code></pre></div><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>ConstantLike</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=results-39>Results: <a class=headline-hash href=#results-39>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmptrtoint-llvmptrtointop><code>llvm.ptrtoint</code> (LLVM::PtrToIntOp) <a class=headline-hash href=#llvmptrtoint-llvmptrtointop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.ptrtoint` $arg attr-dict `:` type($arg) `to` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-38>Operands: <a class=headline-hash href=#operands-38>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg</code></td><td>LLVM pointer type or LLVM dialect-compatible vector of LLVM pointer type</td></tr></tbody></table><h4 id=results-40>Results: <a class=headline-hash href=#results-40>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmresume-llvmresumeop><code>llvm.resume</code> (LLVM::ResumeOp) <a class=headline-hash href=#llvmresume-llvmresumeop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.resume` $value attr-dict `:` type($value) </code></pre><p>Traits: <code>Terminator</code></p><h4 id=operands-39>Operands: <a class=headline-hash href=#operands-39>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>value</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmreturn-llvmreturnop><code>llvm.return</code> (LLVM::ReturnOp) <a class=headline-hash href=#llvmreturn-llvmreturnop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.return` attr-dict ($arg^ `:` type($arg))? </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>ReturnLike</code>, <code>Terminator</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code>, <code>RegionBranchTerminatorOpInterface</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-40>Operands: <a class=headline-hash href=#operands-40>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmsdiv-llvmsdivop><code>llvm.sdiv</code> (LLVM::SDivOp) <a class=headline-hash href=#llvmsdiv-llvmsdivop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.sdiv` (`exact` $isExact^)? $lhs `,` $rhs attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>ExactFlagInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-35>Attributes: <a class=headline-hash href=#attributes-35>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>isExact</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr></table><h4 id=operands-41>Operands: <a class=headline-hash href=#operands-41>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-41>Results: <a class=headline-hash href=#results-41>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmsext-llvmsextop><code>llvm.sext</code> (LLVM::SExtOp) <a class=headline-hash href=#llvmsext-llvmsextop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.sext` $arg attr-dict `:` type($arg) `to` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-42>Operands: <a class=headline-hash href=#operands-42>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-42>Results: <a class=headline-hash href=#results-42>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmsitofp-llvmsitofpop><code>llvm.sitofp</code> (LLVM::SIToFPOp) <a class=headline-hash href=#llvmsitofp-llvmsitofpop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.sitofp` $arg attr-dict `:` type($arg) `to` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-43>Operands: <a class=headline-hash href=#operands-43>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-43>Results: <a class=headline-hash href=#results-43>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h3 id=llvmsrem-llvmsremop><code>llvm.srem</code> (LLVM::SRemOp) <a class=headline-hash href=#llvmsrem-llvmsremop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.srem` $lhs `,` $rhs attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-44>Operands: <a class=headline-hash href=#operands-44>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-44>Results: <a class=headline-hash href=#results-44>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmselect-llvmselectop><code>llvm.select</code> (LLVM::SelectOp) <a class=headline-hash href=#llvmselect-llvmselectop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.select` operands attr-dict `:` type($condition) `,` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code>, <code>SelectLikeOpInterface</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-36>Attributes: <a class=headline-hash href=#attributes-36>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-45>Operands: <a class=headline-hash href=#operands-45>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>condition</code></td><td>1-bit signless integer or LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>trueValue</code></td><td>LLVM dialect-compatible type</td></tr><tr><td style=text-align:center><code>falseValue</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h4 id=results-45>Results: <a class=headline-hash href=#results-45>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmshl-llvmshlop><code>llvm.shl</code> (LLVM::ShlOp) <a class=headline-hash href=#llvmshl-llvmshlop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.shl` $lhs `,` $rhs `` custom<OverflowFlags>($overflowFlags) attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>IntegerOverflowFlagsInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-46>Operands: <a class=headline-hash href=#operands-46>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-46>Results: <a class=headline-hash href=#results-46>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmshufflevector-llvmshufflevectorop><code>llvm.shufflevector</code> (LLVM::ShuffleVectorOp) <a class=headline-hash href=#llvmshufflevector-llvmshufflevectorop>¶</a></h3><p><em>Construct a permutation of two vectors.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.shufflevector` $v1 `,` $v2 $mask attr-dict `:` type($v1) custom<ShuffleType>(ref(type($v1)), type($res), ref($mask)) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-37>Attributes: <a class=headline-hash href=#attributes-37>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>mask</code></td><td>::mlir::DenseI32ArrayAttr</td><td>i32 dense array attribute</td></tr></table><h4 id=operands-47>Operands: <a class=headline-hash href=#operands-47>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>v1</code></td><td>LLVM dialect-compatible vector type</td></tr><tr><td style=text-align:center><code>v2</code></td><td>LLVM dialect-compatible vector type</td></tr></tbody></table><h4 id=results-47>Results: <a class=headline-hash href=#results-47>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible vector type</td></tr></tbody></table><h3 id=llvmstore-llvmstoreop><code>llvm.store</code> (LLVM::StoreOp) <a class=headline-hash href=#llvmstore-llvmstoreop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.store` (`volatile` $volatile_^)? $value `,` $addr (`atomic` (`syncscope` `(` $syncscope^ `)`)? $ordering^)? (`invariant_group` $invariantGroup^)? attr-dict `:` type($value) `,` qualified(type($addr)) </code></pre><p>The <code>store</code> 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.</p><p>An atomic store only supports a limited set of pointer, integer, and floating point types, and requires an explicit alignment.</p><p>Examples:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=c>// A volatile store of a float variable. </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>store volatile <span class=nv>%val</span><span class=p>,</span> <span class=nv>%ptr</span> <span class=p>:</span> <span class=k>f32</span><span class=p>,</span> <span class=p>!</span>llvm<span class=p>.</span>ptr </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// A nontemporal store of a float variable. </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>store <span class=nv>%val</span><span class=p>,</span> <span class=nv>%ptr</span> <span class=p>{</span>nontemporal<span class=p>}</span> <span class=p>:</span> <span class=k>f32</span><span class=p>,</span> <span class=p>!</span>llvm<span class=p>.</span>ptr </span></span><span class=line><span class=cl> </span></span><span class=line><span class=cl><span class=c>// An atomic store of an integer variable. </span></span></span><span class=line><span class=cl><span class=c></span>llvm<span class=p>.</span>store <span class=nv>%val</span><span class=p>,</span> <span class=nv>%ptr</span> atomic monotonic <span class=p>{</span><span class=nl>alignment =</span> <span class=m>8</span> <span class=p>:</span> <span class=k>i64</span><span class=p>}</span> </span></span><span class=line><span class=cl> <span class=p>:</span> <span class=k>i64</span><span class=p>,</span> <span class=p>!</span>llvm<span class=p>.</span>ptr </span></span></code></pre></div><p>See the following link for more details: <a href=https://llvm.org/docs/LangRef.html#store-instruction>https://llvm.org/docs/LangRef.html#store-instruction</a></p><p>Interfaces: <code>AccessGroupOpInterface</code>, <code>AliasAnalysisOpInterface</code>, <code>DestructurableAccessorOpInterface</code>, <code>MemoryEffectOpInterface</code>, <code>PromotableMemOpInterface</code>, <code>SafeMemorySlotAccessOpInterface</code></p><h4 id=attributes-38>Attributes: <a class=headline-hash href=#attributes-38>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>alignment</code></td><td>::mlir::IntegerAttr</td><td>64-bit signless integer attribute</td></tr><tr><td><code>volatile_</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>nontemporal</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>invariantGroup</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr><tr><td><code>ordering</code></td><td>::mlir::LLVM::AtomicOrderingAttr</td><td><details><summary>Atomic ordering for LLVM's memory model</summary><p>Enum cases:</p><ul><li>not_atomic (<code>not_atomic</code>)</li><li>unordered (<code>unordered</code>)</li><li>monotonic (<code>monotonic</code>)</li><li>acquire (<code>acquire</code>)</li><li>release (<code>release</code>)</li><li>acq_rel (<code>acq_rel</code>)</li><li>seq_cst (<code>seq_cst</code>)</li></ul></details></td></tr><tr><td><code>syncscope</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>access_groups</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect access group metadata array</td></tr><tr><td><code>alias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>noalias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>tbaa</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect TBAA tag metadata array</td></tr></table><h4 id=operands-48>Operands: <a class=headline-hash href=#operands-48>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>value</code></td><td>LLVM type with size</td></tr><tr><td style=text-align:center><code>addr</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmsub-llvmsubop><code>llvm.sub</code> (LLVM::SubOp) <a class=headline-hash href=#llvmsub-llvmsubop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.sub` $lhs `,` $rhs `` custom<OverflowFlags>($overflowFlags) attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>IntegerOverflowFlagsInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-49>Operands: <a class=headline-hash href=#operands-49>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-48>Results: <a class=headline-hash href=#results-48>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmswitch-llvmswitchop><code>llvm.switch</code> (LLVM::SwitchOp) <a class=headline-hash href=#llvmswitch-llvmswitchop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.switch` $value `:` type($value) `,` $defaultDestination (`(` $defaultOperands^ `:` type($defaultOperands) `)`)? custom<SwitchOpCases>(ref(type($value)), $case_values, $caseDestinations, $caseOperands, type($caseOperands)) attr-dict </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>AttrSizedOperandSegments</code>, <code>Terminator</code></p><p>Interfaces: <code>BranchOpInterface</code>, <code>BranchWeightOpInterface</code>, <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-39>Attributes: <a class=headline-hash href=#attributes-39>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>case_values</code></td><td>::mlir::DenseIntElementsAttr</td><td>integer elements attribute</td></tr><tr><td><code>case_operand_segments</code></td><td>::mlir::DenseI32ArrayAttr</td><td>i32 dense array attribute</td></tr><tr><td><code>branch_weights</code></td><td>::mlir::DenseI32ArrayAttr</td><td>i32 dense array attribute</td></tr></table><h4 id=operands-50>Operands: <a class=headline-hash href=#operands-50>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>value</code></td><td>signless integer</td></tr><tr><td style=text-align:center><code>defaultOperands</code></td><td>variadic of any type</td></tr><tr><td style=text-align:center><code>caseOperands</code></td><td>variadic of any type</td></tr></tbody></table><h4 id=successors-3>Successors: <a class=headline-hash href=#successors-3>¶</a></h4><table><thead><tr><th style=text-align:center>Successor</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>defaultDestination</code></td><td>any successor</td></tr><tr><td style=text-align:center><code>caseDestinations</code></td><td>any successor</td></tr></tbody></table><h3 id=llvmtrunc-llvmtruncop><code>llvm.trunc</code> (LLVM::TruncOp) <a class=headline-hash href=#llvmtrunc-llvmtruncop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.trunc` $arg `` custom<OverflowFlags>($overflowFlags) attr-dict `:` type($arg) `to` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>IntegerOverflowFlagsInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-51>Operands: <a class=headline-hash href=#operands-51>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-49>Results: <a class=headline-hash href=#results-49>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmudiv-llvmudivop><code>llvm.udiv</code> (LLVM::UDivOp) <a class=headline-hash href=#llvmudiv-llvmudivop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.udiv` (`exact` $isExact^)? $lhs `,` $rhs attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>ExactFlagInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-40>Attributes: <a class=headline-hash href=#attributes-40>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>isExact</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr></table><h4 id=operands-52>Operands: <a class=headline-hash href=#operands-52>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-50>Results: <a class=headline-hash href=#results-50>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmuitofp-llvmuitofpop><code>llvm.uitofp</code> (LLVM::UIToFPOp) <a class=headline-hash href=#llvmuitofp-llvmuitofpop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.uitofp` (`nneg` $nonNeg^)? $arg attr-dict `:` type($arg) `to` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code>, <code>NonNegFlagInterface</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-41>Attributes: <a class=headline-hash href=#attributes-41>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>nonNeg</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr></table><h4 id=operands-53>Operands: <a class=headline-hash href=#operands-53>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-51>Results: <a class=headline-hash href=#results-51>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h3 id=llvmurem-llvmuremop><code>llvm.urem</code> (LLVM::URemOp) <a class=headline-hash href=#llvmurem-llvmuremop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.urem` $lhs `,` $rhs attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-54>Operands: <a class=headline-hash href=#operands-54>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-52>Results: <a class=headline-hash href=#results-52>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmmlirundef-llvmundefop><code>llvm.mlir.undef</code> (LLVM::UndefOp) <a class=headline-hash href=#llvmmlirundef-llvmundefop>¶</a></h3><p><em>Creates an undefined value of LLVM dialect type.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.mlir.undef` attr-dict `:` type($res) </code></pre><p>Unlike LLVM IR, MLIR does not have first-class undefined values. Such values must be created as SSA values using <code>llvm.mlir.undef</code>. This operation has no operands or attributes. It creates an undefined value of the specified LLVM IR dialect type.</p><p>Example:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=c>// Create a structure with a 32-bit integer followed by a float. </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%0</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span>undef <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>struct<span class=p><(</span><span class=k>i32</span><span class=p>,</span> <span class=k>f32</span><span class=p>)></span> </span></span></code></pre></div><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>ConstantLike</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=results-53>Results: <a class=headline-hash href=#results-53>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmunreachable-llvmunreachableop><code>llvm.unreachable</code> (LLVM::UnreachableOp) <a class=headline-hash href=#llvmunreachable-llvmunreachableop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.unreachable` attr-dict </code></pre><p>Traits: <code>Terminator</code></p><h3 id=llvmva_arg-llvmvaargop><code>llvm.va_arg</code> (LLVM::VaArgOp) <a class=headline-hash href=#llvmva_arg-llvmvaargop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.va_arg` $arg attr-dict `:` functional-type($arg, $res) </code></pre><h4 id=operands-55>Operands: <a class=headline-hash href=#operands-55>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg</code></td><td>LLVM pointer type</td></tr></tbody></table><h4 id=results-54>Results: <a class=headline-hash href=#results-54>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmxor-llvmxorop><code>llvm.xor</code> (LLVM::XOrOp) <a class=headline-hash href=#llvmxor-llvmxorop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.xor` $lhs `,` $rhs attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-56>Operands: <a class=headline-hash href=#operands-56>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-55>Results: <a class=headline-hash href=#results-55>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmzext-llvmzextop><code>llvm.zext</code> (LLVM::ZExtOp) <a class=headline-hash href=#llvmzext-llvmzextop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.zext` (`nneg` $nonNeg^)? $arg attr-dict `:` type($arg) `to` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code>, <code>NonNegFlagInterface</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-42>Attributes: <a class=headline-hash href=#attributes-42>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>nonNeg</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr></table><h4 id=operands-57>Operands: <a class=headline-hash href=#operands-57>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-56>Results: <a class=headline-hash href=#results-56>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmmlirzero-llvmzeroop><code>llvm.mlir.zero</code> (LLVM::ZeroOp) <a class=headline-hash href=#llvmmlirzero-llvmzeroop>¶</a></h3><p><em>Creates a zero-initialized value of LLVM dialect type.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.mlir.zero` attr-dict `:` type($res) </code></pre><p>Unlike LLVM IR, MLIR does not have first-class zero-initialized values. Such values must be created as SSA values using <code>llvm.mlir.zero</code>. This operation has no operands or attributes. It creates a zero-initialized value of the specified LLVM IR dialect type.</p><p>Example:</p><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=c>// Create a zero-initialized value for a structure with a 32-bit integer </span></span></span><span class=line><span class=cl><span class=c>// followed by a float. </span></span></span><span class=line><span class=cl><span class=c></span><span class=nv>%0</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span>zero <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>struct<span class=p><(</span><span class=k>i32</span><span class=p>,</span> <span class=k>f32</span><span class=p>)></span> </span></span></code></pre></div><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>ConstantLike</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=results-57>Results: <a class=headline-hash href=#results-57>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h2 id=operations-for-llvm-ir-intrinsics>Operations for LLVM IR Intrinsics <a class=headline-hash href=#operations-for-llvm-ir-intrinsics>¶</a></h2><p>MLIR operation system is open making it unnecessary to introduce a hard bound between “core” operations and “intrinsics”. General LLVM IR intrinsics are modeled as first-class operations in the LLVM dialect. Target-specific LLVM IR intrinsics, e.g., NVVM or ROCDL, are modeled as separate dialects.</p><p><a href=https://github.com/llvm/llvm-project/blob/main/mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td>source</a></p><h3 id=llvmintrabs-llvmabsop><code>llvm.intr.abs</code> (LLVM::AbsOp) <a class=headline-hash href=#llvmintrabs-llvmabsop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-43>Attributes: <a class=headline-hash href=#attributes-43>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>is_int_min_poison</code></td><td>::mlir::IntegerAttr</td><td>1-bit signless integer attribute</td></tr></table><h4 id=operands-58>Operands: <a class=headline-hash href=#operands-58>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-58>Results: <a class=headline-hash href=#results-58>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrannotation-llvmannotation><code>llvm.intr.annotation</code> (LLVM::Annotation) <a class=headline-hash href=#llvmintrannotation-llvmannotation>¶</a></h3><p>Interfaces: <code>InferTypeOpInterface</code></p><h4 id=operands-59>Operands: <a class=headline-hash href=#operands-59>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>integer</code></td><td>signless integer</td></tr><tr><td style=text-align:center><code>annotation</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>fileName</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>line</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-59>Results: <a class=headline-hash href=#results-59>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>signless integer</td></tr></tbody></table><h3 id=llvmintrassume-llvmassumeop><code>llvm.intr.assume</code> (LLVM::AssumeOp) <a class=headline-hash href=#llvmintrassume-llvmassumeop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.assume` $cond ( custom<OpBundles>($op_bundle_operands, type($op_bundle_operands), $op_bundle_tags)^ )? `:` type($cond) attr-dict </code></pre><h4 id=attributes-44>Attributes: <a class=headline-hash href=#attributes-44>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>op_bundle_sizes</code></td><td>::mlir::DenseI32ArrayAttr</td><td>i32 dense array attribute</td></tr><tr><td><code>op_bundle_tags</code></td><td>::mlir::ArrayAttr</td><td>array attribute</td></tr></table><h4 id=operands-60>Operands: <a class=headline-hash href=#operands-60>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>cond</code></td><td>1-bit signless integer</td></tr><tr><td style=text-align:center><code>op_bundle_operands</code></td><td>variadic of LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrbitreverse-llvmbitreverseop><code>llvm.intr.bitreverse</code> (LLVM::BitReverseOp) <a class=headline-hash href=#llvmintrbitreverse-llvmbitreverseop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.bitreverse` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-61>Operands: <a class=headline-hash href=#operands-61>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-60>Results: <a class=headline-hash href=#results-60>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrbswap-llvmbyteswapop><code>llvm.intr.bswap</code> (LLVM::ByteSwapOp) <a class=headline-hash href=#llvmintrbswap-llvmbyteswapop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.bswap` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-62>Operands: <a class=headline-hash href=#operands-62>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-61>Results: <a class=headline-hash href=#results-61>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrexperimentalconstrainedfptrunc-llvmconstrainedfptruncintr><code>llvm.intr.experimental.constrained.fptrunc</code> (LLVM::ConstrainedFPTruncIntr) <a class=headline-hash href=#llvmintrexperimentalconstrainedfptrunc-llvmconstrainedfptruncintr>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.experimental.constrained.fptrunc` $arg_0 $roundingmode $fpExceptionBehavior attr-dict `:` type($arg_0) `to` type(results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FPExceptionBehaviorOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code>, <code>RoundingModeOpInterface</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-45>Attributes: <a class=headline-hash href=#attributes-45>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>roundingmode</code></td><td>::mlir::LLVM::RoundingModeAttr</td><td><details><summary>LLVM Rounding Mode whose minimum value is 0</summary><p>Enum cases:</p><ul><li>towardzero (<code>TowardZero</code>)</li><li>tonearest (<code>NearestTiesToEven</code>)</li><li>upward (<code>TowardPositive</code>)</li><li>downward (<code>TowardNegative</code>)</li><li>tonearestaway (<code>NearestTiesToAway</code>)</li><li>dynamic (<code>Dynamic</code>)</li><li>invalid (<code>Invalid</code>)</li></ul></details></td></tr><tr><td><code>fpExceptionBehavior</code></td><td>::mlir::LLVM::FPExceptionBehaviorAttr</td><td><details><summary>LLVM Exception Behavior</summary><p>Enum cases:</p><ul><li>ignore (<code>Ignore</code>)</li><li>maytrap (<code>MayTrap</code>)</li><li>strict (<code>Strict</code>)</li></ul></details></td></tr></table><h4 id=operands-63>Operands: <a class=headline-hash href=#operands-63>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg_0</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h4 id=results-62>Results: <a class=headline-hash href=#results-62>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrcopysign-llvmcopysignop><code>llvm.intr.copysign</code> (LLVM::CopySignOp) <a class=headline-hash href=#llvmintrcopysign-llvmcopysignop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.copysign` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-46>Attributes: <a class=headline-hash href=#attributes-46>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-64>Operands: <a class=headline-hash href=#operands-64>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr><tr><td style=text-align:center><code>b</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-63>Results: <a class=headline-hash href=#results-63>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrcoroalign-llvmcoroalignop><code>llvm.intr.coro.align</code> (LLVM::CoroAlignOp) <a class=headline-hash href=#llvmintrcoroalign-llvmcoroalignop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.coro.align` attr-dict `:` type($res) </code></pre><h4 id=results-64>Results: <a class=headline-hash href=#results-64>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrcorobegin-llvmcorobeginop><code>llvm.intr.coro.begin</code> (LLVM::CoroBeginOp) <a class=headline-hash href=#llvmintrcorobegin-llvmcorobeginop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.coro.begin` $token `,` $mem attr-dict `:` functional-type(operands, results) </code></pre><h4 id=operands-65>Operands: <a class=headline-hash href=#operands-65>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>token</code></td><td>LLVM token type</td></tr><tr><td style=text-align:center><code>mem</code></td><td>LLVM pointer type</td></tr></tbody></table><h4 id=results-65>Results: <a class=headline-hash href=#results-65>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrcoroend-llvmcoroendop><code>llvm.intr.coro.end</code> (LLVM::CoroEndOp) <a class=headline-hash href=#llvmintrcoroend-llvmcoroendop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.coro.end` $handle `,` $unwind `,` $retvals attr-dict `:` functional-type(operands, results) </code></pre><h4 id=operands-66>Operands: <a class=headline-hash href=#operands-66>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>handle</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>unwind</code></td><td>1-bit signless integer</td></tr><tr><td style=text-align:center><code>retvals</code></td><td>LLVM token type</td></tr></tbody></table><h4 id=results-66>Results: <a class=headline-hash href=#results-66>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrcorofree-llvmcorofreeop><code>llvm.intr.coro.free</code> (LLVM::CoroFreeOp) <a class=headline-hash href=#llvmintrcorofree-llvmcorofreeop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.coro.free` $id `,` $handle attr-dict `:` functional-type(operands, results) </code></pre><h4 id=operands-67>Operands: <a class=headline-hash href=#operands-67>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>id</code></td><td>LLVM token type</td></tr><tr><td style=text-align:center><code>handle</code></td><td>LLVM pointer type</td></tr></tbody></table><h4 id=results-67>Results: <a class=headline-hash href=#results-67>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrcoroid-llvmcoroidop><code>llvm.intr.coro.id</code> (LLVM::CoroIdOp) <a class=headline-hash href=#llvmintrcoroid-llvmcoroidop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.coro.id` $align `,` $promise `,` $coroaddr `,` $fnaddrs attr-dict `:` functional-type(operands, results) </code></pre><h4 id=operands-68>Operands: <a class=headline-hash href=#operands-68>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>align</code></td><td>32-bit signless integer</td></tr><tr><td style=text-align:center><code>promise</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>coroaddr</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>fnaddrs</code></td><td>LLVM pointer type</td></tr></tbody></table><h4 id=results-68>Results: <a class=headline-hash href=#results-68>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrcoropromise-llvmcoropromiseop><code>llvm.intr.coro.promise</code> (LLVM::CoroPromiseOp) <a class=headline-hash href=#llvmintrcoropromise-llvmcoropromiseop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.coro.promise` $handle `,` $align `,` $from attr-dict `:` functional-type(operands, results) </code></pre><h4 id=operands-69>Operands: <a class=headline-hash href=#operands-69>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>handle</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>align</code></td><td>32-bit signless integer</td></tr><tr><td style=text-align:center><code>from</code></td><td>1-bit signless integer</td></tr></tbody></table><h4 id=results-69>Results: <a class=headline-hash href=#results-69>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmintrcororesume-llvmcororesumeop><code>llvm.intr.coro.resume</code> (LLVM::CoroResumeOp) <a class=headline-hash href=#llvmintrcororesume-llvmcororesumeop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.coro.resume` $handle attr-dict `:` qualified(type($handle)) </code></pre><h4 id=operands-70>Operands: <a class=headline-hash href=#operands-70>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>handle</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmintrcorosave-llvmcorosaveop><code>llvm.intr.coro.save</code> (LLVM::CoroSaveOp) <a class=headline-hash href=#llvmintrcorosave-llvmcorosaveop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.coro.save` $handle attr-dict `:` functional-type(operands, results) </code></pre><h4 id=operands-71>Operands: <a class=headline-hash href=#operands-71>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>handle</code></td><td>LLVM pointer type</td></tr></tbody></table><h4 id=results-70>Results: <a class=headline-hash href=#results-70>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrcorosize-llvmcorosizeop><code>llvm.intr.coro.size</code> (LLVM::CoroSizeOp) <a class=headline-hash href=#llvmintrcorosize-llvmcorosizeop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.coro.size` attr-dict `:` type($res) </code></pre><h4 id=results-71>Results: <a class=headline-hash href=#results-71>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrcorosuspend-llvmcorosuspendop><code>llvm.intr.coro.suspend</code> (LLVM::CoroSuspendOp) <a class=headline-hash href=#llvmintrcorosuspend-llvmcorosuspendop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.coro.suspend` $save `,` $final attr-dict `:` type($res) </code></pre><h4 id=operands-72>Operands: <a class=headline-hash href=#operands-72>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>save</code></td><td>LLVM token type</td></tr><tr><td style=text-align:center><code>final</code></td><td>1-bit signless integer</td></tr></tbody></table><h4 id=results-72>Results: <a class=headline-hash href=#results-72>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrcos-llvmcosop><code>llvm.intr.cos</code> (LLVM::CosOp) <a class=headline-hash href=#llvmintrcos-llvmcosop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.cos` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-47>Attributes: <a class=headline-hash href=#attributes-47>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-73>Operands: <a class=headline-hash href=#operands-73>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-73>Results: <a class=headline-hash href=#results-73>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrcosh-llvmcoshop><code>llvm.intr.cosh</code> (LLVM::CoshOp) <a class=headline-hash href=#llvmintrcosh-llvmcoshop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.cosh` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-48>Attributes: <a class=headline-hash href=#attributes-48>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-74>Operands: <a class=headline-hash href=#operands-74>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-74>Results: <a class=headline-hash href=#results-74>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrctlz-llvmcountleadingzerosop><code>llvm.intr.ctlz</code> (LLVM::CountLeadingZerosOp) <a class=headline-hash href=#llvmintrctlz-llvmcountleadingzerosop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-49>Attributes: <a class=headline-hash href=#attributes-49>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>is_zero_poison</code></td><td>::mlir::IntegerAttr</td><td>1-bit signless integer attribute</td></tr></table><h4 id=operands-75>Operands: <a class=headline-hash href=#operands-75>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-75>Results: <a class=headline-hash href=#results-75>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrcttz-llvmcounttrailingzerosop><code>llvm.intr.cttz</code> (LLVM::CountTrailingZerosOp) <a class=headline-hash href=#llvmintrcttz-llvmcounttrailingzerosop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-50>Attributes: <a class=headline-hash href=#attributes-50>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>is_zero_poison</code></td><td>::mlir::IntegerAttr</td><td>1-bit signless integer attribute</td></tr></table><h4 id=operands-76>Operands: <a class=headline-hash href=#operands-76>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-76>Results: <a class=headline-hash href=#results-76>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrctpop-llvmctpopop><code>llvm.intr.ctpop</code> (LLVM::CtPopOp) <a class=headline-hash href=#llvmintrctpop-llvmctpopop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.ctpop` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-77>Operands: <a class=headline-hash href=#operands-77>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-77>Results: <a class=headline-hash href=#results-77>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrdbgdeclare-llvmdbgdeclareop><code>llvm.intr.dbg.declare</code> (LLVM::DbgDeclareOp) <a class=headline-hash href=#llvmintrdbgdeclare-llvmdbgdeclareop>¶</a></h3><p><em>Describes how the address relates to a source language variable.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.dbg.declare` qualified($varInfo) (qualified($locationExpr)^)? `=` $addr `:` qualified(type($addr)) attr-dict </code></pre><p>Interfaces: <code>PromotableOpInterface</code></p><h4 id=attributes-51>Attributes: <a class=headline-hash href=#attributes-51>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>varInfo</code></td><td>::mlir::LLVM::DILocalVariableAttr</td><td></td></tr><tr><td><code>locationExpr</code></td><td>::mlir::LLVM::DIExpressionAttr</td><td></td></tr></table><h4 id=operands-78>Operands: <a class=headline-hash href=#operands-78>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>addr</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmintrdbglabel-llvmdbglabelop><code>llvm.intr.dbg.label</code> (LLVM::DbgLabelOp) <a class=headline-hash href=#llvmintrdbglabel-llvmdbglabelop>¶</a></h3><p><em>Relates the program to a debug information label.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.dbg.label` $label attr-dict </code></pre><h4 id=attributes-52>Attributes: <a class=headline-hash href=#attributes-52>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>label</code></td><td>::mlir::LLVM::DILabelAttr</td><td></td></tr></table><h3 id=llvmintrdbgvalue-llvmdbgvalueop><code>llvm.intr.dbg.value</code> (LLVM::DbgValueOp) <a class=headline-hash href=#llvmintrdbgvalue-llvmdbgvalueop>¶</a></h3><p><em>Describes how the value relates to a source language variable.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.dbg.value` qualified($varInfo) (qualified($locationExpr)^)? `=` $value `:` qualified(type($value)) attr-dict </code></pre><p>Interfaces: <code>PromotableOpInterface</code></p><h4 id=attributes-53>Attributes: <a class=headline-hash href=#attributes-53>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>varInfo</code></td><td>::mlir::LLVM::DILocalVariableAttr</td><td></td></tr><tr><td><code>locationExpr</code></td><td>::mlir::LLVM::DIExpressionAttr</td><td></td></tr></table><h4 id=operands-79>Operands: <a class=headline-hash href=#operands-79>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>value</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrdebugtrap-llvmdebugtrap><code>llvm.intr.debugtrap</code> (LLVM::DebugTrap) <a class=headline-hash href=#llvmintrdebugtrap-llvmdebugtrap>¶</a></h3><h3 id=llvmintrehtypeidfor-llvmehtypeidforop><code>llvm.intr.eh.typeid.for</code> (LLVM::EhTypeidForOp) <a class=headline-hash href=#llvmintrehtypeidfor-llvmehtypeidforop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.eh.typeid.for` $type_info attr-dict `:` functional-type(operands, results) </code></pre><h4 id=operands-80>Operands: <a class=headline-hash href=#operands-80>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>type_info</code></td><td>LLVM pointer type</td></tr></tbody></table><h4 id=results-78>Results: <a class=headline-hash href=#results-78>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrexp2-llvmexp2op><code>llvm.intr.exp2</code> (LLVM::Exp2Op) <a class=headline-hash href=#llvmintrexp2-llvmexp2op>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.exp2` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-54>Attributes: <a class=headline-hash href=#attributes-54>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-81>Operands: <a class=headline-hash href=#operands-81>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-79>Results: <a class=headline-hash href=#results-79>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrexp-llvmexpop><code>llvm.intr.exp</code> (LLVM::ExpOp) <a class=headline-hash href=#llvmintrexp-llvmexpop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.exp` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-55>Attributes: <a class=headline-hash href=#attributes-55>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-82>Operands: <a class=headline-hash href=#operands-82>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-80>Results: <a class=headline-hash href=#results-80>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrexpect-llvmexpectop><code>llvm.intr.expect</code> (LLVM::ExpectOp) <a class=headline-hash href=#llvmintrexpect-llvmexpectop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.expect` $val `,` $expected attr-dict `:` type($val) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-83>Operands: <a class=headline-hash href=#operands-83>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>val</code></td><td>signless integer</td></tr><tr><td style=text-align:center><code>expected</code></td><td>signless integer</td></tr></tbody></table><h4 id=results-81>Results: <a class=headline-hash href=#results-81>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrexpectwithprobability-llvmexpectwithprobabilityop><code>llvm.intr.expect.with.probability</code> (LLVM::ExpectWithProbabilityOp) <a class=headline-hash href=#llvmintrexpectwithprobability-llvmexpectwithprobabilityop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.expect.with.probability` $val `,` $expected `,` $prob attr-dict `:` type($val) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-56>Attributes: <a class=headline-hash href=#attributes-56>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>prob</code></td><td>::mlir::FloatAttr</td><td>64-bit float attribute</td></tr></table><h4 id=operands-84>Operands: <a class=headline-hash href=#operands-84>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>val</code></td><td>signless integer</td></tr><tr><td style=text-align:center><code>expected</code></td><td>signless integer</td></tr></tbody></table><h4 id=results-82>Results: <a class=headline-hash href=#results-82>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrfabs-llvmfabsop><code>llvm.intr.fabs</code> (LLVM::FAbsOp) <a class=headline-hash href=#llvmintrfabs-llvmfabsop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.fabs` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-57>Attributes: <a class=headline-hash href=#attributes-57>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-85>Operands: <a class=headline-hash href=#operands-85>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-83>Results: <a class=headline-hash href=#results-83>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrceil-llvmfceilop><code>llvm.intr.ceil</code> (LLVM::FCeilOp) <a class=headline-hash href=#llvmintrceil-llvmfceilop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.ceil` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-58>Attributes: <a class=headline-hash href=#attributes-58>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-86>Operands: <a class=headline-hash href=#operands-86>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-84>Results: <a class=headline-hash href=#results-84>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrfloor-llvmffloorop><code>llvm.intr.floor</code> (LLVM::FFloorOp) <a class=headline-hash href=#llvmintrfloor-llvmffloorop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.floor` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-59>Attributes: <a class=headline-hash href=#attributes-59>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-87>Operands: <a class=headline-hash href=#operands-87>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-85>Results: <a class=headline-hash href=#results-85>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrfma-llvmfmaop><code>llvm.intr.fma</code> (LLVM::FMAOp) <a class=headline-hash href=#llvmintrfma-llvmfmaop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.fma` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-60>Attributes: <a class=headline-hash href=#attributes-60>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-88>Operands: <a class=headline-hash href=#operands-88>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr><tr><td style=text-align:center><code>b</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr><tr><td style=text-align:center><code>c</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-86>Results: <a class=headline-hash href=#results-86>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrfmuladd-llvmfmuladdop><code>llvm.intr.fmuladd</code> (LLVM::FMulAddOp) <a class=headline-hash href=#llvmintrfmuladd-llvmfmuladdop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.fmuladd` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-61>Attributes: <a class=headline-hash href=#attributes-61>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-89>Operands: <a class=headline-hash href=#operands-89>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr><tr><td style=text-align:center><code>b</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr><tr><td style=text-align:center><code>c</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-87>Results: <a class=headline-hash href=#results-87>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrtrunc-llvmftruncop><code>llvm.intr.trunc</code> (LLVM::FTruncOp) <a class=headline-hash href=#llvmintrtrunc-llvmftruncop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.trunc` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-62>Attributes: <a class=headline-hash href=#attributes-62>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-90>Operands: <a class=headline-hash href=#operands-90>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-88>Results: <a class=headline-hash href=#results-88>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrfshl-llvmfshlop><code>llvm.intr.fshl</code> (LLVM::FshlOp) <a class=headline-hash href=#llvmintrfshl-llvmfshlop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.fshl` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-91>Operands: <a class=headline-hash href=#operands-91>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>b</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>c</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-89>Results: <a class=headline-hash href=#results-89>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrfshr-llvmfshrop><code>llvm.intr.fshr</code> (LLVM::FshrOp) <a class=headline-hash href=#llvmintrfshr-llvmfshrop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.fshr` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-92>Operands: <a class=headline-hash href=#operands-92>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>b</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>c</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-90>Results: <a class=headline-hash href=#results-90>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrgetactivelanemask-llvmgetactivelanemaskop><code>llvm.intr.get.active.lane.mask</code> (LLVM::GetActiveLaneMaskOp) <a class=headline-hash href=#llvmintrgetactivelanemask-llvmgetactivelanemaskop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.get.active.lane.mask` $base `,` $n attr-dict `:` type($base) `,` type($n) `to` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-93>Operands: <a class=headline-hash href=#operands-93>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>base</code></td><td>signless integer</td></tr><tr><td style=text-align:center><code>n</code></td><td>signless integer</td></tr></tbody></table><h4 id=results-91>Results: <a class=headline-hash href=#results-91>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrinvariantend-llvminvariantendop><code>llvm.intr.invariant.end</code> (LLVM::InvariantEndOp) <a class=headline-hash href=#llvmintrinvariantend-llvminvariantendop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.invariant.end` $start `,` $size `,` $ptr attr-dict `:` qualified(type($ptr)) </code></pre><p>Interfaces: <code>PromotableOpInterface</code></p><h4 id=attributes-63>Attributes: <a class=headline-hash href=#attributes-63>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>size</code></td><td>::mlir::IntegerAttr</td><td>64-bit signless integer attribute</td></tr></table><h4 id=operands-94>Operands: <a class=headline-hash href=#operands-94>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>start</code></td><td>LLVM pointer in address space 0</td></tr><tr><td style=text-align:center><code>ptr</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmintrinvariantstart-llvminvariantstartop><code>llvm.intr.invariant.start</code> (LLVM::InvariantStartOp) <a class=headline-hash href=#llvmintrinvariantstart-llvminvariantstartop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.invariant.start` $size `,` $ptr attr-dict `:` qualified(type($ptr)) </code></pre><p>Interfaces: <code>InferTypeOpInterface</code>, <code>PromotableOpInterface</code></p><h4 id=attributes-64>Attributes: <a class=headline-hash href=#attributes-64>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>size</code></td><td>::mlir::IntegerAttr</td><td>64-bit signless integer attribute</td></tr></table><h4 id=operands-95>Operands: <a class=headline-hash href=#operands-95>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>ptr</code></td><td>LLVM pointer type</td></tr></tbody></table><h4 id=results-92>Results: <a class=headline-hash href=#results-92>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM pointer in address space 0</td></tr></tbody></table><h3 id=llvmintrisconstant-llvmisconstantop><code>llvm.intr.is.constant</code> (LLVM::IsConstantOp) <a class=headline-hash href=#llvmintrisconstant-llvmisconstantop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-96>Operands: <a class=headline-hash href=#operands-96>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>val</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h4 id=results-93>Results: <a class=headline-hash href=#results-93>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>1-bit signless integer</td></tr></tbody></table><h3 id=llvmintrisfpclass-llvmisfpclass><code>llvm.intr.is.fpclass</code> (LLVM::IsFPClass) <a class=headline-hash href=#llvmintrisfpclass-llvmisfpclass>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-65>Attributes: <a class=headline-hash href=#attributes-65>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>bit</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr></table><h4 id=operands-97>Operands: <a class=headline-hash href=#operands-97>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-94>Results: <a class=headline-hash href=#results-94>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrlaunderinvariantgroup-llvmlaunderinvariantgroupop><code>llvm.intr.launder.invariant.group</code> (LLVM::LaunderInvariantGroupOp) <a class=headline-hash href=#llvmintrlaunderinvariantgroup-llvmlaunderinvariantgroupop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.launder.invariant.group` $ptr attr-dict `:` qualified(type($ptr)) </code></pre><p>Traits: <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>InferTypeOpInterface</code>, <code>PromotableOpInterface</code></p><h4 id=operands-98>Operands: <a class=headline-hash href=#operands-98>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>ptr</code></td><td>LLVM pointer type</td></tr></tbody></table><h4 id=results-95>Results: <a class=headline-hash href=#results-95>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmintrlifetimeend-llvmlifetimeendop><code>llvm.intr.lifetime.end</code> (LLVM::LifetimeEndOp) <a class=headline-hash href=#llvmintrlifetimeend-llvmlifetimeendop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.lifetime.end` $size `,` $ptr attr-dict `:` qualified(type($ptr)) </code></pre><p>Interfaces: <code>PromotableOpInterface</code></p><h4 id=attributes-66>Attributes: <a class=headline-hash href=#attributes-66>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>size</code></td><td>::mlir::IntegerAttr</td><td>64-bit signless integer attribute</td></tr></table><h4 id=operands-99>Operands: <a class=headline-hash href=#operands-99>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>ptr</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmintrlifetimestart-llvmlifetimestartop><code>llvm.intr.lifetime.start</code> (LLVM::LifetimeStartOp) <a class=headline-hash href=#llvmintrlifetimestart-llvmlifetimestartop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.lifetime.start` $size `,` $ptr attr-dict `:` qualified(type($ptr)) </code></pre><p>Interfaces: <code>PromotableOpInterface</code></p><h4 id=attributes-67>Attributes: <a class=headline-hash href=#attributes-67>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>size</code></td><td>::mlir::IntegerAttr</td><td>64-bit signless integer attribute</td></tr></table><h4 id=operands-100>Operands: <a class=headline-hash href=#operands-100>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>ptr</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmintrllrint-llvmllrintop><code>llvm.intr.llrint</code> (LLVM::LlrintOp) <a class=headline-hash href=#llvmintrllrint-llvmllrintop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.llrint` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-101>Operands: <a class=headline-hash href=#operands-101>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>val</code></td><td>floating point LLVM type</td></tr></tbody></table><h4 id=results-96>Results: <a class=headline-hash href=#results-96>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrllround-llvmllroundop><code>llvm.intr.llround</code> (LLVM::LlroundOp) <a class=headline-hash href=#llvmintrllround-llvmllroundop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.llround` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-102>Operands: <a class=headline-hash href=#operands-102>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>val</code></td><td>floating point LLVM type</td></tr></tbody></table><h4 id=results-97>Results: <a class=headline-hash href=#results-97>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrlog10-llvmlog10op><code>llvm.intr.log10</code> (LLVM::Log10Op) <a class=headline-hash href=#llvmintrlog10-llvmlog10op>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.log10` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-68>Attributes: <a class=headline-hash href=#attributes-68>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-103>Operands: <a class=headline-hash href=#operands-103>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-98>Results: <a class=headline-hash href=#results-98>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrlog2-llvmlog2op><code>llvm.intr.log2</code> (LLVM::Log2Op) <a class=headline-hash href=#llvmintrlog2-llvmlog2op>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.log2` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-69>Attributes: <a class=headline-hash href=#attributes-69>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-104>Operands: <a class=headline-hash href=#operands-104>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-99>Results: <a class=headline-hash href=#results-99>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrlog-llvmlogop><code>llvm.intr.log</code> (LLVM::LogOp) <a class=headline-hash href=#llvmintrlog-llvmlogop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.log` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-70>Attributes: <a class=headline-hash href=#attributes-70>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-105>Operands: <a class=headline-hash href=#operands-105>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-100>Results: <a class=headline-hash href=#results-100>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrlrint-llvmlrintop><code>llvm.intr.lrint</code> (LLVM::LrintOp) <a class=headline-hash href=#llvmintrlrint-llvmlrintop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.lrint` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-106>Operands: <a class=headline-hash href=#operands-106>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>val</code></td><td>floating point LLVM type</td></tr></tbody></table><h4 id=results-101>Results: <a class=headline-hash href=#results-101>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrlround-llvmlroundop><code>llvm.intr.lround</code> (LLVM::LroundOp) <a class=headline-hash href=#llvmintrlround-llvmlroundop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.lround` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-107>Operands: <a class=headline-hash href=#operands-107>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>val</code></td><td>floating point LLVM type</td></tr></tbody></table><h4 id=results-102>Results: <a class=headline-hash href=#results-102>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrmaskedload-llvmmaskedloadop><code>llvm.intr.masked.load</code> (LLVM::MaskedLoadOp) <a class=headline-hash href=#llvmintrmaskedload-llvmmaskedloadop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.masked.load` operands attr-dict `:` functional-type(operands, results) </code></pre><h4 id=attributes-71>Attributes: <a class=headline-hash href=#attributes-71>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>alignment</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr><tr><td><code>nontemporal</code></td><td>::mlir::UnitAttr</td><td>unit attribute</td></tr></table><h4 id=operands-108>Operands: <a class=headline-hash href=#operands-108>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>data</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>pass_thru</code></td><td>variadic of LLVM dialect-compatible vector type</td></tr></tbody></table><h4 id=results-103>Results: <a class=headline-hash href=#results-103>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible vector type</td></tr></tbody></table><h3 id=llvmintrmaskedstore-llvmmaskedstoreop><code>llvm.intr.masked.store</code> (LLVM::MaskedStoreOp) <a class=headline-hash href=#llvmintrmaskedstore-llvmmaskedstoreop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.masked.store` $value `,` $data `,` $mask attr-dict `:` type($value) `,` type($mask) `into` qualified(type($data)) </code></pre><h4 id=attributes-72>Attributes: <a class=headline-hash href=#attributes-72>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>alignment</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr></table><h4 id=operands-109>Operands: <a class=headline-hash href=#operands-109>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>value</code></td><td>LLVM dialect-compatible vector type</td></tr><tr><td style=text-align:center><code>data</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr></tbody></table><h3 id=llvmintrmatrixcolumnmajorload-llvmmatrixcolumnmajorloadop><code>llvm.intr.matrix.column.major.load</code> (LLVM::MatrixColumnMajorLoadOp) <a class=headline-hash href=#llvmintrmatrixcolumnmajorload-llvmmatrixcolumnmajorloadop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.matrix.column.major.load` $data `,` `<` `stride` `=` $stride `>` attr-dict`:` type($res) `from` qualified(type($data)) `stride` type($stride) </code></pre><h4 id=attributes-73>Attributes: <a class=headline-hash href=#attributes-73>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>isVolatile</code></td><td>::mlir::IntegerAttr</td><td>1-bit signless integer attribute</td></tr><tr><td><code>rows</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr><tr><td><code>columns</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr></table><h4 id=operands-110>Operands: <a class=headline-hash href=#operands-110>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>data</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>stride</code></td><td>signless integer</td></tr></tbody></table><h4 id=results-104>Results: <a class=headline-hash href=#results-104>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible vector type</td></tr></tbody></table><h3 id=llvmintrmatrixcolumnmajorstore-llvmmatrixcolumnmajorstoreop><code>llvm.intr.matrix.column.major.store</code> (LLVM::MatrixColumnMajorStoreOp) <a class=headline-hash href=#llvmintrmatrixcolumnmajorstore-llvmmatrixcolumnmajorstoreop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.matrix.column.major.store` $matrix `,` $data `,` `<` `stride` `=` $stride `>` attr-dict`:` type($matrix) `to` qualified(type($data)) `stride` type($stride) </code></pre><h4 id=attributes-74>Attributes: <a class=headline-hash href=#attributes-74>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>isVolatile</code></td><td>::mlir::IntegerAttr</td><td>1-bit signless integer attribute</td></tr><tr><td><code>rows</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr><tr><td><code>columns</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr></table><h4 id=operands-111>Operands: <a class=headline-hash href=#operands-111>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>matrix</code></td><td>LLVM dialect-compatible vector type</td></tr><tr><td style=text-align:center><code>data</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>stride</code></td><td>signless integer</td></tr></tbody></table><h3 id=llvmintrmatrixmultiply-llvmmatrixmultiplyop><code>llvm.intr.matrix.multiply</code> (LLVM::MatrixMultiplyOp) <a class=headline-hash href=#llvmintrmatrixmultiply-llvmmatrixmultiplyop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.matrix.multiply` $lhs `,` $rhs attr-dict `:` `(` type($lhs) `,` type($rhs) `)` `->` type($res) </code></pre><h4 id=attributes-75>Attributes: <a class=headline-hash href=#attributes-75>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>lhs_rows</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr><tr><td><code>lhs_columns</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr><tr><td><code>rhs_columns</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr></table><h4 id=operands-112>Operands: <a class=headline-hash href=#operands-112>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector type</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector type</td></tr></tbody></table><h4 id=results-105>Results: <a class=headline-hash href=#results-105>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible vector type</td></tr></tbody></table><h3 id=llvmintrmatrixtranspose-llvmmatrixtransposeop><code>llvm.intr.matrix.transpose</code> (LLVM::MatrixTransposeOp) <a class=headline-hash href=#llvmintrmatrixtranspose-llvmmatrixtransposeop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.matrix.transpose` $matrix attr-dict `:` type($matrix) `into` type($res) </code></pre><h4 id=attributes-76>Attributes: <a class=headline-hash href=#attributes-76>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>rows</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr><tr><td><code>columns</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr></table><h4 id=operands-113>Operands: <a class=headline-hash href=#operands-113>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>matrix</code></td><td>LLVM dialect-compatible vector type</td></tr></tbody></table><h4 id=results-106>Results: <a class=headline-hash href=#results-106>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible vector type</td></tr></tbody></table><h3 id=llvmintrmaxnum-llvmmaxnumop><code>llvm.intr.maxnum</code> (LLVM::MaxNumOp) <a class=headline-hash href=#llvmintrmaxnum-llvmmaxnumop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.maxnum` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-77>Attributes: <a class=headline-hash href=#attributes-77>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-114>Operands: <a class=headline-hash href=#operands-114>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr><tr><td style=text-align:center><code>b</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-107>Results: <a class=headline-hash href=#results-107>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrmaximum-llvmmaximumop><code>llvm.intr.maximum</code> (LLVM::MaximumOp) <a class=headline-hash href=#llvmintrmaximum-llvmmaximumop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.maximum` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-78>Attributes: <a class=headline-hash href=#attributes-78>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-115>Operands: <a class=headline-hash href=#operands-115>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr><tr><td style=text-align:center><code>b</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-108>Results: <a class=headline-hash href=#results-108>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrmemcpyinline-llvmmemcpyinlineop><code>llvm.intr.memcpy.inline</code> (LLVM::MemcpyInlineOp) <a class=headline-hash href=#llvmintrmemcpyinline-llvmmemcpyinlineop>¶</a></h3><p>Interfaces: <code>AccessGroupOpInterface</code>, <code>AliasAnalysisOpInterface</code>, <code>DestructurableAccessorOpInterface</code>, <code>PromotableMemOpInterface</code>, <code>SafeMemorySlotAccessOpInterface</code></p><h4 id=attributes-79>Attributes: <a class=headline-hash href=#attributes-79>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>len</code></td><td>::mlir::IntegerAttr</td><td>arbitrary integer attribute</td></tr><tr><td><code>isVolatile</code></td><td>::mlir::IntegerAttr</td><td>1-bit signless integer attribute</td></tr><tr><td><code>access_groups</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect access group metadata array</td></tr><tr><td><code>alias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>noalias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>tbaa</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect TBAA tag metadata array</td></tr></table><h4 id=operands-116>Operands: <a class=headline-hash href=#operands-116>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>dst</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>src</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmintrmemcpy-llvmmemcpyop><code>llvm.intr.memcpy</code> (LLVM::MemcpyOp) <a class=headline-hash href=#llvmintrmemcpy-llvmmemcpyop>¶</a></h3><p>Interfaces: <code>AccessGroupOpInterface</code>, <code>AliasAnalysisOpInterface</code>, <code>DestructurableAccessorOpInterface</code>, <code>PromotableMemOpInterface</code>, <code>SafeMemorySlotAccessOpInterface</code></p><h4 id=attributes-80>Attributes: <a class=headline-hash href=#attributes-80>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>isVolatile</code></td><td>::mlir::IntegerAttr</td><td>1-bit signless integer attribute</td></tr><tr><td><code>access_groups</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect access group metadata array</td></tr><tr><td><code>alias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>noalias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>tbaa</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect TBAA tag metadata array</td></tr></table><h4 id=operands-117>Operands: <a class=headline-hash href=#operands-117>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>dst</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>src</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>len</code></td><td>signless integer</td></tr></tbody></table><h3 id=llvmintrmemmove-llvmmemmoveop><code>llvm.intr.memmove</code> (LLVM::MemmoveOp) <a class=headline-hash href=#llvmintrmemmove-llvmmemmoveop>¶</a></h3><p>Interfaces: <code>AccessGroupOpInterface</code>, <code>AliasAnalysisOpInterface</code>, <code>DestructurableAccessorOpInterface</code>, <code>PromotableMemOpInterface</code>, <code>SafeMemorySlotAccessOpInterface</code></p><h4 id=attributes-81>Attributes: <a class=headline-hash href=#attributes-81>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>isVolatile</code></td><td>::mlir::IntegerAttr</td><td>1-bit signless integer attribute</td></tr><tr><td><code>access_groups</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect access group metadata array</td></tr><tr><td><code>alias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>noalias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>tbaa</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect TBAA tag metadata array</td></tr></table><h4 id=operands-118>Operands: <a class=headline-hash href=#operands-118>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>dst</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>src</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>len</code></td><td>signless integer</td></tr></tbody></table><h3 id=llvmintrmemsetinline-llvmmemsetinlineop><code>llvm.intr.memset.inline</code> (LLVM::MemsetInlineOp) <a class=headline-hash href=#llvmintrmemsetinline-llvmmemsetinlineop>¶</a></h3><p>Interfaces: <code>AccessGroupOpInterface</code>, <code>AliasAnalysisOpInterface</code>, <code>DestructurableAccessorOpInterface</code>, <code>PromotableMemOpInterface</code>, <code>SafeMemorySlotAccessOpInterface</code></p><h4 id=attributes-82>Attributes: <a class=headline-hash href=#attributes-82>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>len</code></td><td>::mlir::IntegerAttr</td><td>arbitrary integer attribute</td></tr><tr><td><code>isVolatile</code></td><td>::mlir::IntegerAttr</td><td>1-bit signless integer attribute</td></tr><tr><td><code>access_groups</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect access group metadata array</td></tr><tr><td><code>alias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>noalias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>tbaa</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect TBAA tag metadata array</td></tr></table><h4 id=operands-119>Operands: <a class=headline-hash href=#operands-119>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>dst</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>val</code></td><td>8-bit signless integer</td></tr></tbody></table><h3 id=llvmintrmemset-llvmmemsetop><code>llvm.intr.memset</code> (LLVM::MemsetOp) <a class=headline-hash href=#llvmintrmemset-llvmmemsetop>¶</a></h3><p>Interfaces: <code>AccessGroupOpInterface</code>, <code>AliasAnalysisOpInterface</code>, <code>DestructurableAccessorOpInterface</code>, <code>PromotableMemOpInterface</code>, <code>SafeMemorySlotAccessOpInterface</code></p><h4 id=attributes-83>Attributes: <a class=headline-hash href=#attributes-83>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>isVolatile</code></td><td>::mlir::IntegerAttr</td><td>1-bit signless integer attribute</td></tr><tr><td><code>access_groups</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect access group metadata array</td></tr><tr><td><code>alias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>noalias_scopes</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect alias scope array</td></tr><tr><td><code>tbaa</code></td><td>::mlir::ArrayAttr</td><td>LLVM dialect TBAA tag metadata array</td></tr></table><h4 id=operands-120>Operands: <a class=headline-hash href=#operands-120>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>dst</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>val</code></td><td>8-bit signless integer</td></tr><tr><td style=text-align:center><code>len</code></td><td>signless integer</td></tr></tbody></table><h3 id=llvmintrminnum-llvmminnumop><code>llvm.intr.minnum</code> (LLVM::MinNumOp) <a class=headline-hash href=#llvmintrminnum-llvmminnumop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.minnum` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-84>Attributes: <a class=headline-hash href=#attributes-84>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-121>Operands: <a class=headline-hash href=#operands-121>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr><tr><td style=text-align:center><code>b</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-109>Results: <a class=headline-hash href=#results-109>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrminimum-llvmminimumop><code>llvm.intr.minimum</code> (LLVM::MinimumOp) <a class=headline-hash href=#llvmintrminimum-llvmminimumop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.minimum` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-85>Attributes: <a class=headline-hash href=#attributes-85>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-122>Operands: <a class=headline-hash href=#operands-122>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr><tr><td style=text-align:center><code>b</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-110>Results: <a class=headline-hash href=#results-110>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrnearbyint-llvmnearbyintop><code>llvm.intr.nearbyint</code> (LLVM::NearbyintOp) <a class=headline-hash href=#llvmintrnearbyint-llvmnearbyintop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.nearbyint` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-86>Attributes: <a class=headline-hash href=#attributes-86>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-123>Operands: <a class=headline-hash href=#operands-123>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-111>Results: <a class=headline-hash href=#results-111>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrexperimentalnoaliasscopedecl-llvmnoaliasscopedeclop><code>llvm.intr.experimental.noalias.scope.decl</code> (LLVM::NoAliasScopeDeclOp) <a class=headline-hash href=#llvmintrexperimentalnoaliasscopedecl-llvmnoaliasscopedeclop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.experimental.noalias.scope.decl` $scope attr-dict </code></pre><h4 id=attributes-87>Attributes: <a class=headline-hash href=#attributes-87>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>scope</code></td><td>::mlir::LLVM::AliasScopeAttr</td><td><details><summary>LLVM dialect alias scope</summary><pre><code>Defines an alias scope that can be attached to a memory-accessing operation. Such scopes can be used in combination with `noalias` metadata to indicate that sets of memory-affecting operations in one scope do not alias with memory-affecting operations in another scope. <p>Example:</p> <div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir><span class=line><span class=cl><span class=nv>#domain</span> <span class=p>=</span> <span class=nv>#llvm.alias_scope_domain</span><span class=err>&</span>lt<span class=err>;</span><span class=nl>id =</span> distinct<span class=p>[</span><span class=m>1</span><span class=p>]</span><span class=err>&</span>lt<span class=err>;&</span>gt<span class=err>;</span><span class=p>,</span> <span class=nl>description =</span> <span class=err>&</span>quot<span class=err>;</span>Optional domain description<span class=err>&</span>quot<span class=err>;&</span>gt<span class=err>;</span> </span></span><span class=line><span class=cl><span class=nv>#scope1</span> <span class=p>=</span> <span class=nv>#llvm.alias_scope</span><span class=err>&</span>lt<span class=err>;</span><span class=nl>id =</span> distinct<span class=p>[</span><span class=m>2</span><span class=p>]</span><span class=err>&</span>lt<span class=err>;&</span>gt<span class=err>;</span><span class=p>,</span> <span class=nl>domain =</span> <span class=nv>#domain</span><span class=err>&</span>gt<span class=err>;</span> </span></span><span class=line><span class=cl><span class=nv>#scope2</span> <span class=p>=</span> <span class=nv>#llvm.alias_scope</span><span class=err>&</span>lt<span class=err>;</span><span class=nl>id =</span> distinct<span class=p>[</span><span class=m>3</span><span class=p>]</span><span class=err>&</span>lt<span class=err>;&</span>gt<span class=err>;</span><span class=p>,</span> <span class=nl>domain =</span> <span class=nv>#domain</span><span class=p>,</span> <span class=nl>description =</span> <span class=err>&</span>quot<span class=err>;</span>Optional scope description<span class=err>&</span>quot<span class=err>;&</span>gt<span class=err>;</span> </span></span><span class=line><span class=cl>llvm<span class=p>.</span><span class=kt>func</span> <span class=nf>@foo</span><span class=p>(</span><span class=nv>%ptr1</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr<span class=p>)</span> <span class=p>{</span> </span></span><span class=line><span class=cl> <span class=nv>%c0</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span><span class=kt>constant</span><span class=p>(</span><span class=m>0</span> <span class=p>:</span> <span class=k>i32</span><span class=p>)</span> <span class=p>:</span> <span class=k>i32</span> </span></span><span class=line><span class=cl> <span class=nv>%c4</span> <span class=p>=</span> llvm<span class=p>.</span>mlir<span class=p>.</span><span class=kt>constant</span><span class=p>(</span><span class=m>4</span> <span class=p>:</span> <span class=k>i32</span><span class=p>)</span> <span class=p>:</span> <span class=k>i32</span> </span></span><span class=line><span class=cl> <span class=nv>%1</span> <span class=p>=</span> llvm<span class=p>.</span>ptrtoint <span class=nv>%ptr1</span> <span class=p>:</span> <span class=p>!</span>llvm<span class=p>.</span>ptr to <span class=k>i32</span> </span></span><span class=line><span class=cl> <span class=nv>%2</span> <span class=p>=</span> llvm<span class=p>.</span>add <span class=nv>%1</span><span class=p>,</span> <span class=nv>%c1</span> <span class=p>:</span> <span class=k>i32</span> </span></span><span class=line><span class=cl> <span class=nv>%ptr2</span> <span class=p>=</span> llvm<span class=p>.</span>inttoptr <span class=nv>%2</span> <span class=p>:</span> <span class=k>i32</span> to <span class=p>!</span>llvm<span class=p>.</span>ptr </span></span><span class=line><span class=cl> llvm<span class=p>.</span>store <span class=nv>%c0</span><span class=p>,</span> <span class=nv>%ptr1</span> <span class=p>{</span> <span class=nl>alias_scopes =</span> <span class=p>[</span><span class=nv>#scope1</span><span class=p>],</span> <span class=nl>llvm.noalias =</span> <span class=p>[</span><span class=nv>#scope2</span><span class=p>]</span> <span class=p>}</span> <span class=p>:</span> <span class=k>i32</span><span class=p>,</span> <span class=p>!</span>llvm<span class=p>.</span>ptr </span></span><span class=line><span class=cl> llvm<span class=p>.</span>store <span class=nv>%c4</span><span class=p>,</span> <span class=nv>%ptr2</span> <span class=p>{</span> <span class=nl>alias_scopes =</span> <span class=p>[</span><span class=nv>#scope2</span><span class=p>],</span> <span class=nl>llvm.noalias =</span> <span class=p>[</span><span class=nv>#scope1</span><span class=p>]</span> <span class=p>}</span> <span class=p>:</span> <span class=k>i32</span><span class=p>,</span> <span class=p>!</span>llvm<span class=p>.</span>ptr </span></span><span class=line><span class=cl> llvm<span class=p>.</span><span class=kt>return</span> </span></span><span class=line><span class=cl><span class=p>}</span> </span></span></code></pre></div><p>See the following link for more details: <a href=https://llvm.org/docs/LangRef.html#noalias-and-alias-scope-metadata>https://llvm.org/docs/LangRef.html#noalias-and-alias-scope-metadata</a></code></pre></p></details></td></tr></table><h3 id=llvmintrpowi-llvmpowiop><code>llvm.intr.powi</code> (LLVM::PowIOp) <a class=headline-hash href=#llvmintrpowi-llvmpowiop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.powi` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-88>Attributes: <a class=headline-hash href=#attributes-88>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-124>Operands: <a class=headline-hash href=#operands-124>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>val</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr><tr><td style=text-align:center><code>power</code></td><td>signless integer</td></tr></tbody></table><h4 id=results-112>Results: <a class=headline-hash href=#results-112>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrpow-llvmpowop><code>llvm.intr.pow</code> (LLVM::PowOp) <a class=headline-hash href=#llvmintrpow-llvmpowop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.pow` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-89>Attributes: <a class=headline-hash href=#attributes-89>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-125>Operands: <a class=headline-hash href=#operands-125>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr><tr><td style=text-align:center><code>b</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-113>Results: <a class=headline-hash href=#results-113>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrprefetch-llvmprefetch><code>llvm.intr.prefetch</code> (LLVM::Prefetch) <a class=headline-hash href=#llvmintrprefetch-llvmprefetch>¶</a></h3><h4 id=attributes-90>Attributes: <a class=headline-hash href=#attributes-90>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>rw</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr><tr><td><code>hint</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr><tr><td><code>cache</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr></table><h4 id=operands-126>Operands: <a class=headline-hash href=#operands-126>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>addr</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmintrptrannotation-llvmptrannotation><code>llvm.intr.ptr.annotation</code> (LLVM::PtrAnnotation) <a class=headline-hash href=#llvmintrptrannotation-llvmptrannotation>¶</a></h3><p>Interfaces: <code>InferTypeOpInterface</code></p><h4 id=operands-127>Operands: <a class=headline-hash href=#operands-127>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>ptr</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>annotation</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>fileName</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>line</code></td><td>32-bit signless integer</td></tr><tr><td style=text-align:center><code>attr</code></td><td>LLVM pointer type</td></tr></tbody></table><h4 id=results-114>Results: <a class=headline-hash href=#results-114>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmintrrint-llvmrintop><code>llvm.intr.rint</code> (LLVM::RintOp) <a class=headline-hash href=#llvmintrrint-llvmrintop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.rint` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-91>Attributes: <a class=headline-hash href=#attributes-91>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-128>Operands: <a class=headline-hash href=#operands-128>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-115>Results: <a class=headline-hash href=#results-115>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrroundeven-llvmroundevenop><code>llvm.intr.roundeven</code> (LLVM::RoundEvenOp) <a class=headline-hash href=#llvmintrroundeven-llvmroundevenop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.roundeven` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-92>Attributes: <a class=headline-hash href=#attributes-92>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-129>Operands: <a class=headline-hash href=#operands-129>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-116>Results: <a class=headline-hash href=#results-116>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrround-llvmroundop><code>llvm.intr.round</code> (LLVM::RoundOp) <a class=headline-hash href=#llvmintrround-llvmroundop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.round` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-93>Attributes: <a class=headline-hash href=#attributes-93>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-130>Operands: <a class=headline-hash href=#operands-130>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-117>Results: <a class=headline-hash href=#results-117>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrsaddsat-llvmsaddsat><code>llvm.intr.sadd.sat</code> (LLVM::SAddSat) <a class=headline-hash href=#llvmintrsaddsat-llvmsaddsat>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.sadd.sat` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-131>Operands: <a class=headline-hash href=#operands-131>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>b</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-118>Results: <a class=headline-hash href=#results-118>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrsaddwithoverflow-llvmsaddwithoverflowop><code>llvm.intr.sadd.with.overflow</code> (LLVM::SAddWithOverflowOp) <a class=headline-hash href=#llvmintrsaddwithoverflow-llvmsaddwithoverflowop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-132>Operands: <a class=headline-hash href=#operands-132>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center>«unnamed»</td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center>«unnamed»</td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-119>Results: <a class=headline-hash href=#results-119>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrsmax-llvmsmaxop><code>llvm.intr.smax</code> (LLVM::SMaxOp) <a class=headline-hash href=#llvmintrsmax-llvmsmaxop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.smax` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-133>Operands: <a class=headline-hash href=#operands-133>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>b</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-120>Results: <a class=headline-hash href=#results-120>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrsmin-llvmsminop><code>llvm.intr.smin</code> (LLVM::SMinOp) <a class=headline-hash href=#llvmintrsmin-llvmsminop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.smin` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-134>Operands: <a class=headline-hash href=#operands-134>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>b</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-121>Results: <a class=headline-hash href=#results-121>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrsmulwithoverflow-llvmsmulwithoverflowop><code>llvm.intr.smul.with.overflow</code> (LLVM::SMulWithOverflowOp) <a class=headline-hash href=#llvmintrsmulwithoverflow-llvmsmulwithoverflowop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-135>Operands: <a class=headline-hash href=#operands-135>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center>«unnamed»</td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center>«unnamed»</td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-122>Results: <a class=headline-hash href=#results-122>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrssacopy-llvmssacopyop><code>llvm.intr.ssa.copy</code> (LLVM::SSACopyOp) <a class=headline-hash href=#llvmintrssacopy-llvmssacopyop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.ssa.copy` $operand attr-dict `:` type($operand) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-136>Operands: <a class=headline-hash href=#operands-136>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>operand</code></td><td>any type</td></tr></tbody></table><h4 id=results-123>Results: <a class=headline-hash href=#results-123>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrsshlsat-llvmsshlsat><code>llvm.intr.sshl.sat</code> (LLVM::SSHLSat) <a class=headline-hash href=#llvmintrsshlsat-llvmsshlsat>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.sshl.sat` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-137>Operands: <a class=headline-hash href=#operands-137>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>b</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-124>Results: <a class=headline-hash href=#results-124>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrssubsat-llvmssubsat><code>llvm.intr.ssub.sat</code> (LLVM::SSubSat) <a class=headline-hash href=#llvmintrssubsat-llvmssubsat>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.ssub.sat` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-138>Operands: <a class=headline-hash href=#operands-138>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>b</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-125>Results: <a class=headline-hash href=#results-125>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrssubwithoverflow-llvmssubwithoverflowop><code>llvm.intr.ssub.with.overflow</code> (LLVM::SSubWithOverflowOp) <a class=headline-hash href=#llvmintrssubwithoverflow-llvmssubwithoverflowop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-139>Operands: <a class=headline-hash href=#operands-139>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center>«unnamed»</td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center>«unnamed»</td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-126>Results: <a class=headline-hash href=#results-126>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrsin-llvmsinop><code>llvm.intr.sin</code> (LLVM::SinOp) <a class=headline-hash href=#llvmintrsin-llvmsinop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.sin` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-94>Attributes: <a class=headline-hash href=#attributes-94>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-140>Operands: <a class=headline-hash href=#operands-140>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-127>Results: <a class=headline-hash href=#results-127>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrsinh-llvmsinhop><code>llvm.intr.sinh</code> (LLVM::SinhOp) <a class=headline-hash href=#llvmintrsinh-llvmsinhop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.sinh` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-95>Attributes: <a class=headline-hash href=#attributes-95>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-141>Operands: <a class=headline-hash href=#operands-141>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-128>Results: <a class=headline-hash href=#results-128>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrsqrt-llvmsqrtop><code>llvm.intr.sqrt</code> (LLVM::SqrtOp) <a class=headline-hash href=#llvmintrsqrt-llvmsqrtop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.sqrt` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-96>Attributes: <a class=headline-hash href=#attributes-96>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-142>Operands: <a class=headline-hash href=#operands-142>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-129>Results: <a class=headline-hash href=#results-129>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrstackrestore-llvmstackrestoreop><code>llvm.intr.stackrestore</code> (LLVM::StackRestoreOp) <a class=headline-hash href=#llvmintrstackrestore-llvmstackrestoreop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.stackrestore` $ptr attr-dict `:` qualified(type($ptr)) </code></pre><h4 id=operands-143>Operands: <a class=headline-hash href=#operands-143>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>ptr</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmintrstacksave-llvmstacksaveop><code>llvm.intr.stacksave</code> (LLVM::StackSaveOp) <a class=headline-hash href=#llvmintrstacksave-llvmstacksaveop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.stacksave` attr-dict `:` qualified(type($res)) </code></pre><h4 id=results-130>Results: <a class=headline-hash href=#results-130>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrstepvector-llvmstepvectorop><code>llvm.intr.stepvector</code> (LLVM::StepVectorOp) <a class=headline-hash href=#llvmintrstepvector-llvmstepvectorop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.stepvector` attr-dict `:` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=results-131>Results: <a class=headline-hash href=#results-131>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h3 id=llvmintrstripinvariantgroup-llvmstripinvariantgroupop><code>llvm.intr.strip.invariant.group</code> (LLVM::StripInvariantGroupOp) <a class=headline-hash href=#llvmintrstripinvariantgroup-llvmstripinvariantgroupop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.strip.invariant.group` $ptr attr-dict `:` qualified(type($ptr)) </code></pre><p>Traits: <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>InferTypeOpInterface</code>, <code>PromotableOpInterface</code></p><h4 id=operands-144>Operands: <a class=headline-hash href=#operands-144>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>ptr</code></td><td>LLVM pointer type</td></tr></tbody></table><h4 id=results-132>Results: <a class=headline-hash href=#results-132>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmintrtanh-llvmtanhop><code>llvm.intr.tanh</code> (LLVM::TanhOp) <a class=headline-hash href=#llvmintrtanh-llvmtanhop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.tanh` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-97>Attributes: <a class=headline-hash href=#attributes-97>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-145>Operands: <a class=headline-hash href=#operands-145>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>floating point LLVM type or LLVM dialect-compatible vector of floating point LLVM type</td></tr></tbody></table><h4 id=results-133>Results: <a class=headline-hash href=#results-133>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrthreadlocaladdress-llvmthreadlocaladdressop><code>llvm.intr.threadlocal.address</code> (LLVM::ThreadlocalAddressOp) <a class=headline-hash href=#llvmintrthreadlocaladdress-llvmthreadlocaladdressop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-146>Operands: <a class=headline-hash href=#operands-146>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>global</code></td><td>LLVM pointer type</td></tr></tbody></table><h4 id=results-134>Results: <a class=headline-hash href=#results-134>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrtrap-llvmtrap><code>llvm.intr.trap</code> (LLVM::Trap) <a class=headline-hash href=#llvmintrtrap-llvmtrap>¶</a></h3><h3 id=llvmintruaddsat-llvmuaddsat><code>llvm.intr.uadd.sat</code> (LLVM::UAddSat) <a class=headline-hash href=#llvmintruaddsat-llvmuaddsat>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.uadd.sat` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-147>Operands: <a class=headline-hash href=#operands-147>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>b</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-135>Results: <a class=headline-hash href=#results-135>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintruaddwithoverflow-llvmuaddwithoverflowop><code>llvm.intr.uadd.with.overflow</code> (LLVM::UAddWithOverflowOp) <a class=headline-hash href=#llvmintruaddwithoverflow-llvmuaddwithoverflowop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-148>Operands: <a class=headline-hash href=#operands-148>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center>«unnamed»</td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center>«unnamed»</td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-136>Results: <a class=headline-hash href=#results-136>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrubsantrap-llvmubsantrap><code>llvm.intr.ubsantrap</code> (LLVM::UBSanTrap) <a class=headline-hash href=#llvmintrubsantrap-llvmubsantrap>¶</a></h3><h4 id=attributes-98>Attributes: <a class=headline-hash href=#attributes-98>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>failureKind</code></td><td>::mlir::IntegerAttr</td><td>8-bit signless integer attribute</td></tr></table><h3 id=llvmintrumax-llvmumaxop><code>llvm.intr.umax</code> (LLVM::UMaxOp) <a class=headline-hash href=#llvmintrumax-llvmumaxop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.umax` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-149>Operands: <a class=headline-hash href=#operands-149>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>b</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-137>Results: <a class=headline-hash href=#results-137>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrumin-llvmuminop><code>llvm.intr.umin</code> (LLVM::UMinOp) <a class=headline-hash href=#llvmintrumin-llvmuminop>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.umin` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-150>Operands: <a class=headline-hash href=#operands-150>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>b</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-138>Results: <a class=headline-hash href=#results-138>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrumulwithoverflow-llvmumulwithoverflowop><code>llvm.intr.umul.with.overflow</code> (LLVM::UMulWithOverflowOp) <a class=headline-hash href=#llvmintrumulwithoverflow-llvmumulwithoverflowop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-151>Operands: <a class=headline-hash href=#operands-151>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center>«unnamed»</td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center>«unnamed»</td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-139>Results: <a class=headline-hash href=#results-139>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrushlsat-llvmushlsat><code>llvm.intr.ushl.sat</code> (LLVM::USHLSat) <a class=headline-hash href=#llvmintrushlsat-llvmushlsat>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.ushl.sat` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-152>Operands: <a class=headline-hash href=#operands-152>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>b</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-140>Results: <a class=headline-hash href=#results-140>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrusubsat-llvmusubsat><code>llvm.intr.usub.sat</code> (LLVM::USubSat) <a class=headline-hash href=#llvmintrusubsat-llvmusubsat>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.usub.sat` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-153>Operands: <a class=headline-hash href=#operands-153>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>a</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>b</code></td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-141>Results: <a class=headline-hash href=#results-141>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrusubwithoverflow-llvmusubwithoverflowop><code>llvm.intr.usub.with.overflow</code> (LLVM::USubWithOverflowOp) <a class=headline-hash href=#llvmintrusubwithoverflow-llvmusubwithoverflowop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-154>Operands: <a class=headline-hash href=#operands-154>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center>«unnamed»</td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center>«unnamed»</td><td>signless integer or LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-142>Results: <a class=headline-hash href=#results-142>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpashr-llvmvpashrop><code>llvm.intr.vp.ashr</code> (LLVM::VPAShrOp) <a class=headline-hash href=#llvmintrvpashr-llvmvpashrop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-155>Operands: <a class=headline-hash href=#operands-155>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-143>Results: <a class=headline-hash href=#results-143>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpadd-llvmvpaddop><code>llvm.intr.vp.add</code> (LLVM::VPAddOp) <a class=headline-hash href=#llvmintrvpadd-llvmvpaddop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-156>Operands: <a class=headline-hash href=#operands-156>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-144>Results: <a class=headline-hash href=#results-144>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpand-llvmvpandop><code>llvm.intr.vp.and</code> (LLVM::VPAndOp) <a class=headline-hash href=#llvmintrvpand-llvmvpandop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-157>Operands: <a class=headline-hash href=#operands-157>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-145>Results: <a class=headline-hash href=#results-145>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpfadd-llvmvpfaddop><code>llvm.intr.vp.fadd</code> (LLVM::VPFAddOp) <a class=headline-hash href=#llvmintrvpfadd-llvmvpfaddop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-158>Operands: <a class=headline-hash href=#operands-158>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-146>Results: <a class=headline-hash href=#results-146>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpfdiv-llvmvpfdivop><code>llvm.intr.vp.fdiv</code> (LLVM::VPFDivOp) <a class=headline-hash href=#llvmintrvpfdiv-llvmvpfdivop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-159>Operands: <a class=headline-hash href=#operands-159>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-147>Results: <a class=headline-hash href=#results-147>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpfmuladd-llvmvpfmuladdop><code>llvm.intr.vp.fmuladd</code> (LLVM::VPFMulAddOp) <a class=headline-hash href=#llvmintrvpfmuladd-llvmvpfmuladdop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-160>Operands: <a class=headline-hash href=#operands-160>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>op1</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>op2</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>op3</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-148>Results: <a class=headline-hash href=#results-148>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpfmul-llvmvpfmulop><code>llvm.intr.vp.fmul</code> (LLVM::VPFMulOp) <a class=headline-hash href=#llvmintrvpfmul-llvmvpfmulop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-161>Operands: <a class=headline-hash href=#operands-161>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-149>Results: <a class=headline-hash href=#results-149>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpfneg-llvmvpfnegop><code>llvm.intr.vp.fneg</code> (LLVM::VPFNegOp) <a class=headline-hash href=#llvmintrvpfneg-llvmvpfnegop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-162>Operands: <a class=headline-hash href=#operands-162>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>op</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-150>Results: <a class=headline-hash href=#results-150>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpfpext-llvmvpfpextop><code>llvm.intr.vp.fpext</code> (LLVM::VPFPExtOp) <a class=headline-hash href=#llvmintrvpfpext-llvmvpfpextop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-163>Operands: <a class=headline-hash href=#operands-163>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>src</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-151>Results: <a class=headline-hash href=#results-151>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpfptosi-llvmvpfptosiop><code>llvm.intr.vp.fptosi</code> (LLVM::VPFPToSIOp) <a class=headline-hash href=#llvmintrvpfptosi-llvmvpfptosiop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-164>Operands: <a class=headline-hash href=#operands-164>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>src</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-152>Results: <a class=headline-hash href=#results-152>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpfptoui-llvmvpfptouiop><code>llvm.intr.vp.fptoui</code> (LLVM::VPFPToUIOp) <a class=headline-hash href=#llvmintrvpfptoui-llvmvpfptouiop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-165>Operands: <a class=headline-hash href=#operands-165>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>src</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-153>Results: <a class=headline-hash href=#results-153>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpfptrunc-llvmvpfptruncop><code>llvm.intr.vp.fptrunc</code> (LLVM::VPFPTruncOp) <a class=headline-hash href=#llvmintrvpfptrunc-llvmvpfptruncop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-166>Operands: <a class=headline-hash href=#operands-166>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>src</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-154>Results: <a class=headline-hash href=#results-154>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpfrem-llvmvpfremop><code>llvm.intr.vp.frem</code> (LLVM::VPFRemOp) <a class=headline-hash href=#llvmintrvpfrem-llvmvpfremop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-167>Operands: <a class=headline-hash href=#operands-167>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-155>Results: <a class=headline-hash href=#results-155>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpfsub-llvmvpfsubop><code>llvm.intr.vp.fsub</code> (LLVM::VPFSubOp) <a class=headline-hash href=#llvmintrvpfsub-llvmvpfsubop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-168>Operands: <a class=headline-hash href=#operands-168>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-156>Results: <a class=headline-hash href=#results-156>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpfma-llvmvpfmaop><code>llvm.intr.vp.fma</code> (LLVM::VPFmaOp) <a class=headline-hash href=#llvmintrvpfma-llvmvpfmaop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-169>Operands: <a class=headline-hash href=#operands-169>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>op1</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>op2</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>op3</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-157>Results: <a class=headline-hash href=#results-157>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpinttoptr-llvmvpinttoptrop><code>llvm.intr.vp.inttoptr</code> (LLVM::VPIntToPtrOp) <a class=headline-hash href=#llvmintrvpinttoptr-llvmvpinttoptrop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-170>Operands: <a class=headline-hash href=#operands-170>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>src</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-158>Results: <a class=headline-hash href=#results-158>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvplshr-llvmvplshrop><code>llvm.intr.vp.lshr</code> (LLVM::VPLShrOp) <a class=headline-hash href=#llvmintrvplshr-llvmvplshrop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-171>Operands: <a class=headline-hash href=#operands-171>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-159>Results: <a class=headline-hash href=#results-159>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpload-llvmvploadop><code>llvm.intr.vp.load</code> (LLVM::VPLoadOp) <a class=headline-hash href=#llvmintrvpload-llvmvploadop>¶</a></h3><h4 id=operands-172>Operands: <a class=headline-hash href=#operands-172>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>ptr</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-160>Results: <a class=headline-hash href=#results-160>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpmerge-llvmvpmergeminop><code>llvm.intr.vp.merge</code> (LLVM::VPMergeMinOp) <a class=headline-hash href=#llvmintrvpmerge-llvmvpmergeminop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-173>Operands: <a class=headline-hash href=#operands-173>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>cond</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>true_val</code></td><td>LLVM dialect-compatible vector type</td></tr><tr><td style=text-align:center><code>false_val</code></td><td>LLVM dialect-compatible vector type</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-161>Results: <a class=headline-hash href=#results-161>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpmul-llvmvpmulop><code>llvm.intr.vp.mul</code> (LLVM::VPMulOp) <a class=headline-hash href=#llvmintrvpmul-llvmvpmulop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-174>Operands: <a class=headline-hash href=#operands-174>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-162>Results: <a class=headline-hash href=#results-162>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpor-llvmvporop><code>llvm.intr.vp.or</code> (LLVM::VPOrOp) <a class=headline-hash href=#llvmintrvpor-llvmvporop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-175>Operands: <a class=headline-hash href=#operands-175>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-163>Results: <a class=headline-hash href=#results-163>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpptrtoint-llvmvpptrtointop><code>llvm.intr.vp.ptrtoint</code> (LLVM::VPPtrToIntOp) <a class=headline-hash href=#llvmintrvpptrtoint-llvmvpptrtointop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-176>Operands: <a class=headline-hash href=#operands-176>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>src</code></td><td>LLVM dialect-compatible vector of LLVM pointer type</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-164>Results: <a class=headline-hash href=#results-164>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpreduceadd-llvmvpreduceaddop><code>llvm.intr.vp.reduce.add</code> (LLVM::VPReduceAddOp) <a class=headline-hash href=#llvmintrvpreduceadd-llvmvpreduceaddop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-177>Operands: <a class=headline-hash href=#operands-177>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>satrt_value</code></td><td>signless integer</td></tr><tr><td style=text-align:center><code>val</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-165>Results: <a class=headline-hash href=#results-165>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpreduceand-llvmvpreduceandop><code>llvm.intr.vp.reduce.and</code> (LLVM::VPReduceAndOp) <a class=headline-hash href=#llvmintrvpreduceand-llvmvpreduceandop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-178>Operands: <a class=headline-hash href=#operands-178>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>satrt_value</code></td><td>signless integer</td></tr><tr><td style=text-align:center><code>val</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-166>Results: <a class=headline-hash href=#results-166>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpreducefadd-llvmvpreducefaddop><code>llvm.intr.vp.reduce.fadd</code> (LLVM::VPReduceFAddOp) <a class=headline-hash href=#llvmintrvpreducefadd-llvmvpreducefaddop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-179>Operands: <a class=headline-hash href=#operands-179>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>satrt_value</code></td><td>floating-point</td></tr><tr><td style=text-align:center><code>val</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-167>Results: <a class=headline-hash href=#results-167>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpreducefmax-llvmvpreducefmaxop><code>llvm.intr.vp.reduce.fmax</code> (LLVM::VPReduceFMaxOp) <a class=headline-hash href=#llvmintrvpreducefmax-llvmvpreducefmaxop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-180>Operands: <a class=headline-hash href=#operands-180>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>satrt_value</code></td><td>floating-point</td></tr><tr><td style=text-align:center><code>val</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-168>Results: <a class=headline-hash href=#results-168>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpreducefmin-llvmvpreducefminop><code>llvm.intr.vp.reduce.fmin</code> (LLVM::VPReduceFMinOp) <a class=headline-hash href=#llvmintrvpreducefmin-llvmvpreducefminop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-181>Operands: <a class=headline-hash href=#operands-181>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>satrt_value</code></td><td>floating-point</td></tr><tr><td style=text-align:center><code>val</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-169>Results: <a class=headline-hash href=#results-169>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpreducefmul-llvmvpreducefmulop><code>llvm.intr.vp.reduce.fmul</code> (LLVM::VPReduceFMulOp) <a class=headline-hash href=#llvmintrvpreducefmul-llvmvpreducefmulop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-182>Operands: <a class=headline-hash href=#operands-182>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>satrt_value</code></td><td>floating-point</td></tr><tr><td style=text-align:center><code>val</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-170>Results: <a class=headline-hash href=#results-170>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpreducemul-llvmvpreducemulop><code>llvm.intr.vp.reduce.mul</code> (LLVM::VPReduceMulOp) <a class=headline-hash href=#llvmintrvpreducemul-llvmvpreducemulop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-183>Operands: <a class=headline-hash href=#operands-183>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>satrt_value</code></td><td>signless integer</td></tr><tr><td style=text-align:center><code>val</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-171>Results: <a class=headline-hash href=#results-171>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpreduceor-llvmvpreduceorop><code>llvm.intr.vp.reduce.or</code> (LLVM::VPReduceOrOp) <a class=headline-hash href=#llvmintrvpreduceor-llvmvpreduceorop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-184>Operands: <a class=headline-hash href=#operands-184>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>satrt_value</code></td><td>signless integer</td></tr><tr><td style=text-align:center><code>val</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-172>Results: <a class=headline-hash href=#results-172>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpreducesmax-llvmvpreducesmaxop><code>llvm.intr.vp.reduce.smax</code> (LLVM::VPReduceSMaxOp) <a class=headline-hash href=#llvmintrvpreducesmax-llvmvpreducesmaxop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-185>Operands: <a class=headline-hash href=#operands-185>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>satrt_value</code></td><td>signless integer</td></tr><tr><td style=text-align:center><code>val</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-173>Results: <a class=headline-hash href=#results-173>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpreducesmin-llvmvpreducesminop><code>llvm.intr.vp.reduce.smin</code> (LLVM::VPReduceSMinOp) <a class=headline-hash href=#llvmintrvpreducesmin-llvmvpreducesminop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-186>Operands: <a class=headline-hash href=#operands-186>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>satrt_value</code></td><td>signless integer</td></tr><tr><td style=text-align:center><code>val</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-174>Results: <a class=headline-hash href=#results-174>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpreduceumax-llvmvpreduceumaxop><code>llvm.intr.vp.reduce.umax</code> (LLVM::VPReduceUMaxOp) <a class=headline-hash href=#llvmintrvpreduceumax-llvmvpreduceumaxop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-187>Operands: <a class=headline-hash href=#operands-187>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>satrt_value</code></td><td>signless integer</td></tr><tr><td style=text-align:center><code>val</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-175>Results: <a class=headline-hash href=#results-175>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpreduceumin-llvmvpreduceuminop><code>llvm.intr.vp.reduce.umin</code> (LLVM::VPReduceUMinOp) <a class=headline-hash href=#llvmintrvpreduceumin-llvmvpreduceuminop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-188>Operands: <a class=headline-hash href=#operands-188>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>satrt_value</code></td><td>signless integer</td></tr><tr><td style=text-align:center><code>val</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-176>Results: <a class=headline-hash href=#results-176>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpreducexor-llvmvpreducexorop><code>llvm.intr.vp.reduce.xor</code> (LLVM::VPReduceXorOp) <a class=headline-hash href=#llvmintrvpreducexor-llvmvpreducexorop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-189>Operands: <a class=headline-hash href=#operands-189>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>satrt_value</code></td><td>signless integer</td></tr><tr><td style=text-align:center><code>val</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-177>Results: <a class=headline-hash href=#results-177>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpsdiv-llvmvpsdivop><code>llvm.intr.vp.sdiv</code> (LLVM::VPSDivOp) <a class=headline-hash href=#llvmintrvpsdiv-llvmvpsdivop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-190>Operands: <a class=headline-hash href=#operands-190>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-178>Results: <a class=headline-hash href=#results-178>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpsext-llvmvpsextop><code>llvm.intr.vp.sext</code> (LLVM::VPSExtOp) <a class=headline-hash href=#llvmintrvpsext-llvmvpsextop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-191>Operands: <a class=headline-hash href=#operands-191>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>src</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-179>Results: <a class=headline-hash href=#results-179>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpsitofp-llvmvpsitofpop><code>llvm.intr.vp.sitofp</code> (LLVM::VPSIToFPOp) <a class=headline-hash href=#llvmintrvpsitofp-llvmvpsitofpop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-192>Operands: <a class=headline-hash href=#operands-192>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>src</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-180>Results: <a class=headline-hash href=#results-180>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpsmax-llvmvpsmaxop><code>llvm.intr.vp.smax</code> (LLVM::VPSMaxOp) <a class=headline-hash href=#llvmintrvpsmax-llvmvpsmaxop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-193>Operands: <a class=headline-hash href=#operands-193>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-181>Results: <a class=headline-hash href=#results-181>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpsmin-llvmvpsminop><code>llvm.intr.vp.smin</code> (LLVM::VPSMinOp) <a class=headline-hash href=#llvmintrvpsmin-llvmvpsminop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-194>Operands: <a class=headline-hash href=#operands-194>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-182>Results: <a class=headline-hash href=#results-182>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpsrem-llvmvpsremop><code>llvm.intr.vp.srem</code> (LLVM::VPSRemOp) <a class=headline-hash href=#llvmintrvpsrem-llvmvpsremop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-195>Operands: <a class=headline-hash href=#operands-195>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-183>Results: <a class=headline-hash href=#results-183>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpselect-llvmvpselectminop><code>llvm.intr.vp.select</code> (LLVM::VPSelectMinOp) <a class=headline-hash href=#llvmintrvpselect-llvmvpselectminop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-196>Operands: <a class=headline-hash href=#operands-196>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>cond</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>true_val</code></td><td>LLVM dialect-compatible vector type</td></tr><tr><td style=text-align:center><code>false_val</code></td><td>LLVM dialect-compatible vector type</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-184>Results: <a class=headline-hash href=#results-184>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpshl-llvmvpshlop><code>llvm.intr.vp.shl</code> (LLVM::VPShlOp) <a class=headline-hash href=#llvmintrvpshl-llvmvpshlop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-197>Operands: <a class=headline-hash href=#operands-197>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-185>Results: <a class=headline-hash href=#results-185>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpstore-llvmvpstoreop><code>llvm.intr.vp.store</code> (LLVM::VPStoreOp) <a class=headline-hash href=#llvmintrvpstore-llvmvpstoreop>¶</a></h3><h4 id=operands-198>Operands: <a class=headline-hash href=#operands-198>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>val</code></td><td>LLVM dialect-compatible vector type</td></tr><tr><td style=text-align:center><code>ptr</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h3 id=llvmintrexperimentalvpstridedload-llvmvpstridedloadop><code>llvm.intr.experimental.vp.strided.load</code> (LLVM::VPStridedLoadOp) <a class=headline-hash href=#llvmintrexperimentalvpstridedload-llvmvpstridedloadop>¶</a></h3><h4 id=operands-199>Operands: <a class=headline-hash href=#operands-199>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>ptr</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>stride</code></td><td>signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-186>Results: <a class=headline-hash href=#results-186>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrexperimentalvpstridedstore-llvmvpstridedstoreop><code>llvm.intr.experimental.vp.strided.store</code> (LLVM::VPStridedStoreOp) <a class=headline-hash href=#llvmintrexperimentalvpstridedstore-llvmvpstridedstoreop>¶</a></h3><h4 id=operands-200>Operands: <a class=headline-hash href=#operands-200>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>val</code></td><td>LLVM dialect-compatible vector type</td></tr><tr><td style=text-align:center><code>ptr</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>stride</code></td><td>signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h3 id=llvmintrvpsub-llvmvpsubop><code>llvm.intr.vp.sub</code> (LLVM::VPSubOp) <a class=headline-hash href=#llvmintrvpsub-llvmvpsubop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-201>Operands: <a class=headline-hash href=#operands-201>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-187>Results: <a class=headline-hash href=#results-187>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvptrunc-llvmvptruncop><code>llvm.intr.vp.trunc</code> (LLVM::VPTruncOp) <a class=headline-hash href=#llvmintrvptrunc-llvmvptruncop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-202>Operands: <a class=headline-hash href=#operands-202>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>src</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-188>Results: <a class=headline-hash href=#results-188>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpudiv-llvmvpudivop><code>llvm.intr.vp.udiv</code> (LLVM::VPUDivOp) <a class=headline-hash href=#llvmintrvpudiv-llvmvpudivop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-203>Operands: <a class=headline-hash href=#operands-203>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-189>Results: <a class=headline-hash href=#results-189>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpuitofp-llvmvpuitofpop><code>llvm.intr.vp.uitofp</code> (LLVM::VPUIToFPOp) <a class=headline-hash href=#llvmintrvpuitofp-llvmvpuitofpop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-204>Operands: <a class=headline-hash href=#operands-204>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>src</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-190>Results: <a class=headline-hash href=#results-190>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpumax-llvmvpumaxop><code>llvm.intr.vp.umax</code> (LLVM::VPUMaxOp) <a class=headline-hash href=#llvmintrvpumax-llvmvpumaxop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-205>Operands: <a class=headline-hash href=#operands-205>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-191>Results: <a class=headline-hash href=#results-191>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpumin-llvmvpuminop><code>llvm.intr.vp.umin</code> (LLVM::VPUMinOp) <a class=headline-hash href=#llvmintrvpumin-llvmvpuminop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-206>Operands: <a class=headline-hash href=#operands-206>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-192>Results: <a class=headline-hash href=#results-192>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpurem-llvmvpuremop><code>llvm.intr.vp.urem</code> (LLVM::VPURemOp) <a class=headline-hash href=#llvmintrvpurem-llvmvpuremop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-207>Operands: <a class=headline-hash href=#operands-207>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-193>Results: <a class=headline-hash href=#results-193>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpxor-llvmvpxorop><code>llvm.intr.vp.xor</code> (LLVM::VPXorOp) <a class=headline-hash href=#llvmintrvpxor-llvmvpxorop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-208>Operands: <a class=headline-hash href=#operands-208>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>lhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>rhs</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-194>Results: <a class=headline-hash href=#results-194>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvpzext-llvmvpzextop><code>llvm.intr.vp.zext</code> (LLVM::VPZExtOp) <a class=headline-hash href=#llvmintrvpzext-llvmvpzextop>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-209>Operands: <a class=headline-hash href=#operands-209>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>src</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>evl</code></td><td>32-bit signless integer</td></tr></tbody></table><h4 id=results-195>Results: <a class=headline-hash href=#results-195>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvacopy-llvmvacopyop><code>llvm.intr.vacopy</code> (LLVM::VaCopyOp) <a class=headline-hash href=#llvmintrvacopy-llvmvacopyop>¶</a></h3><p><em>Copies the current argument position from <code>src_list</code> to <code>dest_list</code>.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.vacopy` $src_list `to` $dest_list attr-dict `:` type(operands) </code></pre><h4 id=operands-210>Operands: <a class=headline-hash href=#operands-210>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>dest_list</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>src_list</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmintrvaend-llvmvaendop><code>llvm.intr.vaend</code> (LLVM::VaEndOp) <a class=headline-hash href=#llvmintrvaend-llvmvaendop>¶</a></h3><p><em>Destroys <code>arg_list</code>, which has been initialized by <code>intr.vastart</code> or <code>intr.vacopy</code>.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.vaend` $arg_list attr-dict `:` qualified(type($arg_list)) </code></pre><h4 id=operands-211>Operands: <a class=headline-hash href=#operands-211>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg_list</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmintrvastart-llvmvastartop><code>llvm.intr.vastart</code> (LLVM::VaStartOp) <a class=headline-hash href=#llvmintrvastart-llvmvastartop>¶</a></h3><p><em>Initializes <code>arg_list</code> for subsequent variadic argument extractions.</em></p><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.vastart` $arg_list attr-dict `:` qualified(type($arg_list)) </code></pre><h4 id=operands-212>Operands: <a class=headline-hash href=#operands-212>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arg_list</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmintrvarannotation-llvmvarannotation><code>llvm.intr.var.annotation</code> (LLVM::VarAnnotation) <a class=headline-hash href=#llvmintrvarannotation-llvmvarannotation>¶</a></h3><h4 id=operands-213>Operands: <a class=headline-hash href=#operands-213>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>val</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>annotation</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>fileName</code></td><td>LLVM pointer type</td></tr><tr><td style=text-align:center><code>line</code></td><td>32-bit signless integer</td></tr><tr><td style=text-align:center><code>attr</code></td><td>LLVM pointer type</td></tr></tbody></table><h3 id=llvmintrmaskedcompressstore-llvmmasked_compressstore><code>llvm.intr.masked.compressstore</code> (LLVM::masked_compressstore) <a class=headline-hash href=#llvmintrmaskedcompressstore-llvmmasked_compressstore>¶</a></h3><h4 id=operands-214>Operands: <a class=headline-hash href=#operands-214>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center>«unnamed»</td><td>LLVM dialect-compatible vector type</td></tr><tr><td style=text-align:center>«unnamed»</td><td>LLVM pointer type</td></tr><tr><td style=text-align:center>«unnamed»</td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr></tbody></table><h3 id=llvmintrmaskedexpandload-llvmmasked_expandload><code>llvm.intr.masked.expandload</code> (LLVM::masked_expandload) <a class=headline-hash href=#llvmintrmaskedexpandload-llvmmasked_expandload>¶</a></h3><h4 id=operands-215>Operands: <a class=headline-hash href=#operands-215>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center>«unnamed»</td><td>LLVM pointer type</td></tr><tr><td style=text-align:center>«unnamed»</td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center>«unnamed»</td><td>LLVM dialect-compatible vector type</td></tr></tbody></table><h4 id=results-196>Results: <a class=headline-hash href=#results-196>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrmaskedgather-llvmmasked_gather><code>llvm.intr.masked.gather</code> (LLVM::masked_gather) <a class=headline-hash href=#llvmintrmaskedgather-llvmmasked_gather>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.masked.gather` operands attr-dict `:` functional-type(operands, results) </code></pre><h4 id=attributes-99>Attributes: <a class=headline-hash href=#attributes-99>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>alignment</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr></table><h4 id=operands-216>Operands: <a class=headline-hash href=#operands-216>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>ptrs</code></td><td>LLVM dialect-compatible vector of LLVM pointer type</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr><tr><td style=text-align:center><code>pass_thru</code></td><td>variadic of LLVM dialect-compatible vector type</td></tr></tbody></table><h4 id=results-197>Results: <a class=headline-hash href=#results-197>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible vector type</td></tr></tbody></table><h3 id=llvmintrmaskedscatter-llvmmasked_scatter><code>llvm.intr.masked.scatter</code> (LLVM::masked_scatter) <a class=headline-hash href=#llvmintrmaskedscatter-llvmmasked_scatter>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.masked.scatter` $value `,` $ptrs `,` $mask attr-dict `:` type($value) `,` type($mask) `into` type($ptrs) </code></pre><h4 id=attributes-100>Attributes: <a class=headline-hash href=#attributes-100>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>alignment</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr></table><h4 id=operands-217>Operands: <a class=headline-hash href=#operands-217>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>value</code></td><td>LLVM dialect-compatible vector type</td></tr><tr><td style=text-align:center><code>ptrs</code></td><td>LLVM dialect-compatible vector of LLVM pointer type</td></tr><tr><td style=text-align:center><code>mask</code></td><td>LLVM dialect-compatible vector of 1-bit signless integer</td></tr></tbody></table><h3 id=llvmintrvectordeinterleave2-llvmvector_deinterleave2><code>llvm.intr.vector.deinterleave2</code> (LLVM::vector_deinterleave2) <a class=headline-hash href=#llvmintrvectordeinterleave2-llvmvector_deinterleave2>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-218>Operands: <a class=headline-hash href=#operands-218>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>vec</code></td><td>LLVM dialect-compatible vector type</td></tr></tbody></table><h4 id=results-198>Results: <a class=headline-hash href=#results-198>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvectorextract-llvmvector_extract><code>llvm.intr.vector.extract</code> (LLVM::vector_extract) <a class=headline-hash href=#llvmintrvectorextract-llvmvector_extract>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.vector.extract` $srcvec `[` $pos `]` attr-dict `:` type($res) `from` type($srcvec) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-101>Attributes: <a class=headline-hash href=#attributes-101>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>pos</code></td><td>::mlir::IntegerAttr</td><td>64-bit signless integer attribute</td></tr></table><h4 id=operands-219>Operands: <a class=headline-hash href=#operands-219>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>srcvec</code></td><td>LLVM dialect-compatible vector type</td></tr></tbody></table><h4 id=results-199>Results: <a class=headline-hash href=#results-199>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible vector type</td></tr></tbody></table><h3 id=llvmintrvectorinsert-llvmvector_insert><code>llvm.intr.vector.insert</code> (LLVM::vector_insert) <a class=headline-hash href=#llvmintrvectorinsert-llvmvector_insert>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.vector.insert` $srcvec `,` $dstvec `[` $pos `]` attr-dict `:` type($srcvec) `into` type($res) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>InferTypeOpInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-102>Attributes: <a class=headline-hash href=#attributes-102>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>pos</code></td><td>::mlir::IntegerAttr</td><td>64-bit signless integer attribute</td></tr></table><h4 id=operands-220>Operands: <a class=headline-hash href=#operands-220>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>dstvec</code></td><td>LLVM dialect-compatible vector type</td></tr><tr><td style=text-align:center><code>srcvec</code></td><td>LLVM dialect-compatible vector type</td></tr></tbody></table><h4 id=results-200>Results: <a class=headline-hash href=#results-200>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible vector type</td></tr></tbody></table><h3 id=llvmintrvectorinterleave2-llvmvector_interleave2><code>llvm.intr.vector.interleave2</code> (LLVM::vector_interleave2) <a class=headline-hash href=#llvmintrvectorinterleave2-llvmvector_interleave2>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-221>Operands: <a class=headline-hash href=#operands-221>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>vec1</code></td><td>LLVM dialect-compatible vector type</td></tr><tr><td style=text-align:center><code>vec2</code></td><td>LLVM dialect-compatible vector type</td></tr></tbody></table><h4 id=results-201>Results: <a class=headline-hash href=#results-201>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvectorreduceadd-llvmvector_reduce_add><code>llvm.intr.vector.reduce.add</code> (LLVM::vector_reduce_add) <a class=headline-hash href=#llvmintrvectorreduceadd-llvmvector_reduce_add>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-222>Operands: <a class=headline-hash href=#operands-222>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-202>Results: <a class=headline-hash href=#results-202>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvectorreduceand-llvmvector_reduce_and><code>llvm.intr.vector.reduce.and</code> (LLVM::vector_reduce_and) <a class=headline-hash href=#llvmintrvectorreduceand-llvmvector_reduce_and>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-223>Operands: <a class=headline-hash href=#operands-223>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-203>Results: <a class=headline-hash href=#results-203>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvectorreducefadd-llvmvector_reduce_fadd><code>llvm.intr.vector.reduce.fadd</code> (LLVM::vector_reduce_fadd) <a class=headline-hash href=#llvmintrvectorreducefadd-llvmvector_reduce_fadd>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-103>Attributes: <a class=headline-hash href=#attributes-103>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-224>Operands: <a class=headline-hash href=#operands-224>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>start_value</code></td><td>floating-point</td></tr><tr><td style=text-align:center><code>input</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr></tbody></table><h4 id=results-204>Results: <a class=headline-hash href=#results-204>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvectorreducefmax-llvmvector_reduce_fmax><code>llvm.intr.vector.reduce.fmax</code> (LLVM::vector_reduce_fmax) <a class=headline-hash href=#llvmintrvectorreducefmax-llvmvector_reduce_fmax>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.vector.reduce.fmax` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-104>Attributes: <a class=headline-hash href=#attributes-104>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-225>Operands: <a class=headline-hash href=#operands-225>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr></tbody></table><h4 id=results-205>Results: <a class=headline-hash href=#results-205>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvectorreducefmaximum-llvmvector_reduce_fmaximum><code>llvm.intr.vector.reduce.fmaximum</code> (LLVM::vector_reduce_fmaximum) <a class=headline-hash href=#llvmintrvectorreducefmaximum-llvmvector_reduce_fmaximum>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.vector.reduce.fmaximum` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-105>Attributes: <a class=headline-hash href=#attributes-105>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-226>Operands: <a class=headline-hash href=#operands-226>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr></tbody></table><h4 id=results-206>Results: <a class=headline-hash href=#results-206>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvectorreducefmin-llvmvector_reduce_fmin><code>llvm.intr.vector.reduce.fmin</code> (LLVM::vector_reduce_fmin) <a class=headline-hash href=#llvmintrvectorreducefmin-llvmvector_reduce_fmin>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.vector.reduce.fmin` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-106>Attributes: <a class=headline-hash href=#attributes-106>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-227>Operands: <a class=headline-hash href=#operands-227>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr></tbody></table><h4 id=results-207>Results: <a class=headline-hash href=#results-207>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvectorreducefminimum-llvmvector_reduce_fminimum><code>llvm.intr.vector.reduce.fminimum</code> (LLVM::vector_reduce_fminimum) <a class=headline-hash href=#llvmintrvectorreducefminimum-llvmvector_reduce_fminimum>¶</a></h3><p>Syntax:</p><pre tabindex=0><code>operation ::= `llvm.intr.vector.reduce.fminimum` `(` operands `)` attr-dict `:` functional-type(operands, results) </code></pre><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-107>Attributes: <a class=headline-hash href=#attributes-107>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-228>Operands: <a class=headline-hash href=#operands-228>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr></tbody></table><h4 id=results-208>Results: <a class=headline-hash href=#results-208>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvectorreducefmul-llvmvector_reduce_fmul><code>llvm.intr.vector.reduce.fmul</code> (LLVM::vector_reduce_fmul) <a class=headline-hash href=#llvmintrvectorreducefmul-llvmvector_reduce_fmul>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>FastmathFlagsInterface</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=attributes-108>Attributes: <a class=headline-hash href=#attributes-108>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>fastmathFlags</code></td><td>::mlir::LLVM::FastmathFlagsAttr</td><td><details><summary>LLVM fastmath flags</summary><p>Enum cases:</p><ul><li>none (<code>none</code>)</li><li>nnan (<code>nnan</code>)</li><li>ninf (<code>ninf</code>)</li><li>nsz (<code>nsz</code>)</li><li>arcp (<code>arcp</code>)</li><li>contract (<code>contract</code>)</li><li>afn (<code>afn</code>)</li><li>reassoc (<code>reassoc</code>)</li><li>fast (<code>fast</code>)</li></ul></details></td></tr></table><h4 id=operands-229>Operands: <a class=headline-hash href=#operands-229>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>start_value</code></td><td>floating-point</td></tr><tr><td style=text-align:center><code>input</code></td><td>LLVM dialect-compatible vector of floating-point</td></tr></tbody></table><h4 id=results-209>Results: <a class=headline-hash href=#results-209>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvectorreducemul-llvmvector_reduce_mul><code>llvm.intr.vector.reduce.mul</code> (LLVM::vector_reduce_mul) <a class=headline-hash href=#llvmintrvectorreducemul-llvmvector_reduce_mul>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-230>Operands: <a class=headline-hash href=#operands-230>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-210>Results: <a class=headline-hash href=#results-210>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvectorreduceor-llvmvector_reduce_or><code>llvm.intr.vector.reduce.or</code> (LLVM::vector_reduce_or) <a class=headline-hash href=#llvmintrvectorreduceor-llvmvector_reduce_or>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-231>Operands: <a class=headline-hash href=#operands-231>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-211>Results: <a class=headline-hash href=#results-211>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvectorreducesmax-llvmvector_reduce_smax><code>llvm.intr.vector.reduce.smax</code> (LLVM::vector_reduce_smax) <a class=headline-hash href=#llvmintrvectorreducesmax-llvmvector_reduce_smax>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-232>Operands: <a class=headline-hash href=#operands-232>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-212>Results: <a class=headline-hash href=#results-212>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvectorreducesmin-llvmvector_reduce_smin><code>llvm.intr.vector.reduce.smin</code> (LLVM::vector_reduce_smin) <a class=headline-hash href=#llvmintrvectorreducesmin-llvmvector_reduce_smin>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-233>Operands: <a class=headline-hash href=#operands-233>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-213>Results: <a class=headline-hash href=#results-213>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvectorreduceumax-llvmvector_reduce_umax><code>llvm.intr.vector.reduce.umax</code> (LLVM::vector_reduce_umax) <a class=headline-hash href=#llvmintrvectorreduceumax-llvmvector_reduce_umax>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-234>Operands: <a class=headline-hash href=#operands-234>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-214>Results: <a class=headline-hash href=#results-214>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvectorreduceumin-llvmvector_reduce_umin><code>llvm.intr.vector.reduce.umin</code> (LLVM::vector_reduce_umin) <a class=headline-hash href=#llvmintrvectorreduceumin-llvmvector_reduce_umin>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-235>Operands: <a class=headline-hash href=#operands-235>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-215>Results: <a class=headline-hash href=#results-215>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvectorreducexor-llvmvector_reduce_xor><code>llvm.intr.vector.reduce.xor</code> (LLVM::vector_reduce_xor) <a class=headline-hash href=#llvmintrvectorreducexor-llvmvector_reduce_xor>¶</a></h3><p>Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>SameOperandsAndResultElementType</code></p><p>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code></p><p>Effects: <code>MemoryEffects::Effect{}</code></p><h4 id=operands-236>Operands: <a class=headline-hash href=#operands-236>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>in</code></td><td>LLVM dialect-compatible vector of signless integer</td></tr></tbody></table><h4 id=results-216>Results: <a class=headline-hash href=#results-216>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=llvmintrvscale-llvmvscale><code>llvm.intr.vscale</code> (LLVM::vscale) <a class=headline-hash href=#llvmintrvscale-llvmvscale>¶</a></h3><h4 id=results-217>Results: <a class=headline-hash href=#results-217>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>res</code></td><td>LLVM dialect-compatible type</td></tr></tbody></table><h3 id=debug-info>Debug Info <a class=headline-hash href=#debug-info>¶</a></h3><p>Debug information within the LLVM dialect is represented using locations in combination with a set of attributes that mirror the DINode structure defined by the debug info metadata within LLVM IR. Debug scoping information is attached to LLVM IR dialect operations using a fused location (<code>FusedLoc</code>) whose metadata holds the DIScopeAttr representing the debug scope. Similarly, the subprogram of LLVM IR dialect <code>FuncOp</code> operations is attached using a fused location whose metadata is a DISubprogramAttr.</p><div class=edit-meta><br></div><nav class=pagination><a class="nav nav-prev" href=https://mlir.llvm.org/docs/Dialects/Linalg/OpDSL/ title="Linalg OpDSL"><i class="fas fa-arrow-left" aria-hidden=true></i> Prev - Linalg OpDSL</a> <a class="nav nav-next" href=https://mlir.llvm.org/docs/Dialects/MathOps/ title="'math' Dialect">Next - 'math' Dialect <i class="fas fa-arrow-right" aria-hidden=true></i></a></nav><footer><p class=powered>Powered by <a href=https://gohugo.io>Hugo</a>. Theme by <a href=https://themes.gohugo.io/hugo-theme-techdoc/>TechDoc</a>. Designed by <a href=https://github.com/thingsym/hugo-theme-techdoc>Thingsym</a>.</p></footer></main><div class=sidebar><nav class=slide-menu><ul><li><a href=https://mlir.llvm.org/>Home</a></li><li><a href=https://mlir.llvm.org/users/>Users of MLIR</a></li><li><a href=https://mlir.llvm.org/pubs/>MLIR Related Publications</a></li><li><a href=https://mlir.llvm.org/talks/>Talks</a></li><li><a href=https://mlir.llvm.org/deprecation/>Deprecations & Current Refactoring</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/getting_started/>Getting Started<span class="mark closed">+</span></a><ul class=sub-menu><li><a href=https://mlir.llvm.org/getting_started/ReportingIssues/>Reporting Issues</a></li><li><a href=https://mlir.llvm.org/getting_started/Debugging/>Debugging Tips</a></li><li><a href=https://mlir.llvm.org/getting_started/Faq/>FAQ</a></li><li><a href=https://mlir.llvm.org/getting_started/Contributing/>How to Contribute</a></li><li><a href=https://mlir.llvm.org/getting_started/DeveloperGuide/>Developer Guide</a></li><li><a href=https://mlir.llvm.org/getting_started/openprojects/>Open Projects</a></li><li><a href=https://mlir.llvm.org/getting_started/Glossary/>Glossary</a></li><li><a href=https://mlir.llvm.org/getting_started/TestingGuide/>Testing Guide</a></li></ul></li><li class="parent has-sub-menu"><a href=https://mlir.llvm.org/docs/>Code Documentation<span class="mark opened">-</span></a><ul class=sub-menu><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Bindings/>Bindings<span class="mark closed">+</span></a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Bindings/Python/>MLIR Python Bindings</a></li></ul></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Tools/>Tools<span class="mark closed">+</span></a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Tools/MLIRLSP/>MLIR : Language Server Protocol</a></li><li><a href=https://mlir.llvm.org/docs/Tools/mlir-reduce/>MLIR Reduce</a></li><li><a href=https://mlir.llvm.org/docs/Tools/mlir-rewrite/>mlir-rewrite</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/QuantPasses/></a></li><li><a href=https://mlir.llvm.org/docs/ActionTracing/>Action: Tracing and Debugging MLIR-based Compilers</a></li><li><a href=https://mlir.llvm.org/docs/BufferDeallocationInternals/>Buffer Deallocation - Internals</a></li><li><a href=https://mlir.llvm.org/docs/Bufferization/>Bufferization</a></li><li><a href=https://mlir.llvm.org/docs/DataLayout/>Data Layout Modeling</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/DefiningDialects/>Defining Dialects<span class="mark closed">+</span></a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/DefiningDialects/Constraints/>Constraints</a></li><li><a href=https://mlir.llvm.org/docs/DefiningDialects/AttributesAndTypes/>Defining Dialect Attributes and Types</a></li><li><a href=https://mlir.llvm.org/docs/DefiningDialects/Operations/>Operation Definition Specification (ODS)</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/Diagnostics/>Diagnostic Infrastructure</a></li><li><a href=https://mlir.llvm.org/docs/DialectConversion/>Dialect Conversion</a></li><li class="parent has-sub-menu"><a href=https://mlir.llvm.org/docs/Dialects/>Dialects<span class="mark opened">-</span></a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Dialects/DLTITransformOps/></a></li><li><a href=https://mlir.llvm.org/docs/Dialects/OpenACCDialect/>'acc' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Affine/>'affine' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/AMDGPU/>'amdgpu' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/AMX/>'amx' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ArithOps/>'arith' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ArmNeon/>'arm_neon' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ArmSVE/>'arm_sve' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ArmSME/>'ArmSME' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/AsyncDialect/>'async' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/BufferizationOps/>'bufferization' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ControlFlowDialect/>'cf' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ComplexOps/>'complex' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/DLTIDialect/>'dlti' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/EmitC/>'emitc' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Func/>'func' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/GPU/>'gpu' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/IndexOps/>'index' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/IRDL/>'irdl' Dialect</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Dialects/Linalg/>'linalg' Dialect<span class="mark closed">+</span></a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Dialects/Linalg/OpDSL/>Linalg OpDSL</a></li></ul></li><li class=active><a href=https://mlir.llvm.org/docs/Dialects/LLVM/>'llvm' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/MathOps/>'math' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/MemRef/>'memref' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Mesh/>'mesh' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/MLProgramOps/>'ml_program' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/MPI/>'mpi' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/NVGPU/>'nvgpu' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/NVVMDialect/>'nvvm' Dialect</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Dialects/OpenMPDialect/>'omp' Dialect<span class="mark closed">+</span></a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Dialects/OpenMPDialect/ODS/>ODS Documentation</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/Dialects/PDLInterpOps/>'pdl_interp' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/PDLOps/>'pdl' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/PolynomialDialect/>'polynomial' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/PtrOps/>'ptr' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/QuantDialect/>'quant' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ROCDLDialect/>'rocdl' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/SCFDialect/>'scf' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ShapeDialect/>'shape' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/SparseTensorOps/>'sparse_tensor' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/TensorOps/>'tensor' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/UBOps/>'ub' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/VCIXDialect/>'vcix' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Vector/>'vector' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/X86Vector/>'x86vector' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/XeGPU/>'xegpu' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Builtin/>Builtin Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/MatchOpInterfaces/>OpInterface definitions</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/SPIR-V/>SPIR-V Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/TOSA/>Tensor Operator Set Architecture (TOSA) Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Transform/>Transform Dialect</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/Interfaces/>Interfaces</a></li><li><a href=https://mlir.llvm.org/docs/TargetLLVMIR/>LLVM IR Target</a></li><li><a href=https://mlir.llvm.org/docs/BytecodeFormat/>MLIR Bytecode Format</a></li><li><a href=https://mlir.llvm.org/docs/CAPI/>MLIR C API</a></li><li><a href=https://mlir.llvm.org/docs/LangRef/>MLIR Language Reference</a></li><li><a href=https://mlir.llvm.org/docs/ReleaseNotes/>MLIR Release Notes</a></li><li><a href=https://mlir.llvm.org/docs/Canonicalization/>Operation Canonicalization</a></li><li><a href=https://mlir.llvm.org/docs/OwnershipBasedBufferDeallocation/>Ownership-based Buffer Deallocation</a></li><li><a href=https://mlir.llvm.org/docs/PassManagement/>Pass Infrastructure</a></li><li><a href=https://mlir.llvm.org/docs/Passes/>Passes</a></li><li><a href=https://mlir.llvm.org/docs/PatternRewriter/>Pattern Rewriting : Generic DAG-to-DAG Rewriting</a></li><li><a href=https://mlir.llvm.org/docs/PDLL/>PDLL - PDL Language</a></li><li><a href=https://mlir.llvm.org/docs/Quantization/>Quantization</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Rationale/>Rationale<span class="mark closed">+</span></a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Rationale/RationaleGenericDAGRewriter/>Generic DAG Rewriter Infrastructure Rationale</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/RationaleLinalgDialect/>Linalg Dialect Rationale: The Case For Compiler-Friendly Custom Operations</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/Rationale/>MLIR Rationale</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/MLIRForGraphAlgorithms/>MLIR: Incremental Application to Graph Algorithms in ML Frameworks</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/RationaleSimplifiedPolyhedralForm/>MLIR: The case for a simplified polyhedral form</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/SideEffectsAndSpeculation/>Side Effects & Speculation</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/UsageOfConst/>Usage of 'const' in MLIR, for core IR types</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/ShapeInference/>Shape Inference</a></li><li><a href=https://mlir.llvm.org/docs/SPIRVToLLVMDialectConversion/>SPIR-V Dialect to LLVM Dialect conversion manual</a></li><li><a href=https://mlir.llvm.org/docs/SymbolsAndSymbolTables/>Symbols and Symbol Tables</a></li><li><a href=https://mlir.llvm.org/docs/DeclarativeRewrites/>Table-driven Declarative Rewrite Rule (DRR)</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Traits/>Traits<span class="mark closed">+</span></a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Traits/Broadcastable/>The `Broadcastable` Trait</a></li></ul></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Tutorials/>Tutorials<span class="mark closed">+</span></a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Tutorials/CreatingADialect/>Creating a Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/QuickstartRewrites/>Quickstart tutorial to adding MLIR graph rewrite</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Tutorials/Toy/>Toy Tutorial<span class="mark closed">+</span></a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-1/>Chapter 1: Toy Language and AST</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-2/>Chapter 2: Emitting Basic MLIR</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-3/>Chapter 3: High-level Language-Specific Analysis and Transformation</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-4/>Chapter 4: Enabling Generic Transformation with Interfaces</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-5/>Chapter 5: Partial Lowering to Lower-Level Dialects for Optimization</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-6/>Chapter 6: Lowering to LLVM and CodeGeneration</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-7/>Chapter 7: Adding a Composite Type to Toy</a></li></ul></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Tutorials/transform/>Transform Dialect Tutorial<span class="mark closed">+</span></a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/Ch0/>Chapter 0: A Primer on “Structured” Linalg Operations</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/Ch1/>Chapter 1: Combining Existing Transformations</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/Ch2/>Chapter 2: Adding a Simple New Transformation Operation</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/Ch3/>Chapter 3: More than Simple Transform Operations</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/Ch4/>Chapter 4: Matching Payload with Transform Operations</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/ChH/>Chapter H: Reproducing Halide Schedule</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/Tutorials/UnderstandingTheIRStructure/>Understanding the IR Structure</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/MlirOpt/>Using `mlir-opt`</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/DataFlowAnalysis/>Writing DataFlow Analyses in MLIR</a></li></ul></li></ul></li></ul></nav><div class=sidebar-footer></div></div></div><a href=# id=backtothetop-fixed class=backtothetop data-backtothetop-duration=600 data-backtothetop-easing=easeOutQuart data-backtothetop-fixed-fadein=1000 data-backtothetop-fixed-fadeout=1000 data-backtothetop-fixed-bottom=10 data-backtothetop-fixed-right=20><span class="fa-layers fa-fw"><i class="fas fa-circle"></i> <i class="fas fa-arrow-circle-up"></i></span></a></div></body></html>