llvm::ConstantAggregateZero

Name

Description

ConstantData

Leaf constant with no operands (for example integers and floating‐point literals).

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.

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.

Name

Description

ValueTy

Concrete subclass of this.

Name

Description

ConstantAggregateZero [constructor] [deleted]

ConstantAggregateZero values are uniqued and cannot be copied.

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.

getElementCount

Return the number of elements in the array, vector, or struct.

getElementValue

getElementValue overloads

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

Return operand i.

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.

getSequentialElement

If this CAZ has array or vector type, return a zero with the right element type.

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.

getStructElement

If this CAZ has struct type, return a zero with the right element type for the specified element.

getType

All values are typed, get the type of this value.

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

Return an iterator to the first operand Use.

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

Replace operand i with Val.

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

Name

Description

classof

Methods for support type inquiry through isa, cast, and dyn_cast.

dropDroppableUse

Remove the droppable use U.

get

Return an all‐zero aggregate constant of type Ty.

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

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.

Name

Description

MaxAlignmentExponent

The maximum alignment for instructions.

MaximumAlignment

Maximum absolute alignment in bytes (1 << MaxAlignmentExponent).

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 .

Name

Description

Unnamed enum

SubclassOptionalData bits. Low bits are used by ConstantExpr.

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.

Name

Description

OpFrom

Return the operand Use at compile‐time index Idx from that.

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.

Name

Description

ConstantSubclassBits

Bits reserved in SubclassOptionalData, not to be used for ConstantExpr flags.

Name

Description

llvm::Constant

LLVM Constant Representation

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.