llvm::ConstantVector

Synopsis

Declared in <llvm/IR/Constants.h>

class ConstantVector final
    : public ConstantAggregate

Base Classes

Name	Description
`ConstantAggregate`	Constant composed of other constants (for example arrays, structs, and vectors).

Types

Name	Description
`const_value_op_iterator`	Const iterator for directly iterating over the operand Values.
`value_op_iterator`	Iterator for directly iterating over the operand Values.

Type Aliases

Name	Description
`const_op_iterator`	Const iterator over this user's operand `Use` objects.
`const_op_range`	Range of const operand `Use` iterators.
`const_use_iterator`	Const iterator over this value's uses.
`const_user_iterator`	Const iterator over this value's users.
`op_iterator`	Iterator over this user's operand `Use` objects.
`op_range`	Range of mutable operand `Use` iterators.
`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
`operator=`	Assignment operators
`DoPHITranslation`	`DoPHITranslation` overloads
`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.
`containsConstantExpression`	Return true if this is a fixed width vector constant that includes any constant expressions.
`containsMatchingVectorElement`	Return true if this is a vector constant where at least one element satisfies the given predicate. Scalable vectors are not checked.
`containsPoisonElement`	Return true if this is a vector constant that includes any poison elements.
`containsUndefElement`	Return true if this is a vector constant that includes any strictly undef (not poison) elements.
`containsUndefOrPoisonElement`	Return true if this vector constant includes undef or poison elements.
`deleteValue`	Delete a pointer to a generic Value.
`destroyConstant`	Destroy this constant and any constant users that depend on it.
`dropAllReferences`	Drop all references to operands.
`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()
`getAggregateElement`	`getAggregateElement` overloads
`getContext`	All values hold a context through their type.
`getDescriptor`	Returns the descriptor co-allocated with this User instance.
`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.
`getNumOperands`	Return the number of operands.
`getNumUses`	This method computes the number of uses of this Value.
`getOperand`	`getOperand` overloads
`getOperandList`	`getOperandList` overloads
`getOperandUse`	`getOperandUse` overloads
`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`.
`getRawSubclassOptionalData`	Return the raw optional flags value contained in this value.
`getSingleUndroppableUse`	`getSingleUndroppableUse` overloads
`getSplatValue`	If all elements of the vector constant have the same value, return that value. Otherwise, return nullptr. Ignore poison elements by setting AllowPoison to true.
`getType`	Specialize the getType() method to always return a FixedVectorType, which reduces the amount of casting needed in parts of the compiler.
`getUniqueInteger`	If C is a constant integer then return its value, otherwise C must be a vector of constant integers, all equal, and the common value is returned.
`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.
`handleOperandChange`	Replace all uses of `From` with `To` within this constant.
`hasExactInverseFP`	Return true if this scalar has an exact multiplicative inverse or this vector has an exact multiplicative inverse for each element in the vector.
`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.
`hasOneLiveUse`	Return true if the constant has exactly one live use.
`hasOneUse`	Return true if there is exactly one use of this value.
`hasOneUser`	Return true if there is exactly one user of this value.
`hasUseList`	Check if this Value has a use-list.
`hasValueHandle`	Return true if there is a value handle associated with this value.
`hasZeroLiveUses`	Return true if the constant has no live uses.
`isAllOnesValue`	Return true if this is the value that would be returned by getAllOnesValue.
`isConstantUsed`	Return true if the constant has users other than constant expressions and other dangling things.
`isDLLImportDependent`	Return true if the value is dependent on a dllimport variable.
`isDroppable`	Return whether this user's uses may be dropped without affecting correctness.
`isElementWiseEqual`	Return true if this constant and `Y` are element-wise equal.
`isFiniteNonZeroFP`	Return true if this is a finite and non-zero floating-point scalar constant or a fixed width vector constant with all finite and non-zero elements.
`isManifestConstant`	Return true if a constant is ConstantData or a ConstantAggregate or ConstantExpr that contain only ConstantData.
`isMaxSignedValue`	Return true if the value is the largest signed value.
`isMinSignedValue`	Return true if the value is the smallest signed value.
`isNaN`	Return true if this is a floating-point NaN constant or a vector floating-point constant with all NaN elements.
`isNegativeZeroValue`	Return true if the value is what would be returned by getZeroValueForNegation.
`isNormalFP`	Return true if this is a normal floating-point constant.
`isNotMinSignedValue`	Return true if the value is not the smallest signed value, or, for vectors, does not contain smallest signed value elements.
`isNotOneValue`	Return true if the value is not the one value, or, for vectors, does not contain one value elements.
`isNullValue`	Return true if this is the value that would be returned by getNullValue.
`isOneValue`	Returns true if the value is one.
`isSwiftError`	Return true if this value is a swifterror value.
`isThreadDependent`	Return true if the value can vary between threads.
`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.
`needsDynamicRelocation`	Return true if this constant may generate a dynamic relocation entry.
`needsRelocation`	Return true if this constant may generate a relocation entry.
`op_begin`	`op_begin` overloads
`op_end`	`op_end` overloads
`operand_values`	`operand_values` overloads
`operands`	`operands` overloads
`operator delete`	Delete operators
`print`	`print` overloads
`printAsOperand`	`printAsOperand` overloads
`removeDeadConstantUsers`	Remove any dead constant users dangling off of this constant.
`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.
`replaceUsesOfWith`	Replace uses of one Value with another.
`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.
`setNumHungOffUseOperands`	Set the operand count for a User with hung-off uses.
`setOperand`	`setOperand` overloads
`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.
`toConstantRange`	Convert constant to an approximate constant range. For vectors, the range is the union over the element ranges. Poison elements are ignored.
`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
`value_op_begin`	`value_op_begin` overloads
`value_op_end`	`value_op_end` overloads

Static Member Functions

Name	Description
`classof`	Methods for support type inquiry through isa, cast, and dyn_cast.
`dropDroppableUse`	Remove the droppable use `U.`
`get`	Return a constant vector with elements `V.`
`getAllOnesValue`	Return the all-ones constant of type `Ty.`
`getIntegerValue`	Return the value for an integer or pointer constant, or a vector thereof, with the given scalar value.
`getNullValue`	Return the null constant of type `Ty` (zero for integers, null for pointers, and so on).
`getSplat`	Return a ConstantVector with the specified constant in each element.
`mergeUndefsWith`	Merge undef elements from `Other` into constant `C.`
`replaceUndefsWith`	Try to replace undefined constant `C` or undefined elements in `C` with `Replacement.` If no changes are made, the constant `C` is returned.

Static Data Members

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

Protected Types

Name	Description
`AllocInfo`	Information about how a User object was allocated, to be passed into the User constructor.
`HungOffOperandsAllocMarker`	Indicates this User has operands "hung off" in another allocation.
`IntrusiveOperandsAllocMarker`	Indicates this User has operands co-allocated.
`IntrusiveOperandsAndDescriptorAllocMarker`	Indicates this User has operands and a descriptor co-allocated .

Protected Enums

Name	Description
`Unnamed enum`	SubclassOptionalData bits. Low bits are used by ConstantExpr.

Protected Member Functions

Name	Description
`Op`	`Op` overloads
`addMetadata`	`addMetadata` overloads
`allocHungoffUses`	Allocate the array of Uses, followed by a pointer (with bottom bit set) to the User.
`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.
`growHungoffUses`	Grow the number of hung off uses. Note that allocHungoffUses should be called if there are no uses.
`operator new`	New operators
`setMetadata`	`setMetadata` overloads
`setValueSubclassData`	Set the opaque subclass data bits stored in this value.

Protected Static Member Functions

Name	Description
`OpFrom`	Return the operand Use at compile-time index `Idx` from `that.`

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.

Protected Static Data Members

Name	Description
`ConstantSubclassBits`	Bits reserved in SubclassOptionalData, not to be used for ConstantExpr flags.

Friends

Name	Description
`llvm::Constant`	LLVM Constant Representation
`llvm::ConstantAggrKeyType`	Key type used to unique aggregate constants in the constant pool.

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.
`ConstantFoldConstant`	Fold a constant using the specified DataLayout.
`ConstantFoldExtractElementInstruction`	Attempt to constant fold an extractelement instruction with the specified operands and indices.
`ConstantFoldExtractValueInstruction`	Attempt to constant fold an extractvalue instruction with the specified operands and indices.
`ConstantFoldInsertElementInstruction`	Attempt to constant fold an insertelement instruction with the specified operands and indices.
`ConstantFoldInsertValueInstruction`	Attempt to constant fold an insertvalue instruction with the specified operands and indices.
`ConstantFoldIntegerCast`	Constant fold a zext, sext or trunc, depending on IsSigned and whether the DestTy is wider or narrower than C. Returns nullptr on failure.
`ConstantFoldLoadFromConst`	Extract value of C at the given Offset reinterpreted as Ty. If bits past the end of C are accessed, they are assumed to be poison.
`ConstantFoldLoadFromConst`	Extract value of C reinterpreted as Ty. Same as previous API with zero offset.
`ConstantFoldLoadFromConstPtr`	Return the value that a load from C with offset Offset would produce if it is constant and determinable. If this is not determinable, return null.
`ConstantFoldLoadFromConstPtr`	Return the value that a load from C would produce if it is constant and determinable. If this is not determinable, return null.
`ConstantFoldLoadFromUniformValue`	Return a uniform bit-pattern constant reinterpreted as `Ty,` or null.
`ConstantFoldLoadThroughBitcast`	Try to cast a constant to a destination type through a bitcast-like load.
`ConstantFoldSelectInstruction`	Attempt to constant fold a select instruction with the specified operands. The constant result is returned if successful; if not, null is returned.
`ConstantFoldShuffleVectorInstruction`	Attempt to constant fold a shufflevector instruction with the specified operands and mask.
`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.
`FlushFPConstant`	Flush a floating-point constant according to the parent function's denormal mode.
`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.
`IsConstantOffsetFromGlobal`	Return true if `C` is a constant offset from a global.
`MapValue`	Look up or compute a value in the value map.
`MapValue`	Version of MapValue with type safety for Constant.
`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.
`extractWidenableCondition`	Returns the widenable condition in `U's` expression tree, if uniquely used.
`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.
`gep_type_begin`	Return a begin iterator over the types indexed by GEP `GEP.`
`gep_type_begin`	Return a begin iterator over the types indexed by GEP `GEP.`
`gep_type_end`	Return the end iterator for types indexed by GEP `GEP.`
`gep_type_end`	Return the end iterator for types indexed by GEP `GEP.`
`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.`
`getLosslessInvCast`	Try to cast C to InvC losslessly, satisfying CastOp(InvC) equals C, or CastOp(InvC) is a refined value of undefined C. Will try best to preserve the flags.
`getLosslessSignedTrunc`	Compute a lossless inverse of a signed extend (sext) of `C.`
`getLosslessUnsignedTrunc`	Compute a lossless inverse of an unsigned extend (zext) of `C.`
`getObjectSize`	Compute the size of the object pointed by Ptr.
`getOrEnforceKnownAlignment`	Return a known alignment for a value, optionally raising it first.
`getPointerAtOffset`	Find a trivial pointer located at a byte offset within a constant.
`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.
`isGuard`	Returns true iff `U` has semantics of a guard expressed in a form of call of llvm.experimental.guard intrinsic.
`isGuardAsWidenableBranch`	Returns true iff `U` has semantics of a guard expressed in a form of a widenable conditional branch to deopt block.
`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.
`isSafeToDestroyConstant`	Return true if it is safe to destroy constant `C.`
`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.
`isWidenableBranch`	Returns true iff `U` is a widenable branch (that is, extractWidenableCondition returns widenable condition).
`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.
`parseWidenableBranch`	Parses a widenable branch and returns Uses so they can be modified.
`parseWidenableBranch`	Parses a widenable branch and returns its condition, widenable condition, and successor blocks.
`parseWidenableGuard`	Collects the individual checks from a widenable guard's condition.
`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.
`replaceRelativePointerUsersWithZero`	Finds the same "relative pointer" pattern as described above, where the target is `C`, and replaces the entire pattern with a constant zero.
`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_CheckedFp`	Match a float or vector where CheckFn(ele) is true, binding the constant. For vectors, poison elements are assumed to match.
`PatternMatch::m_CheckedInt`	Match an integer or vector where CheckFn(ele) is true, binding the constant. For vectors, poison elements are assumed to match.
`PatternMatch::m_Constant`	Match a Constant, capturing the value if we match.
`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_ImmConstant`	Match an immediate Constant, capturing the value if we match.
`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::getConstantValueForLoad`	Extract a constant load value from a constant store or load at an offset.
`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.