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

This represents the llvm.coro.save instruction.

== Synopsis

Declared in `<llvm/Transforms/Coroutines/CoroInstr.h>`

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

== Base Classes

[cols="1,4"]
|===
| Name| Description
| `xref:llvm/IntrinsicInst.adoc[IntrinsicInst]`
| A wrapper class for inspecting calls to intrinsic functions. This allows the standard isa/dyncast/cast functionality to work with calls to intrinsic functions.
|===

== Types

[cols="1,4"]
|===
| Name| Description
| xref:llvm/CallBase/BundleOpInfo.adoc[`BundleOpInfo`] 
| Descriptor for one contiguous operand bundle in the Use list.
| 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/CallInst/TailCallKindField.adoc[`TailCallKindField`] 
| Bitfield storing the tail‐call kind in SubclassData. Bitfield element storing the TailCallKind in SubclassData.
| xref:llvm/CallBase/bundle_op_iterator.adoc[`bundle_op_iterator`] 
| Iterator over mutable BundleOpInfo descriptors for this call.
| xref:llvm/CallBase/const_bundle_op_iterator.adoc[`const_bundle_op_iterator`] 
| Iterator over const BundleOpInfo descriptors for this call.
| 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/CallInst/TailCallKind.adoc[`TailCallKind`] 
| Kind of tail‐call marker on a call instruction.
| 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/IntrinsicInst/operator_assign-0d.adoc[`operator=`] 
| Assignment operators
| xref:llvm/Value/DoPHITranslation-07.adoc[`DoPHITranslation`] 
| `DoPHITranslation` overloads
| xref:llvm/Instruction/addAnnotationMetadata-078.adoc[`addAnnotationMetadata`] 
| `addAnnotationMetadata` overloads
| xref:llvm/CallBase/addAttributeAtIndex-0b.adoc[`addAttributeAtIndex`] 
| `addAttributeAtIndex` overloads
| xref:llvm/CallBase/addDereferenceableParamAttr.adoc[`addDereferenceableParamAttr`] 
| Add a dereferenceable‐bytes attribute to parameter `i.`
| xref:llvm/CallBase/addDereferenceableRetAttr.adoc[`addDereferenceableRetAttr`] 
| Add a dereferenceable‐bytes attribute to the return value.
| xref:llvm/CallBase/addFnAttr-07.adoc[`addFnAttr`] 
| `addFnAttr` overloads
| xref:llvm/CallBase/addParamAttr-02.adoc[`addParamAttr`] 
| `addParamAttr` overloads
| xref:llvm/CallBase/addParamAttrs.adoc[`addParamAttrs`] 
| Add parameter attributes from builder `B` to argument `ArgNo.`
| xref:llvm/CallBase/addRangeRetAttr.adoc[`addRangeRetAttr`] 
| Add a range attribute to the return value.
| xref:llvm/CallBase/addRetAttr-0f.adoc[`addRetAttr`] 
| `addRetAttr` overloads
| xref:llvm/CallBase/addRetAttrs.adoc[`addRetAttrs`] 
| Add return attributes from builder `B` to this call.
| 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/CallBase/arg_begin-01.adoc[`arg_begin`] 
| `arg_begin` overloads
| xref:llvm/CallBase/arg_empty.adoc[`arg_empty`] 
| Return true if this call has no arguments.
| xref:llvm/CallBase/arg_end-04.adoc[`arg_end`] 
| `arg_end` overloads
| xref:llvm/CallBase/arg_size.adoc[`arg_size`] 
| Return the number of call arguments.
| xref:llvm/CallBase/args-09.adoc[`args`] 
| `args` overloads
| 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/CallBase/bundleOperandHasAttr.adoc[`bundleOperandHasAttr`] 
| Return whether the bundle operand at index `OpIdx` has attribute `A.`
| xref:llvm/CallBase/bundle_op_info_begin-04f.adoc[`bundle_op_info_begin`] 
| `bundle_op_info_begin` overloads
| xref:llvm/CallBase/bundle_op_info_end-09.adoc[`bundle_op_info_end`] 
| `bundle_op_info_end` overloads
| xref:llvm/CallBase/bundle_op_infos-08.adoc[`bundle_op_infos`] 
| `bundle_op_infos` overloads
| xref:llvm/Value/canBeFreed.adoc[`canBeFreed`] 
| Return true if this pointer's memory may be freed in its defining scope.
| xref:llvm/CallInst/canReturnTwice.adoc[`canReturnTwice`] 
| Return true if the call can return twice
| xref:llvm/CallBase/cannotDuplicate.adoc[`cannotDuplicate`] 
| Return true if this invoke cannot be duplicated.
| xref:llvm/CallBase/cannotMerge.adoc[`cannotMerge`] 
| Return true if this call cannot be tail merged.
| 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/CallBase/countOperandBundlesOfType-0a.adoc[`countOperandBundlesOfType`] 
| `countOperandBundlesOfType` overloads
| xref:llvm/CallBase/dataOperandHasImpliedAttr.adoc[`dataOperandHasImpliedAttr`] 
| Return true if data operand `i` has implied attribute `Kind.`
| xref:llvm/CallBase/data_operands_begin-03.adoc[`data_operands_begin`] 
| `data_operands_begin` overloads
| xref:llvm/CallBase/data_operands_empty.adoc[`data_operands_empty`] 
| Return true if this call has no data operands.
| xref:llvm/CallBase/data_operands_end-07.adoc[`data_operands_end`] 
| `data_operands_end` overloads
| xref:llvm/CallBase/data_operands_size.adoc[`data_operands_size`] 
| Return the number of data operands (arguments plus bundle inputs).
| xref:llvm/CallBase/data_ops-06.adoc[`data_ops`] 
| `data_ops` overloads
| xref:llvm/Value/deleteValue.adoc[`deleteValue`] 
| Delete a pointer to a generic Value.
| xref:llvm/CallBase/doesNoCfCheck.adoc[`doesNoCfCheck`] 
| Return true if this call skips indirect branch tracking.
| xref:llvm/CallBase/doesNotAccessMemory-09.adoc[`doesNotAccessMemory`] 
| `doesNotAccessMemory` overloads
| xref:llvm/CallBase/doesNotCapture.adoc[`doesNotCapture`] 
| Return true if data operand `OpNo` does not capture memory.
| xref:llvm/CallBase/doesNotReturn.adoc[`doesNotReturn`] 
| Return true if this call cannot return to its caller.
| xref:llvm/CallBase/doesNotThrow.adoc[`doesNotThrow`] 
| Return true if this call cannot unwind.
| 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/CallBase/getArgOperand.adoc[`getArgOperand`] 
| Return the `i‐th` call argument operand.
| xref:llvm/CallBase/getArgOperandNo-0b.adoc[`getArgOperandNo`] 
| `getArgOperandNo` overloads
| xref:llvm/CallBase/getArgOperandUse-0b.adoc[`getArgOperandUse`] 
| Return the `Use` for call argument `i.`
| xref:llvm/CallBase/getArgOperandWithAttribute.adoc[`getArgOperandWithAttribute`] 
| Return the first argument with attribute `Kind.`
| xref:llvm/CallBase/getAttributeAtIndex-0b.adoc[`getAttributeAtIndex`] 
| Return attribute `Kind` at attribute index `i.`
| xref:llvm/CallBase/getAttributes.adoc[`getAttributes`] 
| Return the attributes for this call.
| xref:llvm/CallBase/getBundleOpInfoForOperand-03.adoc[`getBundleOpInfoForOperand`] 
| `getBundleOpInfoForOperand` overloads
| xref:llvm/CallBase/getBundleOperandsEndIndex.adoc[`getBundleOperandsEndIndex`] 
| Return the index one past the last bundle operand in the Use array.
| xref:llvm/CallBase/getBundleOperandsStartIndex.adoc[`getBundleOperandsStartIndex`] 
| Return the index of the first bundle operand in the Use array.
| xref:llvm/CallBase/getCalledFunction.adoc[`getCalledFunction`] 
| Return the directly called `Function,` if known.
| xref:llvm/CallBase/getCalledOperand.adoc[`getCalledOperand`] 
| Return the called function or value operand.
| xref:llvm/CallBase/getCalledOperandUse-00.adoc[`getCalledOperandUse`] 
| Return the `Use` for the called operand.
| xref:llvm/CallBase/getCaller-07.adoc[`getCaller`] 
| Return the function containing this call.
| xref:llvm/CallBase/getCallingConv.adoc[`getCallingConv`] 
| Return the calling convention of this call.
| xref:llvm/CallBase/getCaptureInfo.adoc[`getCaptureInfo`] 
| Return which pointer components data operand `OpNo` may capture.
| xref:llvm/Value/getContext.adoc[`getContext`] 
| All values hold a context through their type.
| xref:llvm/CallBase/getConvergenceControlToken.adoc[`getConvergenceControlToken`] 
| Return the convergence control token for this call, if it exists.
| xref:llvm/Instruction/getDataLayout.adoc[`getDataLayout`] 
| Return the data layout of the module this instruction belongs to.
| xref:llvm/CallBase/getDataOperandNo-0b3.adoc[`getDataOperandNo`] 
| `getDataOperandNo` overloads
| 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/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/CallBase/getFnAttr-0b.adoc[`getFnAttr`] 
| Return function attribute `Kind,` including callee lookup if needed.
| xref:llvm/Instruction/getFunction-0a5.adoc[`getFunction`] 
| Return the function this instruction belongs to.
| xref:llvm/CallBase/getFunctionType.adoc[`getFunctionType`] 
| Return the function type of this call.
| xref:llvm/Instruction/getInsertionPointAfterDef.adoc[`getInsertionPointAfterDef`] 
| Return the first insertion point at which this instruction's result is defined.
| xref:llvm/IntrinsicInst/getIntrinsicID.adoc[`getIntrinsicID`] 
| Return the intrinsic ID of this intrinsic.
| xref:llvm/CallBase/getMemoryEffects.adoc[`getMemoryEffects`] 
| Return the memory effects of this call.
| 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/CallBase/getNumOperandBundles.adoc[`getNumOperandBundles`] 
| Return the number of operand bundles on this call.
| xref:llvm/CallBase/getNumOperands.adoc[`getNumOperands`] 
| Return the total number of operands (arguments, called value, and extras).
| xref:llvm/Instruction/getNumSuccessors.adoc[`getNumSuccessors`] 
| Return the number of successors that this terminator has.
| xref:llvm/CallBase/getNumTotalBundleOperands.adoc[`getNumTotalBundleOperands`] 
| Return the total number of bundle input operands on this call.
| xref:llvm/Value/getNumUses.adoc[`getNumUses`] 
| This method computes the number of uses of this Value.
| xref:llvm/Instruction/getOpcode.adoc[`getOpcode`] 
| Return the opcode of this instruction as a member of the opcode enums.
| xref:llvm/Instruction/getOpcodeName-01.adoc[`getOpcodeName`] 
| Return the mnemonic name for this instruction's opcode.
| xref:llvm/CallBase/getOperand.adoc[`getOperand`] 
| Return operand at index `i_nocapture.`
| xref:llvm/CallBase/getOperandBundle-0c.adoc[`getOperandBundle`] 
| `getOperandBundle` overloads
| xref:llvm/CallBase/getOperandBundleAt.adoc[`getOperandBundleAt`] 
| Return the operand bundle at a specific index.
| xref:llvm/CallBase/getOperandBundleForOperand.adoc[`getOperandBundleForOperand`] 
| Return the operand bundle containing the operand at index `OpIdx.`
| xref:llvm/CallBase/getOperandBundlesAsDefs.adoc[`getOperandBundlesAsDefs`] 
| Copy operand bundles on this call into `Defs.`
| xref:llvm/User/getOperandList-07.adoc[`getOperandList`] 
| `getOperandList` overloads
| xref:llvm/User/getOperandUse-01.adoc[`getOperandUse`] 
| `getOperandUse` overloads
| xref:llvm/CallBase/getParamAlign.adoc[`getParamAlign`] 
| Return the alignment for argument `ArgNo,` if known.
| xref:llvm/CallBase/getParamAttr-0f.adoc[`getParamAttr`] 
| Return parameter attribute `Kind` for argument `ArgNo.`
| xref:llvm/CallBase/getParamAttributes.adoc[`getParamAttributes`] 
| Return the param attributes for argument `ArgNo.`
| xref:llvm/CallBase/getParamByRefType.adoc[`getParamByRefType`] 
| Return the byref type for argument `ArgNo.`
| xref:llvm/CallBase/getParamByValType.adoc[`getParamByValType`] 
| Return the byval type for argument `ArgNo.`
| xref:llvm/CallBase/getParamDereferenceableBytes.adoc[`getParamDereferenceableBytes`] 
| Return dereferenceable bytes for argument `i.`
| xref:llvm/CallBase/getParamDereferenceableOrNullBytes.adoc[`getParamDereferenceableOrNullBytes`] 
| Return dereferenceable_or_null bytes for argument `i.`
| xref:llvm/CallBase/getParamElementType.adoc[`getParamElementType`] 
| Return the elementtype for argument `ArgNo.`
| xref:llvm/CallBase/getParamInAllocaType.adoc[`getParamInAllocaType`] 
| Return the inalloca type for argument `ArgNo.`
| xref:llvm/CallBase/getParamNoFPClass.adoc[`getParamNoFPClass`] 
| Return disallowed FP classes for argument `i.`
| xref:llvm/CallBase/getParamPreallocatedType.adoc[`getParamPreallocatedType`] 
| Return the preallocated type for argument `ArgNo.`
| xref:llvm/CallBase/getParamStackAlign.adoc[`getParamStackAlign`] 
| Return the stack alignment for argument `ArgNo,` if specified.
| xref:llvm/CallBase/getParamStructRetType.adoc[`getParamStructRetType`] 
| Return the sret type for argument `ArgNo.`
| 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/Instruction/getPrevNode-02.adoc[`getPrevNode`] 
| `getPrevNode` overloads
| xref:llvm/CallBase/getRange.adoc[`getRange`] 
| Return the constant range of the return value, if any.
| xref:llvm/Value/getRawSubclassOptionalData.adoc[`getRawSubclassOptionalData`] 
| Return the raw optional flags value contained in this value.
| xref:llvm/CallBase/getRetAlign.adoc[`getRetAlign`] 
| Return the alignment of the return value, if known.
| xref:llvm/CallBase/getRetAttr.adoc[`getRetAttr`] 
| Return return attribute `Kind,` including callee lookup if needed.
| xref:llvm/CallBase/getRetAttributes.adoc[`getRetAttributes`] 
| Return the return attributes for this call.
| xref:llvm/CallBase/getRetDereferenceableBytes.adoc[`getRetDereferenceableBytes`] 
| Return dereferenceable bytes for the return value.
| xref:llvm/CallBase/getRetDereferenceableOrNullBytes.adoc[`getRetDereferenceableOrNullBytes`] 
| Return dereferenceable_or_null bytes for the return value.
| xref:llvm/CallBase/getRetNoFPClass.adoc[`getRetNoFPClass`] 
| Return disallowed FP classes for the return value.
| xref:llvm/CallBase/getReturnedArgOperand.adoc[`getReturnedArgOperand`] 
| Return the argument marked with the returned attribute.
| xref:llvm/Value/getSingleUndroppableUse-0d.adoc[`getSingleUndroppableUse`] 
| `getSingleUndroppableUse` overloads
| 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/CallInst/getTailCallKind.adoc[`getTailCallKind`] 
| Return the tail‐call kind.
| 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/CallBase/hasArgument.adoc[`hasArgument`] 
| Return true if `V` is passed as an argument to the called function.
| xref:llvm/CallBase/hasArgumentWithAdditionalReturnCaptureComponents.adoc[`hasArgumentWithAdditionalReturnCaptureComponents`] 
| Return true if some argument has extra return capture components.
| 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/CallBase/hasByValArgument.adoc[`hasByValArgument`] 
| Return true if any call argument has the byval attribute.
| xref:llvm/CallBase/hasClobberingOperandBundles.adoc[`hasClobberingOperandBundles`] 
| Return whether any operand bundle on this call may write to the heap.
| xref:llvm/Instruction/hasDbgRecords.adoc[`hasDbgRecords`] 
| Return true if any DbgRecords are attached to this instruction.
| xref:llvm/CallBase/hasDeoptState.adoc[`hasDeoptState`] 
| Return whether this call has a deopt‐state operand bundle.
| xref:llvm/CallBase/hasFnAttr-05.adoc[`hasFnAttr`] 
| Return true if this call has function attribute `Kind.`
| xref:llvm/CallBase/hasIdenticalOperandBundleSchema.adoc[`hasIdenticalOperandBundleSchema`] 
| Return whether this call has the same operand bundle layout as `Other.`
| xref:llvm/CallBase/hasInAllocaArgument.adoc[`hasInAllocaArgument`] 
| Return true if the last argument has the inalloca attribute.
| 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/CallBase/hasOperandBundles.adoc[`hasOperandBundles`] 
| Return whether this call has any operand bundles.
| xref:llvm/CallBase/hasOperandBundlesOtherThan.adoc[`hasOperandBundlesOtherThan`] 
| Return whether this call has operand bundles whose tags are not in `IDs.`
| 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/CallBase/hasReadingOperandBundles.adoc[`hasReadingOperandBundles`] 
| Return whether any operand bundle on this call may read from the heap.
| xref:llvm/CallBase/hasRetAttr-0a.adoc[`hasRetAttr`] 
| Return true if the return value has attribute `Kind.`
| xref:llvm/Instruction/hasSameSpecialState.adoc[`hasSameSpecialState`] 
| Return true if `I2` has the same opcode‐specific state as this instruction.
| xref:llvm/CallBase/hasStructRetAttr.adoc[`hasStructRetAttr`] 
| Return true if the call returns a structure via the first pointer arg.
| 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/CallBase/isArgOperand-02.adoc[`isArgOperand`] 
| `isArgOperand` overloads
| xref:llvm/Instruction/isArithmeticShift.adoc[`isArithmeticShift`] 
| Return true if this is an arithmetic shift right.
| xref:llvm/IntrinsicInst/isAssociative.adoc[`isAssociative`] 
| Return true if this intrinsic is an associative operation.
| xref:llvm/IntrinsicInst/isAssumeLikeIntrinsic.adoc[`isAssumeLikeIntrinsic`] 
| Checks if the intrinsic is an annotation.
| 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/CallBase/isBundleOperand-0d.adoc[`isBundleOperand`] 
| `isBundleOperand` overloads
| xref:llvm/CallBase/isByValArgument.adoc[`isByValArgument`] 
| Return true if argument `ArgNo` is passed by value.
| xref:llvm/CallBase/isCallee-04.adoc[`isCallee`] 
| `isCallee` overloads
| xref:llvm/Instruction/isCast-0a.adoc[`isCast`] 
| Return true if this instruction is a cast.
| xref:llvm/IntrinsicInst/isCommutableOperand.adoc[`isCommutableOperand`] 
| Return true if operand `Op` participates in a commutative intrinsic.
| xref:llvm/IntrinsicInst/isCommutative.adoc[`isCommutative`] 
| Return true if swapping the first two arguments to the intrinsic produces the same result.
| xref:llvm/CallBase/isConvergent.adoc[`isConvergent`] 
| Return true if this call is convergent.
| xref:llvm/CallBase/isDataOperand-07.adoc[`isDataOperand`] 
| `isDataOperand` overloads
| 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/CallBase/isInAllocaArgument.adoc[`isInAllocaArgument`] 
| Return true if argument `ArgNo` is passed in an alloca.
| xref:llvm/CallBase/isIndirectCall.adoc[`isIndirectCall`] 
| Return true if the callsite is an indirect call.
| xref:llvm/CallBase/isInlineAsm.adoc[`isInlineAsm`] 
| Return true if this call targets inline assembly.
| xref:llvm/Instruction/isIntDivRem-01.adoc[`isIntDivRem`] 
| Return true if this instruction is an integer division or remainder.
| 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/CallInst/isMustTailCall.adoc[`isMustTailCall`] 
| Return true if this call is marked musttail.
| xref:llvm/Instruction/isNilpotent-05.adoc[`isNilpotent`] 
| Return true if the instruction is nilpotent.
| xref:llvm/CallBase/isNoBuiltin.adoc[`isNoBuiltin`] 
| Return true if this call must not be treated as a library builtin.
| xref:llvm/CallBase/isNoInline.adoc[`isNoInline`] 
| Return true if this call must not be inlined.
| xref:llvm/CallInst/isNoTailCall.adoc[`isNoTailCall`] 
| Return true if this call is marked notail.
| xref:llvm/CallInst/isNonContinuableTrap.adoc[`isNonContinuableTrap`] 
| Return true if the call is for a noreturn trap intrinsic.
| xref:llvm/Instruction/isOnlyUserOfAnyOperand.adoc[`isOnlyUserOfAnyOperand`] 
| Return true if this instruction is the only user of at least one operand.
| xref:llvm/CallBase/isOperandBundleOfType.adoc[`isOperandBundleOfType`] 
| Return whether the operand at index `Idx` belongs to a bundle with tag ID `ID.`
| xref:llvm/CallBase/isPassPointeeByValueArgument.adoc[`isPassPointeeByValueArgument`] 
| Return true if argument `ArgNo` is passed by value on the stack.
| xref:llvm/CallBase/isPassingUndefUB.adoc[`isPassingUndefUB`] 
| Return true if passing undef to argument `ArgNo` is undefined behavior.
| xref:llvm/CallBase/isReturnNonNull.adoc[`isReturnNonNull`] 
| Return true if the return value is known non‐null.
| 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/CallBase/isStrictFP.adoc[`isStrictFP`] 
| Return true if this call requires strict floating‐point semantics.
| xref:llvm/Value/isSwiftError.adoc[`isSwiftError`] 
| Return true if this value is a swifterror value.
| xref:llvm/CallInst/isTailCall.adoc[`isTailCall`] 
| Return true if this is a tail call.
| 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/CallBase/mutateFunctionType.adoc[`mutateFunctionType`] 
| Change the function type of this call and update the result type.
| xref:llvm/Value/mutateType.adoc[`mutateType`] 
| Mutate the type of this Value to be of the specified type.
| xref:llvm/CallBase/onlyAccessesArgMemory.adoc[`onlyAccessesArgMemory`] 
| Return true if this call may only access argument‐pointee memory.
| xref:llvm/CallBase/onlyAccessesInaccessibleMemOrArgMem.adoc[`onlyAccessesInaccessibleMemOrArgMem`] 
| Return true if this call may only access arg or inaccessible memory.
| xref:llvm/CallBase/onlyAccessesInaccessibleMemory.adoc[`onlyAccessesInaccessibleMemory`] 
| Return true if this call may only access inaccessible memory.
| xref:llvm/CallBase/onlyReadsMemory-04.adoc[`onlyReadsMemory`] 
| `onlyReadsMemory` overloads
| xref:llvm/CallBase/onlyWritesMemory-00.adoc[`onlyWritesMemory`] 
| `onlyWritesMemory` overloads
| xref:llvm/CallBase/op_begin-00.adoc[`op_begin`] 
| `op_begin` overloads
| xref:llvm/CallBase/op_end-04.adoc[`op_end`] 
| `op_end` overloads
| xref:llvm/CallBase/operandBundleFromBundleOpInfo.adoc[`operandBundleFromBundleOpInfo`] 
| Map a `BOI` descriptor to an OperandBundleUse view.
| xref:llvm/CallBase/operand_bundles.adoc[`operand_bundles`] 
| Iterate over OperandBundleUse views for each bundle on this call.
| 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/CallBase/paramHasAttr.adoc[`paramHasAttr`] 
| Return true if argument `ArgNo` has attribute `Kind.`
| xref:llvm/CallBase/paramHasNonNullAttr.adoc[`paramHasNonNullAttr`] 
| Return true if argument `ArgNo` is known non‐null.
| xref:llvm/CallBase/populateBundleOperandInfos.adoc[`populateBundleOperandInfos`] 
| Populate bundle descriptors and operand uses from `Bundles.`
| xref:llvm/Value/print-0f.adoc[`print`] 
| `print` overloads
| xref:llvm/Value/printAsOperand-07.adoc[`printAsOperand`] 
| `printAsOperand` overloads
| xref:llvm/CallBase/removeAttributeAtIndex-009.adoc[`removeAttributeAtIndex`] 
| Remove attribute `Kind` at attribute index `i.`
| xref:llvm/CallBase/removeFnAttr-03.adoc[`removeFnAttr`] 
| Remove function attribute `Kind` from this call.
| xref:llvm/CallBase/removeFnAttrs.adoc[`removeFnAttrs`] 
| Remove function attributes matching `AttrsToRemove.`
| xref:llvm/Instruction/removeFromParent.adoc[`removeFromParent`] 
| This method unlinks 'this' from the containing basic block, but does not delete it.
| xref:llvm/CallBase/removeParamAttr-08.adoc[`removeParamAttr`] 
| Remove parameter attribute `Kind` from argument `ArgNo.`
| xref:llvm/CallBase/removeParamAttrs.adoc[`removeParamAttrs`] 
| Remove parameter attributes matching `AttrsToRemove` from `ArgNo.`
| xref:llvm/CallBase/removeRetAttr.adoc[`removeRetAttr`] 
| Remove return attribute `Kind` from this call.
| xref:llvm/CallBase/removeRetAttrs.adoc[`removeRetAttrs`] 
| Remove return attributes matching `AttrsToRemove.`
| 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/CallBase/returnDoesNotAlias.adoc[`returnDoesNotAlias`] 
| Return true if the return value has the noalias attribute.
| 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/CallBase/setArgOperand.adoc[`setArgOperand`] 
| Set the `i‐th` call argument operand.
| xref:llvm/CallBase/setAttributes.adoc[`setAttributes`] 
| Set the attributes for this call.
| xref:llvm/CallBase/setCalledFunction-0e0.adoc[`setCalledFunction`] 
| `setCalledFunction` overloads
| xref:llvm/CallBase/setCalledOperand.adoc[`setCalledOperand`] 
| Set the called function or value operand.
| xref:llvm/CallBase/setCallingConv.adoc[`setCallingConv`] 
| Set the calling convention for this call.
| xref:llvm/CallInst/setCanReturnTwice.adoc[`setCanReturnTwice`] 
| Mark this call as able to return twice.
| xref:llvm/CallBase/setCannotDuplicate.adoc[`setCannotDuplicate`] 
| Mark that the invoke cannot be duplicated by the optimizer.
| xref:llvm/CallBase/setCannotMerge.adoc[`setCannotMerge`] 
| Mark that the call cannot be merged with other calls by the optimizer.
| xref:llvm/CallBase/setConvergent.adoc[`setConvergent`] 
| Mark this call as convergent.
| xref:llvm/Instruction/setDebugLoc.adoc[`setDebugLoc`] 
| Set the debug location information for this instruction.
| xref:llvm/CallBase/setDoesNotAccessMemory.adoc[`setDoesNotAccessMemory`] 
| Mark the call as not accessing memory (sets MemoryEffects::none).
| xref:llvm/CallBase/setDoesNotReturn.adoc[`setDoesNotReturn`] 
| Mark this call as noreturn.
| xref:llvm/CallBase/setDoesNotThrow.adoc[`setDoesNotThrow`] 
| Mark this call as nounwind.
| 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/CallBase/setIsNoInline.adoc[`setIsNoInline`] 
| Mark this call as must‐not‐inline.
| xref:llvm/CallBase/setMemoryEffects.adoc[`setMemoryEffects`] 
| Set the memory effects of this call.
| 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/CallBase/setNotConvergent.adoc[`setNotConvergent`] 
| Remove the convergent attribute from this call.
| xref:llvm/User/setNumHungOffUseOperands.adoc[`setNumHungOffUseOperands`] 
| Set the operand count for a User with hung‐off uses.
| xref:llvm/CallBase/setOnlyAccessesArgMemory.adoc[`setOnlyAccessesArgMemory`] 
| Mark the call as only accessing argument‐pointee memory.
| xref:llvm/CallBase/setOnlyAccessesInaccessibleMemOrArgMem.adoc[`setOnlyAccessesInaccessibleMemOrArgMem`] 
| Mark the call as only accessing arg or inaccessible memory.
| xref:llvm/CallBase/setOnlyAccessesInaccessibleMemory.adoc[`setOnlyAccessesInaccessibleMemory`] 
| Mark the call as only accessing inaccessible memory.
| xref:llvm/CallBase/setOnlyReadsMemory.adoc[`setOnlyReadsMemory`] 
| Mark the call as only reading memory.
| xref:llvm/CallBase/setOnlyWritesMemory.adoc[`setOnlyWritesMemory`] 
| Mark the call as only writing memory.
| xref:llvm/CallBase/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/CallInst/setTailCall.adoc[`setTailCall`] 
| Mark or clear this call as a tail‐call candidate.
| xref:llvm/CallInst/setTailCallKind.adoc[`setTailCallKind`] 
| Set the tail‐call kind for this call.
| 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/CallBase/tryIntersectAttributes.adoc[`tryIntersectAttributes`] 
| Intersect this call's attributes with `Other's` attributes.
| xref:llvm/Instruction/updateLocationAfterHoist.adoc[`updateLocationAfterHoist`] 
| Update the debug location after hoisting this instruction to a predecessor.
| xref:llvm/CallInst/updateProfWeight.adoc[`updateProfWeight`] 
| Update profile metadata by scaling it by `S` / `T.`
| 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/CallInst/Create-08.adoc[`Create`] 
| `Create` overloads
| xref:llvm/CallBase/addOperandBundle.adoc[`addOperandBundle`] 
| Create a clone of `CB` with operand bundle `OB` added.
| xref:llvm/CoroSaveInst/classof-01.adoc[`classof`] 
| `classof` overloads
| xref:llvm/Value/dropDroppableUse.adoc[`dropDroppableUse`] 
| Remove the droppable use `U.`
| xref:llvm/Instruction/getOpcodeName-0a.adoc[`getOpcodeName`] 
| Return the mnemonic name for the given opcode (e.g. "add", "ret").
| 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/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/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/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.
| xref:llvm/IntrinsicInst/mayLowerToFunctionCall.adoc[`mayLowerToFunctionCall`] 
| Check if the intrinsic might lower into a regular function call in the course of IR transformations.
| xref:llvm/CallBase/removeOperandBundle.adoc[`removeOperandBundle`] 
| Create a clone of `CB` with operand bundle `ID` removed.
| xref:llvm/CallBase/removeOperandBundleAt.adoc[`removeOperandBundleAt`] 
| Create a clone of `CB` with the operand bundle at `Offset` removed.
|===


== 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).
|===


== Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:llvm/CallBase/getContext.adoc[`getContext`] 
| Bring Instruction::getContext into scope for CallBase users.
|===


== 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/CallBase/CallInstReservedField.adoc[`CallInstReservedField`] 
| Bitfield element reserving bits used by `CallInst` subclass data.
| xref:llvm/CallBase/CallingConvField.adoc[`CallingConvField`] 
| Bitfield element storing the call's calling convention.
| 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/CallBase/Op-03.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/CallInst/cloneImpl.adoc[`cloneImpl`] 
| Create a copy of this instruction without inserting it into a block.
| 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/CallBase/getNumSubclassExtraOperands.adoc[`getNumSubclassExtraOperands`] 
| Return how many extra operands this call subclass stores after the callee.
| xref:llvm/CallBase/getNumSubclassExtraOperandsDynamic.adoc[`getNumSubclassExtraOperandsDynamic`] 
| Get the number of extra operands for instructions that don't have a fixed number of extra operands.
| 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/CallBase/hasDescriptor.adoc[`hasDescriptor`] 
| Return true if this call has an attached descriptor (operand‐bundle info).
| 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/CallBase/CountBundleInputs.adoc[`CountBundleInputs`] 
| Return the total number of bundle input values in `Bundles.`
| 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/CallBase/Attrs.adoc[`Attrs`] 
| parameter attributes for callable
| xref:llvm/FastMathFlagsStorage/FMF.adoc[`FMF`] 
| Fast‐math flags stored by the instruction.
| xref:llvm/CallBase/FTy.adoc[`FTy`] 
| Function type of the call (return type, parameter types, varargs).
| 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.
|===


== Protected Static Data Members

[cols="1,4"]
|===
| Name| Description
| xref:llvm/CallBase/CalledOperandOpEndIdx.adoc[`CalledOperandOpEndIdx`] 
| The last operand is the called operand.
|===


== Protected Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:llvm/CallBase/2constructor-03.adoc[`CallBase`] 
| Inherit `Instruction` constructors for call‐like subclasses.
|===


== Non-Member Functions

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


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