This represents the llvm.coro.alloca.alloc instruction.
Synopsis
Declared in <llvm/Transforms/Coroutines/CoroInstr.h>
class CoroAllocaAllocInst
: public IntrinsicInstBase Classes
Name |
Description |
A wrapper class for inspecting calls to intrinsic functions. This allows the standard isa/dyncast/cast functionality to work with calls to intrinsic functions. |
Types
Name |
Description |
Descriptor for one contiguous operand bundle in the Use list. |
|
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. |
|
Bitfield storing the tail‐call kind in SubclassData. Bitfield element storing the TailCallKind in SubclassData. |
|
Iterator over mutable BundleOpInfo descriptors for this call. |
|
Iterator over const BundleOpInfo descriptors for this call. |
|
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.). |
|
Kind of tail‐call marker on a call instruction. |
|
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 |
|
|
|
|
|
|
|
Add a dereferenceable‐bytes attribute to parameter |
|
Add a dereferenceable‐bytes attribute to the return value. |
|
|
|
|
|
Add parameter attributes from builder |
|
Add a range attribute to the return value. |
|
|
|
Add return attributes from builder |
|
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. |
|
|
|
Return true if this call has no arguments. |
|
|
|
Return the number of call arguments. |
|
|
|
Assert in debug builds that modules containing this value are materialized. |
|
Assert that every module containing this value is fully materialized. |
|
Return whether the bundle operand at index |
|
|
|
|
|
|
|
Return true if this pointer's memory may be freed in its defining scope. |
|
Return true if the call can return twice |
|
Return true if this invoke cannot be duplicated. |
|
Return true if this call cannot be tail merged. |
|
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 |
|
|
|
Return true if data operand |
|
|
|
Return true if this call has no data operands. |
|
|
|
Return the number of data operands (arguments plus bundle inputs). |
|
|
|
Delete a pointer to a generic Value. |
|
Return true if this call skips indirect branch tracking. |
|
|
|
Return true if data operand |
|
Return true if this call cannot return to its caller. |
|
Return true if this call cannot unwind. |
|
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 alignment of this dynamic alloca. |
|
Get all metadata attached to this Instruction. |
|
Get all metadata attached to this Instruction except the debug location. |
|
Return the |
|
|
|
Return the |
|
Return the first argument with attribute |
|
Return attribute |
|
Return the attributes for this call. |
|
|
|
Return the index one past the last bundle operand in the Use array. |
|
Return the index of the first bundle operand in the Use array. |
|
Return the directly called |
|
Return the called function or value operand. |
|
Return the |
|
Return the function containing this call. |
|
Return the calling convention of this call. |
|
Return which pointer components data operand |
|
All values hold a context through their type. |
|
Return the convergence control token for this call, if it exists. |
|
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 function attribute |
|
Return the function this instruction belongs to. |
|
Return the function type of this call. |
|
Return the first insertion point at which this instruction's result is defined. |
|
Return the intrinsic ID of this intrinsic. |
|
Return the memory effects of this call. |
|
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 operand bundles on this call. |
|
Return the total number of operands (arguments, called value, and extras). |
|
Return the number of successors that this terminator has. |
|
Return the total number of bundle input operands on this call. |
|
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. |
|
|
|
|
|
Return the operand bundle at a specific index. |
|
Return the operand bundle containing the operand at index |
|
Copy operand bundles on this call into |
|
|
|
|
|
Return the alignment for argument |
|
Return parameter attribute |
|
Return the param attributes for argument |
|
Return the byref type for argument |
|
Return the byval type for argument |
|
Return dereferenceable bytes for argument |
|
Return dereferenceable_or_null bytes for argument |
|
Return the elementtype for argument |
|
Return the inalloca type for argument |
|
Return disallowed FP classes for argument |
|
Return the preallocated type for argument |
|
Return the stack alignment for argument |
|
Return the sret type for argument |
|
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 constant range of the return value, if any. |
|
Return the raw optional flags value contained in this value. |
|
Return the alignment of the return value, if known. |
|
Return return attribute |
|
Return the return attributes for this call. |
|
Return dereferenceable bytes for the return value. |
|
Return dereferenceable_or_null bytes for the return value. |
|
Return disallowed FP classes for the return value. |
|
Return the argument marked with the returned attribute. |
|
|
|
Return the size operand of this dynamic alloca. |
|
Return a stable debug location for this instruction. |
|
Return the successor at index |
|
Return the tail‐call kind. |
|
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 |
|
Return true if some argument has extra return capture components. |
|
Return true if this atomic instruction loads from memory. |
|
Return true if this atomic instruction stores to memory. |
|
Return true if any call argument has the byval attribute. |
|
Return whether any operand bundle on this call may write to the heap. |
|
Return true if any DbgRecords are attached to this instruction. |
|
Return whether this call has a deopt‐state operand bundle. |
|
Return true if this call has function attribute |
|
Return whether this call has the same operand bundle layout as |
|
Return true if the last argument has the inalloca attribute. |
|
|
|
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 whether this call has any operand bundles. |
|
Return whether this call has operand bundles whose tags are not in |
|
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 whether any operand bundle on this call may read from the heap. |
|
Return true if the return value has attribute |
|
Return true if |
|
Return true if the call returns a structure via the first pointer arg. |
|
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. |
|
|
|
|
|
Insert an unlinked instruction into |
|
|
|
Return true if this is an arithmetic shift right. |
|
Return true if this intrinsic is an associative operation. |
|
Checks if the intrinsic is an annotation. |
|
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 argument |
|
|
|
Return true if this instruction is a cast. |
|
Return true if operand |
|
Return true if swapping the first two arguments to the intrinsic produces the same result. |
|
Return true if this call is convergent. |
|
|
|
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 argument |
|
Return true if the callsite is an indirect call. |
|
Return true if this call targets inline assembly. |
|
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 this call is marked musttail. |
|
Return true if the instruction is nilpotent. |
|
Return true if this call must not be treated as a library builtin. |
|
Return true if this call must not be inlined. |
|
Return true if this call is marked notail. |
|
Return true if the call is for a noreturn trap intrinsic. |
|
Return true if this instruction is the only user of at least one operand. |
|
Return whether the operand at index |
|
Return true if argument |
|
Return true if passing undef to argument |
|
Return true if the return value is known non‐null. |
|
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 call requires strict floating‐point semantics. |
|
Return true if this value is a swifterror value. |
|
Return true if this is a tail call. |
|
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 |
|
|
|
|
|
Change the function type of this call and update the result type. |
|
Mutate the type of this Value to be of the specified type. |
|
Return true if this call may only access argument‐pointee memory. |
|
Return true if this call may only access arg or inaccessible memory. |
|
Return true if this call may only access inaccessible memory. |
|
|
|
|
|
|
|
|
|
Map a |
|
Iterate over OperandBundleUse views for each bundle on this call. |
|
|
|
|
|
Delete operators |
|
Return true if argument |
|
Return true if argument |
|
Populate bundle descriptors and operand uses from |
|
|
|
|
|
Remove attribute |
|
Remove function attribute |
|
Remove function attributes matching |
|
This method unlinks 'this' from the containing basic block, but does not delete it. |
|
Remove parameter attribute |
|
Remove parameter attributes matching |
|
Remove return attribute |
|
Remove return attributes matching |
|
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 |
|
Return true if the return value has the noalias attribute. |
|
Reverse the use‐list. |
|
Set the AA metadata on this instruction from the AAMDNodes structure. |
|
Set the |
|
Set the attributes for this call. |
|
|
|
Set the called function or value operand. |
|
Set the calling convention for this call. |
|
Mark this call as able to return twice. |
|
Mark that the invoke cannot be duplicated by the optimizer. |
|
Mark that the call cannot be merged with other calls by the optimizer. |
|
Mark this call as convergent. |
|
Set the debug location information for this instruction. |
|
Mark the call as not accessing memory (sets MemoryEffects::none). |
|
Mark this call as noreturn. |
|
Mark this call as nounwind. |
|
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. |
|
Mark this call as must‐not‐inline. |
|
Set the memory effects of this call. |
|
|
|
Change the name of the value. |
|
Sets the nosanitize metadata on this instruction. |
|
Set or clear the nneg flag on this instruction. |
|
Remove the convergent attribute from this call. |
|
Set the operand count for a User with hung‐off uses. |
|
Mark the call as only accessing argument‐pointee memory. |
|
Mark the call as only accessing arg or inaccessible memory. |
|
Mark the call as only accessing inaccessible memory. |
|
Mark the call as only reading memory. |
|
Mark the call as only writing memory. |
|
|
|
Update the successor at index |
|
Mark or clear this call as a tail‐call candidate. |
|
Set the tail‐call kind for this call. |
|
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. |
|
Intersect this call's attributes with |
|
Update the debug location after hoisting this instruction to a predecessor. |
|
Update profile metadata by scaling it by |
|
|
|
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 a clone of |
|
|
|
Remove the droppable use |
|
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. |
|
Check if the intrinsic might lower into a regular function call in the course of IR transformations. |
|
Create a clone of |
|
Create a clone of |
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 ( |
Using Declarations
Name |
Description |
Bring Instruction::getContext into scope for CallBase users. |
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 |
|
Bitfield element reserving bits used by |
|
Bitfield element storing the call's calling convention. |
|
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. |
|
Return how many extra operands this call subclass stores after the callee. |
|
Get the number of extra operands for instructions that don't have a fixed number of extra operands. |
|
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. |
|
Return true if this call has an attached descriptor (operand‐bundle info). |
|
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 total number of bundle input values in |
|
Return the operand Use at compile‐time index |
Protected Data Members
Name |
Description |
parameter attributes for callable |
|
Fast‐math flags stored by the instruction. |
|
Function type of the call (return type, parameter types, varargs). |
|
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. |
Protected Static Data Members
Name |
Description |
The last operand is the called operand. |
Protected Using Declarations
Name |
Description |
Inherit |
Non-Member Functions
Name |
Description |
Check if it is legal to perform inlining of the function called by |
|
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 a call to the specified function with the specified arguments, returning null if unsuccessful. |
|
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. |
|
Inline |
|
Inline the callee of |
|
This should generally not be used, use InlineFunction instead. |
|
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. |
|
This is the complement to the above, replacing a specific call to an intrinsic function with a call to the specified new function. |
|
Adapt an instruction's noalias metadata using a scope map. |
|
Appends the set of assumptions |
|
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 this call calls a GC leaf function. |
|
Return true if it is even possible to fold a call to the specified function. |
|
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. |
|
Convert a call into an invoke and split its basic block. |
|
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. |
|
Emit a dontcall diagnostic for call instruction |
|
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 |
|
Apply function Func to each CB's callback call site. |
|
Apply function Func to each CB's callback function. |
|
Returns true if the parent of |
|
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 |
|
Gets the alignment argument for an aligned_alloc‐like function. |
|
Return the size of the requested allocation. |
|
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 call pointer argument that aliasing rules treat as the returned pointer. |
|
Non‐const overload of getArgumentAliasingToReturnedPointer. |
|
Return the set of all assumptions for the call |
|
Return the sync scope of atomic instruction |
|
Decide inlining from user directives and viability, without cost modeling. |
|
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. |
|
Given a deinterleaveN intrinsic, return the (narrow) vector type of each factor. |
|
If this if a call to a free function, return the freed operand. |
|
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. |
|
Get an InlineCost object representing the cost of inlining this callsite. |
|
Get an InlineCost with the callee explicitly specified. |
|
Get the cost estimate ignoring thresholds. |
|
Get the expanded cost features. The features are returned unconditionally, even if inlining is impossible. |
|
Map a call instruction to an intrinsic ID. Libcalls which have equivalent intrinsics are treated as‐if they were intrinsics. |
|
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. |
|
If this is a call to a realloc function, return the reallocated operand. |
|
Get splat value if the input is a splat vector or return nullptr. |
|
Parse a function string attribute on |
|
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 |
|
Return the intrinsic ID mapped from a call, or not_intrinsic. |
|
Replace instruction operands of an unreachable terminator with poison. |
|
Return true if |
|
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 |
|
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. |
|
Test whether an instruction is in a position for tail‐call optimization. |
|
Return true if an unused instruction is trivially dead. |
|
Return true if |
|
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 the given indirect call site can be made to call |
|
Check whether the given call has no side‐effects. Specifically checks for math routimes which sometimes set errno. |
|
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 this is a call to a removable allocation function. |
|
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. |
|
Try to turn a call to @llvm.objectsize into an integer value. |
|
Try to turn a call to @llvm.objectsize into an integer value. |
|
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. |
|
Match a simple binary‐intrinsic value‐accumulating recurrence. |
|
Match a simple ternary‐intrinsic value‐accumulating recurrence. |
|
Returns true if the instruction could have memprof metadata, used to ensure consistency between summary analysis and the ThinLTO backend processing. |
|
Returns true if the result or effects of the given instructions |
|
Mark known string library calls with NoBuiltin for sanitizer interception. |
|
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. |
|
Promote the given indirect call site to unconditionally call |
|
Promote the given indirect call site to conditionally call |
|
Promote an indirect call conditionally while updating contextual profiles. |
|
This is similar to |
|
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 inline‐remark attribute on call site |
|
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. |
|
Return the inline cost when the inliner should attempt |
|
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 a callsite, callee, and arguments, fold the result or return null. |
|
Given a constrained FP intrinsic call, tries to compute its simplified version. |
|
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. |
|
Try to promote (devirtualize) a virtual call on an Alloca. Return true on success. |
|
Update debug locations in any MD_loop metadata attached to |
|
Predicate and clone the given call site. |
|
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 any intrinsic call, capturing it if we match. |
|
Match any const intrinsic call, capturing it if we match. |
|
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. |
|
Populate VariantMappings with Vector Function ABI variant names for CI. |
|
Overwrite the Vector Function ABI variants attribute with the names provide in |
|
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 |
|
Return the resource name from a handle‐from‐binding call. |
|
Evaluate a filter expression for an instrumentation opportunity. |
|
Adds an "ambiguous" memprof attribute to call with a matched allocation profile but that we haven't yet been able to disambiguate. |
|
Removes any existing "ambiguous" memprof attribute. Called before we apply a specific allocation type such as "cold", "notcold", or "hot". |
|
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. |
|
Helper for GetARCInstKind. Determines what kind of construct CS is. |
|
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. |
|
Return whether clang_arc_attachedcall should be emitted with a marker. |
|
Return the ARC runtime function from a clang_arc_attachedcall bundle. |
|
Return the ARCInstKind of the function on clang_arc_attachedcall. |
|
Return true if |
|
Promote an indirect call or invoke |
Created with MrDocs