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. |
ConstantFoldInstOperands | Attempt to constant fold an instruction with the specified operands. |
ConstantFoldInstruction | Try to constant fold the specified instruction. |
DemoteRegToStack | Demote an instruction's virtual register to a stack slot. |
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. |
RemapInstruction | Convert the instruction operands from referencing the current values into those specified by VM. |
RemapSourceAtom | Remap the source-location atom of instruction I. |
ReplaceInstWithInst | Replace one instruction with another and copy its debug location. |
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. |
SplitCriticalEdge | Split a critical edge from a terminator to one of its successors. |
SplitKnownCriticalEdge | Split an edge that is already known to be critical. |
adaptNoAliasScopes | Adapt an instruction's noalias metadata using a scope map. |
addDiffRuntimeChecks | Add runtime checks that compare pointer differences against a distance. |
addRuntimeChecks | Add code that checks at runtime if the accessed arrays in PointerChecks overlap. Returns the final comparator value or NULL if no check is needed. |
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. |
buildAssumeFromInst | Build an llvm.assume call preserving information derived from an instruction. |
canInstructionHaveMMRAs | Return true if I can have !mmra metadata. |
canReplaceOperandWithVariable | Return true if an operand may legally be replaced with a variable. |
canReplacePointersIfEqual | Returns true if pointer From can be replaced with equal pointer To. |
canSinkOrHoistInst | Return true if I may legally be sunk or hoisted, ignoring faults. |
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. |
changeToUnreachable | Insert unreachable before an instruction and make the rest of the block dead. |
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. |
combineAAMetadata | Combine alias-analysis metadata after merging memory accesses. |
combineMetadataForCSE | Combine metadata so one instruction can replace another after CSE. |
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. |
createMemCpyLoopKnownSize | Emit a loop implementing llvm.memcpy when the size is a constant. |
createMemCpyLoopUnknownSize | Emit a loop implementing llvm.memcpy when the size is not a constant. |
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. |
dropDebugUsers | Remove debug intrinsic instructions for a given instruction. |
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. |
extractBranchWeights | Extract branch weights attatched to an Instruction |
extractBranchWeights | Extract branch weights from a conditional branch or select Instruction. |
extractProbe | Extract the pseudo probe stored on Inst, if present. |
extractProfTotalWeight | Retrieve the total of all weights from an instruction. |
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. |
getAtomicSyncScopeID | Return the sync scope of atomic instruction I, or nullopt if not atomic. |
getBaseObjectSize | Like getObjectSize(), but only for base objects. |
getBranchWeightMDNode | Get the branch weights metadata node |
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. |
getConstrainedIntrinsicID | Return the constrained intrinsic ID for an instruction under strictfp. |
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. |
getMemCacheHintMetadata | Return the cache hint metadata node for a memory operand. |
getMetadataToPropagate | Collect metadata from Inst that can be preserved after vectorization. |
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. |
getValidBranchWeightMDNode | Get the valid branch weights metadata node |
getValueProfDataFromInst | Extract value-profile data annotated on instruction Inst. |
handleUnreachableTerminator | Replace instruction operands of an unreachable terminator with poison. |
hasBranchWeightMD | Checks if an instructions has Branch Weight Metadata |
hasBranchWeightOrigin | Check if Branch Weight Metadata has an "expected" field from an llvm.expect* intrinsic |
hasExplicitlyUnknownBranchWeights | Check whether I has explicitly-unknown branch-weight metadata. |
hasProfMD | Checks if an Instruction has MD_prof Metadata |
hasValidBranchWeightMD | Checks if an instructions has valid Branch Weight Metadata |
impliesPoison | Return true if V is poison given that ValAssumedPoison is already poison. |
intersectAccessGroups | Compute the intersection of access groups on two instructions. |
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). |
isAssumeLikeIntrinsic | Return true if it is an intrinsic that cannot be speculated but also cannot trap. |
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. |
isCriticalEdge | Return true if the specified edge is a critical edge. |
isCriticalEdge | Return true if the edge from TI to Succ is a critical edge. |
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. |
isGuaranteedToExecuteForEveryIteration | Return true if this function can prove that the instruction I is executed for every iteration of the loop L. |
isGuaranteedToTransferExecutionToSuccessor | Return true if instruction I always transfers execution to a successor. |
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. |
isInstructionTriviallyDead | Return true if an unused instruction is trivially dead. |
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. |
isNotCrossLaneOperation | Return true if the instruction doesn't potentially cross vector lanes. |
isNotVisibleOnUnwind | Return true if Object memory is not visible after an unwind. |
isOnlyUsedInZeroComparison | Return true if CxtI is only used in comparisons against zero. |
isOnlyUsedInZeroEqualityComparison | Return true if CxtI is only used in equality comparisons against zero. |
isPotentiallyReachable | Determine whether instruction 'To' is reachable from 'From', without passing through any blocks in ExclusionSet, returning true if uncertain. |
isReachedBefore | Return true if I0 is reached before I1 in the control flow. |
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. |
isSafeToMoveBefore | Return true if I can be safely moved before InsertPoint. |
isSafeToSpeculativelyExecute | Return true if the instruction does not have any effects besides calculating the result and does not have undefined behavior. |
isSafeToSpeculativelyExecute | Iterator-context overload of isSafeToSpeculativelyExecute. |
isSafeToSpeculativelyExecuteWithVariableReplaced | Don't use information from its non-constant operands. This helper is used when its operands are going to be replaced. |
isSplatValue | Return true if each element of V is poisoned or equal to the others. |
isValidAssumeForContext | Return true if assume I is valid for the context in simplify query Q. |
isValidAssumeForContext | Return true if assume I is valid to use at context instruction CxtI. |
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. |
mayHaveNonDefUseDependency | Returns true if the result or effects of the given instructions I depend values not reachable through the def use graph. |
mustExecuteUBIfPoisonOnPathTo | Return true if poison from Root would force UB on the path to OnPathTo. |
mustTriggerUB | Return true if I must trigger UB when any of KnownPoison is poison. |
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. |
patchReplacementInstruction | Relax a replacement so it is no more restrictive than the original. |
possiblyDemandedEltsInMask | Return an APInt of active lanes for a <Y x i1> mask. |
programUndefinedIfPoison | Return true if a poison result from Inst implies program undefined behavior. |
programUndefinedIfUndefOrPoison | Return true if this function can prove that if Inst is executed and yields a poison value or undef bits, then that will trigger undefined behavior. |
propagateIRFlags | Intersect IR flags from scalar ops VL onto vector op I. |
propagateMetadata | Propagate common metadata from VL onto instruction I. |
recognizeBSwapOrBitReverseIdiom | Match a bswap or bitreverse idiom and replace it with an intrinsic. |
replaceAllDbgUsesWith | Retarget or salvage debug users when replacing a value that will be deleted. |
replaceAndRecursivelySimplify | Replace all uses of 'I' with 'SimpleV' and simplify the uses recursively. |
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. |
replaceNonLocalUsesWith | Replace non-local uses of an instruction with another value. |
salvageDebugInfo | Salvage debug records that use an instruction before it is deleted. |
salvageDebugInfoForDbgValues | Salvage a specific set of debug records that use an instruction. |
salvageDebugInfoImpl | Append an instruction's effect to a salvaged DIExpression operand list. |
salvageKnowledge | Insert an llvm.assume before an instruction to salvage its derived knowledge. |
scaleProfData | Scaling the profile data attached to 'I' using the ratio of S/T. |
setAtomicSyncScopeID | Set the sync scope of atomic instruction I. |
setBranchWeights | Create a new branch_weights metadata node and add or overwrite a prof metadata reference to instruction I. |
setExplicitlyUnknownBranchWeights | Specify that this terminator's branch weights are unknown at compile time. |
setExplicitlyUnknownBranchWeightsIfProfiled | Set unknown branch weights only if the parent function has an entry count. |
setFittedBranchWeights | Variant of setBranchWeights where the Weights will be fit first to uint32_t by shifting right. |
setLoadStoreAlignment | Set the alignment of load or store instruction I. |
setProbeDistributionFactor | Set the distribution factor of the pseudo probe on Inst. |
setProfMetadata | Attach branch-weight profile metadata to a terminator or select. |
setUnwindEdgeTo | Sets the unwind edge of an instruction to a particular successor. |
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. |
simplifyInstruction | See if we can compute a simplified version of this instruction. |
simplifyInstructionWithOperands | Like simplifyInstruction but the operands of I are replaced with NewOps. |
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. |
succ_begin | Return a const iterator to the first successor of terminator I. |
succ_begin | Return an iterator to the first successor of terminator I. |
succ_empty | Return true if I's terminator has no successor blocks. |
succ_end | Return the end iterator for successors of terminator I. |
succ_end | Return a const end iterator for successors of terminator I. |
succ_size | Return the number of successors of terminator I. |
successors | Return a const range of successor basic blocks of terminator I. |
successors | Return a range of successor basic blocks of terminator I. |
tryEnforceAlignment | Try to raise a controlled object's alignment to a preferred value. |
updateLoopMetadataDebugLocations | Update debug locations in any MD_loop metadata attached to I. |
willNotFreeBetween | Returns true, if no instruction between Assume and CtxI may free (including through synchronization). |
wouldInstructionBeTriviallyDead | Return true if an instruction would be trivially dead with no uses. |
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_Instruction | Match an instruction, capturing it if we match. |
PatternMatch::m_Instruction | Match a const instruction, capturing it if we match. |
PatternMatch::m_Instruction | Match against the nested pattern, and capture the instruction if we match. |
PatternMatch::m_Instruction | Match against the nested pattern, and capture the instruction 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::getValueForLoad | Extract bits for a load from a clobbering store or load at a given offset. |
at::deleteAssignmentMarkers | Delete the llvm.dbg.assign intrinsics linked to Inst. |
at::getDVRAssignmentMarkers | Return a range of dbg_assign records for which Inst performs the assignment they encode. |
coro::isTriviallyMaterializable | Return true if I is trivially rematerializable. |
instrumentor::evaluateFilter | Evaluate a filter expression for an instrumentation opportunity. |
memtag::getUntagLocationIfFunctionExit | Return the instruction at which stack untagging should run for a function exit, or null if Inst is not such an exit. |
misexpect::checkBackendInstrumentation | Check backend instrumentation against llvm.expect thresholds. |
misexpect::checkExpectAnnotations | Check expect annotations against PGO counters for frontend or backend use. |
misexpect::checkFrontendInstrumentation | Check frontend instrumentation against llvm.expect thresholds. |
misexpect::verifyMisExpect | veryifyMisExpect - compares RealWeights to the thresholds used for llvm.expect and warns if the PGO counters are outside of the expected range. |
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::IsNoopInstruction | Return true if I is a bitcast or a zero-index GEP. |
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. |