Base class of globally definable objects such as functions, variables, and aliases.
Synopsis
Declared in <llvm/IR/GlobalValue.h>
class GlobalValue
: public ConstantDescription
Global values can do things other LLVM values cannot, for example using the address of one as a constant. This class is subclassed by GlobalVariable, GlobalAlias, GlobalIFunc, and Function.
Base Classes
Name |
Description |
LLVM Constant Representation |
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 |
A 64‐bit global unique identifier used by PGO and ThinLTO. |
|
Const iterator over this user's operand |
|
Range of const operand |
|
Const iterator over this value's uses. |
|
Const iterator over this value's users. |
|
Iterator over this user's operand |
|
Range of mutable operand |
|
Iterator over this value's uses. |
|
Iterator over this value's users. |
Enums
Name |
Description |
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. |
|
Concrete subclass of this. |
|
An enumeration for the kinds of visibility of global values. |
Member Functions
Name |
Description |
|
Copy construction is deleted; GlobalValue is non‐copyable. |
Assignment operators |
|
|
|
This method should only be used by the Use class. |
|
Assert in debug builds that modules containing this value are materialized. |
|
Assert that every module containing this value is fully materialized. |
|
Return true if this pointer's memory may be freed in its defining scope. |
|
Return true if this global can be left out of the object symbol table. |
|
Return true if this global may use a local alias during code generation. |
|
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. |
|
Delete a pointer to a generic Value. |
|
Destroy this constant and any constant users that depend on it. |
|
Drop all references to operands. |
|
Remove every uses that can safely be removed. |
|
Remove every use of this value in |
|
Support for debugging, callable in GDB: V‐>dump() |
|
This method unlinks 'this' from the containing module and deletes it. |
|
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). |
|
Return the Comdat object for this global value, or null if none. |
|
All values hold a context through their type. |
|
Return the DLL storage class of this global value. |
|
Get the data layout of the module this global belongs to. |
|
Returns the descriptor co‐allocated with this User instance. |
|
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. |
|
Return the linkage type of this global value. |
|
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 operands. |
|
This method computes the number of uses of this Value. |
|
Return operand |
|
|
|
|
|
Return the module that contains this global value. |
|
Return the linker partition name for this global, or empty if none is set. |
|
Returns an alignment of the pointer value. |
|
Returns the number of bytes known to be dereferenceable for the pointer value. |
|
If this ptr is provably equal to |
|
Return the raw optional flags value contained in this value. |
|
Return the sanitizer instrumentation flags for this global. |
|
Return the object‐file section name for this global, or empty if none. |
|
|
|
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. |
|
Return the thread‐local storage model of this global. |
|
Global values are always pointers. |
|
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 an ID for the concrete type of this object. |
|
Return the symbol‐table name entry for this value, if any. |
|
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 global has appending linkage. |
|
Returns true if this value's address is not significant in this module. |
|
Return true if this global has available_externally linkage. |
|
Return true if this global is in 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 this global has the global unnamed_addr attribute. |
|
Return true if this global has hidden visibility. |
|
Return true if this global has internal linkage. |
|
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 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. |
|
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. |
|
Return true if this global has a linker partition name. |
|
Return true if this global has private linkage. |
|
Return true if this global has protected visibility. |
|
Return true if this global has sanitizer metadata attached. |
|
Return true if this global has a non‐empty section name. |
|
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. |
|
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 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 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 a constant is ConstantData or a ConstantAggregate or ConstantExpr that contain only ConstantData. |
|
Return true if this global has not yet been fully read from its source. |
|
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. |
|
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 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. |
|
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. |
|
|
|
|
|
|
|
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. |
|
Return an iterator to the first operand |
|
|
|
|
|
|
|
Delete operators |
|
|
|
|
|
Recompute and assign a GUID to this value, replacing the existing GUID. |
|
Remove any dead constant users dangling off of this constant. |
|
This method unlinks 'this' from the containing module, but does not delete it. |
|
Remove sanitizer metadata from this global 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 uses of one Value with another. |
|
Replace uses of this value that occur outside |
|
Replace selected uses of this value with |
|
Reverse the use‐list. |
|
Set the DLL storage class of this global value. |
|
Set whether this symbol is known to be local to the linkage unit. |
|
Set the linkage type of this global value. |
|
Change the name of the value. |
|
Disable address and HWAddress sanitizer instrumentation for this global. |
|
Set the operand count for a User with hung‐off uses. |
|
Replace operand |
|
Set the linker partition name for this global. |
|
Set sanitizer instrumentation flags for this global value. |
|
Set whether this global is thread‐local using the general‐dynamic model. |
|
Set the thread‐local storage model of this global. |
|
Set how significant this global's address is for merging and linking. |
|
Set the symbol‐table name entry for this value. |
|
Set the visibility of this global value. |
|
Sort the use‐list. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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. |
|
|
|
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. |
|
|
|
|
|
|
|
|
|
|
Static Member Functions
Name |
Description |
Methods for support type inquiry through isa, cast, and dyn_cast. |
|
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 ( |
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 |
SubclassOptionalData bits. Low bits are used by ConstantExpr. |
Protected Member Functions
Name |
Description |
|
Construct a global value with the given type, value kind, linkage, and name. |
|
Destroy this global and remove dead constant users. |
|
|
|
|
Allocate the array of Uses, followed by a pointer (with bottom bit set) to the User. |
|
Erase all metadata attached to this Value. |
|
Copy all additional attributes (those not needed to create a GlobalValue) from the GlobalValue Src to this one. |
|
Erase all metadata attachments with the given kind. |
|
Erase all metadata attachments matching the given predicate. |
|
Append all metadata attached to this value into |
|
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 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 |
|
Number of operands in this user. |
|
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 bits reserved for subclass‐specific data in GlobalValue. |
Friends
Name |
Description |
Module pass that assigns a globally unique identifier to every global value. |
|
LLVM Constant Representation |
Non-Member Functions
Name |
Description |
Get the upper bound on bit size for this Value |
|
Return the number of times the sign bit of the register is replicated into the other bits. |
|
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. |
|
ExtractTypeInfo ‐ Returns the type info, possibly bitcast, encoded in V. |
|
Find the earliest instruction that captures |
|
Given an aggregate and a sequence of indices, see if the scalar value indexed is already around as a register. |
|
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 |
|
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. |
|
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. |
|
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. |
|
Apply a metadata callback if |
|
Return true if the given assume operand bundle implies that |
|
Returns true if pointer |
|
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 |
|
Determine the possible constant range of an integer or vector of integer value. This is intended as a cheap, non‐recursive check. |
|
Returns the known bits rather than passing by reference. |
|
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOne bit sets. |
|
Returns the known bits rather than passing by reference. |
|
Compute known bits for the demanded elements of |
|
Compute known bits for |
|
Compute known bits for |
|
Merge bits known from context‐dependent facts into Known. |
|
Wrapper to account for known fast math flags at the use instruction. |
|
Determine known floating‐point classes for |
|
Wrapper to account for known fast math flags at the use instruction. |
|
Determine which floating‐point classes are valid for |
|
Determine known floating‐point classes for |
|
Return the known sign bit of a floating‐point value, if provable. |
|
Compute whether a signed multiply of |
|
Compute whether a signed subtract of |
|
Compute whether an unsigned multiply of |
|
Compute whether an unsigned subtract of |
|
Converts value |
|
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. |
|
Given a vector and an element number, see if the scalar value is already around as a register, for example if it were inserted then extracted from the vector. |
|
Call |
|
Return a begin iterator over the types indexed by GEP |
|
Return a begin iterator over the types indexed by GEP |
|
Return the end iterator for types indexed by GEP |
|
Return the end iterator for types indexed by GEP |
|
If a function is part of an allocation family (e.g. malloc/realloc/calloc/free), return the identifier for its family of functions. |
|
Like getObjectSize(), but only for base objects. |
|
Returns true if the value |
|
Compute the contents of a null‐terminated C string pointed to by |
|
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 |
|
Compute the size of the object pointed by Ptr. |
|
Return a known alignment for a value, optionally raising it first. |
|
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. |
|
Return true if V is poison given that ValAssumedPoison is already poison. |
|
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. |
|
Return true if the floating‐point value |
|
Return true iff: 1. X is poison implies Y is poison. 2. X is true implies Y is false. 3. X is false implies Y is true. Otherwise, return false. |
|
Return true if the two given values are negation. |
|
Returns true if the given value is known be negative (i.e. non‐positive and non‐zero). |
|
Return true if the floating‐point value can never contain a NaN or infinity. |
|
Return true if the floating‐point scalar value is not an infinity or if the floating‐point vector value has no infinities. |
|
Return true if the floating‐point scalar value is not a NaN or if the floating‐point vector value has no NaN elements. |
|
Return true if the given values are known to be non‐equal when defined. Supports scalar integer types only. |
|
Returns true if the give value is known to be non‐negative. |
|
Return true if the given value is known to be non‐zero when defined. |
|
Returns true if the given value is known be positive (i.e. non‐negative and non‐zero). |
|
Return true if the given value is known to have exactly one bit set when defined. |
|
Return true if |
|
Return true if this pointer is returned by a noalias function. |
|
Return true if Object memory is not visible after an unwind. |
|
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. |
|
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 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 |
|
Intersect IR flags from scalar ops |
|
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 |
|
Set the alignment of load or store instruction |
|
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. |
|
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. |
|
Wrap an array of |
|
Convert a |
|
Try to convert |
|
Return true if |
|
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. |
|
Evaluate a filter expression for an instrumentation opportunity. |
|
Map V to its ARCInstKind equivalence class. |
|
Assuming the given instruction is one of the special calls such as objc_retain or objc_release, return the RCIdentity root of the argument of the call. |
|
Determine which objc runtime call instruction class V belongs to. |
|
Return the RCIdentity root of value |
|
Return the non‐const RCIdentity root of value |
|
Return the underlying ObjC object pointer for |
|
A wrapper for GetUnderlyingObjCPtr used for results memoization. |
|
Return true if |
|
Return true if this value refers to a distinct and identifiable object. |
|
Test whether |
|
Test whether the given value is possible a retainable object pointer. |
Derived Classes
Name |
Description |
Represents a single function or variable alias in the IR. |
|
Base class for independently defined globals such as functions and variables. |
Created with MrDocs