llvm::Argument

Synopsis

Declared in <llvm/IR/Argument.h>

class Argument final
    : public Value

Description

A formal argument, since it is formal'', does not contain an actual value but instead represents the type, argument number, and attributes of an argument for a specific function. When used in the body of said function, the argument of course represents the value of the actual argument that the function was called with.

Base Classes

Name	Description
`Value`	LLVM Value Representation

Type Aliases

Name	Description
`const_use_iterator`	Const iterator over this value's uses.
`const_user_iterator`	Const iterator over this value's users.
`use_iterator`	Iterator over this value's uses.
`user_iterator`	Iterator over this value's users.

Enums

Name	Description
`ValueTy`	Concrete subclass of this.

Member Functions

Name	Description
`Argument` [constructor]	Argument constructor.
`operator=` [deleted]	Values are identity objects and cannot be copy-assigned.
`DoPHITranslation`	`DoPHITranslation` overloads
`addAttr`	Add an attribute to this argument.
`addAttrs`	Add attributes to an argument.
`addUse`	This method should only be used by the Use class.
`assertModuleIsMaterialized`	Assert in debug builds that modules containing this value are materialized.
`assertModuleIsMaterializedImpl`	Assert that every module containing this value is fully materialized.
`canBeFreed`	Return true if this pointer's memory may be freed in its defining scope.
`deleteValue`	Delete a pointer to a generic Value.
`dropDroppableUses`	Remove every uses that can safely be removed.
`dropDroppableUsesIn`	Remove every use of this value in `User` that can safely be removed.
`dump`	Support for debugging, callable in GDB: V->dump()
`getArgNo`	Return the index of this formal argument in its containing function.
`getAttribute`	Return the attribute object for the given kind.
`getAttributes`	Return the attribute set attached to this argument.
`getContext`	All values hold a context through their type.
`getDeadOnReturnInfo`	Returns information on the memory marked dead_on_return for the argument.
`getDereferenceableBytes`	If this argument has the dereferenceable attribute, return the number of bytes known to be dereferenceable. Otherwise, zero is returned.
`getDereferenceableOrNullBytes`	If this argument has the dereferenceable_or_null attribute, return the number of bytes known to be dereferenceable. Otherwise, zero is returned.
`getName`	Return a constant reference to the value's name.
`getNameOrAsOperand`	Return this value's name, or a printed operand string if it is unnamed.
`getNoFPClass`	If this argument has nofpclass attribute, return the mask representing disallowed floating-point values. Otherwise, fcNone is returned.
`getNumUses`	This method computes the number of uses of this Value.
`getParamAlign`	If this is a byval or inalloca argument, return its alignment.
`getParamByRefType`	If this is a byref argument, return its type.
`getParamByValType`	If this is a byval argument, return its type.
`getParamInAllocaType`	If this is an inalloca argument, return its type.
`getParamStackAlign`	If this argument has the `alignstack` attribute, return the requested stack alignment. Otherwise, return an empty alignment.
`getParamStructRetType`	If this is an sret argument, return its type.
`getParent`	Return the function that owns this argument.
`getPassPointeeByValueCopySize`	If this argument satisfies has hasPassPointeeByValueAttr, return the in-memory ABI size copied to the stack for the call. Otherwise, return 0.
`getPointeeInMemoryValueType`	If hasPointeeInMemoryValueAttr returns true, the in-memory ABI type is returned. Otherwise, nullptr.
`getPointerAlignment`	Returns an alignment of the pointer value.
`getPointerDereferenceableBytes`	Returns the number of bytes known to be dereferenceable for the pointer value.
`getPointerOffsetFrom`	If this ptr is provably equal to `Other` plus a constant offset, return that offset in bytes. Essentially `ptr this` subtract `ptr Other`.
`getRange`	If this argument has a range attribute, return the value range of the argument. Otherwise, std::nullopt is returned.
`getRawSubclassOptionalData`	Return the raw optional flags value contained in this value.
`getSingleUndroppableUse`	`getSingleUndroppableUse` overloads
`getType`	All values are typed, get the type of this value.
`getUniqueUndroppableUser`	`getUniqueUndroppableUser` overloads
`getValueID`	Return an ID for the concrete type of this object.
`getValueName`	Return the symbol-table name entry for this value, if any.
`hasAttribute`	`hasAttribute` overloads
`hasByRefAttr`	Return true if this argument has the byref attribute.
`hasByValAttr`	Return true if this argument has the byval attribute.
`hasInAllocaAttr`	Return true if this argument has the inalloca attribute.
`hasInRegAttr`	Return true if this argument has the inreg attribute.
`hasNUndroppableUses`	Return true if this value has exactly N undroppable uses.
`hasNUndroppableUsesOrMore`	Return true if this value has N undroppable uses or more.
`hasNUses`	Return true if this Value has exactly N uses.
`hasNUsesOrMore`	Return true if this value has N uses or more.
`hasName`	Return true if this value has a name in the symbol table.
`hasNestAttr`	Return true if this argument has the nest attribute.
`hasNoAliasAttr`	Return true if this argument has the noalias attribute.
`hasNoCaptureAttr`	Return true if this argument has the nocapture attribute.
`hasNoFreeAttr`	Return true if this argument has the nofree attribute.
`hasNonNullAttr`	Return true if this argument has the nonnull attribute.
`hasOneUse`	Return true if there is exactly one use of this value.
`hasOneUser`	Return true if there is exactly one user of this value.
`hasPassPointeeByValueCopyAttr`	Return true if this argument has the byval, inalloca, or preallocated attribute.
`hasPointeeInMemoryValueAttr`	Return true if this argument has the byval, sret, inalloca, preallocated, or byref attribute.
`hasPreallocatedAttr`	Return true if this argument has the preallocated attribute.
`hasReturnedAttr`	Return true if this argument has the returned attribute.
`hasSExtAttr`	Return true if this argument has the sext attribute.
`hasStructRetAttr`	Return true if this argument has the sret attribute.
`hasSwiftErrorAttr`	Return true if this argument has the swifterror attribute.
`hasSwiftSelfAttr`	Return true if this argument has the swiftself attribute.
`hasUseList`	Check if this Value has a use-list.
`hasValueHandle`	Return true if there is a value handle associated with this value.
`hasZExtAttr`	Return true if this argument has the zext attribute.
`isSwiftError`	Return true if this value is a swifterror value.
`isUsedByMetadata`	Return true if there is metadata referencing this value.
`isUsedInBasicBlock`	Check if this value is used in the specified basic block.
`materialized_use_begin`	`materialized_use_begin` overloads
`materialized_use_empty`	Return true if there are no currently materialized uses.
`materialized_user_begin`	`materialized_user_begin` overloads
`materialized_users`	`materialized_users` overloads
`materialized_uses`	`materialized_uses` overloads
`mutateType`	Mutate the type of this Value to be of the specified type.
`onlyReadsMemory`	Return true if this argument has the readonly or readnone attribute.
`print`	`print` overloads
`printAsOperand`	`printAsOperand` overloads
`removeAttr`	Remove attributes from an argument.
`removeAttrs`	Remove attributes from this argument.
`replaceAllUsesWith`	Change all uses of this to point to a new Value.
`replaceNonMetadataUsesWith`	Change non-metadata uses of this to point to a new Value.
`replaceUsesOutsideBlock`	Replace uses of this value that occur outside `BB` with `V.`
`replaceUsesWithIf`	Replace selected uses of this value with `New.`
`reverseUseList`	Reverse the use-list.
`setName`	Change the name of the value.
`setValueName`	Set the symbol-table name entry for this value.
`sortUseList`	Sort the use-list.
`stripAndAccumulateConstantOffsets`	`stripAndAccumulateConstantOffsets` overloads
`stripAndAccumulateInBoundsConstantOffsets`	`stripAndAccumulateInBoundsConstantOffsets` overloads
`stripInBoundsConstantOffsets`	`stripInBoundsConstantOffsets` overloads
`stripInBoundsOffsets`	`stripInBoundsOffsets` overloads
`stripPointerCasts`	`stripPointerCasts` overloads
`stripPointerCastsAndAliases`	`stripPointerCastsAndAliases` overloads
`stripPointerCastsForAliasAnalysis`	`stripPointerCastsForAliasAnalysis` overloads
`stripPointerCastsSameRepresentation`	`stripPointerCastsSameRepresentation` overloads
`takeName`	Transfer the name from V to this value.
`use_begin`	`use_begin` overloads
`use_empty`	Return true if this value has no uses.
`use_end`	`use_end` overloads
`user_back`	Return the sole user when this value has exactly one user.
`user_begin`	Return an iterator to the first user of this value.
`user_empty`	Return true if this value has no users.
`user_end`	`user_end` overloads
`users`	`users` overloads
`uses`	`uses` overloads

Static Member Functions

Name	Description
`classof`	Method for support type inquiry through isa, cast, and dyn_cast.
`dropDroppableUse`	Remove the droppable use `U.`

Static Data Members

Name	Description
`MaxAlignmentExponent`	The maximum alignment for instructions.
`MaximumAlignment`	Maximum absolute alignment in bytes (`1` << MaxAlignmentExponent).

Protected Enums

Name	Description
`Unnamed enum`	The number of operands in the subclass.

Protected Member Functions

Name	Description
`addMetadata`	`addMetadata` overloads
`clearMetadata`	Erase all metadata attached to this Value.
`eraseMetadata`	Erase all metadata attachments with the given kind.
`eraseMetadataIf`	Erase all metadata attachments matching the given predicate.
`getAllMetadata`	Append all metadata attached to this value into `MDs.`
`getMetadata`	Get the current metadata attachments for the given kind, if any.
`getMetadataImpl`	Get metadata for the given kind, if any.
`getSubclassDataFromValue`	Return the opaque subclass data bits stored in this value.
`setMetadata`	`setMetadata` overloads
`setValueSubclassData`	Set the opaque subclass data bits stored in this value.

Protected Data Members

Name	Description
`HasDescriptor`	True if this value has a descriptor.
`HasHungOffUses`	Whether operands are stored in a separately allocated array.
`HasName`	True if this value has a name in the symbol table.
`IsUsedByMD`	True if metadata references this value.
`NumUserOperands`	Number of operands in this user.
`SubclassOptionalData`	Hold arbitary subclass data.

Friends

Name	Description
`llvm::Function`	A single function or procedure in LLVM IR.

Non-Member Functions

Name	Description
`ComputeMaxSignificantBits`	Get the upper bound on bit size for this Value `Op` as a signed integer.
`ComputeNumSignBits`	Return the number of times the sign bit of the register is replicated into the other bits.
`ExtractTypeInfo`	ExtractTypeInfo - Returns the type info, possibly bitcast, encoded in V.
`FindEarliestCapture`	Find the earliest instruction that captures `V` in `F.`
`FindInsertedValue`	Given an aggregate and a sequence of indices, see if the scalar value indexed is already around as a register.
`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.
`GetPointerBaseWithConstantOffset`	Const overload of GetPointerBaseWithConstantOffset.
`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.
`MapValue`	Look up or compute a value in the value map.
`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.
`PointerMayBeCaptured`	Visit a pointer and derived values to find capturing uses.
`PointerMayBeCaptured`	Return which components of the pointer may be captured.
`PointerMayBeCaptured`	Return true if this pointer may be captured by the enclosing function.
`PointerMayBeCapturedBefore`	Return true if this pointer may be captured before a given instruction.
`PointerMayBeCapturedBefore`	Return which components of the pointer may be captured on the path to `I.`
`RecursivelyDeleteTriviallyDeadInstructions`	Recursively delete a trivially dead instruction and its dead operands.
`SplitBlockAndInsertForEachLane`	Invoke a callback once for each lane up to an effective vector length.
`SplitBlockAndInsertIfElse`	Split a block and insert an else-branch at an instruction.
`SplitBlockAndInsertIfElse`	Split a block and insert a conditional else-branch around the split point.
`SplitBlockAndInsertIfThen`	Split a block and insert a then-branch at an instruction.
`SplitBlockAndInsertIfThen`	Split a block and insert a conditional then-branch around the split point.
`SplitBlockAndInsertIfThenElse`	Split a block and insert optional then/else blocks around the split point.
`SplitBlockAndInsertIfThenElse`	Split a block and insert optional then/else blocks at an instruction.
`SplitBlockAndInsertIfThenElse`	Split a block and insert both then and else branches around the split point.
`SplitBlockAndInsertIfThenElse`	Split a block and insert then/else branches at an instruction.
`SplitBlockAndInsertSimpleForLoop`	Insert a simple counted for-loop at a split point.
`applyProfMetadataIfEnabled`	Apply a metadata callback if `V` is an instruction and profiling is enabled.
`assumeBundleImpliesNonNull`	Return true if the given assume operand bundle implies that `Val` is non-null.
`canReplacePointersIfEqual`	Returns true if pointer `From` can be replaced with equal pointer `To.`
`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.
`cannotBeOrderedLessThanZero`	Return true if we can prove that the specified FP value is either NaN or never less than -0.0.
`classifyEHPersonality`	See if the given exception handling personality function is one that we understand. If so, return a description of it; otherwise return Unknown.
`collectPossibleValues`	Enumerate immediate constant values of `V` into `Constants.`
`computeConstantRange`	Determine the possible constant range of an integer or vector of integer value. This is intended as a cheap, non-recursive check.
`computeKnownBits`	Returns the known bits rather than passing by reference.
`computeKnownBits`	Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOne bit sets.
`computeKnownBits`	Returns the known bits rather than passing by reference.
`computeKnownBits`	Compute known bits for the demanded elements of `V` using `Q.`
`computeKnownBits`	Compute known bits for `V` into `Known` using the simplify query `Q.`
`computeKnownBits`	Compute known bits for `V` using the simplify query `Q.`
`computeKnownBitsFromContext`	Merge bits known from context-dependent facts into Known.
`computeKnownFPClass`	Wrapper to account for known fast math flags at the use instruction.
`computeKnownFPClass`	Determine known floating-point classes for `V.`
`computeKnownFPClass`	Wrapper to account for known fast math flags at the use instruction.
`computeKnownFPClass`	Determine which floating-point classes are valid for `V,` and return them in KnownFPClass bit sets.
`computeKnownFPClass`	Determine known floating-point classes for `V` using explicit analysis context.
`computeKnownFPSignBit`	Return the known sign bit of a floating-point value, if provable.
`computeOverflowForSignedMul`	Compute whether a signed multiply of `LHS` and `RHS` can overflow.
`computeOverflowForSignedSub`	Compute whether a signed subtract of `LHS` and `RHS` can overflow.
`computeOverflowForUnsignedMul`	Compute whether an unsigned multiply of `LHS` and `RHS` can overflow.
`computeOverflowForUnsignedSub`	Compute whether an unsigned subtract of `LHS` and `RHS` can overflow.
`decomposeBitTest`	Decompose an icmp into the form ((X & Mask) pred C) if possible.
`decomposeBitTestICmp`	Decompose an icmp into the form ((X & Mask) pred C) if possible.
`emitBCmp`	Emit a call to the bcmp function.
`emitBinaryFloatFnCall`	Emit a call to the binary floating-point libcall named Name.
`emitBinaryFloatFnCall`	Emit a call to the binary DoubleFn, FloatFn, or LongDoubleFn for Op1's type.
`emitCalloc`	Emit a call to the calloc function.
`emitFPutC`	Emit a call to fputc with an int Char and a FILE pointer.
`emitFPutS`	Emit a call to fputs with a string pointer and a FILE pointer.
`emitFWrite`	Emit a call to fwrite with a pointer, size_t Size, and FILE pointer.
`emitHotColdNew`	Emit a call to the hot/cold operator new function.
`emitHotColdNewAligned`	Emit a call to the hot/cold aligned operator new function.
`emitHotColdNewAlignedNoThrow`	Emit a call to the hot/cold aligned nothrow operator new function.
`emitHotColdNewNoThrow`	Emit a call to the hot/cold nothrow operator new function.
`emitHotColdSizeReturningNew`	Emit a call to the hot/cold size-returning operator new function.
`emitHotColdSizeReturningNewAligned`	Emit a call to the hot/cold size-returning aligned operator new function.
`emitMalloc`	Emit a call to the malloc function.
`emitMemCCpy`	Emit a call to the memccpy function.
`emitMemChr`	Emit a call to memchr with a pointer, int Val, and size_t Len.
`emitMemCmp`	Emit a call to the memcmp function.
`emitMemCpyChk`	Emit a call to __memcpy_chk with size_t Len/ObjSize and pointer Dst/Src.
`emitMemPCpy`	Emit a call to the mempcpy function.
`emitMemRChr`	Emit a call to the memrchr function, analogously to emitMemChr.
`emitPutChar`	Emit a call to putchar, assuming Char is an int.
`emitPutS`	Emit a call to puts, assuming Str is some pointer.
`emitSNPrintf`	Emit a call to the snprintf function.
`emitSPrintf`	Emit a call to the sprintf function.
`emitStpCpy`	Emit a call to stpcpy for the specified pointer arguments.
`emitStpNCpy`	Emit a call to stpncpy for the specified pointer arguments and length.
`emitStrCat`	Emit a call to the strcat function.
`emitStrChr`	Emit a call to strchr for the specified pointer and character.
`emitStrCpy`	Emit a call to strcpy for the specified pointer arguments.
`emitStrDup`	Emit a call to strdup for the specified pointer.
`emitStrLCat`	Emit a call to the strlcat function.
`emitStrLCpy`	Emit a call to the strlcpy function.
`emitStrLen`	Emit a call to strlen for the specified pointer.
`emitStrNCat`	Emit a call to the strncat function.
`emitStrNCmp`	Emit a call to the strncmp function to the builder.
`emitStrNCpy`	Emit a call to strncpy for the specified pointer arguments and length.
`emitUnaryFloatFnCall`	Emit a call to the unary DoubleFn, FloatFn, or LongDoubleFn for Op's type.
`emitUnaryFloatFnCall`	Emit a call to the unary floating-point libcall named Name.
`emitVSNPrintf`	Emit a call to the vsnprintf function.
`emitVSPrintf`	Emit a call to the vsprintf function.
`emitWcsLen`	Emit a call to wcslen for the specified pointer.
`findAllocaForValue`	Const overload of findAllocaForValue.
`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.
`findDVRDeclareValues`	As above, for DVRDeclareValues.
`findDVRDeclares`	Finds dbg.declare records declaring local variables as living in the memory that 'V' points to.
`findDVRValues`	As above, for DVRValues.
`findDbgUsers`	Finds the debug info records describing a value.
`findDbgValues`	Finds the dbg.values describing a value.
`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.
`findValuesAffectedByCondition`	Call `InsertAffected` on all Values whose known bits / value may be affected by the condition `Cond.` Used by AssumptionCache and DomConditionCache.
`getAllocationFamily`	If a function is part of an allocation family (e.g. malloc/realloc/calloc/free), return the identifier for its family of functions.
`getBaseObjectSize`	Like getObjectSize(), but only for base objects.
`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.
`getConstantStringInfo`	Compute the contents of a null-terminated C string pointed to by `V.`
`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.
`getKnowledgeForValue`	Return a valid Knowledge associated to the Value V if its Attribute kind is in AttrKinds and it matches the Filter.
`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.
`getKnownAlignment`	Infer a known alignment for the specified pointer.
`getLoadStoreAddressSpace`	Return the address space of the pointer operand of load or store `I.`
`getLoadStoreAlignment`	Return the alignment of load or store instruction `I.`
`getLoadStorePointerOperand`	Return the pointer operand of a load or store, or null if `V` is neither.
`getLoadStorePointerOperand`	Return the pointer operand of a load or store, or null if `V` is neither.
`getLoadStoreType`	Return the value type accessed by load or store instruction `I.`
`getObjectSize`	Compute the size of the object pointed by Ptr.
`getOrEnforceKnownAlignment`	Return a known alignment for a value, optionally raising it first.
`getPointerOperand`	Return the pointer operand of a load, store, or GEP, or null otherwise.
`getPointerOperand`	Non-const overload of getPointerOperand.
`getSplatValue`	Get splat value if the input is a splat vector or return nullptr.
`getUnderlyingObject`	Strip GEP adjustments, pointer casts, and threadlocal.address from `V.`
`getUnderlyingObject`	Non-const overload of getUnderlyingObject.
`getUnderlyingObjectAggressive`	Like getUnderlyingObject(), but will try harder to find a single underlying object. In particular, this function also looks through selects and phis.
`getUnderlyingObjects`	This method is similar to getUnderlyingObject except that it can look through phi and select instructions and return multiple objects.
`getUnderlyingObjectsForCodeGen`	This is a wrapper around getUnderlyingObjects and adds support for basic ptrtoint+arithmetic+inttoptr sequences.
`impliesPoison`	Return true if V is poison given that ValAssumedPoison is already poison.
`invertCondition`	Invert a boolean condition, reusing an existing inverted copy when possible.
`isAllocLikeFn`	Tests if a value is a call or invoke to a library function that allocates memory (either malloc, calloc, or strdup like).
`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).
`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).
`isBaseOfObject`	Return true if V is known to be the base of its memory object.
`isBytewiseValue`	If the specified value can be set by repeating the same byte in memory, return the i8 value that it is represented with.
`isCheckForZeroAndMulWithOverflow`	Return true if `Op0` and `Op1` match a zero check with mul-with-overflow.
`isCheckForZeroAndMulWithOverflow`	Return true if `Op0` and `Op1` match a zero check with mul-with-overflow.
`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.
`isDereferenceableAndAlignedPointer`	Returns true if V is always a dereferenceable pointer with sufficient alignment.
`isDereferenceableAndAlignedPointer`	Returns true if V is always dereferenceable for Size bytes with sufficient alignment.
`isDereferenceablePointer`	Equivalent to isDereferenceableAndAlignedPointer with an alignment of 1.
`isDereferenceablePointer`	Equivalent to isDereferenceableAndAlignedPointer with an alignment of 1.
`isEscapeSource`	Returns true if the pointer is one which would have been considered an escape by isNotCapturedBefore.
`isGuaranteedNotToBePoison`	Iterator-context overload of isGuaranteedNotToBePoison.
`isGuaranteedNotToBePoison`	Returns true if V cannot be poison, but may be undef.
`isGuaranteedNotToBeUndef`	Returns true if V cannot be undef, but may be poison.
`isGuaranteedNotToBeUndefOrPoison`	Return true if this function can prove that V does not have undef bits and is never poison.
`isIdentifiedFunctionLocal`	Return true if V is unambiguously identified at the function level.
`isIdentifiedObject`	Return true if this pointer refers to a distinct and identifiable object.
`isImpliedByDomCondition`	Return the boolean condition value in the context of the given instruction if it is known based on dominating conditions.
`isImpliedCondition`	Return whether a compare is implied true or false by `LHS,` if known.
`isImpliedCondition`	Return whether RHS is implied true or false by LHS, if known.
`isKnownIntegral`	Return true if the floating-point value `V` is known to be an integer value.
`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.
`isKnownNegation`	Return true if the two given values are negation.
`isKnownNegative`	Returns true if the given value is known be negative (i.e. non-positive and non-zero).
`isKnownNeverInfOrNaN`	Return true if the floating-point value can never contain a NaN or infinity.
`isKnownNeverInfinity`	Return true if the floating-point scalar value is not an infinity or if the floating-point vector value has no infinities.
`isKnownNeverNaN`	Return true if the floating-point scalar value is not a NaN or if the floating-point vector value has no NaN elements.
`isKnownNonEqual`	Return true if the given values are known to be non-equal when defined. Supports scalar integer types only.
`isKnownNonNegative`	Returns true if the give value is known to be non-negative.
`isKnownNonZero`	Return true if the given value is known to be non-zero when defined.
`isKnownPositive`	Returns true if the given value is known be positive (i.e. non-negative and non-zero).
`isKnownToBeAPowerOfTwo`	Return true if the given value is known to have exactly one bit set when defined.
`isKnownToBeAPowerOfTwo`	Return true if `V` is known to be a power of two when defined.
`isNoAliasCall`	Return true if this pointer is returned by a noalias function.
`isNotVisibleOnUnwind`	Return true if Object memory is not visible after an unwind.
`isSafeToLoadUnconditionally`	Return true if we know that executing a load from this value cannot trap.
`isSafeToLoadUnconditionally`	Return true if we know that executing a load from this value cannot trap.
`isSplatValue`	Return true if each element of `V` is poisoned or equal to the others.
`isWidenableCondition`	Returns true iff `V` has semantics of llvm.experimental.widenable.condition call.
`isWritableObject`	Return true if Object is writable without trapping.
`maskContainsAllOneOrUndef`	Return true if any lane of an i1 mask is known true or undef.
`matchSelectPattern`	Const overload of matchSelectPattern.
`matchSelectPattern`	Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind and providing the out parameter results if we successfully match.
`onlyUsedByLifetimeMarkers`	Return true if the only users of this pointer are lifetime markers.
`onlyUsedByLifetimeMarkersOrDroppableInsts`	Return true if the only users of this pointer are lifetime markers or droppable instructions.
`possiblyDemandedEltsInMask`	Return an APInt of active lanes for a `<Y x i1>` mask.
`propagateIRFlags`	Intersect IR flags from scalar ops `VL` onto vector op `I.`
`replaceDbgDeclare`	Replace a dbg.declare when its address is replaced.
`replaceDominatedUsesWith`	Replace uses dominated by an edge with another value.
`replaceDominatedUsesWith`	Replace uses dominated by an instruction with another value.
`replaceDominatedUsesWith`	Replace uses dominated by a block's end with another value.
`replaceDominatedUsesWithIf`	Conditionally replace uses dominated by an instruction with another value.
`replaceDominatedUsesWithIf`	Conditionally replace uses dominated by a block's end with another value.
`replaceDominatedUsesWithIf`	Conditionally replace uses dominated by an edge with another value.
`setLoadStoreAlignment`	Set the alignment of load or store instruction `I.`
`simplifyAShrInst`	Given operands for a AShr, fold the result or return nulll.
`simplifyAddInst`	Given operands for an Add, fold the result or return null.
`simplifyAndInst`	Given operands for an And, fold the result or return null.
`simplifyExtractElementInst`	Given operands for an ExtractElementInst, fold the result or return null.
`simplifyExtractValueInst`	Given operands for an ExtractValueInst, fold the result or return null.
`simplifyFAddInst`	Given operands for an FAdd, fold the result or return null.
`simplifyFDivInst`	Given operands for an FDiv, fold the result or return null.
`simplifyFMAFMul`	Given operands for the multiplication of a FMA, fold the result or return null.
`simplifyFMulInst`	Given operands for an FMul, fold the result or return null.
`simplifyFNegInst`	Given operand for an FNeg, fold the result or return null.
`simplifyFRemInst`	Given operands for an FRem, fold the result or return null.
`simplifyFSubInst`	Given operands for an FSub, fold the result or return null.
`simplifyFreezeInst`	Given an operand for a Freeze, see if we can fold the result.
`simplifyInsertElementInst`	Given operands for an InsertElement, fold the result or return null.
`simplifyInsertValueInst`	Given operands for an InsertValueInst, fold the result or return null.
`simplifyLShrInst`	Given operands for a LShr, fold the result or return null.
`simplifyMulInst`	Given operands for a Mul, fold the result or return null.
`simplifyOrInst`	Given operands for an Or, fold the result or return null.
`simplifySDivInst`	Given operands for an SDiv, fold the result or return null.
`simplifySRemInst`	Given operands for an SRem, fold the result or return null.
`simplifySelectInst`	Given operands for a SelectInst, fold the result or return null.
`simplifyShlInst`	Given operands for a Shl, fold the result or return null.
`simplifyShuffleVectorInst`	Given operands for a ShuffleVectorInst, fold the result or return null.
`simplifySubInst`	Given operands for a Sub, fold the result or return null.
`simplifyUDivInst`	Given operands for a UDiv, fold the result or return null.
`simplifyURemInst`	Given operands for a URem, fold the result or return null.
`simplifyWithOpReplaced`	See if V simplifies when its operand Op is replaced with RepOp.
`simplifyXorInst`	Given operands for an Xor, fold the result or return null.
`stripNullTest`	Const overload of stripNullTest.
`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.
`tryEnforceAlignment`	Try to raise a controlled object's alignment to a preferred value.
`wrap`	Wrap an array of `Value` pointers as opaque `LLVMValueRef` values.
`wrap`	Convert a `Value` pointer to an opaque `LLVMValueRef.`
`AA::getWithType`	Try to convert `V` to type `Ty` without introducing new instructions.
`AA::isValidInScope`	Return true if `V` is a valid value in `Scope,` that is a constant or an instruction/argument of `Scope.`
`PatternMatch::m_Deferred`	Match a deferred const Value* determined later in the same match expression.
`PatternMatch::m_Deferred`	Match a deferred Value* determined later in the same match expression.
`PatternMatch::m_Specific`	Match if we have a specific specified value.
`PatternMatch::m_Value`	Match against the nested pattern, and capture the value if we match.
`PatternMatch::m_Value`	Match a const value, capturing it if we match.
`PatternMatch::m_Value`	Match against the nested pattern, and capture the value if we match.
`PatternMatch::m_Value`	Match a value, capturing it if we match.
`VNCoercion::canCoerceMustAliasedValueToLoad`	Return true if CoerceAvailableValueToLoadType would succeed if it was called.
`VNCoercion::coerceAvailableValueToLoadType`	Try to coerce a stored value to a must-aliased load of a different type.
`VNCoercion::getValueForLoad`	Extract bits for a load from a clobbering store or load at a given offset.
`instrumentor::evaluateFilter`	Evaluate a filter expression for an instrumentation opportunity.
`objcarc::GetARCInstKind`	Map V to its ARCInstKind equivalence class.
`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.
`objcarc::GetBasicARCInstKind`	Determine which objc runtime call instruction class V belongs to.
`objcarc::GetRCIdentityRoot`	Return the RCIdentity root of value `V.`
`objcarc::GetRCIdentityRoot`	Return the non-const RCIdentity root of value `V.`
`objcarc::GetUnderlyingObjCPtr`	Return the underlying ObjC object pointer for `V.`
`objcarc::GetUnderlyingObjCPtrCached`	A wrapper for GetUnderlyingObjCPtr used for results memoization.
`objcarc::IsNullOrUndef`	Return true if `V` is a null pointer constant or undef.
`objcarc::IsObjCIdentifiedObject`	Return true if this value refers to a distinct and identifiable object.
`objcarc::IsPotentialRetainableObjPtr`	Test whether `Op` may be a retainable object pointer using alias analysis.
`objcarc::IsPotentialRetainableObjPtr`	Test whether the given value is possible a retainable object pointer.