[#llvm-AnyMemIntrinsic]
= xref:llvm.adoc[llvm]::AnyMemIntrinsic
:relfileprefix: ../
:mrdocs:

Common base for atomic or non‐atomic memset/memcpy/memmove intrinsics.

== Synopsis

Declared in `<llvm/IR/IntrinsicInst.h>`

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
class AnyMemIntrinsic
    : public xref:llvm/MemIntrinsicBase-0f.adoc[MemIntrinsicBase<AnyMemIntrinsic>]
----

== Description

Covers llvm.element.unordered.atomic.memset/memcpy/memmove and llvm.memset/memcpy/memmove.

== Base Classes

[cols="1,4"]
|===
| Name| Description
| `xref:llvm/MemIntrinsicBase-0f.adoc[MemIntrinsicBase<AnyMemIntrinsic>]`
| CRTP base providing common accessors for memory intrinsics.
|===

== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/AnyMemIntrinsic/getDest.adoc[`getDest`] 
| Return the destination pointer with pointer casts stripped.
| xref:llvm/AnyMemIntrinsic/getDestAddressSpace.adoc[`getDestAddressSpace`] 
| Return the address space of the raw destination pointer.
| xref:llvm/AnyMemIntrinsic/getDestAlign.adoc[`getDestAlign`] 
| Return the alignment of the destination pointer parameter.
| xref:llvm/AnyMemIntrinsic/getElementSizeInBytes.adoc[`getElementSizeInBytes`] 
| Return the element size in bytes (atomic intrinsics only).
| xref:llvm/AnyMemIntrinsic/getLength.adoc[`getLength`] 
| Return the length operand.
| xref:llvm/AnyMemIntrinsic/getLengthInBytes.adoc[`getLengthInBytes`] 
| Return the constant length in bytes, if the length operand is constant.
| xref:llvm/AnyMemIntrinsic/getLengthUse-09.adoc[`getLengthUse`] 
| `getLengthUse` overloads
| xref:llvm/AnyMemIntrinsic/getRawDest.adoc[`getRawDest`] 
| Return the raw destination pointer operand.
| xref:llvm/AnyMemIntrinsic/getRawDestUse-07.adoc[`getRawDestUse`] 
| `getRawDestUse` overloads
| xref:llvm/AnyMemIntrinsic/getRawElementSizeInBytes.adoc[`getRawElementSizeInBytes`] 
| Return the raw element‐size‐in‐bytes operand (atomic intrinsics only).
| xref:llvm/AnyMemIntrinsic/isAtomic.adoc[`isAtomic`] 
| Return true if this is an unordered‐atomic memory intrinsic.
| xref:llvm/AnyMemIntrinsic/isVolatile.adoc[`isVolatile`] 
| Return true if this is a volatile non‐atomic memory intrinsic.
| xref:llvm/AnyMemIntrinsic/setDest.adoc[`setDest`] 
| Set the destination pointer operand.
| xref:llvm/AnyMemIntrinsic/setDestAlignment-0c.adoc[`setDestAlignment`] 
| Set the destination pointer alignment attribute.
| xref:llvm/AnyMemIntrinsic/setLength-07.adoc[`setLength`] 
| `setLength` overloads
|===


== Static Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/AnyMemIntrinsic/classof-0c.adoc[`classof`] 
| Methods for support type inquiry through isa, cast, and dyn_cast.
|===


== Non-Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/CanInlineCallSite.adoc[`CanInlineCallSite`]
| Check if it is legal to perform inlining of the function called by `CB` into the caller at this particular use, and sets fields in `IFI.`
| xref:llvm/ComputeMaxSignificantBits.adoc[`ComputeMaxSignificantBits`]
| Get the upper bound on bit size for this Value `Op` as a signed integer.
| xref:llvm/ComputeNumSignBits.adoc[`ComputeNumSignBits`]
| Return the number of times the sign bit of the register is replicated into the other bits.
| xref:llvm/ConstantFoldCall.adoc[`ConstantFoldCall`]
| Attempt to constant fold a call to the specified function with the specified arguments, returning null if unsuccessful.
| xref:llvm/ConstantFoldInstOperands.adoc[`ConstantFoldInstOperands`]
| Attempt to constant fold an instruction with the specified operands.
| xref:llvm/ConstantFoldInstruction.adoc[`ConstantFoldInstruction`]
| Try to constant fold the specified instruction.
| xref:llvm/DemoteRegToStack.adoc[`DemoteRegToStack`]
| Demote an instruction's virtual register to a stack slot.
| xref:llvm/ExtractTypeInfo.adoc[`ExtractTypeInfo`]
| ExtractTypeInfo ‐ Returns the type info, possibly bitcast, encoded in V.
| xref:llvm/FindEarliestCapture.adoc[`FindEarliestCapture`]
| Find the earliest instruction that captures `V` in `F.`
| xref:llvm/FindInsertedValue.adoc[`FindInsertedValue`]
| Given an aggregate and a sequence of indices, see if the scalar value indexed is already around as a register.
| xref:llvm/GetPointerBaseWithConstantOffset-038.adoc[`GetPointerBaseWithConstantOffset`]
| Analyze the specified pointer to see if it can be expressed as a base pointer plus a constant offset. Return the base and offset to the caller.
| xref:llvm/GetPointerBaseWithConstantOffset-039.adoc[`GetPointerBaseWithConstantOffset`]
| Const overload of GetPointerBaseWithConstantOffset.
| xref:llvm/GetStringLength.adoc[`GetStringLength`]
| If we can compute the length of the string pointed to by the specified pointer, return 'len+1'. If we can't, return 0.
| xref:llvm/InlineFunction-05.adoc[`InlineFunction`]
| Inline `CB` while also updating a contextual profile.
| xref:llvm/InlineFunction-08.adoc[`InlineFunction`]
| Inline the callee of `CB` into its caller's basic block.
| xref:llvm/InlineFunctionImpl.adoc[`InlineFunctionImpl`]
| This should generally not be used, use InlineFunction instead.
| xref:llvm/MapValue-00.adoc[`MapValue`]
| Look up or compute a value in the value map.
| xref:llvm/MaskedValueIsZero.adoc[`MaskedValueIsZero`]
| Return true if 'V & Mask' is known to be zero. We use this predicate to simplify operations downstream. Mask is known to be zero for bits that V cannot have.
| xref:llvm/PointerMayBeCaptured-00.adoc[`PointerMayBeCaptured`]
| Visit a pointer and derived values to find capturing uses.
| xref:llvm/PointerMayBeCaptured-02c.adoc[`PointerMayBeCaptured`]
| Return which components of the pointer may be captured.
| xref:llvm/PointerMayBeCaptured-0d.adoc[`PointerMayBeCaptured`]
| Return true if this pointer may be captured by the enclosing function.
| xref:llvm/PointerMayBeCapturedBefore-08.adoc[`PointerMayBeCapturedBefore`]
| Return true if this pointer may be captured before a given instruction.
| xref:llvm/PointerMayBeCapturedBefore-0c.adoc[`PointerMayBeCapturedBefore`]
| Return which components of the pointer may be captured on the path to `I.`
| xref:llvm/RecursivelyDeleteTriviallyDeadInstructions-0d.adoc[`RecursivelyDeleteTriviallyDeadInstructions`]
| Recursively delete a trivially dead instruction and its dead operands.
| xref:llvm/RemapInstruction.adoc[`RemapInstruction`]
| Convert the instruction operands from referencing the current values into those specified by VM.
| xref:llvm/RemapSourceAtom.adoc[`RemapSourceAtom`]
| Remap the source‐location atom of instruction `I.`
| xref:llvm/ReplaceInstWithInst-01.adoc[`ReplaceInstWithInst`]
| Replace one instruction with another and copy its debug location.
| xref:llvm/SplitBlockAndInsertForEachLane-09.adoc[`SplitBlockAndInsertForEachLane`]
| Invoke a callback once for each lane up to an effective vector length.
| xref:llvm/SplitBlockAndInsertIfElse-09.adoc[`SplitBlockAndInsertIfElse`]
| Split a block and insert an else‐branch at an instruction.
| xref:llvm/SplitBlockAndInsertIfElse-0b.adoc[`SplitBlockAndInsertIfElse`]
| Split a block and insert a conditional else‐branch around the split point.
| xref:llvm/SplitBlockAndInsertIfThen-07.adoc[`SplitBlockAndInsertIfThen`]
| Split a block and insert a then‐branch at an instruction.
| xref:llvm/SplitBlockAndInsertIfThen-0b.adoc[`SplitBlockAndInsertIfThen`]
| Split a block and insert a conditional then‐branch around the split point.
| xref:llvm/SplitBlockAndInsertIfThenElse-09.adoc[`SplitBlockAndInsertIfThenElse`]
| Split a block and insert optional then/else blocks around the split point.
| xref:llvm/SplitBlockAndInsertIfThenElse-0a.adoc[`SplitBlockAndInsertIfThenElse`]
| Split a block and insert optional then/else blocks at an instruction.
| xref:llvm/SplitBlockAndInsertIfThenElse-0c3.adoc[`SplitBlockAndInsertIfThenElse`]
| Split a block and insert both then and else branches around the split point.
| xref:llvm/SplitBlockAndInsertIfThenElse-0c7.adoc[`SplitBlockAndInsertIfThenElse`]
| Split a block and insert then/else branches at an instruction.
| xref:llvm/SplitBlockAndInsertSimpleForLoop.adoc[`SplitBlockAndInsertSimpleForLoop`]
| Insert a simple counted for‐loop at a split point.
| xref:llvm/SplitCriticalEdge-07.adoc[`SplitCriticalEdge`]
| Split a critical edge from a terminator to one of its successors.
| xref:llvm/SplitKnownCriticalEdge.adoc[`SplitKnownCriticalEdge`]
| Split an edge that is already known to be critical.
| xref:llvm/UpgradeIntrinsicCall.adoc[`UpgradeIntrinsicCall`]
| This is the complement to the above, replacing a specific call to an intrinsic function with a call to the specified new function.
| xref:llvm/adaptNoAliasScopes.adoc[`adaptNoAliasScopes`]
| Adapt an instruction's noalias metadata using a scope map.
| xref:llvm/addAssumptions-08.adoc[`addAssumptions`]
| Appends the set of assumptions `Assumptions` to `CB.`
| xref:llvm/addDiffRuntimeChecks.adoc[`addDiffRuntimeChecks`]
| Add runtime checks that compare pointer differences against a distance.
| xref:llvm/addRuntimeChecks.adoc[`addRuntimeChecks`]
| Add code that checks at runtime if the accessed arrays in `PointerChecks` overlap. Returns the final comparator value or NULL if no check is needed.
| xref:llvm/applyProfMetadataIfEnabled.adoc[`applyProfMetadataIfEnabled`]
| Apply a metadata callback if `V` is an instruction and profiling is enabled.
| xref:llvm/assumeBundleImpliesNonNull.adoc[`assumeBundleImpliesNonNull`]
| Return true if the given assume operand bundle implies that `Val` is non‐null.
| xref:llvm/buildAssumeFromInst.adoc[`buildAssumeFromInst`]
| Build an llvm.assume call preserving information derived from an instruction.
| xref:llvm/callsGCLeafFunction.adoc[`callsGCLeafFunction`]
| Return true if this call calls a GC leaf function.
| xref:llvm/canConstantFoldCallTo.adoc[`canConstantFoldCallTo`]
| Return true if it is even possible to fold a call to the specified function.
| xref:llvm/canInstructionHaveMMRAs.adoc[`canInstructionHaveMMRAs`]
| Return true if `I` can have !mmra metadata.
| xref:llvm/canReplaceOperandWithVariable.adoc[`canReplaceOperandWithVariable`]
| Return true if an operand may legally be replaced with a variable.
| xref:llvm/canReplacePointersIfEqual.adoc[`canReplacePointersIfEqual`]
| Returns true if pointer `From` can be replaced with equal pointer `To.`
| xref:llvm/canSinkOrHoistInst.adoc[`canSinkOrHoistInst`]
| Return true if `I` may legally be sunk or hoisted, ignoring faults.
| xref:llvm/cannotBeNegativeZero.adoc[`cannotBeNegativeZero`]
| Return true if we can prove that the specified FP value is never equal to ‐0.0. Users should use caution when considering PreserveSign denormal‐fp‐math.
| xref:llvm/cannotBeOrderedLessThanZero.adoc[`cannotBeOrderedLessThanZero`]
| Return true if we can prove that the specified FP value is either NaN or never less than ‐0.0.
| xref:llvm/changeToInvokeAndSplitBasicBlock.adoc[`changeToInvokeAndSplitBasicBlock`]
| Convert a call into an invoke and split its basic block.
| xref:llvm/changeToUnreachable.adoc[`changeToUnreachable`]
| Insert unreachable before an instruction and make the rest of the block dead.
| xref:llvm/classifyEHPersonality.adoc[`classifyEHPersonality`]
| See if the given exception handling personality function is one that we understand. If so, return a description of it; otherwise return Unknown.
| xref:llvm/collectPossibleValues.adoc[`collectPossibleValues`]
| Enumerate immediate constant values of `V` into `Constants.`
| xref:llvm/combineAAMetadata.adoc[`combineAAMetadata`]
| Combine alias‐analysis metadata after merging memory accesses.
| xref:llvm/combineMetadataForCSE.adoc[`combineMetadataForCSE`]
| Combine metadata so one instruction can replace another after CSE.
| xref:llvm/computeConstantRange.adoc[`computeConstantRange`]
| Determine the possible constant range of an integer or vector of integer value. This is intended as a cheap, non‐recursive check.
| xref:llvm/computeKnownBits-02f.adoc[`computeKnownBits`]
| Returns the known bits rather than passing by reference.
| xref:llvm/computeKnownBits-030.adoc[`computeKnownBits`]
| Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOne bit sets.
| xref:llvm/computeKnownBits-03a.adoc[`computeKnownBits`]
| Returns the known bits rather than passing by reference.
| xref:llvm/computeKnownBits-084.adoc[`computeKnownBits`]
| Compute known bits for the demanded elements of `V` using `Q.`
| xref:llvm/computeKnownBits-08f.adoc[`computeKnownBits`]
| Compute known bits for `V` into `Known` using the simplify query `Q.`
| xref:llvm/computeKnownBits-0d.adoc[`computeKnownBits`]
| Compute known bits for `V` using the simplify query `Q.`
| xref:llvm/computeKnownBitsFromContext.adoc[`computeKnownBitsFromContext`]
| Merge bits known from context‐dependent facts into Known.
| xref:llvm/computeKnownFPClass-00.adoc[`computeKnownFPClass`]
| Wrapper to account for known fast math flags at the use instruction.
| xref:llvm/computeKnownFPClass-01.adoc[`computeKnownFPClass`]
| Determine known floating‐point classes for `V.`
| xref:llvm/computeKnownFPClass-07.adoc[`computeKnownFPClass`]
| Wrapper to account for known fast math flags at the use instruction.
| xref:llvm/computeKnownFPClass-0a.adoc[`computeKnownFPClass`]
| Determine which floating‐point classes are valid for `V,` and return them in KnownFPClass bit sets.
| xref:llvm/computeKnownFPClass-0c.adoc[`computeKnownFPClass`]
| Determine known floating‐point classes for `V` using explicit analysis context.
| xref:llvm/computeKnownFPSignBit.adoc[`computeKnownFPSignBit`]
| Return the known sign bit of a floating‐point value, if provable.
| xref:llvm/computeOverflowForSignedMul.adoc[`computeOverflowForSignedMul`]
| Compute whether a signed multiply of `LHS` and `RHS` can overflow.
| xref:llvm/computeOverflowForSignedSub.adoc[`computeOverflowForSignedSub`]
| Compute whether a signed subtract of `LHS` and `RHS` can overflow.
| xref:llvm/computeOverflowForUnsignedMul.adoc[`computeOverflowForUnsignedMul`]
| Compute whether an unsigned multiply of `LHS` and `RHS` can overflow.
| xref:llvm/computeOverflowForUnsignedSub.adoc[`computeOverflowForUnsignedSub`]
| Compute whether an unsigned subtract of `LHS` and `RHS` can overflow.
| xref:llvm/createMemCpyLoopKnownSize.adoc[`createMemCpyLoopKnownSize`]
| Emit a loop implementing llvm.memcpy when the size is a constant.
| xref:llvm/createMemCpyLoopUnknownSize.adoc[`createMemCpyLoopUnknownSize`]
| Emit a loop implementing llvm.memcpy when the size is not a constant.
| xref:llvm/decomposeBitTest.adoc[`decomposeBitTest`]
| Decompose an icmp into the form ((X & Mask) pred C) if possible.
| xref:llvm/decomposeBitTestICmp.adoc[`decomposeBitTestICmp`]
| Decompose an icmp into the form ((X & Mask) pred C) if possible.
| xref:llvm/diagnoseDontCall.adoc[`diagnoseDontCall`]
| Emit a dontcall diagnostic for call instruction `CI.`
| xref:llvm/dropDebugUsers.adoc[`dropDebugUsers`]
| Remove debug intrinsic instructions for a given instruction.
| xref:llvm/emitBCmp.adoc[`emitBCmp`]
| Emit a call to the bcmp function.
| xref:llvm/emitBinaryFloatFnCall-09.adoc[`emitBinaryFloatFnCall`]
| Emit a call to the binary floating‐point libcall named Name.
| xref:llvm/emitBinaryFloatFnCall-0a.adoc[`emitBinaryFloatFnCall`]
| Emit a call to the binary DoubleFn, FloatFn, or LongDoubleFn for Op1's type.
| xref:llvm/emitCalloc.adoc[`emitCalloc`]
| Emit a call to the calloc function.
| xref:llvm/emitFPutC.adoc[`emitFPutC`]
| Emit a call to fputc with an int Char and a FILE pointer.
| xref:llvm/emitFPutS.adoc[`emitFPutS`]
| Emit a call to fputs with a string pointer and a FILE pointer.
| xref:llvm/emitFWrite.adoc[`emitFWrite`]
| Emit a call to fwrite with a pointer, size_t Size, and FILE pointer.
| xref:llvm/emitHotColdNew.adoc[`emitHotColdNew`]
| Emit a call to the hot/cold operator new function.
| xref:llvm/emitHotColdNewAligned.adoc[`emitHotColdNewAligned`]
| Emit a call to the hot/cold aligned operator new function.
| xref:llvm/emitHotColdNewAlignedNoThrow.adoc[`emitHotColdNewAlignedNoThrow`]
| Emit a call to the hot/cold aligned nothrow operator new function.
| xref:llvm/emitHotColdNewNoThrow.adoc[`emitHotColdNewNoThrow`]
| Emit a call to the hot/cold nothrow operator new function.
| xref:llvm/emitHotColdSizeReturningNew.adoc[`emitHotColdSizeReturningNew`]
| Emit a call to the hot/cold size‐returning operator new function.
| xref:llvm/emitHotColdSizeReturningNewAligned.adoc[`emitHotColdSizeReturningNewAligned`]
| Emit a call to the hot/cold size‐returning aligned operator new function.
| xref:llvm/emitMalloc.adoc[`emitMalloc`]
| Emit a call to the malloc function.
| xref:llvm/emitMemCCpy.adoc[`emitMemCCpy`]
| Emit a call to the memccpy function.
| xref:llvm/emitMemChr.adoc[`emitMemChr`]
| Emit a call to memchr with a pointer, int Val, and size_t Len.
| xref:llvm/emitMemCmp.adoc[`emitMemCmp`]
| Emit a call to the memcmp function.
| xref:llvm/emitMemCpyChk.adoc[`emitMemCpyChk`]
| Emit a call to __memcpy_chk with size_t Len/ObjSize and pointer Dst/Src.
| xref:llvm/emitMemPCpy.adoc[`emitMemPCpy`]
| Emit a call to the mempcpy function.
| xref:llvm/emitMemRChr.adoc[`emitMemRChr`]
| Emit a call to the memrchr function, analogously to emitMemChr.
| xref:llvm/emitPutChar.adoc[`emitPutChar`]
| Emit a call to putchar, assuming Char is an int.
| xref:llvm/emitPutS.adoc[`emitPutS`]
| Emit a call to puts, assuming Str is some pointer.
| xref:llvm/emitSNPrintf.adoc[`emitSNPrintf`]
| Emit a call to the snprintf function.
| xref:llvm/emitSPrintf.adoc[`emitSPrintf`]
| Emit a call to the sprintf function.
| xref:llvm/emitStpCpy.adoc[`emitStpCpy`]
| Emit a call to stpcpy for the specified pointer arguments.
| xref:llvm/emitStpNCpy.adoc[`emitStpNCpy`]
| Emit a call to stpncpy for the specified pointer arguments and length.
| xref:llvm/emitStrCat.adoc[`emitStrCat`]
| Emit a call to the strcat function.
| xref:llvm/emitStrChr.adoc[`emitStrChr`]
| Emit a call to strchr for the specified pointer and character.
| xref:llvm/emitStrCpy.adoc[`emitStrCpy`]
| Emit a call to strcpy for the specified pointer arguments.
| xref:llvm/emitStrDup.adoc[`emitStrDup`]
| Emit a call to strdup for the specified pointer.
| xref:llvm/emitStrLCat.adoc[`emitStrLCat`]
| Emit a call to the strlcat function.
| xref:llvm/emitStrLCpy.adoc[`emitStrLCpy`]
| Emit a call to the strlcpy function.
| xref:llvm/emitStrLen.adoc[`emitStrLen`]
| Emit a call to strlen for the specified pointer.
| xref:llvm/emitStrNCat.adoc[`emitStrNCat`]
| Emit a call to the strncat function.
| xref:llvm/emitStrNCmp.adoc[`emitStrNCmp`]
| Emit a call to the strncmp function to the builder.
| xref:llvm/emitStrNCpy.adoc[`emitStrNCpy`]
| Emit a call to strncpy for the specified pointer arguments and length.
| xref:llvm/emitUnaryFloatFnCall-00.adoc[`emitUnaryFloatFnCall`]
| Emit a call to the unary DoubleFn, FloatFn, or LongDoubleFn for Op's type.
| xref:llvm/emitUnaryFloatFnCall-04.adoc[`emitUnaryFloatFnCall`]
| Emit a call to the unary floating‐point libcall named Name.
| xref:llvm/emitVSNPrintf.adoc[`emitVSNPrintf`]
| Emit a call to the vsnprintf function.
| xref:llvm/emitVSPrintf.adoc[`emitVSPrintf`]
| Emit a call to the vsprintf function.
| xref:llvm/emitWcsLen.adoc[`emitWcsLen`]
| Emit a call to wcslen for the specified pointer.
| xref:llvm/extractBranchWeights-0e8.adoc[`extractBranchWeights`]
| Extract branch weights attatched to an Instruction
| xref:llvm/extractBranchWeights-0e9.adoc[`extractBranchWeights`]
| Extract branch weights from a conditional branch or select Instruction.
| xref:llvm/extractProbe.adoc[`extractProbe`]
| Extract the pseudo probe stored on `Inst,` if present.
| xref:llvm/extractProfTotalWeight-08.adoc[`extractProfTotalWeight`]
| Retrieve the total of all weights from an instruction.
| xref:llvm/extractWidenableCondition.adoc[`extractWidenableCondition`]
| Returns the widenable condition in `U's` expression tree, if uniquely used.
| xref:llvm/findAllocaForValue-005.adoc[`findAllocaForValue`]
| Const overload of findAllocaForValue.
| xref:llvm/findAllocaForValue-0c.adoc[`findAllocaForValue`]
| Returns unique alloca where the value comes from, or nullptr. If OffsetZero is true check that V points to the begining of the alloca.
| xref:llvm/findDVRDeclareValues.adoc[`findDVRDeclareValues`]
| As above, for DVRDeclareValues.
| xref:llvm/findDVRDeclares.adoc[`findDVRDeclares`]
| Finds dbg.declare records declaring local variables as living in the memory that 'V' points to.
| xref:llvm/findDVRValues.adoc[`findDVRValues`]
| As above, for DVRValues.
| xref:llvm/findDbgUsers.adoc[`findDbgUsers`]
| Finds the debug info records describing a value.
| xref:llvm/findDbgValues.adoc[`findDbgValues`]
| Finds the dbg.values describing a value.
| xref:llvm/findScalarElement.adoc[`findScalarElement`]
| Given a vector and an element number, see if the scalar value is already around as a register, for example if it were inserted then extracted from the vector.
| xref:llvm/findValuesAffectedByCondition.adoc[`findValuesAffectedByCondition`]
| Call `InsertAffected` on all Values whose known bits / value may be affected by the condition `Cond.` Used by AssumptionCache and DomConditionCache.
| xref:llvm/forEachCallbackCallSite.adoc[`forEachCallbackCallSite`]
| Apply function Func to each CB's callback call site.
| xref:llvm/forEachCallbackFunction.adoc[`forEachCallbackFunction`]
| Apply function Func to each CB's callback function.
| xref:llvm/funcReturnsFirstArgOfCall.adoc[`funcReturnsFirstArgOfCall`]
| Returns true if the parent of `CI` returns CI's first argument after calling `CI.`
| xref:llvm/gep_type_begin-00.adoc[`gep_type_begin`]
| Return a begin iterator over the types indexed by GEP `GEP.`
| xref:llvm/gep_type_begin-0d.adoc[`gep_type_begin`]
| Return a begin iterator over the types indexed by GEP `GEP.`
| xref:llvm/gep_type_end-0b.adoc[`gep_type_end`]
| Return the end iterator for types indexed by GEP `GEP.`
| xref:llvm/gep_type_end-0d.adoc[`gep_type_end`]
| Return the end iterator for types indexed by GEP `GEP.`
| xref:llvm/getAllocAlignment.adoc[`getAllocAlignment`]
| Gets the alignment argument for an aligned_alloc‐like function.
| xref:llvm/getAllocSize.adoc[`getAllocSize`]
| Return the size of the requested allocation.
| xref:llvm/getAllocationFamily.adoc[`getAllocationFamily`]
| If a function is part of an allocation family (e.g. malloc/realloc/calloc/free), return the identifier for its family of functions.
| xref:llvm/getArgumentAliasingToReturnedPointer-07.adoc[`getArgumentAliasingToReturnedPointer`]
| Return the call pointer argument that aliasing rules treat as the returned pointer.
| xref:llvm/getArgumentAliasingToReturnedPointer-0a.adoc[`getArgumentAliasingToReturnedPointer`]
| Non‐const overload of getArgumentAliasingToReturnedPointer.
| xref:llvm/getAssumptions-0b.adoc[`getAssumptions`]
| Return the set of all assumptions for the call `CB.`
| xref:llvm/getAtomicSyncScopeID.adoc[`getAtomicSyncScopeID`]
| Return the sync scope of atomic instruction `I,` or nullopt if not atomic.
| xref:llvm/getAttributeBasedInliningDecision.adoc[`getAttributeBasedInliningDecision`]
| Decide inlining from user directives and viability, without cost modeling.
| xref:llvm/getBaseObjectSize.adoc[`getBaseObjectSize`]
| Like getObjectSize(), but only for base objects.
| xref:llvm/getBranchWeightMDNode.adoc[`getBranchWeightMDNode`]
| Get the branch weights metadata node
| xref:llvm/getConstantDataArrayInfo.adoc[`getConstantDataArrayInfo`]
| Returns true if the value `V` is a pointer into a ConstantDataArray. If successful `Slice` will point to a ConstantDataArray info object with an appropriate offset.
| xref:llvm/getConstantStringInfo.adoc[`getConstantStringInfo`]
| Compute the contents of a null‐terminated C string pointed to by `V.`
| xref:llvm/getConstrainedIntrinsicID.adoc[`getConstrainedIntrinsicID`]
| Return the constrained intrinsic ID for an instruction under strictfp.
| xref:llvm/getDeinterleavedVectorType.adoc[`getDeinterleavedVectorType`]
| Given a deinterleaveN intrinsic, return the (narrow) vector type of each factor.
| xref:llvm/getFreedOperand.adoc[`getFreedOperand`]
| If this if a call to a free function, return the freed operand.
| xref:llvm/getInitialValueOfAllocation.adoc[`getInitialValueOfAllocation`]
| If this is a call to an allocation function that initializes memory to a fixed value, return said value in the requested type. Otherwise, return nullptr.
| xref:llvm/getInlineCost-07.adoc[`getInlineCost`]
| Get an InlineCost object representing the cost of inlining this callsite.
| xref:llvm/getInlineCost-0f.adoc[`getInlineCost`]
| Get an InlineCost with the callee explicitly specified.
| xref:llvm/getInliningCostEstimate.adoc[`getInliningCostEstimate`]
| Get the cost estimate ignoring thresholds.
| xref:llvm/getInliningCostFeatures.adoc[`getInliningCostFeatures`]
| Get the expanded cost features. The features are returned unconditionally, even if inlining is impossible.
| xref:llvm/getIntrinsicForCallSite.adoc[`getIntrinsicForCallSite`]
| Map a call instruction to an intrinsic ID. Libcalls which have equivalent intrinsics are treated as‐if they were intrinsics.
| xref:llvm/getKnowledgeForValue.adoc[`getKnowledgeForValue`]
| Return a valid Knowledge associated to the Value V if its Attribute kind is in AttrKinds and it matches the Filter.
| xref:llvm/getKnowledgeValidInContext.adoc[`getKnowledgeValidInContext`]
| Return a valid Knowledge associated to the Value V if its Attribute kind is in AttrKinds and the knowledge is suitable to be used in the context of CtxI.
| xref:llvm/getKnownAlignment.adoc[`getKnownAlignment`]
| Infer a known alignment for the specified pointer.
| xref:llvm/getLoadStoreAddressSpace.adoc[`getLoadStoreAddressSpace`]
| Return the address space of the pointer operand of load or store `I.`
| xref:llvm/getLoadStoreAlignment.adoc[`getLoadStoreAlignment`]
| Return the alignment of load or store instruction `I.`
| xref:llvm/getLoadStorePointerOperand-0b.adoc[`getLoadStorePointerOperand`]
| Return the pointer operand of a load or store, or null if `V` is neither.
| xref:llvm/getLoadStorePointerOperand-0d.adoc[`getLoadStorePointerOperand`]
| Return the pointer operand of a load or store, or null if `V` is neither.
| xref:llvm/getLoadStoreType.adoc[`getLoadStoreType`]
| Return the value type accessed by load or store instruction `I.`
| xref:llvm/getMemCacheHintMetadata.adoc[`getMemCacheHintMetadata`]
| Return the cache hint metadata node for a memory operand.
| xref:llvm/getMetadataToPropagate.adoc[`getMetadataToPropagate`]
| Collect metadata from `Inst` that can be preserved after vectorization.
| xref:llvm/getObjectSize.adoc[`getObjectSize`]
| Compute the size of the object pointed by Ptr.
| xref:llvm/getOrEnforceKnownAlignment.adoc[`getOrEnforceKnownAlignment`]
| Return a known alignment for a value, optionally raising it first.
| xref:llvm/getPointerOperand-012.adoc[`getPointerOperand`]
| Return the pointer operand of a load, store, or GEP, or null otherwise.
| xref:llvm/getPointerOperand-0c.adoc[`getPointerOperand`]
| Non‐const overload of getPointerOperand.
| xref:llvm/getReallocatedOperand.adoc[`getReallocatedOperand`]
| If this is a call to a realloc function, return the reallocated operand.
| xref:llvm/getSplatValue.adoc[`getSplatValue`]
| Get splat value if the input is a splat vector or return nullptr.
| xref:llvm/getStringFnAttrAsInt.adoc[`getStringFnAttrAsInt`]
| Parse a function string attribute on `CB` as a decimal integer.
| xref:llvm/getUnderlyingObject-0e.adoc[`getUnderlyingObject`]
| Strip GEP adjustments, pointer casts, and threadlocal.address from `V.`
| xref:llvm/getUnderlyingObject-0f.adoc[`getUnderlyingObject`]
| Non‐const overload of getUnderlyingObject.
| xref:llvm/getUnderlyingObjectAggressive.adoc[`getUnderlyingObjectAggressive`]
| Like getUnderlyingObject(), but will try harder to find a single underlying object. In particular, this function also looks through selects and phis.
| xref:llvm/getUnderlyingObjects.adoc[`getUnderlyingObjects`]
| This method is similar to getUnderlyingObject except that it can look through phi and select instructions and return multiple objects.
| xref:llvm/getUnderlyingObjectsForCodeGen.adoc[`getUnderlyingObjectsForCodeGen`]
| This is a wrapper around getUnderlyingObjects and adds support for basic ptrtoint+arithmetic+inttoptr sequences.
| xref:llvm/getValidBranchWeightMDNode.adoc[`getValidBranchWeightMDNode`]
| Get the valid branch weights metadata node
| xref:llvm/getValueProfDataFromInst.adoc[`getValueProfDataFromInst`]
| Extract value‐profile data annotated on instruction `Inst.`
| xref:llvm/getVectorIntrinsicIDForCall.adoc[`getVectorIntrinsicIDForCall`]
| Return the intrinsic ID mapped from a call, or not_intrinsic.
| xref:llvm/handleUnreachableTerminator.adoc[`handleUnreachableTerminator`]
| Replace instruction operands of an unreachable terminator with poison.
| xref:llvm/hasAssumption-04.adoc[`hasAssumption`]
| Return true if `CB` or the callee has the assumption `AssumptionStr` attached.
| xref:llvm/hasBranchWeightMD.adoc[`hasBranchWeightMD`]
| Checks if an instructions has Branch Weight Metadata
| xref:llvm/hasBranchWeightOrigin-0b.adoc[`hasBranchWeightOrigin`]
| Check if Branch Weight Metadata has an "expected" field from an llvm.expect* intrinsic
| xref:llvm/hasExplicitlyUnknownBranchWeights.adoc[`hasExplicitlyUnknownBranchWeights`]
| Check whether `I` has explicitly‐unknown branch‐weight metadata.
| xref:llvm/hasProfMD.adoc[`hasProfMD`]
| Checks if an Instruction has MD_prof Metadata
| xref:llvm/hasValidBranchWeightMD.adoc[`hasValidBranchWeightMD`]
| Checks if an instructions has valid Branch Weight Metadata
| xref:llvm/impliesPoison.adoc[`impliesPoison`]
| Return true if V is poison given that ValAssumedPoison is already poison.
| xref:llvm/intersectAccessGroups.adoc[`intersectAccessGroups`]
| Compute the intersection of access groups on two instructions.
| xref:llvm/invertCondition.adoc[`invertCondition`]
| Invert a boolean condition, reusing an existing inverted copy when possible.
| xref:llvm/isAllocLikeFn.adoc[`isAllocLikeFn`]
| Tests if a value is a call or invoke to a library function that allocates memory (either malloc, calloc, or strdup like).
| xref:llvm/isAllocationFn-07.adoc[`isAllocationFn`]
| Tests if a value is a call or invoke to a library function that allocates or reallocates memory (either malloc, calloc, realloc, or strdup like).
| xref:llvm/isAllocationFn-0bc.adoc[`isAllocationFn`]
| Tests if a value is a call or invoke to a library function that allocates or reallocates memory (either malloc, calloc, realloc, or strdup like).
| xref:llvm/isAssumeLikeIntrinsic.adoc[`isAssumeLikeIntrinsic`]
| Return true if it is an intrinsic that cannot be speculated but also cannot trap.
| xref:llvm/isBaseOfObject.adoc[`isBaseOfObject`]
| Return true if V is known to be the base of its memory object.
| xref:llvm/isBytewiseValue.adoc[`isBytewiseValue`]
| If the specified value can be set by repeating the same byte in memory, return the i8 value that it is represented with.
| xref:llvm/isCFGuardCall.adoc[`isCFGuardCall`]
| Return true if `CB` is a Control Flow Guard check or dispatch call.
| xref:llvm/isCheckForZeroAndMulWithOverflow-07.adoc[`isCheckForZeroAndMulWithOverflow`]
| Return true if `Op0` and `Op1` match a zero check with mul‐with‐overflow.
| xref:llvm/isCheckForZeroAndMulWithOverflow-0a.adoc[`isCheckForZeroAndMulWithOverflow`]
| Return true if `Op0` and `Op1` match a zero check with mul‐with‐overflow.
| xref:llvm/isConsecutiveAccess.adoc[`isConsecutiveAccess`]
| Returns true if the memory operations `A` and `B` are consecutive. This is a simple API that does not depend on the analysis pass.
| xref:llvm/isCriticalEdge-00.adoc[`isCriticalEdge`]
| Return true if the specified edge is a critical edge.
| xref:llvm/isCriticalEdge-0d.adoc[`isCriticalEdge`]
| Return true if the edge from `TI` to `Succ` is a critical edge.
| xref:llvm/isDereferenceableAndAlignedPointer-06.adoc[`isDereferenceableAndAlignedPointer`]
| Returns true if V is always a dereferenceable pointer with sufficient alignment.
| xref:llvm/isDereferenceableAndAlignedPointer-0a.adoc[`isDereferenceableAndAlignedPointer`]
| Returns true if V is always dereferenceable for Size bytes with sufficient alignment.
| xref:llvm/isDereferenceablePointer-01.adoc[`isDereferenceablePointer`]
| Equivalent to isDereferenceableAndAlignedPointer with an alignment of 1.
| xref:llvm/isDereferenceablePointer-0d.adoc[`isDereferenceablePointer`]
| Equivalent to isDereferenceableAndAlignedPointer with an alignment of 1.
| xref:llvm/isEscapeSource.adoc[`isEscapeSource`]
| Returns true if the pointer is one which would have been considered an escape by isNotCapturedBefore.
| xref:llvm/isGuaranteedNotToBePoison-04.adoc[`isGuaranteedNotToBePoison`]
| Iterator‐context overload of isGuaranteedNotToBePoison.
| xref:llvm/isGuaranteedNotToBePoison-08.adoc[`isGuaranteedNotToBePoison`]
| Returns true if V cannot be poison, but may be undef.
| xref:llvm/isGuaranteedNotToBeUndef-09.adoc[`isGuaranteedNotToBeUndef`]
| Returns true if V cannot be undef, but may be poison.
| xref:llvm/isGuaranteedNotToBeUndefOrPoison-05.adoc[`isGuaranteedNotToBeUndefOrPoison`]
| Return true if this function can prove that V does not have undef bits and is never poison.
| xref:llvm/isGuaranteedToExecuteForEveryIteration.adoc[`isGuaranteedToExecuteForEveryIteration`]
| Return true if this function can prove that the instruction I is executed for every iteration of the loop L.
| xref:llvm/isGuaranteedToTransferExecutionToSuccessor-06.adoc[`isGuaranteedToTransferExecutionToSuccessor`]
| Return true if instruction `I` always transfers execution to a successor.
| xref:llvm/isGuard.adoc[`isGuard`]
| Returns true iff `U` has semantics of a guard expressed in a form of call of llvm.experimental.guard intrinsic.
| xref:llvm/isGuardAsWidenableBranch.adoc[`isGuardAsWidenableBranch`]
| Returns true iff `U` has semantics of a guard expressed in a form of a widenable conditional branch to deopt block.
| xref:llvm/isIdentifiedFunctionLocal.adoc[`isIdentifiedFunctionLocal`]
| Return true if V is unambiguously identified at the function level.
| xref:llvm/isIdentifiedObject.adoc[`isIdentifiedObject`]
| Return true if this pointer refers to a distinct and identifiable object.
| xref:llvm/isImpliedByDomCondition-0f1.adoc[`isImpliedByDomCondition`]
| Return the boolean condition value in the context of the given instruction if it is known based on dominating conditions.
| xref:llvm/isImpliedCondition-0a.adoc[`isImpliedCondition`]
| Return whether a compare is implied true or false by `LHS,` if known.
| xref:llvm/isImpliedCondition-0c.adoc[`isImpliedCondition`]
| Return whether RHS is implied true or false by LHS, if known.
| xref:llvm/isInTailCallPosition.adoc[`isInTailCallPosition`]
| Test whether an instruction is in a position for tail‐call optimization.
| xref:llvm/isInstructionTriviallyDead.adoc[`isInstructionTriviallyDead`]
| Return true if an unused instruction is trivially dead.
| xref:llvm/isIntrinsicReturningPointerAliasingArgumentWithoutCapturing.adoc[`isIntrinsicReturningPointerAliasingArgumentWithoutCapturing`]
| Return true if `Call` is an intrinsic that returns a pointer aliasing an argument without capturing it otherwise.
| xref:llvm/isKnownIntegral.adoc[`isKnownIntegral`]
| Return true if the floating‐point value `V` is known to be an integer value.
| xref:llvm/isKnownInversion.adoc[`isKnownInversion`]
| Return true iff: 1. X is poison implies Y is poison. 2. X is true implies Y is false. 3. X is false implies Y is true. Otherwise, return false.
| xref:llvm/isKnownNegation.adoc[`isKnownNegation`]
| Return true if the two given values are negation.
| xref:llvm/isKnownNegative.adoc[`isKnownNegative`]
| Returns true if the given value is known be negative (i.e. non‐positive and non‐zero).
| xref:llvm/isKnownNeverInfOrNaN.adoc[`isKnownNeverInfOrNaN`]
| Return true if the floating‐point value can never contain a NaN or infinity.
| xref:llvm/isKnownNeverInfinity.adoc[`isKnownNeverInfinity`]
| Return true if the floating‐point scalar value is not an infinity or if the floating‐point vector value has no infinities.
| xref:llvm/isKnownNeverNaN.adoc[`isKnownNeverNaN`]
| Return true if the floating‐point scalar value is not a NaN or if the floating‐point vector value has no NaN elements.
| xref:llvm/isKnownNonEqual.adoc[`isKnownNonEqual`]
| Return true if the given values are known to be non‐equal when defined. Supports scalar integer types only.
| xref:llvm/isKnownNonNegative.adoc[`isKnownNonNegative`]
| Returns true if the give value is known to be non‐negative.
| xref:llvm/isKnownNonZero.adoc[`isKnownNonZero`]
| Return true if the given value is known to be non‐zero when defined.
| xref:llvm/isKnownPositive.adoc[`isKnownPositive`]
| Returns true if the given value is known be positive (i.e. non‐negative and non‐zero).
| xref:llvm/isKnownToBeAPowerOfTwo-08.adoc[`isKnownToBeAPowerOfTwo`]
| Return true if the given value is known to have exactly one bit set when defined.
| xref:llvm/isKnownToBeAPowerOfTwo-09.adoc[`isKnownToBeAPowerOfTwo`]
| Return true if `V` is known to be a power of two when defined.
| xref:llvm/isLegalToPromote.adoc[`isLegalToPromote`]
| Return true if the given indirect call site can be made to call `Callee.`
| xref:llvm/isMathLibCallNoop.adoc[`isMathLibCallNoop`]
| Check whether the given call has no side‐effects. Specifically checks for math routimes which sometimes set errno.
| xref:llvm/isNoAliasCall.adoc[`isNoAliasCall`]
| Return true if this pointer is returned by a noalias function.
| xref:llvm/isNotCrossLaneOperation.adoc[`isNotCrossLaneOperation`]
| Return true if the instruction doesn't potentially cross vector lanes.
| xref:llvm/isNotVisibleOnUnwind.adoc[`isNotVisibleOnUnwind`]
| Return true if Object memory is not visible after an unwind.
| xref:llvm/isOnlyUsedInZeroComparison.adoc[`isOnlyUsedInZeroComparison`]
| Return true if `CxtI` is only used in comparisons against zero.
| xref:llvm/isOnlyUsedInZeroEqualityComparison.adoc[`isOnlyUsedInZeroEqualityComparison`]
| Return true if `CxtI` is only used in equality comparisons against zero.
| xref:llvm/isPotentiallyReachable-0e.adoc[`isPotentiallyReachable`]
| Determine whether instruction 'To' is reachable from 'From', without passing through any blocks in ExclusionSet, returning true if uncertain.
| xref:llvm/isReachedBefore.adoc[`isReachedBefore`]
| Return true if `I0` is reached before `I1` in the control flow.
| xref:llvm/isRemovableAlloc.adoc[`isRemovableAlloc`]
| Return true if this is a call to a removable allocation function.
| xref:llvm/isSafeToLoadUnconditionally-07.adoc[`isSafeToLoadUnconditionally`]
| Return true if we know that executing a load from this value cannot trap.
| xref:llvm/isSafeToLoadUnconditionally-0f.adoc[`isSafeToLoadUnconditionally`]
| Return true if we know that executing a load from this value cannot trap.
| xref:llvm/isSafeToMoveBefore-08.adoc[`isSafeToMoveBefore`]
| Return true if `I` can be safely moved before `InsertPoint.`
| xref:llvm/isSafeToSpeculativelyExecute-0a.adoc[`isSafeToSpeculativelyExecute`]
| Return true if the instruction does not have any effects besides calculating the result and does not have undefined behavior.
| xref:llvm/isSafeToSpeculativelyExecute-0f.adoc[`isSafeToSpeculativelyExecute`]
| Iterator‐context overload of isSafeToSpeculativelyExecute.
| xref:llvm/isSafeToSpeculativelyExecuteWithVariableReplaced.adoc[`isSafeToSpeculativelyExecuteWithVariableReplaced`]
| Don't use information from its non‐constant operands. This helper is used when its operands are going to be replaced.
| xref:llvm/isSplatValue.adoc[`isSplatValue`]
| Return true if each element of `V` is poisoned or equal to the others.
| xref:llvm/isValidAssumeForContext-037.adoc[`isValidAssumeForContext`]
| Return true if assume `I` is valid for the context in simplify query `Q.`
| xref:llvm/isValidAssumeForContext-03c.adoc[`isValidAssumeForContext`]
| Return true if assume `I` is valid to use at context instruction `CxtI.`
| xref:llvm/isWidenableBranch.adoc[`isWidenableBranch`]
| Returns true iff `U` is a widenable branch (that is, extractWidenableCondition returns widenable condition).
| xref:llvm/isWidenableCondition.adoc[`isWidenableCondition`]
| Returns true iff `V` has semantics of llvm.experimental.widenable.condition call.
| xref:llvm/isWritableObject.adoc[`isWritableObject`]
| Return true if Object is writable without trapping.
| xref:llvm/lowerObjectSizeCall-0a9.adoc[`lowerObjectSizeCall`]
| Try to turn a call to @llvm.objectsize into an integer value.
| xref:llvm/lowerObjectSizeCall-0ad.adoc[`lowerObjectSizeCall`]
| Try to turn a call to @llvm.objectsize into an integer value.
| xref:llvm/maskContainsAllOneOrUndef.adoc[`maskContainsAllOneOrUndef`]
| Return true if any lane of an i1 mask is known true or undef.
| xref:llvm/matchSelectPattern-09.adoc[`matchSelectPattern`]
| Const overload of matchSelectPattern.
| xref:llvm/matchSelectPattern-0c.adoc[`matchSelectPattern`]
| Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind and providing the out parameter results if we successfully match.
| xref:llvm/matchSimpleBinaryIntrinsicRecurrence.adoc[`matchSimpleBinaryIntrinsicRecurrence`]
| Match a simple binary‐intrinsic value‐accumulating recurrence.
| xref:llvm/matchSimpleTernaryIntrinsicRecurrence.adoc[`matchSimpleTernaryIntrinsicRecurrence`]
| Match a simple ternary‐intrinsic value‐accumulating recurrence.
| xref:llvm/mayHaveMemprofSummary.adoc[`mayHaveMemprofSummary`]
| Returns true if the instruction could have memprof metadata, used to ensure consistency between summary analysis and the ThinLTO backend processing.
| xref:llvm/mayHaveNonDefUseDependency.adoc[`mayHaveNonDefUseDependency`]
| Returns true if the result or effects of the given instructions `I` depend values not reachable through the def use graph.
| xref:llvm/maybeMarkSanitizerLibraryCallNoBuiltin.adoc[`maybeMarkSanitizerLibraryCallNoBuiltin`]
| Mark known string library calls with NoBuiltin for sanitizer interception.
| xref:llvm/mustExecuteUBIfPoisonOnPathTo.adoc[`mustExecuteUBIfPoisonOnPathTo`]
| Return true if poison from Root would force UB on the path to OnPathTo.
| xref:llvm/mustTriggerUB.adoc[`mustTriggerUB`]
| Return true if `I` must trigger UB when any of `KnownPoison` is poison.
| xref:llvm/onlyUsedByLifetimeMarkers.adoc[`onlyUsedByLifetimeMarkers`]
| Return true if the only users of this pointer are lifetime markers.
| xref:llvm/onlyUsedByLifetimeMarkersOrDroppableInsts.adoc[`onlyUsedByLifetimeMarkersOrDroppableInsts`]
| Return true if the only users of this pointer are lifetime markers or droppable instructions.
| xref:llvm/parseWidenableBranch-05.adoc[`parseWidenableBranch`]
| Parses a widenable branch and returns Uses so they can be modified.
| xref:llvm/parseWidenableBranch-0e.adoc[`parseWidenableBranch`]
| Parses a widenable branch and returns its condition, widenable condition, and successor blocks.
| xref:llvm/parseWidenableGuard.adoc[`parseWidenableGuard`]
| Collects the individual checks from a widenable guard's condition.
| xref:llvm/patchReplacementInstruction.adoc[`patchReplacementInstruction`]
| Relax a replacement so it is no more restrictive than the original.
| xref:llvm/possiblyDemandedEltsInMask.adoc[`possiblyDemandedEltsInMask`]
| Return an APInt of active lanes for a `<Y x i1>` mask.
| xref:llvm/programUndefinedIfPoison.adoc[`programUndefinedIfPoison`]
| Return true if a poison result from `Inst` implies program undefined behavior.
| xref:llvm/programUndefinedIfUndefOrPoison.adoc[`programUndefinedIfUndefOrPoison`]
| Return true if this function can prove that if Inst is executed and yields a poison value or undef bits, then that will trigger undefined behavior.
| xref:llvm/promoteCall.adoc[`promoteCall`]
| Promote the given indirect call site to unconditionally call `Callee.`
| xref:llvm/promoteCallWithIfThenElse-0c.adoc[`promoteCallWithIfThenElse`]
| Promote the given indirect call site to conditionally call `Callee.` The promoted direct call instruction is predicated on `CB.getCalledOperand() == Callee`.
| xref:llvm/promoteCallWithIfThenElse-0e.adoc[`promoteCallWithIfThenElse`]
| Promote an indirect call conditionally while updating contextual profiles.
| xref:llvm/promoteCallWithVTableCmp.adoc[`promoteCallWithVTableCmp`]
| This is similar to `promoteCallWithIfThenElse` except that the condition to promote a virtual call is that `VPtr` is the same as any of `AddressPoints.`
| xref:llvm/propagateIRFlags.adoc[`propagateIRFlags`]
| Intersect IR flags from scalar ops `VL` onto vector op `I.`
| xref:llvm/propagateMetadata.adoc[`propagateMetadata`]
| Propagate common metadata from `VL` onto instruction `I.`
| xref:llvm/recognizeBSwapOrBitReverseIdiom.adoc[`recognizeBSwapOrBitReverseIdiom`]
| Match a bswap or bitreverse idiom and replace it with an intrinsic.
| xref:llvm/replaceAllDbgUsesWith.adoc[`replaceAllDbgUsesWith`]
| Retarget or salvage debug users when replacing a value that will be deleted.
| xref:llvm/replaceAndRecursivelySimplify.adoc[`replaceAndRecursivelySimplify`]
| Replace all uses of 'I' with 'SimpleV' and simplify the uses recursively.
| xref:llvm/replaceDbgDeclare.adoc[`replaceDbgDeclare`]
| Replace a dbg.declare when its address is replaced.
| xref:llvm/replaceDominatedUsesWith-03.adoc[`replaceDominatedUsesWith`]
| Replace uses dominated by an edge with another value.
| xref:llvm/replaceDominatedUsesWith-0d.adoc[`replaceDominatedUsesWith`]
| Replace uses dominated by an instruction with another value.
| xref:llvm/replaceDominatedUsesWith-0f.adoc[`replaceDominatedUsesWith`]
| Replace uses dominated by a block's end with another value.
| xref:llvm/replaceDominatedUsesWithIf-01.adoc[`replaceDominatedUsesWithIf`]
| Conditionally replace uses dominated by an instruction with another value.
| xref:llvm/replaceDominatedUsesWithIf-0d.adoc[`replaceDominatedUsesWithIf`]
| Conditionally replace uses dominated by a block's end with another value.
| xref:llvm/replaceDominatedUsesWithIf-0e.adoc[`replaceDominatedUsesWithIf`]
| Conditionally replace uses dominated by an edge with another value.
| xref:llvm/replaceNonLocalUsesWith.adoc[`replaceNonLocalUsesWith`]
| Replace non‐local uses of an instruction with another value.
| xref:llvm/salvageDebugInfo-07.adoc[`salvageDebugInfo`]
| Salvage debug records that use an instruction before it is deleted.
| xref:llvm/salvageDebugInfoForDbgValues.adoc[`salvageDebugInfoForDbgValues`]
| Salvage a specific set of debug records that use an instruction.
| xref:llvm/salvageDebugInfoImpl.adoc[`salvageDebugInfoImpl`]
| Append an instruction's effect to a salvaged DIExpression operand list.
| xref:llvm/salvageKnowledge.adoc[`salvageKnowledge`]
| Insert an llvm.assume before an instruction to salvage its derived knowledge.
| xref:llvm/scaleProfData.adoc[`scaleProfData`]
| Scaling the profile data attached to 'I' using the ratio of S/T.
| xref:llvm/setAtomicSyncScopeID.adoc[`setAtomicSyncScopeID`]
| Set the sync scope of atomic instruction `I.`
| xref:llvm/setBranchWeights.adoc[`setBranchWeights`]
| Create a new `branch_weights` metadata node and add or overwrite a `prof` metadata reference to instruction `I`.
| xref:llvm/setExplicitlyUnknownBranchWeights.adoc[`setExplicitlyUnknownBranchWeights`]
| Specify that this terminator's branch weights are unknown at compile time.
| xref:llvm/setExplicitlyUnknownBranchWeightsIfProfiled.adoc[`setExplicitlyUnknownBranchWeightsIfProfiled`]
| Set unknown branch weights only if the parent function has an entry count.
| xref:llvm/setFittedBranchWeights.adoc[`setFittedBranchWeights`]
| Variant of `setBranchWeights` where the `Weights` will be fit first to uint32_t by shifting right.
| xref:llvm/setInlineRemark.adoc[`setInlineRemark`]
| Set the inline‐remark attribute on call site `CB.`
| xref:llvm/setLoadStoreAlignment.adoc[`setLoadStoreAlignment`]
| Set the alignment of load or store instruction `I.`
| xref:llvm/setProbeDistributionFactor.adoc[`setProbeDistributionFactor`]
| Set the distribution factor of the pseudo probe on `Inst.`
| xref:llvm/setProfMetadata.adoc[`setProfMetadata`]
| Attach branch‐weight profile metadata to a terminator or select.
| xref:llvm/setUnwindEdgeTo.adoc[`setUnwindEdgeTo`]
| Sets the unwind edge of an instruction to a particular successor.
| xref:llvm/shouldInline.adoc[`shouldInline`]
| Return the inline cost when the inliner should attempt `CB,` else nullopt.
| xref:llvm/simplifyAShrInst.adoc[`simplifyAShrInst`]
| Given operands for a AShr, fold the result or return nulll.
| xref:llvm/simplifyAddInst.adoc[`simplifyAddInst`]
| Given operands for an Add, fold the result or return null.
| xref:llvm/simplifyAndInst.adoc[`simplifyAndInst`]
| Given operands for an And, fold the result or return null.
| xref:llvm/simplifyCall.adoc[`simplifyCall`]
| Given a callsite, callee, and arguments, fold the result or return null.
| xref:llvm/simplifyConstrainedFPCall.adoc[`simplifyConstrainedFPCall`]
| Given a constrained FP intrinsic call, tries to compute its simplified version.
| xref:llvm/simplifyExtractElementInst.adoc[`simplifyExtractElementInst`]
| Given operands for an ExtractElementInst, fold the result or return null.
| xref:llvm/simplifyExtractValueInst.adoc[`simplifyExtractValueInst`]
| Given operands for an ExtractValueInst, fold the result or return null.
| xref:llvm/simplifyFAddInst.adoc[`simplifyFAddInst`]
| Given operands for an FAdd, fold the result or return null.
| xref:llvm/simplifyFDivInst.adoc[`simplifyFDivInst`]
| Given operands for an FDiv, fold the result or return null.
| xref:llvm/simplifyFMAFMul.adoc[`simplifyFMAFMul`]
| Given operands for the multiplication of a FMA, fold the result or return null.
| xref:llvm/simplifyFMulInst.adoc[`simplifyFMulInst`]
| Given operands for an FMul, fold the result or return null.
| xref:llvm/simplifyFNegInst.adoc[`simplifyFNegInst`]
| Given operand for an FNeg, fold the result or return null.
| xref:llvm/simplifyFRemInst.adoc[`simplifyFRemInst`]
| Given operands for an FRem, fold the result or return null.
| xref:llvm/simplifyFSubInst.adoc[`simplifyFSubInst`]
| Given operands for an FSub, fold the result or return null.
| xref:llvm/simplifyFreezeInst.adoc[`simplifyFreezeInst`]
| Given an operand for a Freeze, see if we can fold the result.
| xref:llvm/simplifyInsertElementInst.adoc[`simplifyInsertElementInst`]
| Given operands for an InsertElement, fold the result or return null.
| xref:llvm/simplifyInsertValueInst.adoc[`simplifyInsertValueInst`]
| Given operands for an InsertValueInst, fold the result or return null.
| xref:llvm/simplifyInstruction.adoc[`simplifyInstruction`]
| See if we can compute a simplified version of this instruction.
| xref:llvm/simplifyInstructionWithOperands.adoc[`simplifyInstructionWithOperands`]
| Like `simplifyInstruction` but the operands of `I` are replaced with `NewOps.`
| xref:llvm/simplifyLShrInst.adoc[`simplifyLShrInst`]
| Given operands for a LShr, fold the result or return null.
| xref:llvm/simplifyMulInst.adoc[`simplifyMulInst`]
| Given operands for a Mul, fold the result or return null.
| xref:llvm/simplifyOrInst.adoc[`simplifyOrInst`]
| Given operands for an Or, fold the result or return null.
| xref:llvm/simplifySDivInst.adoc[`simplifySDivInst`]
| Given operands for an SDiv, fold the result or return null.
| xref:llvm/simplifySRemInst.adoc[`simplifySRemInst`]
| Given operands for an SRem, fold the result or return null.
| xref:llvm/simplifySelectInst.adoc[`simplifySelectInst`]
| Given operands for a SelectInst, fold the result or return null.
| xref:llvm/simplifyShlInst.adoc[`simplifyShlInst`]
| Given operands for a Shl, fold the result or return null.
| xref:llvm/simplifyShuffleVectorInst.adoc[`simplifyShuffleVectorInst`]
| Given operands for a ShuffleVectorInst, fold the result or return null.
| xref:llvm/simplifySubInst.adoc[`simplifySubInst`]
| Given operands for a Sub, fold the result or return null.
| xref:llvm/simplifyUDivInst.adoc[`simplifyUDivInst`]
| Given operands for a UDiv, fold the result or return null.
| xref:llvm/simplifyURemInst.adoc[`simplifyURemInst`]
| Given operands for a URem, fold the result or return null.
| xref:llvm/simplifyWithOpReplaced.adoc[`simplifyWithOpReplaced`]
| See if V simplifies when its operand Op is replaced with RepOp.
| xref:llvm/simplifyXorInst.adoc[`simplifyXorInst`]
| Given operands for an Xor, fold the result or return null.
| xref:llvm/stripNullTest-0b.adoc[`stripNullTest`]
| Const overload of stripNullTest.
| xref:llvm/stripNullTest-0d.adoc[`stripNullTest`]
| Returns the inner value X if the expression has the form f(X) where f(X) == 0 if and only if X == 0, otherwise returns nullptr.
| xref:llvm/succ_begin-087.adoc[`succ_begin`]
| Return a const iterator to the first successor of terminator `I.`
| xref:llvm/succ_begin-08c.adoc[`succ_begin`]
| Return an iterator to the first successor of terminator `I.`
| xref:llvm/succ_empty-0e.adoc[`succ_empty`]
| Return true if `I's` terminator has no successor blocks.
| xref:llvm/succ_end-0e.adoc[`succ_end`]
| Return the end iterator for successors of terminator `I.`
| xref:llvm/succ_end-0f.adoc[`succ_end`]
| Return a const end iterator for successors of terminator `I.`
| xref:llvm/succ_size-09.adoc[`succ_size`]
| Return the number of successors of terminator `I.`
| xref:llvm/successors-0e.adoc[`successors`]
| Return a const range of successor basic blocks of terminator `I.`
| xref:llvm/successors-0f.adoc[`successors`]
| Return a range of successor basic blocks of terminator `I.`
| xref:llvm/tryEnforceAlignment.adoc[`tryEnforceAlignment`]
| Try to raise a controlled object's alignment to a preferred value.
| xref:llvm/tryPromoteCall.adoc[`tryPromoteCall`]
| Try to promote (devirtualize) a virtual call on an Alloca. Return true on success.
| xref:llvm/updateLoopMetadataDebugLocations.adoc[`updateLoopMetadataDebugLocations`]
| Update debug locations in any MD_loop metadata attached to `I.`
| xref:llvm/versionCallSite.adoc[`versionCallSite`]
| Predicate and clone the given call site.
| xref:llvm/willNotFreeBetween.adoc[`willNotFreeBetween`]
| Returns true, if no instruction between `Assume` and `CtxI` may free (including through synchronization).
| xref:llvm/wouldInstructionBeTriviallyDead.adoc[`wouldInstructionBeTriviallyDead`]
| Return true if an instruction would be trivially dead with no uses.
| xref:llvm/wrap-04.adoc[`wrap`]
| Wrap an array of `Value` pointers as opaque `LLVMValueRef` values.
| xref:llvm/wrap-076.adoc[`wrap`]
| Convert a `Value` pointer to an opaque `LLVMValueRef.`
| xref:llvm/AA/getWithType.adoc[`AA::getWithType`]
| Try to convert `V` to type `Ty` without introducing new instructions.
| xref:llvm/AA/isValidInScope.adoc[`AA::isValidInScope`]
| Return true if `V` is a valid value in `Scope,` that is a constant or an instruction/argument of `Scope.`
| xref:llvm/PatternMatch/m_AnyIntrinsic-01.adoc[`PatternMatch::m_AnyIntrinsic`]
| Match any intrinsic call, capturing it if we match.
| xref:llvm/PatternMatch/m_AnyIntrinsic-03.adoc[`PatternMatch::m_AnyIntrinsic`]
| Match any const intrinsic call, capturing it if we match.
| xref:llvm/PatternMatch/m_Deferred-0a.adoc[`PatternMatch::m_Deferred`]
| Match a deferred const Value* determined later in the same match expression.
| xref:llvm/PatternMatch/m_Deferred-0c.adoc[`PatternMatch::m_Deferred`]
| Match a deferred Value* determined later in the same match expression.
| xref:llvm/PatternMatch/m_Instruction-04.adoc[`PatternMatch::m_Instruction`]
| Match an instruction, capturing it if we match.
| xref:llvm/PatternMatch/m_Instruction-05.adoc[`PatternMatch::m_Instruction`]
| Match a const instruction, capturing it if we match.
| xref:llvm/PatternMatch/m_Instruction-06.adoc[`PatternMatch::m_Instruction`]
| Match against the nested pattern, and capture the instruction if we match.
| xref:llvm/PatternMatch/m_Instruction-0b.adoc[`PatternMatch::m_Instruction`]
| Match against the nested pattern, and capture the instruction if we match.
| xref:llvm/PatternMatch/m_Specific.adoc[`PatternMatch::m_Specific`]
| Match if we have a specific specified value.
| xref:llvm/PatternMatch/m_Value-00.adoc[`PatternMatch::m_Value`]
| Match against the nested pattern, and capture the value if we match.
| xref:llvm/PatternMatch/m_Value-08.adoc[`PatternMatch::m_Value`]
| Match a const value, capturing it if we match.
| xref:llvm/PatternMatch/m_Value-0ab.adoc[`PatternMatch::m_Value`]
| Match against the nested pattern, and capture the value if we match.
| xref:llvm/PatternMatch/m_Value-0ae.adoc[`PatternMatch::m_Value`]
| Match a value, capturing it if we match.
| xref:llvm/VFABI/getVectorVariantNames.adoc[`VFABI::getVectorVariantNames`]
| Populate VariantMappings with Vector Function ABI variant names for CI.
| xref:llvm/VFABI/setVectorVariantNames.adoc[`VFABI::setVectorVariantNames`]
| Overwrite the Vector Function ABI variants attribute with the names provide in `VariantMappings.`
| xref:llvm/VNCoercion/canCoerceMustAliasedValueToLoad.adoc[`VNCoercion::canCoerceMustAliasedValueToLoad`]
| Return true if CoerceAvailableValueToLoadType would succeed if it was called.
| xref:llvm/VNCoercion/coerceAvailableValueToLoadType.adoc[`VNCoercion::coerceAvailableValueToLoadType`]
| Try to coerce a stored value to a must‐aliased load of a different type.
| xref:llvm/VNCoercion/getValueForLoad.adoc[`VNCoercion::getValueForLoad`]
| Extract bits for a load from a clobbering store or load at a given offset.
| xref:llvm/at/deleteAssignmentMarkers.adoc[`at::deleteAssignmentMarkers`]
| Delete the llvm.dbg.assign intrinsics linked to `Inst.`
| xref:llvm/at/getDVRAssignmentMarkers.adoc[`at::getDVRAssignmentMarkers`]
| Return a range of dbg_assign records for which `Inst` performs the assignment they encode.
| xref:llvm/coro/isTriviallyMaterializable.adoc[`coro::isTriviallyMaterializable`]
| Return true if `I` is trivially rematerializable.
| xref:llvm/dxil/getResourceNameFromBindingCall.adoc[`dxil::getResourceNameFromBindingCall`]
| Return the resource name from a handle‐from‐binding call.
| xref:llvm/instrumentor/evaluateFilter.adoc[`instrumentor::evaluateFilter`]
| Evaluate a filter expression for an instrumentation opportunity.
| xref:llvm/memprof/addAmbiguousAttribute.adoc[`memprof::addAmbiguousAttribute`]
| Adds an "ambiguous" memprof attribute to call with a matched allocation profile but that we haven't yet been able to disambiguate.
| xref:llvm/memprof/removeAnyExistingAmbiguousAttribute.adoc[`memprof::removeAnyExistingAmbiguousAttribute`]
| Removes any existing "ambiguous" memprof attribute. Called before we apply a specific allocation type such as "cold", "notcold", or "hot".
| xref:llvm/memtag/getUntagLocationIfFunctionExit.adoc[`memtag::getUntagLocationIfFunctionExit`]
| Return the instruction at which stack untagging should run for a function exit, or null if `Inst` is not such an exit.
| xref:llvm/misexpect/checkBackendInstrumentation.adoc[`misexpect::checkBackendInstrumentation`]
| Check backend instrumentation against llvm.expect thresholds.
| xref:llvm/misexpect/checkExpectAnnotations.adoc[`misexpect::checkExpectAnnotations`]
| Check expect annotations against PGO counters for frontend or backend use.
| xref:llvm/misexpect/checkFrontendInstrumentation.adoc[`misexpect::checkFrontendInstrumentation`]
| Check frontend instrumentation against llvm.expect thresholds.
| xref:llvm/misexpect/verifyMisExpect.adoc[`misexpect::verifyMisExpect`]
| veryifyMisExpect ‐ compares RealWeights to the thresholds used for llvm.expect and warns if the PGO counters are outside of the expected range.
| xref:llvm/objcarc/GetARCInstKind.adoc[`objcarc::GetARCInstKind`]
| Map V to its ARCInstKind equivalence class.
| xref:llvm/objcarc/GetArgRCIdentityRoot.adoc[`objcarc::GetArgRCIdentityRoot`]
| Assuming the given instruction is one of the special calls such as objc_retain or objc_release, return the RCIdentity root of the argument of the call.
| xref:llvm/objcarc/GetBasicARCInstKind.adoc[`objcarc::GetBasicARCInstKind`]
| Determine which objc runtime call instruction class V belongs to.
| xref:llvm/objcarc/GetCallSiteClass.adoc[`objcarc::GetCallSiteClass`]
| Helper for GetARCInstKind. Determines what kind of construct CS is.
| xref:llvm/objcarc/GetRCIdentityRoot-05.adoc[`objcarc::GetRCIdentityRoot`]
| Return the RCIdentity root of value `V.`
| xref:llvm/objcarc/GetRCIdentityRoot-07.adoc[`objcarc::GetRCIdentityRoot`]
| Return the non‐const RCIdentity root of value `V.`
| xref:llvm/objcarc/GetUnderlyingObjCPtr.adoc[`objcarc::GetUnderlyingObjCPtr`]
| Return the underlying ObjC object pointer for `V.`
| xref:llvm/objcarc/GetUnderlyingObjCPtrCached.adoc[`objcarc::GetUnderlyingObjCPtrCached`]
| A wrapper for GetUnderlyingObjCPtr used for results memoization.
| xref:llvm/objcarc/IsNoopInstruction.adoc[`objcarc::IsNoopInstruction`]
| Return true if `I` is a bitcast or a zero‐index GEP.
| xref:llvm/objcarc/IsNullOrUndef.adoc[`objcarc::IsNullOrUndef`]
| Return true if `V` is a null pointer constant or undef.
| xref:llvm/objcarc/IsObjCIdentifiedObject.adoc[`objcarc::IsObjCIdentifiedObject`]
| Return true if this value refers to a distinct and identifiable object.
| xref:llvm/objcarc/IsPotentialRetainableObjPtr-06.adoc[`objcarc::IsPotentialRetainableObjPtr`]
| Test whether `Op` may be a retainable object pointer using alias analysis.
| xref:llvm/objcarc/IsPotentialRetainableObjPtr-0f.adoc[`objcarc::IsPotentialRetainableObjPtr`]
| Test whether the given value is possible a retainable object pointer.
| xref:llvm/objcarc/attachedCallOpBundleNeedsMarker.adoc[`objcarc::attachedCallOpBundleNeedsMarker`]
| Return whether clang_arc_attachedcall should be emitted with a marker.
| xref:llvm/objcarc/getAttachedARCFunction.adoc[`objcarc::getAttachedARCFunction`]
| Return the ARC runtime function from a clang_arc_attachedcall bundle.
| xref:llvm/objcarc/getAttachedARCFunctionKind.adoc[`objcarc::getAttachedARCFunctionKind`]
| Return the ARCInstKind of the function on clang_arc_attachedcall.
| xref:llvm/objcarc/hasAttachedCallOpBundle.adoc[`objcarc::hasAttachedCallOpBundle`]
| Return true if `CB` has a clang_arc_attachedcall operand bundle.
| xref:llvm/pgo/promoteIndirectCall.adoc[`pgo::promoteIndirectCall`]
| Promote an indirect call or invoke `CB` to a conditional direct call to `F.`
|===


[.small]#Created with https://www.mrdocs.com[MrDocs]#