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

Instruction that casts a pointer to a non‐capturing address integer.

== Synopsis

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

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
class PtrToAddrInst
    : public xref:llvm/CastInst.adoc[CastInst]
----

== Base Classes

[cols="1,4"]
|===
| Name| Description
| `xref:llvm/CastInst.adoc[CastInst]`
| Base class of casting instructions.
|===

== Types

[cols="1,4"]
|===
| Name| Description
| xref:llvm/Instruction/const_succ_iterator.adoc[`const_succ_iterator`] 
| The const version of `succ_iterator`.
| xref:llvm/User/const_value_op_iterator.adoc[`const_value_op_iterator`] 
| Const iterator for directly iterating over the operand Values.
| xref:llvm/Instruction/succ_iterator.adoc[`succ_iterator`] 
| Iterator type that casts an operand to a basic block.
| xref:llvm/User/value_op_iterator.adoc[`value_op_iterator`] 
| Iterator for directly iterating over the operand Values.
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:llvm/Instruction/InstListType.adoc[`InstListType`] 
| Intrusive instruction list type used by BasicBlock.
| xref:llvm/User/const_op_iterator.adoc[`const_op_iterator`] 
| Const iterator over this user's operand `Use` objects.
| xref:llvm/User/const_op_range.adoc[`const_op_range`] 
| Range of const operand `Use` iterators.
| xref:llvm/Value/const_use_iterator.adoc[`const_use_iterator`] 
| Const iterator over this value's uses.
| xref:llvm/Value/const_user_iterator.adoc[`const_user_iterator`] 
| Const iterator over this value's users.
| xref:llvm/User/op_iterator.adoc[`op_iterator`] 
| Iterator over this user's operand `Use` objects.
| xref:llvm/User/op_range.adoc[`op_range`] 
| Range of mutable operand `Use` iterators.
| xref:llvm/Value/use_iterator.adoc[`use_iterator`] 
| Iterator over this value's uses.
| xref:llvm/Value/user_iterator.adoc[`user_iterator`] 
| Iterator over this value's users.
|===


== Enums

[cols="1,4"]
|===
| Name| Description
| xref:llvm/Instruction/BinaryOps.adoc[`BinaryOps`] 
| Opcodes for binary operators (arithmetic, shifts, and bitwise logic).
| xref:llvm/Instruction/CastOps.adoc[`CastOps`] 
| Opcodes for cast instructions (trunc, zext, bitcast, addrspacecast, etc.).
| xref:llvm/Instruction/FuncletPadOps.adoc[`FuncletPadOps`] 
| Opcodes for funclet pad instructions (cleanuppad, catchpad).
| xref:llvm/Instruction/MemoryOps.adoc[`MemoryOps`] 
| Opcodes for memory instructions (alloca, load, store, GEP, atomics, etc.).
| xref:llvm/Instruction/OperationEquivalenceFlags.adoc[`OperationEquivalenceFlags`] 
| When checking for operation equivalence (using isSameOperationAs) it is sometimes useful to ignore certain attributes.
| xref:llvm/Instruction/OtherOps.adoc[`OtherOps`] 
| Opcodes for other non‐terminating instructions (cmp, phi, call, select, etc.).
| xref:llvm/Instruction/TermOps.adoc[`TermOps`] 
| Opcodes that terminate a basic block (return, branch, switch, etc.).
| xref:llvm/Instruction/UnaryOps.adoc[`UnaryOps`] 
| Opcodes for unary instructions (e.g. fneg).
| xref:llvm/Value/ValueTy.adoc[`ValueTy`] 
| Concrete subclass of this.
|===


== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/PtrToAddrInst/2constructor.adoc[`PtrToAddrInst`]         [.small]#[constructor]#
| Cast pointer `S` to address integer type `Ty` and optionally insert before `InsertBefore.`
| xref:llvm/Instruction/operator_assign-0c.adoc[`operator=`] 
| Assignment operators
| xref:llvm/Value/DoPHITranslation-07.adoc[`DoPHITranslation`] 
| `DoPHITranslation` overloads
| xref:llvm/Instruction/addAnnotationMetadata-078.adoc[`addAnnotationMetadata`] 
| `addAnnotationMetadata` overloads
| xref:llvm/Value/addUse.adoc[`addUse`] 
| This method should only be used by the Use class.
| xref:llvm/Instruction/adoptDbgRecords.adoc[`adoptDbgRecords`] 
| Transfer any DbgRecords on the position `It` onto this instruction.
| xref:llvm/Instruction/andIRFlags.adoc[`andIRFlags`] 
| Intersect wrapping, exact, and fast‐math flags of `V` with this instruction.
| xref:llvm/Instruction/applyMergedLocation.adoc[`applyMergedLocation`] 
| Merge two debug locations and apply the result to this instruction.
| xref:llvm/Value/assertModuleIsMaterialized.adoc[`assertModuleIsMaterialized`] 
| Assert in debug builds that modules containing this value are materialized.
| xref:llvm/Value/assertModuleIsMaterializedImpl.adoc[`assertModuleIsMaterializedImpl`] 
| Assert that every module containing this value is fully materialized.
| xref:llvm/Value/canBeFreed.adoc[`canBeFreed`] 
| Return true if this pointer's memory may be freed in its defining scope.
| xref:llvm/Instruction/clone.adoc[`clone`] 
| Create a copy of this instruction that is identical except it has no parent and no name.
| xref:llvm/Instruction/cloneDebugInfoFrom.adoc[`cloneDebugInfoFrom`] 
| Clone any debug‐info attached to `From` onto this instruction.
| xref:llvm/Instruction/comesBefore.adoc[`comesBefore`] 
| Return true if this instruction comes before `Other` in the same block.
| xref:llvm/Instruction/copyFastMathFlags-0f.adoc[`copyFastMathFlags`] 
| `copyFastMathFlags` overloads
| xref:llvm/Instruction/copyIRFlags.adoc[`copyIRFlags`] 
| Copy supported exact, fast‐math, and optionally wrapping flags from `V.`
| xref:llvm/Instruction/copyMetadata.adoc[`copyMetadata`] 
| Copy metadata from `SrcInst` onto this instruction.
| xref:llvm/Instruction/copyProfileAndDebugMetadata.adoc[`copyProfileAndDebugMetadata`] 
| Copy debug, profile, and memprof metadata from `SrcInst.`
| xref:llvm/Value/deleteValue.adoc[`deleteValue`] 
| Delete a pointer to a generic Value.
| xref:llvm/User/dropAllReferences.adoc[`dropAllReferences`] 
| Drop all references to operands.
| xref:llvm/Instruction/dropDbgRecords.adoc[`dropDbgRecords`] 
| Erase any DbgRecords attached to this instruction.
| xref:llvm/Value/dropDroppableUses.adoc[`dropDroppableUses`] 
| Remove every uses that can safely be removed.
| xref:llvm/Value/dropDroppableUsesIn.adoc[`dropDroppableUsesIn`] 
| Remove every use of this value in `User` that can safely be removed.
| xref:llvm/Instruction/dropLocation.adoc[`dropLocation`] 
| Drop the instruction's debug location.
| xref:llvm/Instruction/dropOneDbgRecord.adoc[`dropOneDbgRecord`] 
| Erase a single DbgRecord `I` that is attached to this instruction.
| xref:llvm/Instruction/dropPoisonGeneratingAnnotations.adoc[`dropPoisonGeneratingAnnotations`] 
| Drops flags, attributes and metadata that may generate poison.
| xref:llvm/Instruction/dropPoisonGeneratingAttributes.adoc[`dropPoisonGeneratingAttributes`] 
| Drops attributes that may generate poison.
| xref:llvm/Instruction/dropPoisonGeneratingFlags.adoc[`dropPoisonGeneratingFlags`] 
| Drops flags that may cause this instruction to evaluate to poison despite having non‐poison inputs.
| xref:llvm/Instruction/dropPoisonGeneratingMetadata.adoc[`dropPoisonGeneratingMetadata`] 
| Drops metadata that may generate poison.
| xref:llvm/Instruction/dropUBImplyingAttrsAndMetadata.adoc[`dropUBImplyingAttrsAndMetadata`] 
| Drop attributes or metadata that can cause immediate undefined behavior.
| xref:llvm/Instruction/dropUBImplyingAttrsAndUnknownMetadata.adoc[`dropUBImplyingAttrsAndUnknownMetadata`] 
| Drop non‐debug unknown metadata and UB‐implying call attributes.
| xref:llvm/Instruction/dropUnknownNonDebugMetadata.adoc[`dropUnknownNonDebugMetadata`] 
| Drop all unknown metadata except for debug locations.
| xref:llvm/Value/dump.adoc[`dump`] 
| Support for debugging, callable in GDB: V‐>dump()
| xref:llvm/Instruction/eraseFromParent.adoc[`eraseFromParent`] 
| This method unlinks 'this' from the containing basic block and deletes it.
| xref:llvm/Instruction/eraseMetadataIf.adoc[`eraseMetadataIf`] 
| Erase all metadata that matches the predicate.
| xref:llvm/Instruction/extractProfTotalWeight.adoc[`extractProfTotalWeight`] 
| Retrieve total raw weight values of a branch.
| xref:llvm/Instruction/getAAMetadata.adoc[`getAAMetadata`] 
| Return the AA metadata for this instruction.
| xref:llvm/Instruction/getAccessType.adoc[`getAccessType`] 
| Return the type this instruction accesses in memory, if any.
| xref:llvm/Instruction/getAllMetadata.adoc[`getAllMetadata`] 
| Get all metadata attached to this Instruction.
| xref:llvm/Instruction/getAllMetadataOtherThanDebugLoc.adoc[`getAllMetadataOtherThanDebugLoc`] 
| Get all metadata attached to this Instruction except the debug location.
| xref:llvm/Value/getContext.adoc[`getContext`] 
| All values hold a context through their type.
| xref:llvm/Instruction/getDataLayout.adoc[`getDataLayout`] 
| Return the data layout of the module this instruction belongs to.
| xref:llvm/Instruction/getDbgRecordRange.adoc[`getDbgRecordRange`] 
| Return a range over the DbgRecords attached to this instruction.
| xref:llvm/Instruction/getDbgReinsertionPosition.adoc[`getDbgReinsertionPosition`] 
| Return an iterator to the next DbgRecord after this instruction.
| xref:llvm/Instruction/getDebugLoc.adoc[`getDebugLoc`] 
| Return the debug location for this node as a DebugLoc.
| xref:llvm/User/getDescriptor-01.adoc[`getDescriptor`] 
| Returns the descriptor co‐allocated with this User instance.
| xref:llvm/CastInst/getDestTy.adoc[`getDestTy`] 
| Return the destination type of this cast.
| xref:llvm/Instruction/getFastMathFlags.adoc[`getFastMathFlags`] 
| Return all fast‐math flags for this instruction.
| xref:llvm/Instruction/getFastMathFlagsOrNone.adoc[`getFastMathFlagsOrNone`] 
| Return fast‐math flags, or default flags when not a FPMathOperator.
| xref:llvm/Instruction/getFunction-0a5.adoc[`getFunction`] 
| Return the function this instruction belongs to.
| xref:llvm/Instruction/getInsertionPointAfterDef.adoc[`getInsertionPointAfterDef`] 
| Return the first insertion point at which this instruction's result is defined.
| xref:llvm/Instruction/getMemoryEffects.adoc[`getMemoryEffects`] 
| Return the memory effects of this instruction.
| xref:llvm/Instruction/getMetadata-09.adoc[`getMetadata`] 
| Get the metadata of given kind attached to this Instruction.
| xref:llvm/Instruction/getModule-05.adoc[`getModule`] 
| `getModule` overloads
| xref:llvm/Value/getName.adoc[`getName`] 
| Return a constant reference to the value's name.
| xref:llvm/Value/getNameOrAsOperand.adoc[`getNameOrAsOperand`] 
| Return this value's name, or a printed operand string if it is unnamed.
| xref:llvm/Instruction/getNextNode-0c.adoc[`getNextNode`] 
| Get the next node, or `nullptr` for the list tail.
| xref:llvm/UnaryInstruction/getNumOperands.adoc[`getNumOperands`] 
| Return the number of operands.
| xref:llvm/Instruction/getNumSuccessors.adoc[`getNumSuccessors`] 
| Return the number of successors that this terminator has.
| xref:llvm/Value/getNumUses.adoc[`getNumUses`] 
| This method computes the number of uses of this Value.
| xref:llvm/CastInst/getOpcode.adoc[`getOpcode`] 
| Return the cast opcode of this instruction.
| xref:llvm/Instruction/getOpcodeName-01.adoc[`getOpcodeName`] 
| Return the mnemonic name for this instruction's opcode.
| xref:llvm/UnaryInstruction/getOperand.adoc[`getOperand`] 
| Return operand at index `i_nocapture.`
| xref:llvm/User/getOperandList-07.adoc[`getOperandList`] 
| `getOperandList` overloads
| xref:llvm/User/getOperandUse-01.adoc[`getOperandUse`] 
| `getOperandUse` overloads
| xref:llvm/PtrToAddrInst/getPointerAddressSpace.adoc[`getPointerAddressSpace`] 
| Returns the address space of the pointer operand.
| xref:llvm/Value/getPointerAlignment.adoc[`getPointerAlignment`] 
| Returns an alignment of the pointer value.
| xref:llvm/Value/getPointerDereferenceableBytes.adoc[`getPointerDereferenceableBytes`] 
| Returns the number of bytes known to be dereferenceable for the pointer value.
| xref:llvm/Value/getPointerOffsetFrom.adoc[`getPointerOffsetFrom`] 
| If this ptr is provably equal to `Other` plus a constant offset, return that offset in bytes. Essentially `ptr this` subtract `ptr Other`.
| xref:llvm/PtrToAddrInst/getPointerOperand-09.adoc[`getPointerOperand`] 
| Gets the pointer operand.
| xref:llvm/Instruction/getPrevNode-02.adoc[`getPrevNode`] 
| `getPrevNode` overloads
| xref:llvm/Value/getRawSubclassOptionalData.adoc[`getRawSubclassOptionalData`] 
| Return the raw optional flags value contained in this value.
| xref:llvm/Value/getSingleUndroppableUse-0d.adoc[`getSingleUndroppableUse`] 
| `getSingleUndroppableUse` overloads
| xref:llvm/CastInst/getSrcTy.adoc[`getSrcTy`] 
| Return the source type of this cast.
| xref:llvm/Instruction/getStableDebugLoc.adoc[`getStableDebugLoc`] 
| Return a stable debug location for this instruction.
| xref:llvm/Instruction/getSuccessor.adoc[`getSuccessor`] 
| Return the successor at index `Idx.`
| xref:llvm/Value/getType.adoc[`getType`] 
| All values are typed, get the type of this value.
| xref:llvm/Value/getUniqueUndroppableUser-06.adoc[`getUniqueUndroppableUser`] 
| `getUniqueUndroppableUser` overloads
| xref:llvm/Value/getValueID.adoc[`getValueID`] 
| Return an ID for the concrete type of this object.
| xref:llvm/Value/getValueName.adoc[`getValueName`] 
| Return the symbol‐table name entry for this value, if any.
| xref:llvm/Instruction/handleMarkerRemoval.adoc[`handleMarkerRemoval`] 
| Handle the debug‐info implications of this instruction being removed. Any attached DbgRecords need to "fall" down onto the next instruction.
| xref:llvm/Instruction/hasAllowContract.adoc[`hasAllowContract`] 
| Determine whether the allow‐contract flag is set.
| xref:llvm/Instruction/hasAllowReassoc.adoc[`hasAllowReassoc`] 
| Determine whether the allow‐reassociation flag is set.
| xref:llvm/Instruction/hasAllowReciprocal.adoc[`hasAllowReciprocal`] 
| Determine whether the allow‐reciprocal flag is set.
| xref:llvm/Instruction/hasApproxFunc.adoc[`hasApproxFunc`] 
| Determine whether the approximate‐math‐functions flag is set.
| xref:llvm/Instruction/hasAtomicLoad.adoc[`hasAtomicLoad`] 
| Return true if this atomic instruction loads from memory.
| xref:llvm/Instruction/hasAtomicStore.adoc[`hasAtomicStore`] 
| Return true if this atomic instruction stores to memory.
| xref:llvm/Instruction/hasDbgRecords.adoc[`hasDbgRecords`] 
| Return true if any DbgRecords are attached to this instruction.
| xref:llvm/Instruction/hasMetadata-02.adoc[`hasMetadata`] 
| `hasMetadata` overloads
| xref:llvm/Instruction/hasMetadataOtherThanDebugLoc.adoc[`hasMetadataOtherThanDebugLoc`] 
| Return true if this instruction has metadata attached to it other than a debug location.
| xref:llvm/Value/hasNUndroppableUses.adoc[`hasNUndroppableUses`] 
| Return true if this value has exactly N undroppable uses.
| xref:llvm/Value/hasNUndroppableUsesOrMore.adoc[`hasNUndroppableUsesOrMore`] 
| Return true if this value has N undroppable uses or more.
| xref:llvm/Value/hasNUses.adoc[`hasNUses`] 
| Return true if this Value has exactly N uses.
| xref:llvm/Value/hasNUsesOrMore.adoc[`hasNUsesOrMore`] 
| Return true if this value has N uses or more.
| xref:llvm/Value/hasName-0b.adoc[`hasName`] 
| Return true if this value has a name in the symbol table.
| xref:llvm/Instruction/hasNoInfs.adoc[`hasNoInfs`] 
| Determine whether the no‐infs flag is set.
| xref:llvm/Instruction/hasNoNaNs.adoc[`hasNoNaNs`] 
| Determine whether the no‐NaNs flag is set.
| xref:llvm/Instruction/hasNoSignedWrap.adoc[`hasNoSignedWrap`] 
| Determine whether the no signed wrap flag is set.
| xref:llvm/Instruction/hasNoSignedZeros.adoc[`hasNoSignedZeros`] 
| Determine whether the no‐signed‐zeros flag is set.
| xref:llvm/Instruction/hasNoUnsignedWrap.adoc[`hasNoUnsignedWrap`] 
| Determine whether the no unsigned wrap flag is set.
| xref:llvm/Instruction/hasNonDebugLocLoopMetadata.adoc[`hasNonDebugLocLoopMetadata`] 
| Return true if this instruction contains loop metadata other than a debug location.
| xref:llvm/Instruction/hasNonNeg.adoc[`hasNonNeg`] 
| Determine whether the nneg flag is set.
| xref:llvm/Value/hasOneUse.adoc[`hasOneUse`] 
| Return true if there is exactly one use of this value.
| xref:llvm/Value/hasOneUser.adoc[`hasOneUser`] 
| Return true if there is exactly one user of this value.
| xref:llvm/Instruction/hasPoisonGeneratingAnnotations.adoc[`hasPoisonGeneratingAnnotations`] 
| Return true if this instruction has poison‐generating flags, attributes or metadata.
| xref:llvm/Instruction/hasPoisonGeneratingAttributes.adoc[`hasPoisonGeneratingAttributes`] 
| Return true if this instruction has poison‐generating attribute.
| xref:llvm/Instruction/hasPoisonGeneratingFlags.adoc[`hasPoisonGeneratingFlags`] 
| Return true if this operator has flags which may cause poison.
| xref:llvm/Instruction/hasPoisonGeneratingMetadata.adoc[`hasPoisonGeneratingMetadata`] 
| Return true if this instruction has poison‐generating metadata.
| xref:llvm/Instruction/hasSameSpecialState.adoc[`hasSameSpecialState`] 
| Return true if `I2` has the same opcode‐specific state as this instruction.
| xref:llvm/Instruction/hasUBImplyingAttrs.adoc[`hasUBImplyingAttrs`] 
| Return true if this instruction has UB‐implying attributes that can cause immediate undefined behavior.
| xref:llvm/Value/hasUseList.adoc[`hasUseList`] 
| Check if this Value has a use‐list.
| xref:llvm/Value/hasValueHandle-07.adoc[`hasValueHandle`] 
| Return true if there is a value handle associated with this value.
| xref:llvm/Instruction/insertAfter-00.adoc[`insertAfter`] 
| `insertAfter` overloads
| xref:llvm/Instruction/insertBefore-0b.adoc[`insertBefore`] 
| `insertBefore` overloads
| xref:llvm/Instruction/insertInto.adoc[`insertInto`] 
| Insert an unlinked instruction into `ParentBB` at position `It.`
| xref:llvm/Instruction/isArithmeticShift.adoc[`isArithmeticShift`] 
| Return true if this is an arithmetic shift right.
| xref:llvm/Instruction/isAssociative-0d.adoc[`isAssociative`] 
| Return true if the instruction is associative.
| xref:llvm/Instruction/isAtomic.adoc[`isAtomic`] 
| Return true if this instruction has an AtomicOrdering of unordered or higher.
| xref:llvm/Instruction/isBinaryOp-01.adoc[`isBinaryOp`] 
| Return true if this instruction is a binary operator.
| xref:llvm/Instruction/isBitwiseLogicOp-058.adoc[`isBitwiseLogicOp`] 
| Return true if this is and/or/xor.
| xref:llvm/Instruction/isCast-0a.adoc[`isCast`] 
| Return true if this instruction is a cast.
| xref:llvm/Instruction/isCommutableOperand.adoc[`isCommutableOperand`] 
| Return true if operand `Op` may be swapped in this commutative instruction.
| xref:llvm/Instruction/isCommutative-0e.adoc[`isCommutative`] 
| Return true if the instruction is commutative.
| xref:llvm/Instruction/isDebugOrPseudoInst.adoc[`isDebugOrPseudoInst`] 
| Return true if the instruction is a DbgInfoIntrinsic or PseudoProbeInst.
| xref:llvm/User/isDroppable.adoc[`isDroppable`] 
| Return whether this user's uses may be dropped without affecting correctness.
| xref:llvm/Instruction/isEHPad.adoc[`isEHPad`] 
| Return true if the instruction is a variety of EH‐block.
| xref:llvm/Instruction/isExact.adoc[`isExact`] 
| Determine whether the exact flag is set.
| xref:llvm/Instruction/isFPDivRem-0a.adoc[`isFPDivRem`] 
| Return true if this instruction is a floating‐point division or remainder.
| xref:llvm/Instruction/isFast.adoc[`isFast`] 
| Determine whether all fast‐math‐flags are set.
| xref:llvm/Instruction/isFenceLike.adoc[`isFenceLike`] 
| Return true if this instruction behaves like a memory fence.
| xref:llvm/Instruction/isFuncletPad-08.adoc[`isFuncletPad`] 
| Return true if this instruction is a funclet pad.
| xref:llvm/Instruction/isIdempotent-07.adoc[`isIdempotent`] 
| Return true if the instruction is idempotent.
| xref:llvm/Instruction/isIdenticalTo.adoc[`isIdenticalTo`] 
| Return true if `I` is exactly identical to this instruction.
| xref:llvm/Instruction/isIdenticalToWhenDefined.adoc[`isIdenticalToWhenDefined`] 
| Return true if `I` matches this instruction ignoring undefined‐result flags.
| xref:llvm/Instruction/isIntDivRem-01.adoc[`isIntDivRem`] 
| Return true if this instruction is an integer division or remainder.
| xref:llvm/CastInst/isIntegerCast.adoc[`isIntegerCast`] 
| Return true if this cast uses only integer types.
| xref:llvm/Instruction/isLaunderOrStripInvariantGroup.adoc[`isLaunderOrStripInvariantGroup`] 
| Return true if the instruction is a llvm.launder.invariant.group or llvm.strip.invariant.group.
| xref:llvm/Instruction/isLifetimeStartOrEnd.adoc[`isLifetimeStartOrEnd`] 
| Return true if the instruction is a llvm.lifetime.start or llvm.lifetime.end marker.
| xref:llvm/Instruction/isLogicalShift.adoc[`isLogicalShift`] 
| Return true if this is a logical shift left or a logical shift right.
| xref:llvm/Instruction/isNilpotent-05.adoc[`isNilpotent`] 
| Return true if the instruction is nilpotent.
| xref:llvm/CastInst/isNoopCast-0c3.adoc[`isNoopCast`] 
| Return true if this cast changes no bits.
| xref:llvm/Instruction/isOnlyUserOfAnyOperand.adoc[`isOnlyUserOfAnyOperand`] 
| Return true if this instruction is the only user of at least one operand.
| xref:llvm/Instruction/isSafeToRemove.adoc[`isSafeToRemove`] 
| Return true if the instruction can be removed if the result is unused.
| xref:llvm/Instruction/isSameOperationAs.adoc[`isSameOperationAs`] 
| Return true if `I` executes the same operation as this instruction.
| xref:llvm/Instruction/isShift-05.adoc[`isShift`] 
| Return true if this instruction is a shift.
| xref:llvm/Instruction/isSpecialTerminator-07.adoc[`isSpecialTerminator`] 
| Return true if this instruction is a special terminator.
| xref:llvm/Value/isSwiftError.adoc[`isSwiftError`] 
| Return true if this value is a swifterror value.
| xref:llvm/Instruction/isTerminator-02.adoc[`isTerminator`] 
| Return true if this instruction is a terminator.
| xref:llvm/Instruction/isUnaryOp-08.adoc[`isUnaryOp`] 
| Return true if this instruction is a unary operator.
| xref:llvm/Value/isUsedByMetadata.adoc[`isUsedByMetadata`] 
| Return true if there is metadata referencing this value.
| xref:llvm/Value/isUsedInBasicBlock.adoc[`isUsedInBasicBlock`] 
| Check if this value is used in the specified basic block.
| xref:llvm/Instruction/isUsedOutsideOfBlock.adoc[`isUsedOutsideOfBlock`] 
| Return true if any use of this instruction is outside `BB.`
| xref:llvm/Instruction/isVolatile.adoc[`isVolatile`] 
| Return true if this instruction has a volatile memory access.
| xref:llvm/Value/materialized_use_begin-00.adoc[`materialized_use_begin`] 
| `materialized_use_begin` overloads
| xref:llvm/Value/materialized_use_empty.adoc[`materialized_use_empty`] 
| Return true if there are no currently materialized uses.
| xref:llvm/Value/materialized_user_begin-0a.adoc[`materialized_user_begin`] 
| `materialized_user_begin` overloads
| xref:llvm/Value/materialized_users-01.adoc[`materialized_users`] 
| `materialized_users` overloads
| xref:llvm/Value/materialized_uses-08.adoc[`materialized_uses`] 
| `materialized_uses` overloads
| xref:llvm/Instruction/mayHaveSideEffects.adoc[`mayHaveSideEffects`] 
| Return true if the instruction may have side effects.
| xref:llvm/Instruction/mayReadFromMemory.adoc[`mayReadFromMemory`] 
| Return true if this instruction may read memory.
| xref:llvm/Instruction/mayReadOrWriteMemory.adoc[`mayReadOrWriteMemory`] 
| Return true if this instruction may read or write memory.
| xref:llvm/Instruction/maySynchronize.adoc[`maySynchronize`] 
| Return true if this instruction may synchronize.
| xref:llvm/Instruction/mayThrow.adoc[`mayThrow`] 
| Return true if this instruction may throw an exception.
| xref:llvm/Instruction/mayWriteToMemory.adoc[`mayWriteToMemory`] 
| Return true if this instruction may modify memory.
| xref:llvm/Instruction/mergeDIAssignID.adoc[`mergeDIAssignID`] 
| Merge DIAssignID metadata from this instruction and `SourceInstructions.`
| xref:llvm/Instruction/moveAfter-04.adoc[`moveAfter`] 
| Unlink this instruction from its current basic block and insert it into the basic block that MovePos lives in, right after MovePos.
| xref:llvm/Instruction/moveAfterPreserving.adoc[`moveAfterPreserving`] 
| Move this instruction after `MovePos` while preserving instruction order.
| xref:llvm/Instruction/moveBefore-0e0.adoc[`moveBefore`] 
| `moveBefore` overloads
| xref:llvm/Instruction/moveBeforePreserving-003.adoc[`moveBeforePreserving`] 
| `moveBeforePreserving` overloads
| xref:llvm/Value/mutateType.adoc[`mutateType`] 
| Mutate the type of this Value to be of the specified type.
| xref:llvm/UnaryInstruction/op_begin-00.adoc[`op_begin`] 
| `op_begin` overloads
| xref:llvm/UnaryInstruction/op_end-03.adoc[`op_end`] 
| `op_end` overloads
| xref:llvm/User/operand_values-09.adoc[`operand_values`] 
| `operand_values` overloads
| xref:llvm/User/operands-06.adoc[`operands`] 
| `operands` overloads
| xref:llvm/UnaryInstruction/operator_del-07.adoc[`operator delete`] 
| Delete operators
| xref:llvm/UnaryInstruction/operator_new.adoc[`operator new`] 
| Allocate a unary instruction with space for its single operand.
| xref:llvm/Value/print-0f.adoc[`print`] 
| `print` overloads
| xref:llvm/Value/printAsOperand-07.adoc[`printAsOperand`] 
| `printAsOperand` overloads
| xref:llvm/Instruction/removeFromParent.adoc[`removeFromParent`] 
| This method unlinks 'this' from the containing basic block, but does not delete it.
| xref:llvm/Value/replaceAllUsesWith.adoc[`replaceAllUsesWith`] 
| Change all uses of this to point to a new Value.
| xref:llvm/Value/replaceNonMetadataUsesWith.adoc[`replaceNonMetadataUsesWith`] 
| Change non‐metadata uses of this to point to a new Value.
| xref:llvm/Instruction/replaceSuccessorWith.adoc[`replaceSuccessorWith`] 
| Replace successor `OldBB` with `NewBB.`
| xref:llvm/User/replaceUsesOfWith.adoc[`replaceUsesOfWith`] 
| Replace uses of one Value with another.
| xref:llvm/Value/replaceUsesOutsideBlock.adoc[`replaceUsesOutsideBlock`] 
| Replace uses of this value that occur outside `BB` with `V.`
| xref:llvm/Value/replaceUsesWithIf.adoc[`replaceUsesWithIf`] 
| Replace selected uses of this value with `New.`
| xref:llvm/Value/reverseUseList.adoc[`reverseUseList`] 
| Reverse the use‐list.
| xref:llvm/Instruction/setAAMetadata.adoc[`setAAMetadata`] 
| Set the AA metadata on this instruction from the AAMDNodes structure.
| xref:llvm/Instruction/setDebugLoc.adoc[`setDebugLoc`] 
| Set the debug location information for this instruction.
| xref:llvm/Instruction/setFast.adoc[`setFast`] 
| Set or clear all fast‐math‐flags on this instruction.
| xref:llvm/Instruction/setFastMathFlags.adoc[`setFastMathFlags`] 
| Set multiple fast‐math flags on this instruction.
| xref:llvm/Instruction/setHasAllowContract.adoc[`setHasAllowContract`] 
| Set or clear the allow‐contract flag on this instruction.
| xref:llvm/Instruction/setHasAllowReassoc.adoc[`setHasAllowReassoc`] 
| Set or clear the reassociation flag on this instruction.
| xref:llvm/Instruction/setHasAllowReciprocal.adoc[`setHasAllowReciprocal`] 
| Set or clear the allow‐reciprocal flag on this instruction.
| xref:llvm/Instruction/setHasApproxFunc.adoc[`setHasApproxFunc`] 
| Set or clear the approximate‐math‐functions flag on this instruction.
| xref:llvm/Instruction/setHasNoInfs.adoc[`setHasNoInfs`] 
| Set or clear the no‐infs flag on this instruction.
| xref:llvm/Instruction/setHasNoNaNs.adoc[`setHasNoNaNs`] 
| Set or clear the no‐nans flag on this instruction.
| xref:llvm/Instruction/setHasNoSignedWrap.adoc[`setHasNoSignedWrap`] 
| Set or clear the nsw flag on this instruction.
| xref:llvm/Instruction/setHasNoSignedZeros.adoc[`setHasNoSignedZeros`] 
| Set or clear the no‐signed‐zeros flag on this instruction.
| xref:llvm/Instruction/setHasNoUnsignedWrap.adoc[`setHasNoUnsignedWrap`] 
| Set or clear the nuw flag on this instruction.
| xref:llvm/Instruction/setIsExact.adoc[`setIsExact`] 
| Set or clear the exact flag on this instruction.
| xref:llvm/Instruction/setMetadata-03.adoc[`setMetadata`] 
| `setMetadata` overloads
| xref:llvm/Value/setName.adoc[`setName`] 
| Change the name of the value.
| xref:llvm/Instruction/setNoSanitizeMetadata.adoc[`setNoSanitizeMetadata`] 
| Sets the nosanitize metadata on this instruction.
| xref:llvm/Instruction/setNonNeg.adoc[`setNonNeg`] 
| Set or clear the nneg flag on this instruction.
| xref:llvm/User/setNumHungOffUseOperands.adoc[`setNumHungOffUseOperands`] 
| Set the operand count for a User with hung‐off uses.
| xref:llvm/UnaryInstruction/setOperand.adoc[`setOperand`] 
| Set operand at index `i_nocapture` to `Val_nocapture.`
| xref:llvm/Instruction/setSuccessor.adoc[`setSuccessor`] 
| Update the successor at index `Idx` to point at `BB.`
| xref:llvm/Value/setValueName.adoc[`setValueName`] 
| Set the symbol‐table name entry for this value.
| xref:llvm/Value/sortUseList.adoc[`sortUseList`] 
| Sort the use‐list.
| xref:llvm/Value/stripAndAccumulateConstantOffsets-06.adoc[`stripAndAccumulateConstantOffsets`] 
| `stripAndAccumulateConstantOffsets` overloads
| xref:llvm/Value/stripAndAccumulateInBoundsConstantOffsets-0b.adoc[`stripAndAccumulateInBoundsConstantOffsets`] 
| `stripAndAccumulateInBoundsConstantOffsets` overloads
| xref:llvm/Value/stripInBoundsConstantOffsets-0c.adoc[`stripInBoundsConstantOffsets`] 
| `stripInBoundsConstantOffsets` overloads
| xref:llvm/Value/stripInBoundsOffsets-00.adoc[`stripInBoundsOffsets`] 
| `stripInBoundsOffsets` overloads
| xref:llvm/Value/stripPointerCasts-0e1.adoc[`stripPointerCasts`] 
| `stripPointerCasts` overloads
| xref:llvm/Value/stripPointerCastsAndAliases-00.adoc[`stripPointerCastsAndAliases`] 
| `stripPointerCastsAndAliases` overloads
| xref:llvm/Value/stripPointerCastsForAliasAnalysis-07.adoc[`stripPointerCastsForAliasAnalysis`] 
| `stripPointerCastsForAliasAnalysis` overloads
| xref:llvm/Value/stripPointerCastsSameRepresentation-0e.adoc[`stripPointerCastsSameRepresentation`] 
| `stripPointerCastsSameRepresentation` overloads
| xref:llvm/Instruction/successors-05.adoc[`successors`] 
| `successors` overloads
| xref:llvm/Instruction/swapProfMetadata.adoc[`swapProfMetadata`] 
| If the instruction has "branch_weights" MD_prof metadata and the MDNode has three operands (including name string), swap the order of the metadata.
| xref:llvm/Value/takeName.adoc[`takeName`] 
| Transfer the name from V to this value.
| xref:llvm/Instruction/updateLocationAfterHoist.adoc[`updateLocationAfterHoist`] 
| Update the debug location after hoisting this instruction to a predecessor.
| xref:llvm/Value/use_begin-011.adoc[`use_begin`] 
| `use_begin` overloads
| xref:llvm/Value/use_empty.adoc[`use_empty`] 
| Return true if this value has no uses.
| xref:llvm/Value/use_end-0e.adoc[`use_end`] 
| `use_end` overloads
| xref:llvm/Instruction/user_back-03.adoc[`user_back`] 
| `user_back` overloads
| xref:llvm/Value/user_begin-07.adoc[`user_begin`] 
| Return an iterator to the first user of this value.
| xref:llvm/Value/user_empty.adoc[`user_empty`] 
| Return true if this value has no users.
| xref:llvm/Value/user_end-02.adoc[`user_end`] 
| `user_end` overloads
| xref:llvm/Value/users-00.adoc[`users`] 
| `users` overloads
| xref:llvm/Value/uses-01.adoc[`uses`] 
| `uses` overloads
| xref:llvm/User/value_op_begin-03.adoc[`value_op_begin`] 
| `value_op_begin` overloads
| xref:llvm/User/value_op_end-0e.adoc[`value_op_end`] 
| `value_op_end` overloads
| xref:llvm/Instruction/willReturn.adoc[`willReturn`] 
| Return true if the instruction will return.
|===


== Static Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/CastInst/Create.adoc[`Create`] 
| Construct any CastInst subclass from an opcode.
| xref:llvm/CastInst/CreateBitOrPointerCast.adoc[`CreateBitOrPointerCast`] 
| Create a bitcast, pointer‐to‐integer, or integer‐to‐pointer cast.
| xref:llvm/CastInst/CreateFPCast.adoc[`CreateFPCast`] 
| Create a floating‐point extension, bitcast, or truncation.
| xref:llvm/CastInst/CreateIntegerCast.adoc[`CreateIntegerCast`] 
| Create a zero‐extension, bitcast, or truncation for integer casts.
| xref:llvm/CastInst/CreatePointerBitCastOrAddrSpaceCast.adoc[`CreatePointerBitCastOrAddrSpaceCast`] 
| Create a bitcast or address‐space cast instruction.
| xref:llvm/CastInst/CreatePointerCast.adoc[`CreatePointerCast`] 
| Create a bitcast, address‐space cast, or pointer‐to‐integer cast.
| xref:llvm/CastInst/CreateSExtOrBitCast.adoc[`CreateSExtOrBitCast`] 
| Create a sign‐extension or bitcast cast instruction.
| xref:llvm/CastInst/CreateTruncOrBitCast.adoc[`CreateTruncOrBitCast`] 
| Create a truncation or bitcast cast instruction.
| xref:llvm/CastInst/CreateZExtOrBitCast.adoc[`CreateZExtOrBitCast`] 
| Create a zero‐extension or bitcast cast instruction.
| xref:llvm/CastInst/castIsValid-0b.adoc[`castIsValid`] 
| `castIsValid` overloads
| xref:llvm/PtrToAddrInst/classof-08.adoc[`classof`] 
| Methods for support type inquiry through isa, cast, and dyn_cast.
| xref:llvm/Value/dropDroppableUse.adoc[`dropDroppableUse`] 
| Remove the droppable use `U.`
| xref:llvm/CastInst/getCastOpcode.adoc[`getCastOpcode`] 
| Infer the cast opcode for a value and destination type.
| xref:llvm/Instruction/getOpcodeName-0a.adoc[`getOpcodeName`] 
| Return the mnemonic name for the given opcode (e.g. "add", "ret").
| xref:llvm/PtrToAddrInst/getPointerOperandIndex.adoc[`getPointerOperandIndex`] 
| Gets the operand index of the pointer operand.
| xref:llvm/Instruction/isAssociative-02.adoc[`isAssociative`] 
| Return true if `Opcode` is an associative binary operator.
| xref:llvm/Instruction/isBinaryOp-06.adoc[`isBinaryOp`] 
| Return true if the opcode is a binary operator.
| xref:llvm/CastInst/isBitCastable.adoc[`isBitCastable`] 
| Check whether a bitcast between two types is valid.
| xref:llvm/CastInst/isBitOrNoopPointerCastable.adoc[`isBitOrNoopPointerCastable`] 
| Check whether a no‐op bitcast or pointer cast is valid.
| xref:llvm/Instruction/isBitwiseLogicOp-05e.adoc[`isBitwiseLogicOp`] 
| Return true if `Opcode` is and/or/xor.
| xref:llvm/Instruction/isCast-07.adoc[`isCast`] 
| Return true if `Opcode` is one of the CastInst instructions.
| xref:llvm/Instruction/isCommutative-0a.adoc[`isCommutative`] 
| Return true if `Opcode` is a commutative binary operator.
| xref:llvm/CastInst/isEliminableCastPair.adoc[`isEliminableCastPair`] 
| Return the opcode that replaces an eliminable cast pair.
| xref:llvm/Instruction/isFPDivRem-0b.adoc[`isFPDivRem`] 
| Return true if the opcode is a floating‐point division or remainder.
| xref:llvm/Instruction/isFuncletPad-02.adoc[`isFuncletPad`] 
| Return true if `Opcode` is one of the FuncletPadInst instructions.
| xref:llvm/Instruction/isIdempotent-0b.adoc[`isIdempotent`] 
| Return true if `Opcode` is an idempotent operator (And or Or in LLVM).
| xref:llvm/Instruction/isIntDivRem-0b.adoc[`isIntDivRem`] 
| Return true if the opcode is an integer division or remainder.
| xref:llvm/Instruction/isNilpotent-0c.adoc[`isNilpotent`] 
| Return true if `Opcode` is a nilpotent operator (Xor in LLVM).
| xref:llvm/CastInst/isNoopCast-0cb.adoc[`isNoopCast`] 
| Return true if a cast changes no bits.
| xref:llvm/Instruction/isShift-0f.adoc[`isShift`] 
| Return true if `Opcode` is one of the shift instructions.
| xref:llvm/Instruction/isSpecialTerminator-08.adoc[`isSpecialTerminator`] 
| Return true if `Opcode` is a special terminator.
| xref:llvm/Instruction/isTerminator-04.adoc[`isTerminator`] 
| Return true if the opcode is a terminator instruction.
| xref:llvm/Instruction/isUnaryOp-0e.adoc[`isUnaryOp`] 
| Return true if the opcode is a unary operator.
|===


== Data Members

[cols="1,4"]
|===
| Name| Description
| xref:llvm/Instruction/DebugMarker.adoc[`DebugMarker`] 
| Optional marker for debugging information immediately before this instruction.
|===


== Static Data Members

[cols="1,4"]
|===
| Name| Description
| xref:llvm/Value/MaxAlignmentExponent.adoc[`MaxAlignmentExponent`] 
| The maximum alignment for instructions.
| xref:llvm/Value/MaximumAlignment.adoc[`MaximumAlignment`] 
| Maximum absolute alignment in bytes (`1` << MaxAlignmentExponent).
|===


== Protected Types

[cols="1,4"]
|===
| Name| Description
| xref:llvm/User/AllocInfo.adoc[`AllocInfo`] 
| Information about how a User object was allocated, to be passed into the User constructor.
| xref:llvm/User/HungOffOperandsAllocMarker.adoc[`HungOffOperandsAllocMarker`] 
| Indicates this User has operands "hung off" in another allocation.
| xref:llvm/User/IntrusiveOperandsAllocMarker.adoc[`IntrusiveOperandsAllocMarker`] 
| Indicates this User has operands co‐allocated.
| xref:llvm/User/IntrusiveOperandsAndDescriptorAllocMarker.adoc[`IntrusiveOperandsAndDescriptorAllocMarker`] 
| Indicates this User has operands and a descriptor co‐allocated .
|===


== Protected Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:llvm/Instruction/AlignmentBitfieldElementT.adoc[`AlignmentBitfieldElementT`] 
| Bitfield element template for an alignment at bit offset `Offset.`
| xref:llvm/Instruction/AtomicOrderingBitfieldElementT.adoc[`AtomicOrderingBitfieldElementT`] 
| Bitfield element template for atomic ordering at bit offset `Offset.`
| xref:llvm/Instruction/BoolBitfieldElementT.adoc[`BoolBitfieldElementT`] 
| Bitfield element template for a single boolean flag at bit offset `Offset.`
| xref:llvm/Instruction/OpaqueField.adoc[`OpaqueField`] 
| Opaque 16‐bit bitfield covering the full Instruction subclass data.
|===


== Protected Enums

[cols="1,4"]
|===
| Name| Description
| xref:llvm/Value/_04enum.adoc[`Unnamed enum`] 
| The number of operands in the subclass.
|===


== Protected Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/UnaryInstruction/Op-04.adoc[`Op`] 
| `Op` overloads
| xref:llvm/Value/addMetadata-02.adoc[`addMetadata`] 
| `addMetadata` overloads
| xref:llvm/User/allocHungoffUses.adoc[`allocHungoffUses`] 
| Allocate the array of Uses, followed by a pointer (with bottom bit set) to the User.
| xref:llvm/Value/clearMetadata.adoc[`clearMetadata`] 
| Erase all metadata attached to this Value.
| xref:llvm/PtrToAddrInst/cloneImpl.adoc[`cloneImpl`] 
| Clone an identical PtrToAddrInst.
| xref:llvm/Value/eraseMetadata.adoc[`eraseMetadata`] 
| Erase all metadata attachments with the given kind.
| xref:llvm/Value/eraseMetadataIf.adoc[`eraseMetadataIf`] 
| Erase all metadata attachments matching the given predicate.
| xref:llvm/Value/getAllMetadata.adoc[`getAllMetadata`] 
| Append all metadata attached to this value into `MDs.`
| xref:llvm/Value/getMetadata.adoc[`getMetadata`] 
| Get the current metadata attachments for the given kind, if any.
| xref:llvm/Value/getMetadataImpl.adoc[`getMetadataImpl`] 
| Get metadata for the given kind, if any.
| xref:llvm/Instruction/getSubclassData.adoc[`getSubclassData`] 
| Read a bitfield element from this instruction's subclass data.
| xref:llvm/Value/getSubclassDataFromValue.adoc[`getSubclassDataFromValue`] 
| Return the opaque subclass data bits stored in this value.
| xref:llvm/User/growHungoffUses.adoc[`growHungoffUses`] 
| Grow the number of hung off uses. Note that allocHungoffUses should be called if there are no uses.
| xref:llvm/User/operator_new-07cc.adoc[`operator new`] 
| New operators
| xref:llvm/Value/setMetadata-06.adoc[`setMetadata`] 
| `setMetadata` overloads
| xref:llvm/Instruction/setSubclassData.adoc[`setSubclassData`] 
| Store a bitfield element into this instruction's subclass data.
| xref:llvm/Value/setValueSubclassData.adoc[`setValueSubclassData`] 
| Set the opaque subclass data bits stored in this value.
|===


== Protected Static Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/User/OpFrom.adoc[`OpFrom`] 
| Return the operand Use at compile‐time index `Idx` from `that.`
|===


== Protected Data Members

[cols="1,4"]
|===
| Name| Description
| xref:llvm/Value/HasDescriptor.adoc[`HasDescriptor`] 
| True if this value has a descriptor.
| xref:llvm/Value/HasHungOffUses.adoc[`HasHungOffUses`] 
| Whether operands are stored in a separately allocated array.
| xref:llvm/Value/HasName-00.adoc[`HasName`] 
| True if this value has a name in the symbol table.
| xref:llvm/Value/IsUsedByMD.adoc[`IsUsedByMD`] 
| True if metadata references this value.
| xref:llvm/Value/NumUserOperands.adoc[`NumUserOperands`] 
| Number of operands in this user.
| xref:llvm/Value/SubclassOptionalData.adoc[`SubclassOptionalData`] 
| Hold arbitary subclass data.
|===


== Friends

[cols="1,4"]
|===
| Name| Description
| `xref:llvm/Instruction.adoc[llvm::Instruction]`
| Base class for all LLVM IR instructions.
|===

== Non-Member Functions

[cols="1,4"]
|===
| Name| Description
| 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/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/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/adaptNoAliasScopes.adoc[`adaptNoAliasScopes`]
| Adapt an instruction's noalias metadata using a scope map.
| 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/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/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/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/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/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/getAtomicSyncScopeID.adoc[`getAtomicSyncScopeID`]
| Return the sync scope of atomic instruction `I,` or nullopt if not atomic.
| 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/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/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/getSplatValue.adoc[`getSplatValue`]
| Get splat value if the input is a splat vector or return nullptr.
| 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/handleUnreachableTerminator.adoc[`handleUnreachableTerminator`]
| Replace instruction operands of an unreachable terminator with poison.
| 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/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/isInstructionTriviallyDead.adoc[`isInstructionTriviallyDead`]
| Return true if an unused instruction is trivially dead.
| 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/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/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/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/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/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/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/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/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/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/updateLoopMetadataDebugLocations.adoc[`updateLoopMetadataDebugLocations`]
| Update debug locations in any MD_loop metadata attached to `I.`
| 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_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/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/instrumentor/evaluateFilter.adoc[`instrumentor::evaluateFilter`]
| Evaluate a filter expression for an instrumentation opportunity.
| 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/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.
|===


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