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

Common base for MemoryUse and MemoryDef.

== Synopsis

Declared in `<llvm/Analysis/MemorySSA.h>`

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

== Description

Class that has the common methods + fields of memory uses/defs. It's a little awkward to have, but there are many cases where we want either a use or def, and there are many cases where uses are needed (defs aren't acceptable), and vice‐versa.

This class should never be instantiated directly; make a MemoryUse or MemoryDef instead.

== Base Classes

[cols="1,4"]
|===
| Name| Description
| `xref:llvm/MemoryAccess.adoc[MemoryAccess]`
| Base class for MemoryUse, MemoryDef, and MemoryPhi nodes in MemorySSA.
|===

== Types

[cols="1,4"]
|===
| Name| Description
| xref:llvm/User/const_value_op_iterator.adoc[`const_value_op_iterator`] 
| Const iterator for directly iterating over the operand Values.
| 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/MemoryAccess/AllAccessType.adoc[`AllAccessType`] 
| Intrusive‐list node type for the all‐accesses list.
| xref:llvm/MemoryAccess/DefsOnlyType.adoc[`DefsOnlyType`] 
| Intrusive‐list node type for the defs‐only list.
| xref:llvm/MemoryAccess/const_iterator.adoc[`const_iterator`] 
| Const user iterator for a memory access.
| 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/MemoryAccess/iterator.adoc[`iterator`] 
| The user iterators for a memory access
| 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/Value/ValueTy.adoc[`ValueTy`] 
| Concrete subclass of this.
|===


== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/MemoryAccess/operator_assign-0f6.adoc[`operator=`] 
| Assignment operators
| xref:llvm/Value/DoPHITranslation-07.adoc[`DoPHITranslation`] 
| `DoPHITranslation` overloads
| xref:llvm/Value/addUse.adoc[`addUse`] 
| This method should only be used by the Use class.
| 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/MemoryAccess/defs_begin-07.adoc[`defs_begin`] 
| `defs_begin` overloads
| xref:llvm/MemoryAccess/defs_end-0a.adoc[`defs_end`] 
| `defs_end` overloads
| 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/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/MemoryAccess/dump.adoc[`dump`] 
| Dump this memory access to stderr for debugging.
| xref:llvm/MemoryAccess/getBlock.adoc[`getBlock`] 
| Return the basic block that contains this memory access.
| xref:llvm/Value/getContext.adoc[`getContext`] 
| All values hold a context through their type.
| xref:llvm/MemoryUseOrDef/getDefiningAccess.adoc[`getDefiningAccess`] 
| Get the access that produces the memory state used by this Use.
| xref:llvm/MemoryAccess/getDefsIterator-07.adoc[`getDefsIterator`] 
| `getDefsIterator` overloads
| xref:llvm/User/getDescriptor-01.adoc[`getDescriptor`] 
| Returns the descriptor co‐allocated with this User instance.
| xref:llvm/MemoryAccess/getIterator-08.adoc[`getIterator`] 
| `getIterator` overloads
| xref:llvm/MemoryUseOrDef/getMemoryInst.adoc[`getMemoryInst`] 
| Get the instruction that this MemoryUse represents.
| 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/MemoryUseOrDef/getNumOperands.adoc[`getNumOperands`] 
| Return the number of operands.
| xref:llvm/Value/getNumUses.adoc[`getNumUses`] 
| This method computes the number of uses of this Value.
| xref:llvm/MemoryUseOrDef/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/MemoryUseOrDef/getOptimized.adoc[`getOptimized`] 
| Return the MemoryAccess associated with the optimized use, or nullptr.
| 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/Value/getRawSubclassOptionalData.adoc[`getRawSubclassOptionalData`] 
| Return the raw optional flags value contained in this value.
| xref:llvm/MemoryAccess/getReverseDefsIterator-0d.adoc[`getReverseDefsIterator`] 
| `getReverseDefsIterator` overloads
| xref:llvm/MemoryAccess/getReverseIterator-02.adoc[`getReverseIterator`] 
| `getReverseIterator` overloads
| xref:llvm/Value/getSingleUndroppableUse-0d.adoc[`getSingleUndroppableUse`] 
| `getSingleUndroppableUse` overloads
| 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/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/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/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/User/isDroppable.adoc[`isDroppable`] 
| Return whether this user's uses may be dropped without affecting correctness.
| xref:llvm/MemoryUseOrDef/isOptimized.adoc[`isOptimized`] 
| Do we have an optimized use?
| xref:llvm/Value/isSwiftError.adoc[`isSwiftError`] 
| Return true if this value is a swifterror value.
| 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/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/Value/mutateType.adoc[`mutateType`] 
| Mutate the type of this Value to be of the specified type.
| xref:llvm/MemoryUseOrDef/op_begin-03.adoc[`op_begin`] 
| `op_begin` overloads
| xref:llvm/MemoryUseOrDef/op_end-0d.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/User/operator_del-067.adoc[`operator delete`] 
| Delete operators
| xref:llvm/MemoryUseOrDef/operator_new.adoc[`operator new`]  [.small]#[deleted]#
| Deleted; allocate MemoryUse or MemoryDef instead.
| xref:llvm/MemoryAccess/print-02.adoc[`print`] 
| `print` overloads
| xref:llvm/Value/printAsOperand-07.adoc[`printAsOperand`] 
| `printAsOperand` overloads
| 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/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/MemoryUseOrDef/resetOptimized.adoc[`resetOptimized`] 
| Reset the ID of what this MemoryUse was optimized to, causing it to be rewalked by the walker if necessary. This really should only be called by tests.
| xref:llvm/Value/reverseUseList.adoc[`reverseUseList`] 
| Reverse the use‐list.
| xref:llvm/Value/setName.adoc[`setName`] 
| Change the name of the value.
| xref:llvm/User/setNumHungOffUseOperands.adoc[`setNumHungOffUseOperands`] 
| Set the operand count for a User with hung‐off uses.
| xref:llvm/MemoryUseOrDef/setOperand-06.adoc[`setOperand`] 
| `setOperand` overloads
| xref:llvm/MemoryUseOrDef/setOptimized.adoc[`setOptimized`] 
| Sets the optimized use for a MemoryDef.
| 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/Value/takeName.adoc[`takeName`] 
| Transfer the name from V to this value.
| 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/Value/user_back-03.adoc[`user_back`] 
| Return the sole user when this value has exactly one user.
| 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
|===


== Static Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/MemoryUseOrDef/classof.adoc[`classof`] 
| Methods for support type inquiry through isa, cast, and dyn_cast.
| xref:llvm/Value/dropDroppableUse.adoc[`dropDroppableUse`] 
| Remove the droppable use `U.`
|===


== 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/DerivedUser/DeleteValueTy.adoc[`DeleteValueTy`] 
| Function pointer type used to destroy a DerivedUser instance.
|===


== 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/MemoryUseOrDef/2constructor.adoc[`MemoryUseOrDef`]         [.small]#[constructor]#
| Construct a MemoryUseOrDef for instruction `MI` in block `BB.`
| xref:llvm/MemoryUseOrDef/2destructor.adoc[`~MemoryUseOrDef`] [.small]#[destructor]#
| Destroy a MemoryUseOrDef; clients should call deleteValue().
| xref:llvm/MemoryUseOrDef/Op-08.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/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/MemoryAccess/getID.adoc[`getID`] 
| Return the unique ID of this MemoryDef or MemoryPhi.
| 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/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/MemoryAccess/setBlock.adoc[`setBlock`] 
| Used by MemorySSA to change the block of a MemoryAccess when it is moved.
| xref:llvm/MemoryUseOrDef/setDefiningAccess.adoc[`setDefiningAccess`] 
| Set the defining access to `DMA,` optionally as an optimized use.
| xref:llvm/Value/setMetadata-06.adoc[`setMetadata`] 
| `setMetadata` overloads
| 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/MemorySSAUpdater.adoc[llvm::MemorySSAUpdater]`
| Automatic updater that inserts, deletes, and moves MemorySSA accesses.
| `xref:llvm/MemorySSA.adoc[llvm::MemorySSA]`
| Encapsulates MemorySSA, including all data associated with memory accesses.
|===

== 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/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/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/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/canReplacePointersIfEqual.adoc[`canReplacePointersIfEqual`]
| Returns true if pointer `From` can be replaced with equal pointer `To.`
| 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/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/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/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/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/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/getBaseObjectSize.adoc[`getBaseObjectSize`]
| Like getObjectSize(), but only for base objects.
| 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/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/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/impliesPoison.adoc[`impliesPoison`]
| Return true if V is poison given that ValAssumedPoison is already poison.
| 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/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/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/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/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/isNotVisibleOnUnwind.adoc[`isNotVisibleOnUnwind`]
| Return true if Object memory is not visible after an unwind.
| 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/isSplatValue.adoc[`isSplatValue`]
| Return true if each element of `V` is poisoned or equal to the others.
| 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/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/possiblyDemandedEltsInMask.adoc[`possiblyDemandedEltsInMask`]
| Return an APInt of active lanes for a `<Y x i1>` mask.
| xref:llvm/propagateIRFlags.adoc[`propagateIRFlags`]
| Intersect IR flags from scalar ops `VL` onto vector op `I.`
| 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/setLoadStoreAlignment.adoc[`setLoadStoreAlignment`]
| Set the alignment of load or store instruction `I.`
| 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/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/tryEnforceAlignment.adoc[`tryEnforceAlignment`]
| Try to raise a controlled object's alignment to a preferred value.
| 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_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/instrumentor/evaluateFilter.adoc[`instrumentor::evaluateFilter`]
| Evaluate a filter expression for an instrumentation opportunity.
| 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/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.
|===

== Derived Classes

[cols="1,4"]
|===
| Name| Description
| xref:llvm/MemoryDef.adoc[`MemoryDef`] 
| Represents a read‐write access to memory, whether it is a must‐alias, or a may‐alias.
| xref:llvm/MemoryUse.adoc[`MemoryUse`] 
| Represents read‐only accesses to memory
|===


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