Insert a struct field or array element into an aggregate value.
Synopsis
Declared in <llvm/IR/Instructions.h>
class InsertValueInst
: public InstructionDescription
This instruction inserts a struct field of array element value into an aggregate value.
Base Classes
Name |
Description |
Base class for all LLVM IR instructions. |
Types
Name |
Description |
The const version of |
|
Const iterator for directly iterating over the operand Values. |
|
Iterator type that casts an operand to a basic block. |
|
Iterator for directly iterating over the operand Values. |
Type Aliases
Name |
Description |
Intrusive instruction list type used by BasicBlock. |
|
Const iterator over this user's operand |
|
Range of const operand |
|
Const iterator over this value's uses. |
|
Const iterator over this value's users. |
|
Iterator over insertvalue index operands. |
|
Iterator over this user's operand |
|
Range of mutable operand |
|
Iterator over this value's uses. |
|
Iterator over this value's users. |
Enums
Name |
Description |
Opcodes for binary operators (arithmetic, shifts, and bitwise logic). |
|
Opcodes for cast instructions (trunc, zext, bitcast, addrspacecast, etc.). |
|
Opcodes for funclet pad instructions (cleanuppad, catchpad). |
|
Opcodes for memory instructions (alloca, load, store, GEP, atomics, etc.). |
|
When checking for operation equivalence (using isSameOperationAs) it is sometimes useful to ignore certain attributes. |
|
Opcodes for other non‐terminating instructions (cmp, phi, call, select, etc.). |
|
Opcodes that terminate a basic block (return, branch, switch, etc.). |
|
Opcodes for unary instructions (e.g. fneg). |
|
Concrete subclass of this. |
Member Functions
Name |
Description |
Assignment operators |
|
|
|
|
|
This method should only be used by the Use class. |
|
Transfer any DbgRecords on the position |
|
Intersect wrapping, exact, and fast‐math flags of |
|
Merge two debug locations and apply the result to this instruction. |
|
Assert in debug builds that modules containing this value are materialized. |
|
Assert that every module containing this value is fully materialized. |
|
Return true if this pointer's memory may be freed in its defining scope. |
|
Create a copy of this instruction that is identical except it has no parent and no name. |
|
Clone any debug‐info attached to |
|
Return true if this instruction comes before |
|
|
|
Copy supported exact, fast‐math, and optionally wrapping flags from |
|
Copy metadata from |
|
Copy debug, profile, and memprof metadata from |
|
Delete a pointer to a generic Value. |
|
Drop all references to operands. |
|
Erase any DbgRecords attached to this instruction. |
|
Remove every uses that can safely be removed. |
|
Remove every use of this value in |
|
Drop the instruction's debug location. |
|
Erase a single DbgRecord |
|
Drops flags, attributes and metadata that may generate poison. |
|
Drops attributes that may generate poison. |
|
Drops flags that may cause this instruction to evaluate to poison despite having non‐poison inputs. |
|
Drops metadata that may generate poison. |
|
Drop attributes or metadata that can cause immediate undefined behavior. |
|
Drop non‐debug unknown metadata and UB‐implying call attributes. |
|
Drop all unknown metadata except for debug locations. |
|
Support for debugging, callable in GDB: V‐>dump() |
|
This method unlinks 'this' from the containing basic block and deletes it. |
|
Erase all metadata that matches the predicate. |
|
Retrieve total raw weight values of a branch. |
|
Return the AA metadata for this instruction. |
|
Return the type this instruction accesses in memory, if any. |
|
Return the aggregate operand. |
|
Get all metadata attached to this Instruction. |
|
Get all metadata attached to this Instruction except the debug location. |
|
All values hold a context through their type. |
|
Return the data layout of the module this instruction belongs to. |
|
Return a range over the DbgRecords attached to this instruction. |
|
Return an iterator to the next DbgRecord after this instruction. |
|
Return the debug location for this node as a DebugLoc. |
|
Returns the descriptor co‐allocated with this User instance. |
|
Return all fast‐math flags for this instruction. |
|
Return fast‐math flags, or default flags when not a FPMathOperator. |
|
Return the function this instruction belongs to. |
|
Return the index list. |
|
Return the inserted value operand. |
|
Return the first insertion point at which this instruction's result is defined. |
|
Return the memory effects of this instruction. |
|
Get the metadata of given kind attached to this Instruction. |
|
|
|
Return a constant reference to the value's name. |
|
Return this value's name, or a printed operand string if it is unnamed. |
|
Get the next node, or |
|
Return the number of indices. |
|
Return the number of operands. |
|
Return the number of successors that this terminator has. |
|
This method computes the number of uses of this Value. |
|
Return the opcode of this instruction as a member of the opcode enums. |
|
Return the mnemonic name for this instruction's opcode. |
|
|
|
|
|
|
|
Returns an alignment of the pointer value. |
|
Returns the number of bytes known to be dereferenceable for the pointer value. |
|
If this ptr is provably equal to |
|
|
|
Return the raw optional flags value contained in this value. |
|
|
|
Return a stable debug location for this instruction. |
|
Return the successor at index |
|
All values are typed, get the type of this value. |
|
|
|
Return an ID for the concrete type of this object. |
|
Return the symbol‐table name entry for this value, if any. |
|
Handle the debug‐info implications of this instruction being removed. Any attached DbgRecords need to "fall" down onto the next instruction. |
|
Determine whether the allow‐contract flag is set. |
|
Determine whether the allow‐reassociation flag is set. |
|
Determine whether the allow‐reciprocal flag is set. |
|
Determine whether the approximate‐math‐functions flag is set. |
|
Return true if this atomic instruction loads from memory. |
|
Return true if this atomic instruction stores to memory. |
|
Return true if any DbgRecords are attached to this instruction. |
|
Return true if this instruction has indices. |
|
|
|
Return true if this instruction has metadata attached to it other than a debug location. |
|
Return true if this value has exactly N undroppable uses. |
|
Return true if this value has N undroppable uses or more. |
|
Return true if this Value has exactly N uses. |
|
Return true if this value has N uses or more. |
|
Return true if this value has a name in the symbol table. |
|
Determine whether the no‐infs flag is set. |
|
Determine whether the no‐NaNs flag is set. |
|
Determine whether the no signed wrap flag is set. |
|
Determine whether the no‐signed‐zeros flag is set. |
|
Determine whether the no unsigned wrap flag is set. |
|
Return true if this instruction contains loop metadata other than a debug location. |
|
Determine whether the nneg flag is set. |
|
Return true if there is exactly one use of this value. |
|
Return true if there is exactly one user of this value. |
|
Return true if this instruction has poison‐generating flags, attributes or metadata. |
|
Return true if this instruction has poison‐generating attribute. |
|
Return true if this operator has flags which may cause poison. |
|
Return true if this instruction has poison‐generating metadata. |
|
Return true if |
|
Return true if this instruction has UB‐implying attributes that can cause immediate undefined behavior. |
|
Check if this Value has a use‐list. |
|
Return true if there is a value handle associated with this value. |
|
Return an iterator to the first index. |
|
Return an iterator past the last index. |
|
Return a range over indices. |
|
|
|
|
|
Insert an unlinked instruction into |
|
Return true if this is an arithmetic shift right. |
|
Return true if the instruction is associative. |
|
Return true if this instruction has an AtomicOrdering of unordered or higher. |
|
Return true if this instruction is a binary operator. |
|
Return true if this is and/or/xor. |
|
Return true if this instruction is a cast. |
|
Return true if operand |
|
Return true if the instruction is commutative. |
|
Return true if the instruction is a DbgInfoIntrinsic or PseudoProbeInst. |
|
Return whether this user's uses may be dropped without affecting correctness. |
|
Return true if the instruction is a variety of EH‐block. |
|
Determine whether the exact flag is set. |
|
Return true if this instruction is a floating‐point division or remainder. |
|
Determine whether all fast‐math‐flags are set. |
|
Return true if this instruction behaves like a memory fence. |
|
Return true if this instruction is a funclet pad. |
|
Return true if the instruction is idempotent. |
|
Return true if |
|
Return true if |
|
Return true if this instruction is an integer division or remainder. |
|
Return true if the instruction is a llvm.launder.invariant.group or llvm.strip.invariant.group. |
|
Return true if the instruction is a llvm.lifetime.start or llvm.lifetime.end marker. |
|
Return true if this is a logical shift left or a logical shift right. |
|
Return true if the instruction is nilpotent. |
|
Return true if this instruction is the only user of at least one operand. |
|
Return true if the instruction can be removed if the result is unused. |
|
Return true if |
|
Return true if this instruction is a shift. |
|
Return true if this instruction is a special terminator. |
|
Return true if this value is a swifterror value. |
|
Return true if this instruction is a terminator. |
|
Return true if this instruction is a unary operator. |
|
Return true if there is metadata referencing this value. |
|
Check if this value is used in the specified basic block. |
|
Return true if any use of this instruction is outside |
|
Return true if this instruction has a volatile memory access. |
|
|
|
Return true if there are no currently materialized uses. |
|
|
|
|
|
|
|
Return true if the instruction may have side effects. |
|
Return true if this instruction may read memory. |
|
Return true if this instruction may read or write memory. |
|
Return true if this instruction may synchronize. |
|
Return true if this instruction may throw an exception. |
|
Return true if this instruction may modify memory. |
|
Merge DIAssignID metadata from this instruction and |
|
Unlink this instruction from its current basic block and insert it into the basic block that MovePos lives in, right after MovePos. |
|
Move this instruction after |
|
|
|
|
|
Mutate the type of this Value to be of the specified type. |
|
|
|
|
|
|
|
|
|
Delete operators |
|
Allocate an InsertValueInst with the fixed‐size operand allocator. |
|
|
|
|
|
This method unlinks 'this' from the containing basic block, but does not delete it. |
|
Change all uses of this to point to a new Value. |
|
Change non‐metadata uses of this to point to a new Value. |
|
Replace successor |
|
Replace uses of one Value with another. |
|
Replace uses of this value that occur outside |
|
Replace selected uses of this value with |
|
Reverse the use‐list. |
|
Set the AA metadata on this instruction from the AAMDNodes structure. |
|
Set the debug location information for this instruction. |
|
Set or clear all fast‐math‐flags on this instruction. |
|
Set multiple fast‐math flags on this instruction. |
|
Set or clear the allow‐contract flag on this instruction. |
|
Set or clear the reassociation flag on this instruction. |
|
Set or clear the allow‐reciprocal flag on this instruction. |
|
Set or clear the approximate‐math‐functions flag on this instruction. |
|
Set or clear the no‐infs flag on this instruction. |
|
Set or clear the no‐nans flag on this instruction. |
|
Set or clear the nsw flag on this instruction. |
|
Set or clear the no‐signed‐zeros flag on this instruction. |
|
Set or clear the nuw flag on this instruction. |
|
Set or clear the exact flag on this instruction. |
|
|
|
Change the name of the value. |
|
Sets the nosanitize metadata on this instruction. |
|
Set or clear the nneg flag on this instruction. |
|
Set the operand count for a User with hung‐off uses. |
|
|
|
Update the successor at index |
|
Set the symbol‐table name entry for this value. |
|
Sort the use‐list. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
If the instruction has "branch_weights" MD_prof metadata and the MDNode has three operands (including name string), swap the order of the metadata. |
|
Transfer the name from V to this value. |
|
Update the debug location after hoisting this instruction to a predecessor. |
|
|
|
Return true if this value has no uses. |
|
|
|
|
|
Return an iterator to the first user of this value. |
|
Return true if this value has no users. |
|
|
|
|
|
|
|
|
|
|
|
Return true if the instruction will return. |
Static Member Functions
Name |
Description |
Create an insertvalue into |
|
Methods for support type inquiry through isa, cast, and dyn_cast. |
|
Remove the droppable use |
|
Return the operand index of the aggregate. |
|
Return the operand index of the inserted value. |
|
Return the mnemonic name for the given opcode (e.g. "add", "ret"). |
|
Return true if |
|
Return true if the opcode is a binary operator. |
|
Return true if |
|
Return true if |
|
Return true if |
|
Return true if the opcode is a floating‐point division or remainder. |
|
Return true if |
|
Return true if |
|
Return true if the opcode is an integer division or remainder. |
|
Return true if |
|
Return true if |
|
Return true if |
|
Return true if the opcode is a terminator instruction. |
|
Return true if the opcode is a unary operator. |
Data Members
Name |
Description |
Optional marker for debugging information immediately before this instruction. |
Static Data Members
Name |
Description |
The maximum alignment for instructions. |
|
Maximum absolute alignment in bytes ( |
Protected Types
Name |
Description |
Information about how a User object was allocated, to be passed into the User constructor. |
|
Indicates this User has operands "hung off" in another allocation. |
|
Indicates this User has operands co‐allocated. |
|
Indicates this User has operands and a descriptor co‐allocated . |
Protected Type Aliases
Name |
Description |
Bitfield element template for an alignment at bit offset |
|
Bitfield element template for atomic ordering at bit offset |
|
Bitfield element template for a single boolean flag at bit offset |
|
Opaque 16‐bit bitfield covering the full Instruction subclass data. |
Protected Enums
Name |
Description |
The number of operands in the subclass. |
Protected Member Functions
Name |
Description |
|
|
|
|
Allocate the array of Uses, followed by a pointer (with bottom bit set) to the User. |
|
Erase all metadata attached to this Value. |
|
Clone an identical InsertValueInst. |
|
Erase all metadata attachments with the given kind. |
|
Erase all metadata attachments matching the given predicate. |
|
Append all metadata attached to this value into |
|
Get the current metadata attachments for the given kind, if any. |
|
Get metadata for the given kind, if any. |
|
Read a bitfield element from this instruction's subclass data. |
|
Return the opaque subclass data bits stored in this value. |
|
Grow the number of hung off uses. Note that allocHungoffUses should be called if there are no uses. |
|
New operators |
|
|
|
Store a bitfield element into this instruction's subclass data. |
|
Set the opaque subclass data bits stored in this value. |
Protected Static Member Functions
Name |
Description |
Return the operand Use at compile‐time index |
Protected Data Members
Name |
Description |
True if this value has a descriptor. |
|
Whether operands are stored in a separately allocated array. |
|
True if this value has a name in the symbol table. |
|
True if metadata references this value. |
|
Number of operands in this user. |
|
Hold arbitary subclass data. |
Friends
Name |
Description |
Base class for all LLVM IR instructions. |
Non-Member Functions
Name |
Description |
Get the upper bound on bit size for this Value |
|
Return the number of times the sign bit of the register is replicated into the other bits. |
|
Attempt to constant fold an instruction with the specified operands. |
|
Try to constant fold the specified instruction. |
|
Demote an instruction's virtual register to a stack slot. |
|
ExtractTypeInfo ‐ Returns the type info, possibly bitcast, encoded in V. |
|
Find the earliest instruction that captures |
|
Given an aggregate and a sequence of indices, see if the scalar value indexed is already around as a register. |
|
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. |
|
Const overload of GetPointerBaseWithConstantOffset. |
|
If we can compute the length of the string pointed to by the specified pointer, return 'len+1'. If we can't, return 0. |
|
Look up or compute a value in the value map. |
|
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. |
|
Visit a pointer and derived values to find capturing uses. |
|
Return which components of the pointer may be captured. |
|
Return true if this pointer may be captured by the enclosing function. |
|
Return true if this pointer may be captured before a given instruction. |
|
Return which components of the pointer may be captured on the path to |
|
Recursively delete a trivially dead instruction and its dead operands. |
|
Convert the instruction operands from referencing the current values into those specified by VM. |
|
Remap the source‐location atom of instruction |
|
Replace one instruction with another and copy its debug location. |
|
Invoke a callback once for each lane up to an effective vector length. |
|
Split a block and insert an else‐branch at an instruction. |
|
Split a block and insert a conditional else‐branch around the split point. |
|
Split a block and insert a then‐branch at an instruction. |
|
Split a block and insert a conditional then‐branch around the split point. |
|
Split a block and insert optional then/else blocks around the split point. |
|
Split a block and insert optional then/else blocks at an instruction. |
|
Split a block and insert both then and else branches around the split point. |
|
Split a block and insert then/else branches at an instruction. |
|
Insert a simple counted for‐loop at a split point. |
|
Split a critical edge from a terminator to one of its successors. |
|
Split an edge that is already known to be critical. |
|
Adapt an instruction's noalias metadata using a scope map. |
|
Add runtime checks that compare pointer differences against a distance. |
|
Add code that checks at runtime if the accessed arrays in |
|
Apply a metadata callback if |
|
Return true if the given assume operand bundle implies that |
|
Build an llvm.assume call preserving information derived from an instruction. |
|
Return true if |
|
Return true if an operand may legally be replaced with a variable. |
|
Returns true if pointer |
|
Return true if |
|
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. |
|
Return true if we can prove that the specified FP value is either NaN or never less than ‐0.0. |
|
Insert unreachable before an instruction and make the rest of the block dead. |
|
See if the given exception handling personality function is one that we understand. If so, return a description of it; otherwise return Unknown. |
|
Enumerate immediate constant values of |
|
Combine alias‐analysis metadata after merging memory accesses. |
|
Combine metadata so one instruction can replace another after CSE. |
|
Determine the possible constant range of an integer or vector of integer value. This is intended as a cheap, non‐recursive check. |
|
Returns the known bits rather than passing by reference. |
|
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOne bit sets. |
|
Returns the known bits rather than passing by reference. |
|
Compute known bits for the demanded elements of |
|
Compute known bits for |
|
Compute known bits for |
|
Merge bits known from context‐dependent facts into Known. |
|
Wrapper to account for known fast math flags at the use instruction. |
|
Determine known floating‐point classes for |
|
Wrapper to account for known fast math flags at the use instruction. |
|
Determine which floating‐point classes are valid for |
|
Determine known floating‐point classes for |
|
Return the known sign bit of a floating‐point value, if provable. |
|
Compute whether a signed multiply of |
|
Compute whether a signed subtract of |
|
Compute whether an unsigned multiply of |
|
Compute whether an unsigned subtract of |
|
Emit a loop implementing llvm.memcpy when the size is a constant. |
|
Emit a loop implementing llvm.memcpy when the size is not a constant. |
|
Decompose an icmp into the form ((X & Mask) pred C) if possible. |
|
Decompose an icmp into the form ((X & Mask) pred C) if possible. |
|
Remove debug intrinsic instructions for a given instruction. |
|
Emit a call to the bcmp function. |
|
Emit a call to the binary floating‐point libcall named Name. |
|
Emit a call to the binary DoubleFn, FloatFn, or LongDoubleFn for Op1's type. |
|
Emit a call to the calloc function. |
|
Emit a call to fputc with an int Char and a FILE pointer. |
|
Emit a call to fputs with a string pointer and a FILE pointer. |
|
Emit a call to fwrite with a pointer, size_t Size, and FILE pointer. |
|
Emit a call to the hot/cold operator new function. |
|
Emit a call to the hot/cold aligned operator new function. |
|
Emit a call to the hot/cold aligned nothrow operator new function. |
|
Emit a call to the hot/cold nothrow operator new function. |
|
Emit a call to the hot/cold size‐returning operator new function. |
|
Emit a call to the hot/cold size‐returning aligned operator new function. |
|
Emit a call to the malloc function. |
|
Emit a call to the memccpy function. |
|
Emit a call to memchr with a pointer, int Val, and size_t Len. |
|
Emit a call to the memcmp function. |
|
Emit a call to __memcpy_chk with size_t Len/ObjSize and pointer Dst/Src. |
|
Emit a call to the mempcpy function. |
|
Emit a call to the memrchr function, analogously to emitMemChr. |
|
Emit a call to putchar, assuming Char is an int. |
|
Emit a call to puts, assuming Str is some pointer. |
|
Emit a call to the snprintf function. |
|
Emit a call to the sprintf function. |
|
Emit a call to stpcpy for the specified pointer arguments. |
|
Emit a call to stpncpy for the specified pointer arguments and length. |
|
Emit a call to the strcat function. |
|
Emit a call to strchr for the specified pointer and character. |
|
Emit a call to strcpy for the specified pointer arguments. |
|
Emit a call to strdup for the specified pointer. |
|
Emit a call to the strlcat function. |
|
Emit a call to the strlcpy function. |
|
Emit a call to strlen for the specified pointer. |
|
Emit a call to the strncat function. |
|
Emit a call to the strncmp function to the builder. |
|
Emit a call to strncpy for the specified pointer arguments and length. |
|
Emit a call to the unary DoubleFn, FloatFn, or LongDoubleFn for Op's type. |
|
Emit a call to the unary floating‐point libcall named Name. |
|
Emit a call to the vsnprintf function. |
|
Emit a call to the vsprintf function. |
|
Emit a call to wcslen for the specified pointer. |
|
Extract branch weights attatched to an Instruction |
|
Extract branch weights from a conditional branch or select Instruction. |
|
Extract the pseudo probe stored on |
|
Retrieve the total of all weights from an instruction. |
|
Returns the widenable condition in |
|
Const overload of 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. |
|
As above, for DVRDeclareValues. |
|
Finds dbg.declare records declaring local variables as living in the memory that 'V' points to. |
|
As above, for DVRValues. |
|
Finds the debug info records describing a value. |
|
Finds the dbg.values describing a value. |
|
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. |
|
Call |
|
Return a begin iterator over the types indexed by GEP |
|
Return a begin iterator over the types indexed by GEP |
|
Return the end iterator for types indexed by GEP |
|
Return the end iterator for types indexed by GEP |
|
If a function is part of an allocation family (e.g. malloc/realloc/calloc/free), return the identifier for its family of functions. |
|
Return the sync scope of atomic instruction |
|
Like getObjectSize(), but only for base objects. |
|
Get the branch weights metadata node |
|
Returns true if the value |
|
Compute the contents of a null‐terminated C string pointed to by |
|
Return the constrained intrinsic ID for an instruction under strictfp. |
|
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. |
|
Return a valid Knowledge associated to the Value V if its Attribute kind is in AttrKinds and it matches the Filter. |
|
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. |
|
Infer a known alignment for the specified pointer. |
|
Return the address space of the pointer operand of load or store |
|
Return the alignment of load or store instruction |
|
Return the pointer operand of a load or store, or null if |
|
Return the pointer operand of a load or store, or null if |
|
Return the value type accessed by load or store instruction |
|
Return the cache hint metadata node for a memory operand. |
|
Collect metadata from |
|
Compute the size of the object pointed by Ptr. |
|
Return a known alignment for a value, optionally raising it first. |
|
Return the pointer operand of a load, store, or GEP, or null otherwise. |
|
Non‐const overload of getPointerOperand. |
|
Get splat value if the input is a splat vector or return nullptr. |
|
Strip GEP adjustments, pointer casts, and threadlocal.address from |
|
Non‐const overload of getUnderlyingObject. |
|
Like getUnderlyingObject(), but will try harder to find a single underlying object. In particular, this function also looks through selects and phis. |
|
This method is similar to getUnderlyingObject except that it can look through phi and select instructions and return multiple objects. |
|
This is a wrapper around getUnderlyingObjects and adds support for basic ptrtoint+arithmetic+inttoptr sequences. |
|
Get the valid branch weights metadata node |
|
Extract value‐profile data annotated on instruction |
|
Replace instruction operands of an unreachable terminator with poison. |
|
Checks if an instructions has Branch Weight Metadata |
|
Check if Branch Weight Metadata has an "expected" field from an llvm.expect* intrinsic |
|
Check whether |
|
Checks if an Instruction has MD_prof Metadata |
|
Checks if an instructions has valid Branch Weight Metadata |
|
Return true if V is poison given that ValAssumedPoison is already poison. |
|
Compute the intersection of access groups on two instructions. |
|
Invert a boolean condition, reusing an existing inverted copy when possible. |
|
Tests if a value is a call or invoke to a library function that allocates memory (either malloc, calloc, or strdup like). |
|
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). |
|
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). |
|
Return true if it is an intrinsic that cannot be speculated but also cannot trap. |
|
Return true if V is known to be the base of its memory object. |
|
If the specified value can be set by repeating the same byte in memory, return the i8 value that it is represented with. |
|
Return true if |
|
Return true if |
|
Returns true if the memory operations |
|
Return true if the specified edge is a critical edge. |
|
Return true if the edge from |
|
Returns true if V is always a dereferenceable pointer with sufficient alignment. |
|
Returns true if V is always dereferenceable for Size bytes with sufficient alignment. |
|
Equivalent to isDereferenceableAndAlignedPointer with an alignment of 1. |
|
Equivalent to isDereferenceableAndAlignedPointer with an alignment of 1. |
|
Returns true if the pointer is one which would have been considered an escape by isNotCapturedBefore. |
|
Iterator‐context overload of isGuaranteedNotToBePoison. |
|
Returns true if V cannot be poison, but may be undef. |
|
Returns true if V cannot be undef, but may be poison. |
|
Return true if this function can prove that V does not have undef bits and is never poison. |
|
Return true if this function can prove that the instruction I is executed for every iteration of the loop L. |
|
Return true if instruction |
|
Returns true iff |
|
Returns true iff |
|
Return true if V is unambiguously identified at the function level. |
|
Return true if this pointer refers to a distinct and identifiable object. |
|
Return the boolean condition value in the context of the given instruction if it is known based on dominating conditions. |
|
Return whether a compare is implied true or false by |
|
Return whether RHS is implied true or false by LHS, if known. |
|
Return true if an unused instruction is trivially dead. |
|
Return true if the floating‐point value |
|
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. |
|
Return true if the two given values are negation. |
|
Returns true if the given value is known be negative (i.e. non‐positive and non‐zero). |
|
Return true if the floating‐point value can never contain a NaN or infinity. |
|
Return true if the floating‐point scalar value is not an infinity or if the floating‐point vector value has no infinities. |
|
Return true if the floating‐point scalar value is not a NaN or if the floating‐point vector value has no NaN elements. |
|
Return true if the given values are known to be non‐equal when defined. Supports scalar integer types only. |
|
Returns true if the give value is known to be non‐negative. |
|
Return true if the given value is known to be non‐zero when defined. |
|
Returns true if the given value is known be positive (i.e. non‐negative and non‐zero). |
|
Return true if the given value is known to have exactly one bit set when defined. |
|
Return true if |
|
Return true if this pointer is returned by a noalias function. |
|
Return true if the instruction doesn't potentially cross vector lanes. |
|
Return true if Object memory is not visible after an unwind. |
|
Return true if |
|
Return true if |
|
Determine whether instruction 'To' is reachable from 'From', without passing through any blocks in ExclusionSet, returning true if uncertain. |
|
Return true if |
|
Return true if we know that executing a load from this value cannot trap. |
|
Return true if we know that executing a load from this value cannot trap. |
|
Return true if |
|
Return true if the instruction does not have any effects besides calculating the result and does not have undefined behavior. |
|
Iterator‐context overload of isSafeToSpeculativelyExecute. |
|
Don't use information from its non‐constant operands. This helper is used when its operands are going to be replaced. |
|
Return true if each element of |
|
Return true if assume |
|
Return true if assume |
|
Returns true iff |
|
Returns true iff |
|
Return true if Object is writable without trapping. |
|
Return true if any lane of an i1 mask is known true or undef. |
|
Const overload of matchSelectPattern. |
|
Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind and providing the out parameter results if we successfully match. |
|
Returns true if the result or effects of the given instructions |
|
Return true if poison from Root would force UB on the path to OnPathTo. |
|
Return true if |
|
Return true if the only users of this pointer are lifetime markers. |
|
Return true if the only users of this pointer are lifetime markers or droppable instructions. |
|
Parses a widenable branch and returns Uses so they can be modified. |
|
Parses a widenable branch and returns its condition, widenable condition, and successor blocks. |
|
Collects the individual checks from a widenable guard's condition. |
|
Relax a replacement so it is no more restrictive than the original. |
|
Return an APInt of active lanes for a |
|
Return true if a poison result from |
|
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. |
|
Intersect IR flags from scalar ops |
|
Propagate common metadata from |
|
Match a bswap or bitreverse idiom and replace it with an intrinsic. |
|
Retarget or salvage debug users when replacing a value that will be deleted. |
|
Replace all uses of 'I' with 'SimpleV' and simplify the uses recursively. |
|
Replace a dbg.declare when its address is replaced. |
|
Replace uses dominated by an edge with another value. |
|
Replace uses dominated by an instruction with another value. |
|
Replace uses dominated by a block's end with another value. |
|
Conditionally replace uses dominated by an instruction with another value. |
|
Conditionally replace uses dominated by a block's end with another value. |
|
Conditionally replace uses dominated by an edge with another value. |
|
Replace non‐local uses of an instruction with another value. |
|
Salvage debug records that use an instruction before it is deleted. |
|
Salvage a specific set of debug records that use an instruction. |
|
Append an instruction's effect to a salvaged DIExpression operand list. |
|
Insert an llvm.assume before an instruction to salvage its derived knowledge. |
|
Scaling the profile data attached to 'I' using the ratio of S/T. |
|
Set the sync scope of atomic instruction |
|
Create a new |
|
Specify that this terminator's branch weights are unknown at compile time. |
|
Set unknown branch weights only if the parent function has an entry count. |
|
Variant of |
|
Set the alignment of load or store instruction |
|
Set the distribution factor of the pseudo probe on |
|
Attach branch‐weight profile metadata to a terminator or select. |
|
Sets the unwind edge of an instruction to a particular successor. |
|
Given operands for a AShr, fold the result or return nulll. |
|
Given operands for an Add, fold the result or return null. |
|
Given operands for an And, fold the result or return null. |
|
Given operands for an ExtractElementInst, fold the result or return null. |
|
Given operands for an ExtractValueInst, fold the result or return null. |
|
Given operands for an FAdd, fold the result or return null. |
|
Given operands for an FDiv, fold the result or return null. |
|
Given operands for the multiplication of a FMA, fold the result or return null. |
|
Given operands for an FMul, fold the result or return null. |
|
Given operand for an FNeg, fold the result or return null. |
|
Given operands for an FRem, fold the result or return null. |
|
Given operands for an FSub, fold the result or return null. |
|
Given an operand for a Freeze, see if we can fold the result. |
|
Given operands for an InsertElement, fold the result or return null. |
|
Given operands for an InsertValueInst, fold the result or return null. |
|
See if we can compute a simplified version of this instruction. |
|
Like |
|
Given operands for a LShr, fold the result or return null. |
|
Given operands for a Mul, fold the result or return null. |
|
Given operands for an Or, fold the result or return null. |
|
Given operands for an SDiv, fold the result or return null. |
|
Given operands for an SRem, fold the result or return null. |
|
Given operands for a SelectInst, fold the result or return null. |
|
Given operands for a Shl, fold the result or return null. |
|
Given operands for a ShuffleVectorInst, fold the result or return null. |
|
Given operands for a Sub, fold the result or return null. |
|
Given operands for a UDiv, fold the result or return null. |
|
Given operands for a URem, fold the result or return null. |
|
See if V simplifies when its operand Op is replaced with RepOp. |
|
Given operands for an Xor, fold the result or return null. |
|
Const overload of 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. |
|
Return a const iterator to the first successor of terminator |
|
Return an iterator to the first successor of terminator |
|
Return true if |
|
Return the end iterator for successors of terminator |
|
Return a const end iterator for successors of terminator |
|
Return the number of successors of terminator |
|
Return a const range of successor basic blocks of terminator |
|
Return a range of successor basic blocks of terminator |
|
Try to raise a controlled object's alignment to a preferred value. |
|
Update debug locations in any MD_loop metadata attached to |
|
Returns true, if no instruction between |
|
Return true if an instruction would be trivially dead with no uses. |
|
Wrap an array of |
|
Convert a |
|
Try to convert |
|
Return true if |
|
Match a deferred const Value* determined later in the same match expression. |
|
Match a deferred Value* determined later in the same match expression. |
|
Match an instruction, capturing it if we match. |
|
Match a const instruction, capturing it if we match. |
|
Match against the nested pattern, and capture the instruction if we match. |
|
Match against the nested pattern, and capture the instruction if we match. |
|
Match if we have a specific specified value. |
|
Match against the nested pattern, and capture the value if we match. |
|
Match a const value, capturing it if we match. |
|
Match against the nested pattern, and capture the value if we match. |
|
Match a value, capturing it if we match. |
|
Return true if CoerceAvailableValueToLoadType would succeed if it was called. |
|
Try to coerce a stored value to a must‐aliased load of a different type. |
|
Extract bits for a load from a clobbering store or load at a given offset. |
|
Delete the llvm.dbg.assign intrinsics linked to |
|
Return a range of dbg_assign records for which |
|
Return true if |
|
Evaluate a filter expression for an instrumentation opportunity. |
|
Return the instruction at which stack untagging should run for a function exit, or null if |
|
Check backend instrumentation against llvm.expect thresholds. |
|
Check expect annotations against PGO counters for frontend or backend use. |
|
Check frontend instrumentation against llvm.expect thresholds. |
|
veryifyMisExpect ‐ compares RealWeights to the thresholds used for llvm.expect and warns if the PGO counters are outside of the expected range. |
|
Map V to its ARCInstKind equivalence class. |
|
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. |
|
Determine which objc runtime call instruction class V belongs to. |
|
Return the RCIdentity root of value |
|
Return the non‐const RCIdentity root of value |
|
Return the underlying ObjC object pointer for |
|
A wrapper for GetUnderlyingObjCPtr used for results memoization. |
|
Return true if |
|
Return true if |
|
Return true if this value refers to a distinct and identifiable object. |
|
Test whether |
|
Test whether the given value is possible a retainable object pointer. |
Created with MrDocs