A single function or procedure in LLVM IR.
Synopsis
Declared in <llvm/IR/Function.h>
class Function
: public GlobalObject
, public ilist_node<Function>Description
A function consists of a list of basic blocks, a list of arguments, and a symbol table.
Base Classes
Name |
Description |
Base class for independently defined globals such as functions and variables. |
|
An intrusive list node. |
Types
Name |
Description |
Per‐global sanitizer instrumentation flags for ASan, HWASan, and Memtag. |
|
Const iterator for directly iterating over the operand Values. |
|
Iterator for directly iterating over the operand Values. |
Type Aliases
Name |
Description |
The list type used to store this function's basic blocks. |
|
A 64‐bit global unique identifier used by PGO and ThinLTO. |
|
Iterator over this function's formal arguments. |
|
Const iterator over this function's formal arguments. |
|
Const iterator over this function's basic blocks. |
|
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 function's basic blocks. |
|
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 |
Storage classes of global values for PE targets. |
|
An enumeration for the kinds of linkage for global values. |
|
Thread‐local storage models for global variables. |
|
How significant this global's address is when merging or linking. |
|
Values for visibility metadata attached to vtables. |
|
Concrete subclass of this. |
|
An enumeration for the kinds of visibility of global values. |
Member Functions
Name |
Description |
|
Copy construction is deleted; Function owns its basic blocks and state. |
|
Destroy this function and its basic blocks. |
Assignment operators |
|
|
|
adds the attribute to the list of attributes. |
|
adds the dereferenceable_or_null attribute to the list of attributes for the given arg. |
|
adds the dereferenceable attribute to the list of attributes for the given arg. |
|
Add function attributes to this function. |
|
Add function attributes to this function. |
|
adds the attribute to the list of attributes for the given arg. |
|
adds the attributes to the list of attributes for the given arg. |
|
adds the range attribute to the list of attributes for the return value. |
|
Add return value attributes to this function. |
|
Add return value attributes to this function. |
|
Attach type metadata at the given offset for this global object. |
|
This method should only be used by the Use class. |
|
|
|
Return true if this function has no formal arguments. |
|
|
|
Return the number of formal arguments. |
|
|
|
Assert in debug builds that modules containing this value are materialized. |
|
Assert that every module containing this value is fully materialized. |
|
Return the last basic block in this function. |
|
|
|
callsFunctionThatReturnsTwice ‐ Return true if the function has a call to setjmp or other function that gcc recognizes as "returning twice". |
|
Return true if this pointer's memory may be freed in its defining scope. |
|
Return true if this global can be left out of the object symbol table. |
|
Return true if this global may use a local alias during code generation. |
|
Determine whether interprocedural transforms may rewrite this function's signature. |
|
Returns true if the alignment of the value can be unilaterally increased. |
|
Determine if the call cannot be duplicated. |
|
Remove the garbage‐collection algorithm name from this function. |
|
Return true if this is a fixed width vector constant that includes any constant expressions. |
|
Return true if this is a vector constant where at least one element satisfies the given predicate. Scalable vectors are not checked. |
|
Return true if this is a vector constant that includes any poison elements. |
|
Return true if this is a vector constant that includes any strictly undef (not poison) elements. |
|
Return true if this vector constant includes undef or poison elements. |
|
Convert all basic blocks in this function back from the new debug‐info format. |
|
Convert all basic blocks in this function to the new debug‐info format. |
|
copyAttributesFrom ‐ copy all additional attributes (those not needed to create a Function) from the Function Src to this one. |
|
Copy metadata from |
|
deleteBody ‐ This method deletes the body of the function, and converts the linkage to external. |
|
Delete a pointer to a generic Value. |
|
Destroy this constant and any constant users that depend on it. |
|
Determine if the function should not perform indirect branch tracking. |
|
Determine if the function does not access memory. |
|
Determine if the call might deallocate memory. |
|
Determine if the function is known not to recurse, directly or indirectly. |
|
Determine if the function cannot return. |
|
Determine if the function cannot unwind. |
|
Drop all references held by instructions in this function's body. |
|
Remove every uses that can safely be removed. |
|
Remove every use of this value in |
|
Support for debugging, callable in GDB: V‐>dump() |
|
Return true if this function has no basic blocks. |
|
|
|
Erases a range of BasicBlocks from |
|
eraseFromParent ‐ This method unlinks 'this' from the containing module and deletes it. |
|
Return the first basic block in this function. |
|
If this is an absolute symbol reference, returns the range of the symbol, otherwise returns std::nullopt. |
|
Return the address space of this global value's pointer type. |
|
|
|
Return the underlying GlobalObject this value ultimately refers to, if any (following aliases). |
|
Returns the alignment of the given function. |
|
Return the formal argument at zero‐based index |
|
gets the attribute from the list of attributes. |
|
Return the attribute list for this Function. |
|
Return the epoch of the current basic‐block numbering. |
|
Return the calling convention of this function. |
|
Return the Comdat object for this global object, or null if none. |
|
getContext ‐ Return a reference to the LLVMContext associated with this function. |
|
Return the DLL storage class of this global value. |
|
Get the data layout of the module this function belongs to. |
|
Extract the number of dead_on_return bytes for a parameter. |
|
Return the representational value of the denormal_fpenv attribute. |
|
Returns the denormal handling type for the default rounding mode of the function. |
|
Returns the descriptor co‐allocated with this User instance. |
|
Return the entry basic block of this function. |
|
Get the entry count for this function. |
|
Return the attribute for the given attribute kind. |
|
For a string attribute |
|
Return the stack alignment for the function. |
|
Return this function (identity helper for generic FunctionT code). |
|
Returns the FunctionType for me. |
|
Return the name of the garbage collection algorithm for this function. |
|
Return a 64‐bit global unique ID for this value. |
|
Return this value's GUID if one has been assigned, or nullopt otherwise. |
|
Return the GUID for this value if it has been assigned, otherwise fall back to computing it based on its current name and linkage. |
|
Returns the set of GUIDs that needs to be imported to the function for sample PGO, to enable the same inlines as the profiled optimized binary. |
|
Returns the number of non‐debug IR instructions in this function. This is equivalent to the sum of the sizes of each basic block contained within this function. |
|
Return the intrinsic ID for this function, or not_intrinsic. |
|
Return the linkage type of this global value. |
|
Return a value larger than the largest block number. Intended to allocate a vector that is sufficiently large to hold all blocks indexed by their number. |
|
Return the memory effects attributed to this function. |
|
|
|
Return a constant reference to the value's name. |
|
Return this value's name, or a printed operand string if it is unnamed. |
|
Return the number of hung‐off operands. |
|
This method computes the number of uses of this Value. |
|
|
|
|
|
|
|
Return the alignment attribute for parameter |
|
gets the specified attribute from the list of attributes. |
|
Extract the byref type for a parameter. |
|
Extract the byval type for a parameter. |
|
Extract the number of dereferenceable bytes for a parameter. |
|
Extract the number of dereferenceable_or_null bytes for a parameter. |
|
Extract the inalloca type for a parameter. |
|
Extract the nofpclass attribute for a parameter. |
|
Extract the preallocated type for a parameter. |
|
Return the stack alignment attribute for parameter |
|
Extract the sret type for a parameter. |
|
Return the module that contains this global value. |
|
Return the linker partition name for this global, or empty if none is set. |
|
Get the personality function associated with this function. |
|
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 |
|
Returns the prefalign of the given function. |
|
Get the prefix data associated with this function. |
|
Get the prologue data associated with this function. |
|
Return the raw optional flags value contained in this value. |
|
Return the attribute for the given attribute kind for the return value. |
|
Returns the type of the ret val. |
|
Return the sanitizer instrumentation flags for this global. |
|
Get the custom section of this global if it has one. |
|
Get the section prefix for this global object. |
|
|
|
If all elements of the vector constant have the same value, return that value. Otherwise, return nullptr. Ignore poison elements by setting AllowPoison to true. |
|
Get the attached subprogram. |
|
Return the thread‐local storage model of this global. |
|
Global values are always pointers. |
|
Get what kind of unwind table entry to generate for this function. |
|
If C is a constant integer then return its value, otherwise C must be a vector of constant integers, all equal, and the common value is returned. |
|
|
|
Return how significant this global's address is for merging/linking. |
|
Return the vcall visibility recorded on this global object. |
|
Return the value for vscale based on the vscale_range attribute or 0 when unknown. |
|
Return an ID for the concrete type of this object. |
|
Return the symbol‐table name entry for this value, if any. |
|
Return the value symbol table for this function, or null if none. |
|
Return the type of the value (the pointee type for pointer globals). |
|
Return the visibility of this global value. |
|
Replace all uses of |
|
Return true if this function has non‐call uses that take its address. |
|
Return true if this global has appending linkage. |
|
Returns true if this value's address is not significant in this module. |
|
Check if attribute of the given kind is set at the given index. |
|
Return true if this global has available_externally linkage. |
|
Return true if this global object belongs to a COMDAT group. |
|
Return true if this global has common linkage. |
|
Return true if this global is exported from a DLL. |
|
Return true if this global is imported from a DLL. |
|
Return true if this global has default visibility. |
|
Return true if this global has an exact defintion. |
|
Return true if this scalar has an exact multiplicative inverse or this vector has an exact multiplicative inverse for each element in the vector. |
|
Return true if this global has external linkage. |
|
Return true if this global has external weak linkage. |
|
Return true if the function has the attribute. |
|
hasGC/getGC/setGC/clearGC ‐ The name of the garbage collection algorithm to use during code generation. |
|
Return true if this global has the global unnamed_addr attribute. |
|
Return true if this global has hidden visibility. |
|
Return true if this global has internal linkage. |
|
Does it have a kernel calling convention? |
|
Return true if the formal argument list has not been built yet. |
|
Return true if this global has linkonce‐any linkage. |
|
Return true if this global has linkonce or linkonce_odr linkage. |
|
Return true if this global has linkonce_odr linkage. |
|
Return true if this global has internal or private linkage. |
|
|
|
Return true if this global has metadata other than debug location and GUID. |
|
Optimize this function for minimum size (‐Oz). |
|
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 if the call can synchroize with other threads |
|
Return true if the constant has exactly one live use. |
|
Return true if there is exactly one use of this value. |
|
Return true if there is exactly one user of this value. |
|
Do not optimize this function (‐O0). |
|
Optimize this function for size (‐Os) or minimum size (‐Oz). |
|
|
|
Return true if this global has a linker partition name. |
|
Check whether this function has a personality function. |
|
Check whether this function has prefix data. |
|
Return true if this global has private linkage. |
|
Return true if the function is annotated with profile data. |
|
Check whether this function has prologue data. |
|
Return true if this global has protected visibility. |
|
check if an attribute is in the list of attributes for the return value. |
|
Return true if this global has sanitizer metadata attached. |
|
Check if this global has a custom object file section. |
|
Returns true if the function has ssp, sspstrong, or sspreq fn attrs. |
|
Determine if the function returns a structure through first or second pointer argument. |
|
True if the ABI mandates (or the user requested) that this function be in a unwind table. |
|
Check if this Value has a use‐list. |
|
Return true if this global has a linkage valid for a declaration. |
|
Return true if there is a value handle associated with this value. |
|
Return true if this global has weak_any linkage. |
|
Return true if this global has weak or weak ODR linkage. |
|
Return true if this global has weak_odr linkage. |
|
Return true if the constant has no live uses. |
|
Insert |
|
Returns whether this is a reference to an absolute symbol. |
|
Return true if this is the value that would be returned by getAllOnesValue. |
|
Return true if the constant has users other than constant expressions and other dangling things. |
|
Return true if this is a constrained floating‐point intrinsic. |
|
Determine if the call is convergent. |
|
Return true if coroutine destroy runs only when the coro is complete. |
|
Return true if the value is dependent on a dllimport variable. |
|
Return true if this symbol is known to be local to the DSO. |
|
Return true if the primary definition of this global value is outside of the current translation unit. |
|
Return true if the linker should treat this global as a declaration. |
|
Return true if this function definition is trivially safe to remove. |
|
Return true if the currently visible definition of this global (if any) is exactly the definition we will see at runtime. |
|
Return true if this global's definition may be discarded if unused. |
|
Return whether this user's uses may be dropped without affecting correctness. |
|
Return true if this constant and |
|
Return true if this is a finite and non‐zero floating‐point scalar constant or a fixed width vector constant with all finite and non‐zero elements. |
|
Return true if linkage or visibility implies this symbol is dso_local. |
|
Return true if this global's definition can be substituted arbitrarily. |
|
Return true if this function's name starts with "llvm.". |
|
Return true if a constant is ConstantData or a ConstantAggregate or ConstantExpr that contain only ConstantData. |
|
Return true if this function's body may be lazily materialized. |
|
Return true if the value is the largest signed value. |
|
Return true if the value is the smallest signed value. |
|
Return true if this is a floating‐point NaN constant or a vector floating‐point constant with all NaN elements. |
|
Return true if the value is what would be returned by getZeroValueForNegation. |
|
Return true if this is a normal floating‐point constant. |
|
Return true if the value is not the smallest signed value, or, for vectors, does not contain smallest signed value elements. |
|
Return true if the value is not the one value, or, for vectors, does not contain one value elements. |
|
Return true if this is the value that would be returned by getNullValue. |
|
Returns true if the value is one. |
|
Determine if the function is presplit coroutine. |
|
Determine if the call has sideeffects. |
|
Determine if the function has strict floating point sematics. |
|
Returns true if this global's definition will be the one chosen by the linker. |
|
Return true if this value is a swifterror value. |
|
Return true if memtag sanitization is requested for this global. |
|
Return true if this function is a target‐specific intrinsic. |
|
Return true if the value can vary between threads. |
|
If the value is "Thread Local", its value isn't shared by the threads. |
|
Return true if there is metadata referencing this value. |
|
Check if this value is used in the specified basic block. |
|
isVarArg ‐ Return true if this function takes a variable number of arguments. |
|
Return true if this global's definition may be replaced at link time. |
|
Make sure this GlobalValue is fully read. |
|
|
|
Return true if there are no currently materialized uses. |
|
|
|
|
|
|
|
Determine if the function is required to make forward progress. |
|
Mutate the type of this Value to be of the specified type. |
|
Return true if this constant may generate a dynamic relocation entry. |
|
Return true if this constant may generate a relocation entry. |
|
True if this function needs an unwind table. |
|
Return whether null pointer dereference is defined for this function. |
|
Determine if the call can access memory 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 function does not access or only reads memory. |
|
Determine if the function does not access or only writes memory. |
|
|
|
|
|
|
|
|
|
Delete operators |
|
|
|
|
|
Recompute and assign a GUID to this value, replacing the existing GUID. |
|
removes the attribute from the list of attributes. |
|
Remove any dead constant users dangling off of this constant. |
|
|
|
Remove function attributes matching |
|
removeFromParent ‐ This method unlinks 'this' from the containing module, but does not delete it. |
|
removes the attribute from the list of attributes. |
|
removes the attribute from the list of attributes. |
|
removes the attribute from the return value list of attributes. |
|
removes the attributes from the return value list of attributes. |
|
Remove sanitizer metadata from this global value. |
|
Renumber basic blocks into a dense range starting from zero. |
|
Change all uses of this to point to a new Value. |
|
Change non‐metadata uses of this to point to a new Value. |
|
Replace uses of one Value with another. |
|
Replace uses of this value that occur outside |
|
Replace selected uses of this value with |
|
Determine if the parameter or return value is marked with NoAlias attribute. |
|
Reverse the use‐list. |
|
|
|
Set the attribute list for this Function. |
|
Set the calling convention of this function. |
|
Mark that the function cannot be duplicated. |
|
Set the COMDAT group for this global object, or clear it if |
|
Mark that the function is convergent. |
|
Mark that the coroutine destroy runs only when the coro is complete. |
|
Set the DLL storage class of this global value. |
|
Set whether this symbol is known to be local to the linkage unit. |
|
Mark that the function does not access memory. |
|
Mark the function as not deallocating memory (adds |
|
Mark that the function does not recurse. |
|
Mark that the function does not return. |
|
Mark that the function does not throw. |
|
Set the entry count for this function. |
|
Set the garbage collection algorithm name used during code generation. |
|
Mark whether this function's body may be lazily materialized from bitcode. |
|
Set the linkage type of this global value. |
|
Set the memory effects attributed to this function. |
|
Mark that the function must make forward progress. |
|
Change the name of the value. |
|
Disable address and HWAddress sanitizer instrumentation for this global. |
|
Mark that the function does not synchronize with other threads. |
|
Clear the convergent attribute so the function is not treated as convergent. |
|
Set the operand count for a User with hung‐off uses. |
|
Mark that the function may only access memory through its arguments. |
|
Mark that memory access is limited to inaccessible or argument memory. |
|
Mark that the function may only access memory inaccessible from the IR. |
|
Mark that the function does not access or only reads memory. |
|
Mark that the function does not access or only writes memory. |
|
|
|
Set the linker partition name for this global. |
|
Set the personality function used for exception handling in this function. |
|
Sets the prefalign attribute of the Function. |
|
Set the constant prefix data emitted before this function's entry block. |
|
Mark this function as a presplit coroutine. |
|
Set the constant prologue data emitted at the start of this function. |
|
Mark that the return value does not alias any other pointer. |
|
Set sanitizer instrumentation flags for this global value. |
|
Change the section for this global. |
|
Update the section prefix metadata if it differs from |
|
Mark the function as safe to speculate (no side effects or undefined behavior). |
|
Clear the presplit‐coroutine attribute after splitting. |
|
Set the attached subprogram. |
|
Set whether this global is thread‐local using the general‐dynamic model. |
|
Set the thread‐local storage model of this global. |
|
Set the unwind‐table kind for this function. |
|
Set how significant this global's address is for merging and linking. |
|
Set the vcall visibility metadata for this global object. |
|
Set the symbol‐table name entry for this value. |
|
Set the visibility of this global value. |
|
Mark that the function will return. |
|
Returns true if we should emit debug info for profiling. |
|
Return the number of basic blocks in this function. |
|
Sort the use‐list. |
|
|
|
Steal arguments from another function. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Transfer the name from V to this value. |
|
Convert constant to an approximate constant range. For vectors, the range is the union over the element ranges. Poison elements are ignored. |
|
Update internal caches that depend on the function name. |
|
|
|
Return true if this value has no uses. |
|
|
|
Return the sole user when this value has exactly one user. |
|
Return an iterator to the first user of this value. |
|
Return true if this value has no users. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Determine if the function will return. |
Static Member Functions
Name |
Description |
|
|
Methods for support type inquiry through isa, cast, and dyn_cast. |
|
Creates a function with some attributes recorded in llvm.module.flags and the LLVMContext applied. |
|
Remove the droppable use |
|
If the given string begins with the GlobalValue name mangling escape character '1', drop it. |
|
Return the all‐ones constant of type |
|
Return a 64‐bit GUID for a global symbol name, assuming external linkage. |
|
Return a lookup key for a global value used by PGO and ThinLTO. |
|
Return the value for an integer or pointer constant, or a vector thereof, with the given scalar value. |
|
Return linkonce or linkonce_odr linkage depending on |
|
Return the more significant unnamed_addr of |
|
Return the null constant of type |
|
Return weak or weak_odr linkage depending on |
|
Return true if |
|
Return true if |
|
Return true if |
|
Whether the definition of this global may be discarded if it is not used in its compilation unit. |
|
Return true if |
|
Return true if |
|
Return true if |
|
Return true if a definition with |
|
Return true if |
|
Return true if |
|
Return true if |
|
Return true if |
|
Return true if |
|
Return true if |
|
Return true if |
|
Return true if a definition with |
|
Return true if |
|
Return true if |
|
Merge undef elements from |
|
Try to replace undefined constant |
Static Data Members
Name |
Description |
The maximum alignment for instructions. |
|
Maximum absolute alignment in bytes ( |
Using Declarations
Name |
Description |
Add a metadata attachment to this global object. |
|
Erase all metadata attached to this global object. |
|
Erase all metadata attachments with the given kind. |
|
Erase all metadata attachments matching the given predicate. |
|
Appends all metadata attached to this global object to |
|
Set a particular kind of metadata attachment on this global object. |
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 Enums
Name |
Description |
Bit indices for data packed into |
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. |
|
|
|
Erase all metadata attachments with the given kind. |
|
Erase all metadata attachments matching the given predicate. |
|
Returns the alignment of the given variable or function. |
|
Append all metadata attached to this value into |
|
Return subclass‐specific data packed above |
|
Return subclass‐specific data packed into this global value. |
|
Get the current metadata attachments for the given kind, if any. |
|
Get metadata for the given kind, if any. |
|
Return the opaque subclass data bits stored in this value. |
|
Grow the number of hung off uses. Note that allocHungoffUses should be called if there are no uses. |
|
New operators |
|
|
|
Set subclass‐specific data packed above |
|
Set subclass‐specific data packed into this global value. |
|
|
|
Set the module that contains this global value. |
|
Set the opaque subclass data bits stored in this value. |
Protected Static Member Functions
Name |
Description |
Return the operand Use at compile‐time index |
Protected Data Members
Name |
Description |
DLL storage class of this global (see |
|
True if this value has a descriptor. |
|
Whether operands are stored in a separately allocated array. |
|
True if this value's name starts with "llvm.". |
|
True if this value has a name in the symbol table. |
|
True if this symbol has a partition name assigned (see https://lld.llvm.org/Partitions.html). |
|
True if this symbol has sanitizer metadata available. Should only happen if sanitizers were enabled when building the translation unit which contains this GV. |
|
The intrinsic ID for this subclass (which must be a Function). |
|
If true then there is a definition within the same linkage unit and that definition cannot be runtime preempted. |
|
True if metadata references this value. |
|
Linkage type of this global (see |
|
Index of first metadata attachment in context, or zero. |
|
Number of operands in this user. |
|
The COMDAT group for this global, or null if none. |
|
The module containing this global value. |
|
Hold arbitary subclass data. |
|
Is this symbol "Thread Local", if so, what is the desired model? |
|
This value's unnamed address mode (see |
|
The type of the value this global points to (the pointee type). |
|
The visibility of this global (see |
Protected Static Data Members
Name |
Description |
Bits reserved in SubclassOptionalData, not to be used for ConstantExpr flags. |
|
Number of subclass data bits remaining after GlobalObject's reserved bits. |
|
Number of bits reserved for subclass‐specific data in GlobalValue. |
Friends
Name |
Description |
An ilist node that can access its parent list. |
|
Traits that keep parent links and symbol tables in sync with list changes. |
|
Grant |
|
Unlink 'this' from the containing function and delete it. |
|
Unlink 'this' from the containing function, but do not delete it. |
|
Implementation of the target library information. |
|
Non-Member Functions
Name |
Description |
Clone OldFunc into NewFunc with on‐the‐fly constant prop and DCE. |
|
Clone and prune OldFunc into NewFunc starting at a given instruction. |
|
Return a copy of the specified function and add it to its module. |
|
Clone OldFunc's attributes into NewFunc, transforming values based on the mappings in VMap. |
|
Clone OldFunc's body into NewFunc. |
|
Clone OldFunc into NewFunc using the provided value map. |
|
Clone OldFunc's metadata into NewFunc. |
|
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. |
|
Fold a constant using the specified DataLayout. |
|
Attempt to constant fold an extractelement instruction with the specified operands and indices. |
|
Attempt to constant fold an extractvalue instruction with the specified operands and indices. |
|
Attempt to constant fold an insertelement instruction with the specified operands and indices. |
|
Attempt to constant fold an insertvalue instruction with the specified operands and indices. |
|
Constant fold a zext, sext or trunc, depending on IsSigned and whether the DestTy is wider or narrower than C. Returns nullptr on failure. |
|
Extract value of C at the given Offset reinterpreted as Ty. If bits past the end of C are accessed, they are assumed to be poison. |
|
Extract value of C reinterpreted as Ty. Same as previous API with zero offset. |
|
Return the value that a load from C with offset Offset would produce if it is constant and determinable. If this is not determinable, return null. |
|
Return the value that a load from C would produce if it is constant and determinable. If this is not determinable, return null. |
|
Return a uniform bit‐pattern constant reinterpreted as |
|
Try to cast a constant to a destination type through a bitcast‐like load. |
|
Attempt to constant fold a select instruction with the specified operands. The constant result is returned if successful; if not, null is returned. |
|
Attempt to constant fold a shufflevector instruction with the specified operands and mask. |
|
Delete all basic blocks in |
|
ExtractTypeInfo ‐ Returns the type info, possibly bitcast, encoded in V. |
|
Find the earliest instruction that captures |
|
Find all loop backedges in the specified function. |
|
Given an aggregate and a sequence of indices, see if the scalar value indexed is already around as a register. |
|
Flush a floating‐point constant according to the parent function's denormal mode. |
|
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. |
|
Return true if |
|
Lower dbg.declare records into dbg.value records. |
|
Look up or compute a value in the value map. |
|
Version of MapValue with type safety for Constant. |
|
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. |
|
Return whether null pointer dereference is defined for |
|
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. |
|
Remap the operands, metadata, arguments, and instructions of a function. |
|
Split every critical edge in a function. |
|
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 critical edges leaving an indirectbr when a simple case applies. |
|
Returns a hash of the function |
|
Computes a structural hash of a function while selectively ignoring operands. |
|
Upgrade an old intrinsic function and all of its call sites. |
|
Correct any IR that is relying on old function attribute behavior. |
|
Check whether an intrinsic function needs upgrading. |
|
Write a function analysis graph to a DOT file with a custom name prefix. |
|
Appends the set of assumptions |
|
Apply a metadata callback if |
|
Return true if the given assume operand bundle implies that |
|
Check whether caller/callee attribute mismatches inhibit a tail call. |
|
Build WinEHFuncInfo CoreCLR state numbers and unwind‐map tables. |
|
Build WinEHFuncInfo SEH state numbers and unwind‐map tables. |
|
Build WinEHFuncInfo state numbers and tables for __CxxFrameHandler3. |
|
Return true if Comdat function |
|
Returns true if pointer |
|
Return true if there is at least a path through which F can return, false if there is no such path. |
|
Return true if invokes of nounwind callees in |
|
Return true if |
|
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. |
|
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 |
|
Recompute which basic blocks belong to which EH funclets in |
|
Determine the possible constant range of an integer or vector of integer value. This is intended as a cheap, non‐recursive check. |
|
Returns the memory access properties of this copy of the function. |
|
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 |
|
Converts value |
|
Create PGOFuncName metadata when it differs from |
|
Create the global variable that stores |
|
Create PGOName metadata when it differs from |
|
Creates sanitizer constructor function. |
|
Creates sanitizer constructor function, and calls sanitizer's init function from it. |
|
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 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. |
|
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. |
|
Return all indirect call sites in function |
|
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. |
|
Return vtable address instructions feeding indirect calls in |
|
Call |
|
Return a begin iterator over the types indexed by GEP |
|
Return a begin iterator over the types indexed by GEP |
|
Return the end iterator for types indexed by GEP |
|
Return the end iterator for types indexed by GEP |
|
If a function is part of an allocation family (e.g. malloc/realloc/calloc/free), return the identifier for its family of functions. |
|
Return the set of all assumptions for the function |
|
Like getObjectSize(), but only for base objects. |
|
Returns true if the value |
|
Compute the contents of a null‐terminated C string pointed to by |
|
Returns a metadata node containing unknown branch weights if the function has an entry count, otherwise returns nullptr. |
|
Return the function and pointer at a vtable offset, if they refer to a function. |
|
Return the IRPGO profile lookup name for function |
|
If this is a call to an allocation function that initializes memory to a fixed value, return said value in the requested type. Otherwise, return nullptr. |
|
Return a valid Knowledge associated to the Value V if its Attribute kind is in AttrKinds and it matches the Filter. |
|
Return a valid Knowledge associated to the Value V if its Attribute kind is in AttrKinds and the knowledge is suitable to be used in the context of CtxI. |
|
Infer a known alignment for the specified pointer. |
|
Return the address space of the pointer operand of load or store |
|
Return the alignment of load or store instruction |
|
Return the pointer operand of a load or store, or null if |
|
Return the pointer operand of a load or store, or null if |
|
Return the value type accessed by load or store instruction |
|
Try to cast C to InvC losslessly, satisfying CastOp(InvC) equals C, or CastOp(InvC) is a refined value of undefined C. Will try best to preserve the flags. |
|
Compute a lossless inverse of a signed extend (sext) of |
|
Compute a lossless inverse of an unsigned extend (zext) of |
|
Return the maximum frequency of a basic block in a function. |
|
Return the number of calls of |
|
Compute the size of the object pointed by Ptr. |
|
Return |
|
Creates sanitizer constructor and init functions lazily. |
|
Return a known alignment for a value, optionally raising it first. |
|
Return a front‐end PGO lookup name for function |
|
Return the PGOFuncName metadata node associated with function |
|
Find a trivial pointer located at a byte offset within a constant. |
|
Return the pointer operand of a load, store, or GEP, or null otherwise. |
|
Non‐const overload of getPointerOperand. |
|
Get splat value if the input is a splat vector or return nullptr. |
|
Strip GEP adjustments, pointer casts, and threadlocal.address from |
|
Non‐const overload of getUnderlyingObject. |
|
Like getUnderlyingObject(), but will try harder to find a single underlying object. In particular, this function also looks through selects and phis. |
|
This method is similar to getUnderlyingObject except that it can look through phi and select instructions and return multiple objects. |
|
This is a wrapper around getUnderlyingObjects and adds support for basic ptrtoint+arithmetic+inttoptr sequences. |
|
Determine the possible constant range of vscale with the given bit width, based on the vscale_range function attribute. |
|
Return true if |
|
Return true if V is poison given that ValAssumedPoison is already poison. |
|
Materialize attributes that can be inferred from others on a function. |
|
Infer and set non‐mandatory attributes on an existing function. |
|
Return an iterator to the first instruction in |
|
Return an iterator to the first instruction in |
|
Return a const iterator to the first instruction in |
|
Return a const iterator to the first instruction in |
|
Return the end iterator for instructions in |
|
Return the end iterator for instructions in |
|
Return the const end iterator for instructions in |
|
Return the const end iterator for instructions in |
|
Return a range over all instructions in |
|
Return a range over all instructions in |
|
Return a const range over all instructions in |
|
Return a const range over all instructions in |
|
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 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 |
|
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. |
|
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. |
|
Check if it is mechanically possible to inline the function |
|
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 |
|
isLibFreeFunction ‐ Returns true if the function is a builtin free() |
|
Return true if this pointer is returned by a noalias function. |
|
Return true if Object memory is not visible after an unwind. |
|
Tests if a function is a call or invoke to a library function that reallocates memory (e.g., realloc). |
|
Return true if it is safe to destroy constant |
|
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 each element of |
|
Returns true iff |
|
Returns true iff |
|
Return true if Object is writable without trapping. |
|
Lint a function. |
|
Lower remaining objectsize and is.constant intrinsic calls in a function. |
|
Splits control flow at |
|
Apply ‐mregparm‐style register parameter attributes to a function. |
|
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. |
|
Return true if |
|
Return true if profile counters for |
|
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. |
|
Return an APInt of active lanes for a |
|
Write an analysis graph for a function to a DOT file. |
|
Intersect IR flags from scalar ops |
|
Remove memory attributes incompatible with ASan/HWASan instrumentation. |
|
Remove blocks unreachable from a function's entry. |
|
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. |
|
Finds the same "relative pointer" pattern as described above, where the target is |
|
Test if given that the input instruction is in the tail call position if the return type or any attributes of the function will inhibit tail call optimization. |
|
Analogous to setExplicitlyUnknownBranchWeights, but for functions and their entry counts. |
|
Set the alignment of load or store instruction |
|
Returns true if function |
|
Given operands for a AShr, fold the result or return nulll. |
|
Given operands for an Add, fold the result or return null. |
|
Given operands for an And, fold the result or return null. |
|
Given operands for an ExtractElementInst, fold the result or return null. |
|
Given operands for an ExtractValueInst, fold the result or return null. |
|
Given operands for an FAdd, fold the result or return null. |
|
Given operands for an FDiv, fold the result or return null. |
|
Given operands for the multiplication of a FMA, fold the result or return null. |
|
Given operands for an FMul, fold the result or return null. |
|
Given operand for an FNeg, fold the result or return null. |
|
Given operands for an FRem, fold the result or return null. |
|
Given operands for an FSub, fold the result or return null. |
|
Given an operand for a Freeze, see if we can fold the result. |
|
Given operands for an InsertElement, fold the result or return null. |
|
Given operands for an InsertValueInst, fold the result or return null. |
|
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. |
|
Strip debug info from a single function. |
|
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. |
|
Try to raise a controlled object's alignment to a preferred value. |
|
Update callee profile counts after cloning or inlining. |
|
Check a function for errors, useful for use when debugging a pass. |
|
Run the safepoint verifier over a single function. Crashes on failure. |
|
Open a Graphviz viewer for a function's analysis graph. |
|
Analyze the regions of a function and open its GraphViz visualization in a viewer. |
|
Analyze the regions of a function and open its GraphViz visualization in a viewer. |
|
Wrap an array of |
|
Convert a |
|
Try to convert |
|
Return true if |
|
Return true if Caller and Callee have compatible attributes for inlining. |
|
Checks if there are any incompatible function attributes between |
|
Return true unless Callee is strictfp while Caller is not. |
|
Merge caller's and callee's attributes. |
|
Merges the functions attributes from |
|
Update min‐legal‐vector‐width if it is in Attribute and less than Width. |
|
This version supports overloaded intrinsics. |
|
Look up the Function declaration of intrinsic |
|
Look up or insert the Function declaration for intrinsic |
|
Look up or insert the Function declaration for intrinsic |
|
Same as previous, but accepts a Function instead of ID and FunctionType. |
|
Remangle an intrinsic if its name does not match its signature. |
|
Match a float or vector where CheckFn(ele) is true, binding the constant. For vectors, poison elements are assumed to match. |
|
Match an integer or vector where CheckFn(ele) is true, binding the constant. For vectors, poison elements are assumed to match. |
|
Match a Constant, capturing the value 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 immediate Constant, capturing the value if we match. |
|
Match if we have a specific specified value. |
|
Match against the nested pattern, and capture the value if we match. |
|
Match a const value, capturing it if we match. |
|
Match against the nested pattern, and capture the value if we match. |
|
Match a value, capturing it if we match. |
|
Return true if CoerceAvailableValueToLoadType would succeed if it was called. |
|
Try to coerce a stored value to a must‐aliased load of a different type. |
|
Extract a constant load value from a constant store or load at an offset. |
|
Extract bits for a load from a clobbering store or load at a given offset. |
|
Remove all Assignment Tracking related intrinsics and metadata from |
|
Set function attributes of function |
|
Rematerialize instructions across suspend points instead of spilling them. |
|
Evaluate a filter expression for an instrumentation opportunity. |
|
Return true if |
|
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. |
|
Determine if F is one of the special known Functions. If it isn't, return ARCInstKind::CallOrUser. |
|
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 this value refers to a distinct and identifiable object. |
|
Test whether |
|
Test whether the given value is possible a retainable object pointer. |
|
Return the ARC runtime function from a clang_arc_attachedcall bundle. |
|
Return true iff |
|
Clone a function declaration into a new module. |
|
Turn a function declaration into a stub function that makes an indirect call using the given function pointer. |
Created with MrDocs