This instruction constructs a fixed permutation of two input vectors.
Synopsis
Declared in <llvm/IR/Instructions.h>
class ShuffleVectorInst
: public InstructionDescription
For each element of the result vector, the shuffle mask selects an element from one of the input vectors to copy to the result. Non‐negative elements in the mask represent an index into the concatenated pair of input vectors. PoisonMaskElem (‐1) specifies that the result element is poison.
For scalable vectors, all the elements of the mask must be 0 or ‐1. This requirement may be relaxed in the future.
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 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 |
|
Constructors |
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. |
|
Return true if the result vector length differs from the sources. |
|
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 |
|
Swap the operands and adjust the mask to preserve the semantics of the instruction. |
|
|
|
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. |
|
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 first insertion point at which this instruction's result is defined. |
|
Return shuffle mask element |
|
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 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 the mask for this instruction, for use in bitcode. |
|
|
|
Return a stable debug location for this instruction. |
|
Return the successor at index |
|
Overload to return most specific vector type. |
|
|
|
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 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 true if the result vector is longer than the sources. |
|
|
|
|
|
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 this shuffle concatenates its two source vectors. |
|
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 shuffle extracts a subvector at |
|
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 shuffle is an in‐order single‐source selection. |
|
Return true if the first elements of one source vector are extracted. |
|
Return true if one source vector is extended with undef padding. |
|
Return true if this shuffle inserts a subvector at |
|
Return true if this instruction is an integer division or remainder. |
|
Return true if this shuffle interleaves its inputs with factor |
|
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 shuffle is a clustered single‐source mask of width |
|
Return true if this instruction is the only user of at least one operand. |
|
Return true if this shuffle replicates each lane |
|
Return true if this shuffle reverses elements from one source vector. |
|
Return true if the instruction can be removed if the result is unused. |
|
Return true if |
|
Return true if this shuffle is equivalent to a vector select. |
|
Return true if this instruction is a shift. |
|
Return true if this shuffle selects from one source without changing length. |
|
Return true if this instruction is a special terminator. |
|
Return true if this shuffle splices its inputs at |
|
Return true if this value is a swifterror value. |
|
Return true if this instruction is a terminator. |
|
Return true if this shuffle transposes its inputs without changing length. |
|
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 this shuffle splats element zero from one source vector. |
|
|
|
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 a ShuffleVectorInst 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. |
|
|
|
Replace this instruction's shuffle mask with |
|
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 |
|
|
Adjust |
|
Convert integer shuffle mask |
|
Remove the droppable use |
|
Return the mnemonic name for the given opcode (e.g. "add", "ret"). |
|
Convert constant shuffle mask |
|
Return true if |
|
Return true if the opcode is a binary operator. |
|
Return true if |
|
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 |
|
|
|
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. |
|
Create a copy of this instruction without inserting it into a block. |
|
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