Represents calls to the gc.relocate intrinsic.
Synopsis
Declared in <llvm/IR/IntrinsicInst.h>
class GCRelocateInst
: public GCProjectionInstBase Classes
Name |
Description |
Common base class for representing values projected from a statepoint. Currently, the only projections available are gc.result and gc.relocate. |
Types
Name |
Description |
Used to keep track of an operand bundle. See the main comment on OperandBundleUser above. |
|
The const version of |
|
Iterator type that casts an operand to a basic block. |
|
Iterator for directly iterating over the operand Values. |
Type Aliases
Enums
Name |
Description |
When checking for operation equivalence (using isSameOperationAs) it is sometimes useful to ignore certain attributes. |
|
Concrete subclass of this. |
Member Functions
Name |
Description |
Assignment operators |
|
Translate PHI node to its predecessor from the given basic block. |
|
|
|
adds the attribute to the list of attributes. |
|
adds the dereferenceable attribute to the list of attributes. |
|
adds the dereferenceable attribute to the list of attributes. |
|
Adds the attribute to the function. |
|
Adds the attribute to the indicated argument |
|
Adds attributes to the indicated argument |
|
adds the range attribute to the list of attributes. |
|
Adds the attribute to the return value. |
|
Adds attributes to the return value. |
|
This method should only be used by the Use class. |
|
Transfer any DbgRecords on the position |
|
Logical 'and' of any supported wrapping, exact, and fast‐math flags of V and this instruction. |
|
Merge 2 debug locations and apply it to the Instruction. If the instruction is a CallIns, we need to traverse the inline chain to find the common scope. This is not efficient for N‐way merging as each time you merge 2 iterations, you need to rebuild the hashmap to find the common scope. However, we still choose this API because: 1) Simplicity: it takes 2 locations instead of a list of locations. 2) In worst case, it increases the complexity from O(N*I) to O(2_N_I), where N is # of Instructions to merge, and I is the maximum level of inline stack. So it is still linear. 3) Merging of call instructions should be extremely rare in real applications, thus the N‐way merging should be in code path. The DebugLoc attached to this instruction will be overwritten by the merged DebugLoc. |
|
Return the iterator pointing to the beginning of the argument list. |
|
Return the iterator pointing to the end of the argument list. |
|
Iteration adapter for range‐for loops. |
|
Return true if the bundle operand at index |
|
Return the start of the list of BundleOpInfo instances associated with this OperandBundleUser. |
|
Return the end of the list of BundleOpInfo instances associated with this OperandBundleUser. |
|
Return the range []`bundle_op_info_begin,` |
|
Return true if the memory object referred to by V can by freed in the scope for which the SSA value defining the allocation is statically defined. E.g. deallocation after the static scope of a value does not count, but a deallocation before that does. |
|
Return true if the call can return twice |
|
Determine if the invoke cannot be duplicated. |
|
Determine if the call cannot be tail merged. |
|
Create a copy of 'this' instruction that is identical in all ways except the following: * The instruction has no parent * The instruction has no name |
|
Clone any debug‐info attached to |
|
Given an instruction Other in the same basic block as this instruction, return true if this instruction comes before Other. In this worst case, this takes linear time in the number of instructions in the block. The results are cached, so in common cases when the block remains unmodified, it takes constant time. |
|
|
|
Convenience method to copy supported exact, fast‐math, and (optionally) wrapping flags from V to this instruction. |
|
Copy metadata from |
|
Copy debug, profile, and memprof metadata from |
|
|
|
Return true if the data operand at index |
|
data_operands_begin/data_operands_end ‐ Return iterators iterating over the call / invoke argument list and bundle operands. For invokes, this is the set of instruction operands except the invoke target and the two successor blocks; and for calls this is the set of instruction operands except the call target. |
|
Delete a pointer to a generic Value. |
|
Determine if the call should not perform indirect branch tracking. |
|
Determine if the call does not access memory. |
|
Determine whether this data operand is not captured. |
|
Determine if the call cannot return. |
|
Determine if the 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. This does not guarantee removal of the !dbg source location attachment, as it must set a line 0 location with scope information attached on call instructions. To guarantee removal of the !dbg attachment, use the |
|
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 any attributes or metadata that can cause immediate undefined behavior. Retain other attributes/metadata on a best‐effort basis, as well as those passed in |
|
This function drops non‐debug unknown metadata (through dropUnknownNonDebugMetadata). For calls, it also drops parameter and return attributes that can cause undefined behaviour. Both of these should be done by passes which move instructions in IR. |
|
Drop all unknown metadata except for debug locations. @{ Passes are required to drop metadata they don't understand. This is a convenience method for passes to do so. dropUBImplyingAttrsAndUnknownMetadata should be used instead of this API if the Instruction being modified is a call. |
|
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. Returns true on success with profile total weights filled in. Returns false if no metadata was found. |
|
Returns the AA metadata for this instruction. |
|
Return the type this instruction accesses in memory, if any. |
|
Get all metadata attached to this Instruction. The first element of each pair returned is the KindID, the second element is the metadata value. This list is returned sorted by the KindID. |
|
This does the same thing as getAllMetadata, except that it filters out the debug location. |
|
|
|
Wrappers for getting the |
|
If one of the arguments has the specified attribute, returns its operand value. Otherwise, return nullptr. |
|
Get the attribute of a given kind at a position. |
|
Return the attributes for this call. |
|
The index into the associate statepoint's argument list which contains the base pointer of the pointer whose relocation this gc.relocate describes. |
|
Return the BundleOpInfo for the operand at index OpIdx. |
|
Return the index of the last bundle operand in the Use array. |
|
Return the index of the first bundle operand in the Use array. |
|
Returns the function called, or null if this is an indirect function invocation or the function signature does not match the call signature, or the call target is an alias. |
|
Helper to get the caller (the parent function). |
|
Return which pointer components this operand may capture. |
|
All values hold a context through their type. |
|
Return the convergence control token for this call, if it exists. |
|
Get 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 position of the "Next" DbgRecord after this instruction, or std::nullopt. This is the position to pass to BasicBlock::reinsertInstInDbgRecords when re‐inserting an instruction. |
|
Return the debug location for this node as a DebugLoc. |
|
The index into the associate statepoint's argument list which contains the pointer whose relocation this gc.relocate describes. |
|
Returns the descriptor co‐allocated with this User instance. |
|
Convenience function for getting all the fast‐math flags, which must be an operator which supports these flags. See LangRef.html for the meaning of these flags. |
|
Convenience function for getting fast‐math flags, or default‐constructed FastMathFlags when not a FPMathOperator. |
|
Get the attribute of a given kind for the function. |
|
Return the function this instruction belongs to. |
|
Get the first insertion point at which the result of this instruction is defined. This is not the directly following instruction in a number of cases, e.g. phi nodes or terminators that return values. This function may return null if the insertion after the definition is not possible, e.g. due to a catchswitch terminator. |
|
Return the intrinsic ID of this intrinsic. |
|
Get the metadata of given kind attached to this Instruction. If the metadata is not found then return null. |
|
Return the module owning the function this instruction belongs to or nullptr it the function does not have a module. |
|
Return a constant reference to the value's name. |
|
Get the next node, or |
|
Return the number of operand bundles associated with this User. |
|
Return the number of successors that this instruction has. The instruction must be a terminator. |
|
Return the total number operands (not operand bundles) used by every operand bundle in this OperandBundleUser. |
|
This method computes the number of uses of this Value. |
|
Returns a member of one of the enums like Instruction::Add. |
|
|
|
Return the operand bundle at a specific index. |
|
Return the operand bundle for the operand at index OpIdx. |
|
Return the list of operand bundles attached to this instruction as a vector of OperandBundleDefs. |
|
Extract the alignment for a call or parameter (0=unknown). |
|
Get the attribute of a given kind from a given arg |
|
Return the param attributes for this call. |
|
Extract the byref type for a call or parameter. |
|
Extract the byval type for a call or parameter. |
|
Extract the number of dereferenceable bytes for a call or parameter (0=unknown). |
|
Extract the number of dereferenceable_or_null bytes for a parameter (0=unknown). |
|
Extract the elementtype type for a parameter. Note that elementtype() can only be applied to call arguments, not function declaration parameters. |
|
Extract the inalloca type for a call or parameter. |
|
Extract a test mask for disallowed floating‐point value classes for the parameter. |
|
Extract the preallocated type for a call or parameter. |
|
Extract the sret type for a call or parameter. |
|
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 |
|
|
|
If this return value has a range attribute, return the value range of the argument. Otherwise, std::nullopt is returned. |
|
Return the raw optional flags value contained in this value. |
|
Extract the alignment of the return value. |
|
Return the attribute for the given attribute kind for the return value. |
|
Return the return attributes for this call. |
|
Extract the number of dereferenceable bytes for a call or parameter (0=unknown). |
|
Extract the number of dereferenceable_or_null bytes for a call (0=unknown). |
|
Extract a test mask for disallowed floating‐point value classes for the return value. |
|
If one of the arguments has the 'returned' attribute, returns its operand value. Otherwise, return nullptr. |
|
Return true if there is exactly one use of this value that cannot be dropped. |
|
Fetch the debug location for this node, unless this is a debug intrinsic, in which case fetch the debug location of the next non‐debug node. |
|
The statepoint with which this gc.relocate is associated. |
|
Return the specified successor. This instruction must be a terminator. |
|
All values are typed, get the type of this value. |
|
Return true if there is exactly one unique user of this value that cannot be dropped (that user can have multiple uses of this value). |
|
Return an ID for the concrete type of this object. |
|
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. |
|
Returns true if this CallSite passes the given Value* as an argument to the called function. |
|
Returns whether the call has an argument that has an attribute like captures(ret: address, provenance), where the return capture components are not a subset of the other capture components. |
|
Return true if this atomic instruction loads from memory. |
|
Return true if this atomic instruction stores to memory. |
|
Determine if any call argument is an aggregate passed by value. |
|
Return true if this operand bundle user has operand bundles that may write to the heap. |
|
Returns true if any DbgRecords are attached to this instruction. |
|
Return true if the call has deopt state bundle. |
|
Determine whether this call has the given attribute. If it does not then determine if the called function has the attribute, but only if the attribute is allowed for the call. |
|
Return true if |
|
Determine if there are is an inalloca argument. Only the last argument can have the inalloca attribute. |
|
|
|
Return true if this instruction has metadata attached to it other than a debug location. |
|
Return true if there this value. |
|
Return true if this value has N uses or more. |
|
Return true if this Value has exactly N uses. |
|
Return true if this value has N uses or more. |
|
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. |
|
Determine whether the 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 User has any operand bundles. |
|
Return true if this operand bundle user contains operand bundles with tags other than those specified 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 this instruction to evaluate to poison despite having non‐poison inputs. |
|
Return true if this instruction has poison‐generating metadata. |
|
Return true if this operand bundle user has operand bundles that may read from the heap. |
|
Determine whether the return value has the given attribute. |
|
This function determines if the speficied instruction has the same "special" characteristics as the current one. This means that opcode specific details are the same. As a common example, if we are comparing loads, then hasSameSpecialState would compare the alignments (among other things). |
|
Determine if the call returns a structure through first pointer argument. |
|
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 a basic block immediately before the specified position. |
|
Inserts an unlinked instruction into |
|
Return true if this is an arithmetic shift right. |
|
Checks if the intrinsic is an annotation. |
|
Return true if this instruction has an AtomicOrdering of unordered or higher. |
|
Return true if this is and/or/xor. |
|
|
|
Determine whether this argument is passed by value. |
|
|
|
Return true if the operand is commutable. |
|
Return true if swapping the first two arguments to the intrinsic produces the same result. |
|
Determine if the invoke is convergent |
|
Return true if the instruction is a DbgInfoIntrinsic or PseudoProbeInst. |
|
A droppable user is a user for which uses can be dropped without affecting correctness and should be dropped rather than preventing a transformation from happening. |
|
Return true if the instruction is a variety of EH‐block. |
|
Determine whether the exact flag is set. |
|
Determine whether all fast‐math‐flags are set. |
|
Return true if this instruction behaves like a memory fence: it can load or store to memory location without being given a memory location. |
|
Return true if the instruction is idempotent: |
|
Return true if the specified instruction is exactly identical to the current one. This means that all operands match and any extra information (e.g. load is volatile) agree. |
|
This is like isIdenticalTo, except that it ignores the SubclassOptionalData flags, which may specify conditions under which the instruction's result is undefined. |
|
Determine whether this argument is passed in an alloca. |
|
Return true if the callsite is an indirect call. |
|
Check if this call is an inline asm statement. |
|
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 the call should not be treated as a call to a builtin. |
|
Return true if the call should not be inlined. |
|
Return true if the call is for a noreturn trap intrinsic. |
|
It checks if this instruction is the only user of at least one of its operands. |
|
Return true if the operand at index |
|
Determine whether this argument is passed by value, in an alloca, or is preallocated. |
|
Determine whether passing undef to this argument is undefined behavior. If passing undef to this argument is UB, passing poison is UB as well because poison is more undefined than undef. |
|
Return true if the return value is known to be not null. This may be because it has the nonnull attribute, or because at least one byte is dereferenceable and the pointer is in addrspace(0). |
|
Return true if the instruction can be removed if the result is unused. |
|
This function determines if the specified instruction executes the same operation as the current one. This means that the opcodes, type, operand types and any other factors affecting the operation must be the same. This is similar to isIdenticalTo except the operands themselves don't have to be identical. |
|
Determine if the call requires strict floating point semantics. |
|
Return true if this value is a swifterror value. |
|
Return true if this relocate is tied to the invoke statepoint. This includes relocates which are on the unwinding path. |
|
Return true if there is metadata referencing this value. |
|
Check if this value is used in the specified basic block. |
|
Return true if there are any uses of this instruction in blocks other than the specified block. Note that PHI nodes are considered to evaluate their operands in the corresponding predecessor block. |
|
Return true if this instruction has a volatile memory access. |
|
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, in the sense that it may introduce a synchronizes‐with edge. |
|
Return true if this instruction may throw an exception. |
|
Return true if this instruction may modify memory. |
|
Merge the DIAssignID metadata from this instruction and those attached to instructions in |
|
Unlink this instruction from its current basic block and insert it into the basic block that MovePos lives in, right after MovePos. |
|
See |
|
|
|
Perform a |
|
Mutate the type of this Value to be of the specified type. |
|
Determine if the call can access memmory only using pointers based on its arguments. |
|
Determine if the function may only access memory that is either inaccessible from the IR or pointed to by its arguments. |
|
Determine if the function may only access memory that is inaccessible from the IR. |
|
Determine if the call does not access or only reads memory. |
|
Determine if the call does not access or only writes memory. |
|
Simple helper function to map a BundleOpInfo to an OperandBundleUse. |
|
Delete operators |
|
Determine whether the argument or parameter has the given attribute. |
|
Return true if this argument has the nonnull attribute on either the CallBase instruction or the called function. Also returns true if at least one byte is known to be dereferenceable and the pointer is in addrspace(0). If |
|
Populate the BundleOpInfo instances and the Use& vector from |
|
Implement operator<< on Value. @{ |
|
Print the name of this Value out to the specified raw_ostream. |
|
removes the attribute from the list of attributes. |
|
Removes the attribute from the function |
|
Removes the attributes from the function |
|
This method unlinks 'this' from the containing basic block, but does not delete it. |
|
Removes the attribute from the given argument |
|
Removes the attributes from the given argument |
|
Removes the attribute from the return value |
|
Removes the attributes from the return value |
|
Change all uses of this to point to a new Value. |
|
Change non‐metadata uses of this to point to a new Value. |
|
Replace specified successor OldBB to point at the provided block. This instruction must be a terminator. |
|
Replace uses of one Value with another. |
|
replaceUsesOutsideBlock ‐ Go through the uses list for this definition and make each use point to "V" instead of "this" when the use is outside the block. 'This's use list is expected to have at least one element. Unlike replaceAllUsesWith() this function does not support basic block values. |
|
Go through the uses list for this definition and make each use point to "V" if the callback ShouldReplace returns true for the given Use. Unlike replaceAllUsesWith() this function does not support basic block values. Returns whether any uses have been replaced. |
|
Determine if the return value is marked with NoAlias attribute. |
|
Reverse the use‐list. |
|
Sets the AA metadata on this instruction from the AAMDNodes structure. |
|
Set the attributes for this call. |
|
|
|
Set the debug location information for this instruction. |
|
Set or clear all fast‐math‐flags on this instruction, which must be an operator which supports this flag. See LangRef.html for the meaning of this flag. |
|
Convenience function for setting multiple fast‐math flags on this instruction, which must be an operator which supports these flags. See LangRef.html for the meaning of these flags. |
|
Set or clear the allow‐contract flag on this instruction, which must be an operator which supports this flag. See LangRef.html for the meaning of this flag. |
|
Set or clear the reassociation flag on this instruction, which must be an operator which supports this flag. See LangRef.html for the meaning of this flag. |
|
Set or clear the allow‐reciprocal flag on this instruction, which must be an operator which supports this flag. See LangRef.html for the meaning of this flag. |
|
Set or clear the approximate‐math‐functions flag on this instruction, which must be an operator which supports this flag. See LangRef.html for the meaning of this flag. |
|
Set or clear the no‐infs flag on this instruction, which must be an operator which supports this flag. See LangRef.html for the meaning of this flag. |
|
Set or clear the no‐nans flag on this instruction, which must be an operator which supports this flag. See LangRef.html for the meaning of this flag. |
|
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag. See LangRef.html for the meaning of this flag. |
|
Set or clear the no‐signed‐zeros flag on this instruction, which must be an operator which supports this flag. See LangRef.html for the meaning of this flag. |
|
Set or clear the nuw flag on this instruction, which must be an operator which supports this flag. See LangRef.html for the meaning of this flag. |
|
Set or clear the exact flag on this instruction, which must be an operator which supports this flag. See LangRef.html for the meaning of this flag. |
|
Set the metadata of the specified kind to the specified node. This updates or replaces metadata if already present, or removes it if Node is null. |
|
Change the name of the value. |
|
Sets the nosanitize metadata on this instruction. |
|
Set or clear the nneg flag on this instruction, which must be a zext instruction. |
|
Subclasses with hung off uses need to manage the operand count themselves. In these instances, the operand count isn't used to find the OperandList, so there's no issue in having the operand count change. |
|
Update the specified successor to point at the provided block. This instruction must be a terminator. |
|
Sort the use‐list. |
|
Accumulate the constant offset this value has compared to a base pointer. Only 'getelementptr' instructions (GEPs) are accumulated but other instructions, e.g., casts, are stripped away as well. The accumulated constant offset is added to |
|
This is a wrapper around stripAndAccumulateConstantOffsets with the in‐bounds requirement set to false. |
|
Strip off pointer casts and all‐constant inbounds GEPs. |
|
Strip off pointer casts and inbounds GEPs. |
|
Strip off pointer casts, all‐zero GEPs and address space casts. |
|
Strip off pointer casts, all‐zero GEPs, address space casts, and aliases. |
|
Strip off pointer casts, all‐zero GEPs, single‐argument phi nodes and invariant group info. |
|
Strip off pointer casts, all‐zero GEPs and address space casts but ensures the representation of the result stays the same. |
|
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. |
|
Try to intersect the attributes from 'this' CallBase and the 'Other' CallBase. Sets the intersected attributes to 'this' and return true if successful. Doesn't modify 'this' and returns false if unsuccessful. |
|
Updates the debug location given that the instruction has been hoisted from a block to a predecessor of that block. Note: it is undefined behavior to call this on an instruction not currently inserted into a function. |
|
Updates profile metadata by scaling it by |
|
Specialize the methods defined in Value, as we know that an instruction can only be used by other instructions. |
|
Return true if the instruction will return (unwinding is considered as a form of returning control flow here). |
Static Member Functions
Name |
Description |
|
|
Create a clone of |
|
Methods for support type inquiry through isa, cast, and dyn_cast: |
|
Remove the droppable use |
|
Determine if the Opcode is and/or/xor. |
|
Determine if the Opcode is one of the CastInst instructions. |
|
Determine if the Opcode is one of the FuncletPadInst instructions. |
|
Determine if the Opcode is one of the shift instructions. |
|
Returns true if the Opcode is a "special" terminator that does more than branch to a successor (e.g. have a side effect or return a value). |
|
Check if the intrinsic might lower into a regular function call in the course of IR transformations |
|
Create a clone of |
|
Data Members
Name |
Description |
Optional marker recording the position for debugging information that takes effect immediately before this instruction. Null unless there is debugging information present. |
Static Data Members
Name |
Description |
The maximum alignment for instructions. |
|
Using Declarations
Name |
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
Protected Enums
Name |
Description |
The number of operands in the subclass. |
Protected Member Functions
Name |
Description |
Add a metadata attachment. @{ |
|
Allocate the array of Uses, followed by a pointer (with bottom bit set) to the User. |
|
Erase all metadata attached to this Value. |
|
Erase all metadata attachments with the given kind. |
|
Erase all metadata attachments matching the given predicate. |
|
Appends all metadata attached to this value to |
|
Get the current metadata attachments for the given kind, if any. |
|
Get metadata for the given kind, if any. This is an internal function that must only be called after checking that |
|
Get the number of extra operands for instructions that don't have a fixed number of extra operands. |
|
Grow the number of hung off uses. Note that allocHungoffUses should be called if there are no uses. |
|
New operators |
|
Set a particular kind of metadata attachment. |
|
Protected Static Member Functions
Name |
Description |
Return the total number of values used in |
|
Protected Data Members
Name |
Description |
parameter attributes for callable |
|
Hold arbitary subclass data. |
Protected Static Data Members
Name |
Description |
The last operand is the called operand. |
Protected Using Declarations
Name |
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. We know that at least 1 bit is always equal to the sign bit (itself), but other cases can give us information. For example, immediately after an "ashr X, 2", we know that the top 3 bits are all equal to each other, so we return 3. For vectors, return the number of sign bits for the vector element with the mininum number of known sign bits. |
|
ConstantFoldCall ‐ Attempt to constant fold a call to the specified function with the specified arguments, returning null if unsuccessful. |
|
ConstantFoldInstOperands ‐ Attempt to constant fold an instruction with the specified operands. If successful, the constant result is returned, if not, null is returned. Note that this function can fail when attempting to fold instructions like loads and stores, which have no constant expression form. |
|
ConstantFoldInstruction ‐ Try to constant fold the specified instruction. If successful, the constant result is returned, if not, null is returned. Note that this fails if not all of the operands are constant. Otherwise, this function can only fail when attempting to fold instructions like loads and stores, which have no constant expression form. |
|
This function takes a virtual register computed by an Instruction and replaces it with a slot in the stack frame, allocated via alloca. This allows the CFG to be changed around without fear of invalidating the SSA information for the value. It returns the pointer to the alloca inserted to create a stack slot for X. |
|
ExtractTypeInfo ‐ Returns the type info, possibly bitcast, encoded in V. |
|
Given an aggregate and an sequence of indices, see if the scalar value indexed is already around as a register, for example if it were inserted directly into the aggregate. |
|
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. |
|
If we can compute the length of the string pointed to by the specified pointer, return 'len+1'. If we can't, return 0. |
|
Same as above, but it will update the contextual profile. If the contextual profile is invalid (i.e. not loaded because it is not present), it defaults to the behavior of the non‐contextual profile updating variant above. This makes it easy to drop‐in replace uses of the non‐contextual overload. |
|
This function inlines the called function into the basic block of the caller. This returns false if it is not possible to inline this call. The program is still in a well defined state if this occurs though. |
|
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. |
|
PointerMayBeCaptured ‐ Visit the value and the values derived from it and find values which appear to be capturing the pointer value. This feeds results into and is controlled by the CaptureTracker object. MaxUsesToExplore specifies how many uses the analysis should explore for one value before giving up due too "too many uses". If MaxUsesToExplore is zero, a default value is assumed. This function only considers captures of the passed value via its def‐use chain, without considering captures of values it may be based on, or implicit captures such as for external globals. |
|
Return which components of the pointer may be captured. Only consider components that are part of |
|
PointerMayBeCaptured ‐ Return true if this pointer value may be captured by the enclosing function (which is required to exist). This routine can be expensive, so consider caching the results. The boolean ReturnCaptures specifies whether returning the value (or part of it) from the function counts as capturing it or not. MaxUsesToExplore specifies how many uses the analysis should explore for one value before giving up due too "too many uses". If MaxUsesToExplore is zero, a default value is assumed. This function only considers captures of the passed value via its def‐use chain, without considering captures of values it may be based on, or implicit captures such as for external globals. |
|
PointerMayBeCapturedBefore ‐ Return true if this pointer value may be captured by the enclosing function (which is required to exist). If a DominatorTree is provided, only captures which happen before the given instruction are considered. This routine can be expensive, so consider caching the results. The boolean ReturnCaptures specifies whether returning the value (or part of it) from the function counts as capturing it or not. Captures by the provided instruction are considered if the final parameter is true. MaxUsesToExplore specifies how many uses the analysis should explore for one value before giving up due too "too many uses". If MaxUsesToExplore is zero, a default value is assumed. This function only considers captures of the passed value via its def‐use chain, without considering captures of values it may be based on, or implicit captures such as for external globals. |
|
Return which components of the pointer may be captured on the path to |
|
If the specified value is a trivially dead instruction, delete it. If that makes any of its operands trivially dead, delete them too, recursively. Return true if any instructions were deleted. |
|
Convert the instruction operands from referencing the current values into those specified by VM. |
|
Remap source location atom. Called by RemapInstruction. This updates the instruction's atom group number if it has been mapped (e.g. with llvm::mapAtomInstance), which is necessary to distinguish source code atoms on duplicated code paths. |
|
Replace the instruction specified by From with the instruction specified by To. Copies DebugLoc from BI to I, if I doesn't already have a DebugLoc. |
|
Utility function for performing a given action on each lane of a vector with |
|
Similar to SplitBlockAndInsertIfThen, but the inserted block is on the false path of the branch. |
|
Split the containing block at the specified instruction ‐ everything before SplitBefore stays in the old basic block, and the rest of the instructions in the BB are moved to a new block. The two blocks are connected by a conditional branch (with value of Cmp being the condition). Before: Head SplitBefore Tail After: Head if (Cond) ThenBlock SplitBefore Tail |
|
Split the containing block at the specified instruction ‐ everything before SplitBefore stays in the old basic block, and the rest of the instructions in the BB are moved to a new block. The two blocks are connected by a conditional branch (with value of Cmp being the condition). Before: Head SplitBefore Tail After: Head if (Cond) TrueBlock else/ FalseBlock SplitBefore Tail |
|
SplitBlockAndInsertIfThenElse is similar to SplitBlockAndInsertIfThen, but also creates the ElseBlock. Before: Head SplitBefore Tail After: Head if (Cond) ThenBlock else ElseBlock SplitBefore Tail |
|
Insert a for (int i = 0; i < End; i++) loop structure (with the exception that |
|
If this edge is a critical edge, insert a new node to split the critical edge. This will update the analyses passed in through the option struct. This returns the new block if the edge was split, null otherwise. |
|
If it is known that an edge is critical, SplitKnownCriticalEdge can be called directly, rather than calling SplitCriticalEdge first. |
|
This is the complement to the above, replacing a specific call to an intrinsic function with a call to the specified new function. |
|
Adapt the metadata for the specified instruction according to the provided mapping. This is normally used after cloning an instruction, when some noalias scopes needed to be cloned. |
|
Appends the set of assumptions |
|
Add code that checks at runtime if the accessed arrays in |
|
Build a call to llvm.assume to preserve informations that can be derived from the given instruction. If no information derived from |
|
Return true if this call calls a gc leaf function. |
|
canConstantFoldCallTo ‐ Return true if its even possible to fold a call to the specified function. |
|
Given an instruction, is it legal to set operand OpIdx to a non‐constant value? |
|
Returns true if a pointer value |
|
Returns true if is legal to hoist or sink this instruction disregarding the possible introduction of faults. Reasoning about potential faulting instructions is the responsibility of the caller since it is challenging to do efficiently from within this routine. |
|
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 the CallInst to InvokeInst with the specified unwind edge basic block. This also splits the basic block where CI is located, because InvokeInst is a terminator instruction. Returns the newly split basic block. |
|
Insert an unreachable instruction before the specified instruction, making it and the rest of the code in 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. |
|
Enumerates all possible immediate values of V and inserts them into the set |
|
Combine metadata of two instructions, where instruction J is a memory access that has been merged into K. This will intersect alias‐analysis metadata, while preserving other known metadata. |
|
Combine the metadata of two instructions so that K can replace J. This specifically handles the case of CSE‐like transformations. Some metadata can only be kept if K dominates J. For this to be correct, K cannot be hoisted. |
|
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. |
|
Merge bits known from context‐dependent facts into Known. |
|
Wrapper to account for known fast math flags at the use instruction. |
|
|
|
Return false if we can prove that the specified FP value's sign bit is 0. Return true if we can prove that the specified FP value's sign bit is 1. Otherwise return std::nullopt. |
|
Emit a loop implementing the semantics of an llvm.memcpy whose size is a compile time constant. Loop is inserted at |
|
Emit a loop implementing the semantics of llvm.memcpy where the size is not a compile‐time constant. Loop will be inserted at |
|
Decompose an icmp into the form ((X & Mask) pred C) if possible. Unless |
|
Decompose an icmp into the form ((X & Mask) pred C) if possible. Unless |
|
Remove the debug intrinsic instructions for the given instruction. |
|
Emit a call to the bcmp function. |
|
Emit a call to the binary function named 'Name' (e.g. 'fmin'). This function is known to take type matching 'Op1' and 'Op2' and return one value with the same type. If 'Op1/Op2' are long double, 'l' is added as the suffix of name, if 'Op1/Op2' are float, we add a 'f' suffix. |
|
Emit a call to the binary function DoubleFn, FloatFn or LongDoubleFn, depending of the type of Op1. |
|
Emit a call to the calloc function. |
|
Emit a call to the fputc function. This assumes that Char is an 'int', and File is a pointer to FILE. |
|
Emit a call to the fputs function. Str is required to be a pointer and File is a pointer to FILE. |
|
Emit a call to the fwrite function. This assumes that Ptr is a pointer, Size is an 'size_t', and File is a pointer to FILE. |
|
Emit a call to the hot/cold operator new function. |
|
Emit a call to the malloc function. |
|
Emit a call to the memccpy function. |
|
Emit a call to the memchr function. This assumes that Ptr is a pointer, Val is an 'int' value, and Len is an 'size_t' value. |
|
Emit a call to the memcmp function. |
|
Emit a call to the __memcpy_chk function to the builder. This expects that the Len and ObjSize have type 'size_t' and Dst/Src are pointers. |
|
Emit a call to the mempcpy function. |
|
Emit a call to the memrchr function, analogously to emitMemChr. |
|
Emit a call to the putchar function. This assumes that Char is an 'int'. |
|
Emit a call to the puts function. This assumes that Str is some pointer. |
|
Emit a call to the snprintf function. |
|
Emit a call to the sprintf function. |
|
Emit a call to the stpcpy function to the builder, for the specified pointer arguments. |
|
Emit a call to the stpncpy function to the builder, for the specified pointer arguments and length. |
|
Emit a call to the strcat function. |
|
Emit a call to the strchr function to the builder, for the specified pointer and character. Ptr is required to be some pointer type, and the return value has 'i8*' type. |
|
Emit a call to the strcpy function to the builder, for the specified pointer arguments. |
|
Emit a call to the strdup function to the builder, for the specified pointer. Ptr is required to be some pointer type, and the return value has 'i8*' type. |
|
Emit a call to the strlcat function. |
|
Emit a call to the strlcpy function. |
|
Emit a call to the strlen function to the builder, for the specified pointer. Ptr is required to be some pointer type, and the return value has 'size_t' type. |
|
Emit a call to the strncat function. |
|
Emit a call to the strncmp function to the builder. |
|
Emit a call to the strncpy function to the builder, for the specified pointer arguments and length. |
|
Emit a call to the unary function DoubleFn, FloatFn or LongDoubleFn, depending of the type of Op. |
|
Emit a call to the unary function named 'Name' (e.g. 'floor'). This function is known to take a single of type matching 'Op' and returns one value with the same type. If 'Op' is a long double, 'l' is added as the suffix of name, if 'Op' is a float, we add a 'f' suffix. |
|
Emit a call to the vsnprintf function. |
|
Emit a call to the vsprintf function. |
|
Emit a call to the wcslen function to the builder, for the specified pointer. Ptr is required to be some pointer type, and the return value has 'size_t' type. |
|
Extract branch weights attatched to an Instruction |
|
Extract branch weights from a conditional branch or select Instruction. |
|
Retrieve the total of all weights from an instruction. |
|
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 |
|
Gets the alignment argument for an aligned_alloc‐like function, using either built‐in knowledge based on fuction names/signatures or allocalign attributes. Note: the Value returned may not indicate a valid alignment, per the definition of the allocalign attribute. |
|
Return the size of the requested allocation. With a trivial mapper, this is similar to calling getObjectSize(..., Exact), but without looking through calls that return their argument. A mapper function can be used to replace one Value* (operand to the allocation) with another. This is useful when doing abstract interpretation. |
|
If a function is part of an allocation family (e.g. malloc/realloc/calloc/free), return the identifier for its family of functions. |
|
This function returns call pointer argument that is considered the same by aliasing rules. You CAN'T use it to replace one value with another. If |
|
Return the set of all assumptions for the call |
|
A helper function that returns an atomic operation's sync scope; returns std::nullopt if it is not an atomic operation. |
|
Returns InlineResult::success() if the call site should be always inlined because of user directives, and the inlining is viable. Returns InlineResult::failure() if the inlining may never happen because of user directives or incompatibilities detectable without needing callee traversal. Otherwise returns std::nullopt, meaning that inlining should be decided based on other criteria (e.g. cost modeling). |
|
Like getObjectSize(), but only returns the size of base objects (like allocas, global variables and allocator calls) and std::nullopt otherwise. Requires ExactSizeFromOffset mode. |
|
Get the branch weights metadata node |
|
Returns true if the value |
|
This function computes the length of a null‐terminated C string pointed to by V. If successful, it returns true and returns the string in Str. If unsuccessful, it returns false. This does not include the trailing null character by default. If TrimAtNul is set to false, then this returns any trailing null characters as well as any other characters that come after it. |
|
Returns constrained intrinsic id to represent the given instruction in strictfp function. If the instruction is already a constrained intrinsic or does not have a constrained intrinsic counterpart, the function returns zero. |
|
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. This allows you to calculate the cost of inlining a function via a pointer. This behaves exactly as the version with no explicit callee parameter in all other respects. |
|
Get the cost estimate ignoring thresholds. This is similar to getInlineCost when passed InlineParams::ComputeFullInlineCost, or a non‐null ORE. It uses default InlineParams otherwise. Contrary to getInlineCost, which makes a threshold‐based final evaluation of should/shouldn't inline, captured in InlineResult, getInliningCostEstimate returns: ‐ std::nullopt, if the inlining cannot happen (is illegal) ‐ an integer, representing the cost. |
|
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. |
|
Try to infer an alignment for the specified pointer. |
|
A helper function that returns the address space of the pointer operand of load or store instruction. |
|
A helper function that returns the alignment of load or store instruction. |
|
A helper function that returns the pointer operand of a load or store instruction. Returns nullptr if not load or store. |
|
A helper function that returns the type of a load or store instruction. |
|
Return the cache hint metadata node for memory operand |
|
Add metadata from |
|
Compute the size of the object pointed by Ptr. Returns true and the object size in Size if successful, and false otherwise. In this context, by object we mean the region of memory starting at Ptr to the end of the underlying object pointed to by Ptr. |
|
Try to ensure that the alignment of |
|
A helper function that returns the pointer operand of a load, store or GEP instruction. Returns nullptr if not load, store, or GEP. |
|
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. The value may be extracted from a splat constants vector or from a sequence of instructions that broadcast a single value into a vector. |
|
This method strips off any GEP address adjustments, pointer casts or |
|
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 the value profile data from |
|
Returns intrinsic ID for call. For the input call instruction it finds mapping intrinsic and returns its intrinsic ID, in case it does not found it return not_intrinsic. |
|
If a terminator in an unreachable basic block has an operand of type Instruction, transform it into poison. Return true if any operands are changed to poison. Original Values prior to being changed to poison are returned in |
|
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 |
|
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. For example, if ValAssumedPoison is |
|
Compute the access‐group list of access groups that |
|
Invert the given true/false value, possibly reusing an existing copy. |
|
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). |
|
Return true if it is an intrinsic that cannot be speculated but also cannot trap. |
|
Return true if we know V to the base address of the corresponding memory object. This implies that any address less than V must be out of bounds for the underlying object. Note that just being isIdentifiedObject() is not enough ‐ For example, a negative offset from a noalias argument or call can be inbounds w.r.t the actual underlying object. |
|
If the specified value can be set by repeating the same byte in memory, return the i8 value that it is represented with. This is true for all i8 values obviously, but is also true for i32 0, i32 ‐1, i16 0xF0F0, double 0.0 etc. If the value can't be handled with a repeated byte store (e.g. i16 0x1234), return null. If the value is entirely undef and padding, return undef. |
|
Match one of the patterns up to the select/logic op: %Op0 = icmp ne i4 %X, 0 %Agg = call { i4, i1 } llvm.[us]mul.with.overflow.i4(i4 %X, i4 %Y) %Op1 = extractvalue { i4, i1 } %Agg, 1 %ret = select i1 %Op0, i1 %Op1, i1 false / %ret = and i1 %Op0, %Op1 |
|
Returns true if the memory operations |
|
Return true if the specified edge is a critical edge. Critical edges are edges from a block with multiple successors to a block with multiple predecessors. |
|
Returns true if V is always a dereferenceable pointer with alignment greater or equal than requested. If the context instruction is specified performs context‐sensitive analysis and returns true if the pointer is dereferenceable at the specified instruction. If |
|
Returns true if V is always dereferenceable for Size byte with alignment greater or equal than requested. If the context instruction is specified performs context‐sensitive analysis and returns true if the pointer is dereferenceable at the specified instruction. If |
|
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. |
|
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. If V is an aggregate value or vector, check whether all elements (except padding) are not undef or poison. Note that this is different from canCreateUndefOrPoison because the function assumes Op's operands are not poison/undef. |
|
Return true if this function can prove that the instruction I is executed for every iteration of the loop L. |
|
Return true if this function can prove that the instruction I will always transfer execution to one of its successors (including the next instruction that follows within a basic block). E.g. this is not guaranteed for function calls that could loop infinitely. |
|
Returns true iff |
|
Returns true iff |
|
Return true if V is umabigously identified at the function‐level. Different IdentifiedFunctionLocals can't alias. Further, an IdentifiedFunctionLocal can not alias with any function arguments other than itself, which is not necessarily true for IdentifiedObjects. |
|
Return true if this pointer refers to a distinct and identifiable object. This returns true for: Global Variables and Functions (but not Global Aliases) Allocas ByVal and NoAlias Arguments NoAlias returns (e.g. calls to malloc) |
|
Return the boolean condition value in the context of the given instruction if it is known based on dominating conditions. |
|
Return true if RHS is known to be implied true by LHS. Return false if RHS is known to be implied false by LHS. Otherwise, return std::nullopt if no implication can be made. A & B must be i1 (boolean) values or a vector of such values. Note that the truth table for implication is the same as <=u on i1 values (but not <=s!). The truth table for both is: | T | F (B) T | T | F F | T | T (A) |
|
Test if the given instruction is in a position to be optimized with a tail‐call. This roughly means that it's in a block with a return and there's nothing that needs to be scheduled between it and the return. |
|
Return true if the result produced by the instruction is not used, and the instruction will return. Certain side‐effecting instructions are also considered dead if there are no uses of the instruction. |
|
{launder,strip}.invariant.group returns pointer that aliases its argument, and it only captures pointer by returning it. These intrinsics are not marked as nocapture, because returning is considered as capture. The arguments are not marked as returned neither, because it would make it useless. 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. Currently can recoginze Value pair: 1: <X, Y> if X = sub (0, Y) or Y = sub (0, X) 2: <X, Y> if X = sub (A, B) and Y = sub (B, A) |
|
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 false if a value could ever be infinity. |
|
Return true if the floating‐point scalar value is not a NaN or if the floating‐point vector value has no NaN elements. Return false if a value could ever be NaN. |
|
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. For vectors, return true if every element is known to be non‐zero when defined. For pointers, if the context instruction and dominator tree are specified, perform context‐sensitive analysis and return true if the pointer couldn't possibly be null at the specified instruction. Supports values with integer or pointer type and vectors of integers. |
|
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. For vectors return true if every element is known to be a power of two when defined. Supports values with integer or pointer type and vectors of integers. If 'OrZero' is set, then return true if the given value is either a power of two or zero. |
|
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. This condition is weaker than checking that the instruction is lanewise: lanewise means that the same operation is splatted across all lanes, but we also include the case where there is a different operation on each lane, as long as the operation only uses data from that lane. An example of an operation that is not lanewise, but doesn't cross vector lanes is insertelement. |
|
Return true if Object memory is not visible after an unwind, in the sense that program semantics cannot depend on Object containing any particular value on unwind. If the RequiresNoCaptureBeforeUnwind out parameter is set to true, then the memory is only not visible if the object has not been captured prior to the unwind. Otherwise it is not visible even if captured. |
|
Determine whether instruction 'To' is reachable from 'From', without passing through any blocks in ExclusionSet, returning true if uncertain. |
|
Return true if this is a call to an allocation function that does not have side effects that we are required to preserve beyond the effect of allocating a new object. Ex: If our allocation routine has a counter for the number of objects allocated, and the program prints it on exit, can the value change due to optimization? Answer is highly language dependent. Note: Removable really does mean removable; it does not mean observable. A language (e.g. C++) can allow removing allocations without allowing insertion or speculative execution of allocation routines. |
|
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. |
|
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 the vector value |
|
Return true if it is valid to use the assumptions provided by an assume intrinsic, I, at the point in the control‐flow identified by the context instruction, CxtI. By default, ephemeral values of the assumption are treated as an invalid context, to prevent the assumption from being used to optimize away its argument. If the caller can ensure that this won't happen, it can call with AllowEphemerals set to true to get more valid assumptions. |
|
Returns true iff |
|
Returns true iff |
|
Return true if the Object is writable, in the sense that any location based on this pointer that can be loaded can also be stored to without trapping. Additionally, at the point Object is declared, stores can be introduced without data races. At later points, this is only the case if the pointer can not escape to a different thread. |
|
Try to turn a call to @llvm.objectsize into an integer value of the given Type. Returns null on failure. If MustSucceed is true, this function will not return null, and may return conservative values governed by the second argument of the call to objectsize. |
|
Given a mask vector of i1, Return true if any of the elements of this predicate mask are known to be true or undef. That is, return true if at least one lane can be assumed active. |
|
Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind and providing the out parameter results if we successfully match. |
|
Attempt to match a simple value‐accumulating recurrence of the form: %llvm.intrinsic.acc = phi Ty [%Init, %Entry], [%llvm.intrinsic, %backedge] %llvm.intrinsic = call Ty llvm.intrinsic(%OtherOp, %llvm.intrinsic.acc) OR %llvm.intrinsic.acc = phi Ty [%Init, %Entry], [%llvm.intrinsic, %backedge] %llvm.intrinsic = call Ty llvm.intrinsic(%llvm.intrinsic.acc, %OtherOp) |
|
Attempt to match a simple value‐accumulating recurrence of the form: %llvm.intrinsic.acc = phi Ty [%Init, %Entry], [%llvm.intrinsic, %backedge] %llvm.intrinsic = call Ty llvm.intrinsic(%OtherOp0, %OtherOp1, %llvm.intrinsic.acc) OR %llvm.intrinsic.acc = phi Ty [%Init, %Entry], [%llvm.intrinsic, %backedge] %llvm.intrinsic = call Ty llvm.intrinsic(%llvm.intrinsic.acc, %OtherOp0, %OtherOp1) |
|
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 |
|
Given a CallInst, check if it calls a string function known to CodeGen, and mark it with NoBuiltin if so. To be used by sanitizers that intend to intercept string functions and want to avoid converting them to target specific instructions. |
|
Return true if undefined behavior would provable be executed on the path to OnPathTo if Root produced a posion result. Note that this doesn't say anything about whether OnPathTo is actually executed or whether Root is actually poison. This can be used to assess whether a new use of Root can be added at a location which is control equivalent with OnPathTo (such as immediately before it) without introducing UB which didn't previously exist. Note that a false result conveys no information. |
|
Return true if the given instruction must trigger undefined behavior when I is executed with any operands which appear in KnownPoison holding a poison value at the point of execution. |
|
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. |
|
Analogous to the above, but return the Uses so that they can be modified. Unlike previous version, Condition is optional and may be null. |
|
If U is widenable branch looking like: %cond = ... %wc = call i1 llvm.experimental.widenable.condition() %branch_cond = and i1 %cond, %wc br i1 %branch_cond, label %if_true_bb, label %if_false_bb ; <‐‐‐ U The function returns true, and the values %cond and %wc and blocks %if_true_bb, if_false_bb are returned in the parameters (Condition, WidenableCondition, IfTrueBB and IfFalseFF) respectively. If |
|
Patch the replacement so that it is not more restrictive than the value being replaced. It assumes that the replacement does not get moved from its original position. |
|
Given a mask vector of the form <Y x i1>, return an APInt (of bitwidth Y) for each lane which may be active. |
|
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 |
|
This is similar to |
|
Get the intersection (logical and) of all of the potential IR flags of each scalar operation (VL) that will be converted into a vector (I). If OpValue is non‐null, we only consider operations similar to OpValue when intersecting. Flag set: NSW, NUW (if IncludeWrapFlags is true), exact, and all of fast‐math. |
|
Specifically, let Kinds = [MD_tbaa, MD_alias_scope, MD_noalias, MD_fpmath,] MD_nontemporal, MD_access_group, MD_mmra]. For K in Kinds, we get the MDNode for K from each of the elements of VL, compute their "intersection" (i.e., the most generic metadata value that covers all of the individual values), and set I's metadata for M equal to the intersection value. |
|
Try to match a bswap or bitreverse idiom. |
|
Point debug users of |
|
Replace all uses of 'I' with 'SimpleV' and simplify the uses recursively. |
|
Replaces dbg.declare record when the address it describes is replaced with a new value. If Deref is true, an additional DW_OP_deref is prepended to the expression. If Offset is non‐zero, a constant displacement is added to the expression (between the optional Deref operations). Offset can be negative. |
|
Replace each use of 'From' with 'To' if that use is dominated by the given edge. Returns the number of replacements made. |
|
Replace each use of 'From' with 'To' if that use is dominated by the given instruction. Returns the number of replacements made. |
|
Replace each use of 'From' with 'To' if that use is dominated by the end of the given BasicBlock. Returns the number of replacements made. |
|
Replace each use of 'From' with 'To' if that use is dominated by the given instruction and the callback ShouldReplace returns true. Returns the number of replacements made. |
|
Replace each use of 'From' with 'To' if that use is dominated by the end of the given BasicBlock and the callback ShouldReplace returns true. Returns the number of replacements made. |
|
Replace each use of 'From' with 'To' if that use is dominated by the given edge and the callback ShouldReplace returns true. Returns the number of replacements made. |
|
Salvage debug records that use |
|
Salvage only the records in |
|
Given an instruction |
|
Calls BuildAssumeFromInst and if the resulting llvm.assume is valid insert if before I. This is usually what need to be done to salvage the knowledge contained in the instruction I. The AssumptionCache must be provided if it is available or the cache may become silently be invalid. The DominatorTree can optionally be provided to enable cross‐block reasoning. This returns if a change was made. |
|
Scaling the profile data attached to 'I' using the ratio of S/T. |
|
A helper function that sets an atomic operation's sync scope. |
|
Create a new |
|
Specify that the branch weights for this terminator cannot be known at compile time. This should only be called by passes, and never as a default behavior in e.g. MDBuilder. The goal is to use this info to validate passes do not accidentally drop profile info, and this API is called in cases where the pass explicitly cannot provide that info. Defaulting it in would hide bugs where the pass forgets to transfer over or otherwise specify profile info. Use |
|
Like setExplicitlyUnknownBranchWeights(...), but only sets unknown branch weights in the new instruction if the parent function of the original instruction has an entry count. This is to not confuse users by injecting profile data into non‐profiled functions. If |
|
Variant of |
|
Set the inline‐remark attribute. |
|
A helper function that set the alignment of load or store instruction. |
|
Sets the unwind edge of an instruction to a particular successor. |
|
Return the cost only if the inliner should attempt to inline at the given CallSite. If we return the cost, we will emit an optimisation remark later using that cost, so we won't do so from this function. Return std::nullopt if inlining should not be attempted. |
|
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. Returns a simplified result or 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. In contrast to simplifyFMulInst, this function will not perform simplifications whose unrounded results differ when rounded to the argument type. |
|
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. If not, this returns null. |
|
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. If not, return null. |
|
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. See class ShuffleVectorInst for a description of the mask representation. |
|
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. If not, return null. AllowRefinement specifies whether the simplification can be a refinement (e.g. 0 instead of poison), or whether it needs to be strictly identical. Op and RepOp can be assumed to not be poison when determining refinement. |
|
Given operands for an Xor, fold the result or return null. |
|
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. |
|
If the specified pointer points to an object that we control, try to modify the object's alignment to PrefAlign. Returns a minimum known alignment of the value after the operation, which may be lower than PrefAlign. |
|
Try to promote (devirtualize) a virtual call on an Alloca. Return true on success. |
|
Update the debug locations contained within the MD_loop metadata attached to the instruction |
|
Predicate and clone the given call site. |
|
Returns true, if no instruction between |
|
Return true if the result produced by the instruction would have no side effects if it was not used. This is equivalent to checking whether isInstructionTriviallyDead would be true if the use count was 0. |
|
Try to convert |
|
Return true if |
|
Match any intrinsic call, capturing it if we match. |
|
Like m_Specific(), but works if the specific value to match is determined as part of the same match() expression. For example: m_Add(m_Value(X), m_Specific(X)) is incorrect, because m_Specific() will bind X before the pattern match starts. m_Add(m_Value(X), m_Deferred(X)) is correct, and will check against whichever value m_Value(X) populated. |
|
Match an instruction, capturing it 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 against the nested pattern, and capture the value if we match. |
|
Match a value, capturing it if we match. |
|
Populates a set of strings representing the Vector Function ABI variants associated to the CallInst CI. If the CI does not contain the vector‐function‐abi‐variant attribute, we return without populating VariantMappings, i.e. callers of getVectorVariantNames need not check for the presence of the attribute (see InjectTLIMappings). |
|
Overwrite the Vector Function ABI variants attribute with the names provide in |
|
Return true if CoerceAvailableValueToLoadType would succeed if it was called. |
|
If we saw a store of a value to memory, and then a load from a must‐aliased pointer of a different type, try to coerce the stored value to the loaded type. LoadedTy is the type of the load we want to replace. IRB is IRBuilder used to insert new instructions. |
|
If analyzeLoadFromClobberingStore/Load returned an offset, this function can be used to actually perform the extraction of the bits from the store. It inserts instructions to do so at InsertPt, and returns the extracted value. |
|
Delete the llvm.dbg.assign intrinsics linked to |
|
Return a range of dbg_assign records for which |
|
Evaluate the filter expression against the current instrumentation opportunity. Returns true if the filter passes (or is empty), false otherwise. Dynamic values (non‐constants) are assumed to pass. |
|
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". |
|
checkBackendInstrumentation ‐ compares PGO counters to the thresholds used for llvm.expect and warns if the PGO counters are outside of the expected range. It extracts the expected weights from the MD_prof weights attached to the instruction, which are assumed to come from lowered llvm.expect intrinsics. The RealWeights parameter and the extracted expected weights are then passed to verifyMisexpect() for verification |
|
checkExpectAnnotations ‐ compares PGO counters to the thresholds used for llvm.expect and warns if the PGO counters are outside of the expected range. It extracts the expected weights from the MD_prof weights attached to the instruction, which are assumed to come from lowered llvm.expect intrinsics. The RealWeights parameter and the extracted expected weights are then passed to verifyMisexpect() for verification. It is a thin wrapper around the checkFrontendInstrumentation and checkBackendInstrumentation APIs |
|
checkFrontendInstrumentation ‐ compares PGO counters to the thresholds used for llvm.expect and warns if the PGO counters are outside of the expected range. It extracts the expected weights from the MD_prof weights attached to the instruction, which are assumed to come from profiling data attached by the frontend prior to llvm.expect intrinsic lowering. The ExpectedWeights parameter and the extracted real weights are then passed to verifyMisexpect() for verification |
|
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. |
|
The RCIdentity root of a value |
|
Helper which calls const Value *GetRCIdentityRoot(const Value *V) and just casts away the const of the result. For documentation about what an RCIdentityRoot (and by extension GetRCIdentityRoot is) look at that function. |
|
This is a wrapper around getUnderlyingObject which also knows how to look through objc_retain and objc_autorelease calls, which we know to return their argument verbatim. |
|
A wrapper for GetUnderlyingObjCPtr used for results memoization. |
|
Return true if this value refers to a distinct and identifiable object. |
|
Test whether the given value is possible a retainable object pointer. |
|
This function determines whether the clang_arc_attachedcall should be emitted with or without the marker. Concretely, this is the difference between: objc_retainAutoreleasedReturnValue and objc_claimAutoreleasedReturnValue retainRV (and unsafeClaimRV) requires a marker, but claimRV does not. |
|
This function returns operand bundle clang_arc_attachedcall's argument, which is the address of the ARC runtime function. |
|
This function returns the ARCInstKind of the function attached to operand bundle clang_arc_attachedcall. It returns std::nullopt if the call doesn't have the operand bundle or the operand is null. Otherwise it returns either RetainRV or UnsafeClaimRV. |
Created with MrDocs