LLVM Constant Representation
Synopsis
Declared in <llvm/IR/Constant.h>
class Constant
: public UserDescription
This is an important base class in LLVM. It provides the common facilities of all constant values in an LLVM program. A constant is a value that is immutable at runtime. Functions are constants because their address is immutable. Same with global variables.
All constants share the capabilities provided in this class. All constants can have a null value. They can have an operand list. Constants can be simple (integer and floating point values), complex (arrays and structures), or expression based (computations yielding a constant value composed of only certain operators and other constant values).
Note that Constants are immutable (once created they never change) and are fully shared by structural equivalence. This means that two structurally equivalent constants will always have the same address. Constants are created on demand as needed and never deleted: thus clients don't have to worry about the lifetime of the objects.
Base Classes
Name |
Description |
A Value that uses other Values as operands. |
Types
Name |
Description |
Const iterator for directly iterating over the operand Values. |
|
Iterator for directly iterating over the operand Values. |
Type Aliases
Name |
Description |
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 |
Concrete subclass of this. |
Member Functions
Name |
Description |
|
Constants are uniqued and cannot be copied. |
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 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() |
|
|
|
All values hold a context through their type. |
|
Returns the descriptor co‐allocated with this User instance. |
|
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 |
|
|
|
|
|
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. |
|
|
|
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. |
|
All values are typed, get the type of this value. |
|
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 an ID for the concrete type of this object. |
|
Return the symbol‐table name entry for this value, if any. |
|
Replace all uses of |
|
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 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. |
|
Check if this Value has a use‐list. |
|
Return true if there is a value handle associated with this value. |
|
Return true if the constant has no live uses. |
|
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 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 a constant is ConstantData or a ConstantAggregate or ConstantExpr that contain only ConstantData. |
|
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. |
|
Return true if this value is a swifterror value. |
|
Return true if the value can vary between threads. |
|
Return true if there is metadata referencing this value. |
|
Check if this value is used in the specified basic block. |
|
|
|
Return true if there are 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 |
|
|
|
|
|
Remove any dead constant users dangling off of this constant. |
|
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. |
|
Change the name of the value. |
|
Set the operand count for a User with hung‐off uses. |
|
Replace operand |
|
Set the symbol‐table name entry for this 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: Return true if |
|
Remove the droppable use |
|
Return the all‐ones constant of type |
|
Return the value for an integer or pointer constant, or a vector thereof, with the given scalar value. |
|
Return the null constant of type |
|
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 constant of type |
|
Destroy this constant. |
|
|
|
|
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. |
|
Append all metadata attached to this value into |
|
Get the current metadata attachments for the given kind, if any. |
|
Get metadata for the given kind, if any. |
|
Return 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 the opaque subclass data bits stored in this value. |
Protected Static Member Functions
Name |
Description |
Return the operand Use at compile‐time index |
Protected Data Members
Name |
Description |
True if this value has a descriptor. |
|
Whether operands are stored in a separately allocated array. |
|
True if this value has a name in the symbol table. |
|
True if metadata references this value. |
|
Number of operands in this user. |
|
Hold arbitary subclass data. |
Protected Static Data Members
Name |
Description |
Bits reserved in SubclassOptionalData, not to be used for ConstantExpr flags. |
Non-Member Functions
Name |
Description |
Get the upper bound on bit size for this Value |
|
Return the number of times the sign bit of the register is replicated into the other bits. |
|
Attempt to constant fold a binary instruction with the specified operands. |
|
Attempt to constant fold a binary operation with the specified operands. Returns null or a constant expression of the specified operands on failure. |
|
Attempt to constant fold a call to the specified function with the specified arguments, returning null if unsuccessful. |
|
Attempt to constant fold a cast instruction with the specified operand. |
|
Attempt to constant fold a cast with the specified operand. If it fails, it returns a constant expression of the specified operand. |
|
Attempt to constant fold a compare instruction with the specified operands. |
|
Attempt to constant fold a compare instruction with the specified operands. |
|
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 a floating‐point binary operation with denormal handling. |
|
Attempt to constant fold a getelementptr instruction with the specified operands. |
|
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. |
|
Attempt to constant fold an instruction with the specified operands. |
|
Try to constant fold the specified instruction. |
|
Constant fold a zext, sext or trunc, depending on IsSigned and whether the DestTy is wider or narrower than C. Returns nullptr on failure. |
|
Attempt to constant fold a call to the specified intrinsic. |
|
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. |
|
Attempt to constant fold a unary instruction with the specified operand. |
|
Attempt to constant fold a unary operation with the specified operand. Returns null on failure. |
|
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 |
|
Read the trailing bytes of a global's initializer starting at |
|
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. |
|
This is an auto‐upgrade for bitcast constant expression between pointers with different address spaces: the instruction is replaced by a pair ptrtoint+inttoptr. |
|
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 |
|
Create a mask that filters the members of an interleave group where there are gaps. |
|
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. |
|
Convert a predicate code into a constant or an FCmp predicate. |
|
Convert a predicate code into a constant or an ICmp predicate. |
|
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 |
|
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. |
|
Parse a type and a constant value in the given string. |
|
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 |
|
Return the initial value of |
|
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 memory intrinsic at a given offset. |
|
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. |
|
Return a small list of potentially interesting constants of a given type. |
|
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. |
|
Creates a pair of constants used to iterate the array of offloading entries by accessing the section variables provided by the linker. |
|
Create a constant struct initializer used to register this global at runtime. |
|
Build a function pointer of FunctionType with the given constant address. |
Derived Classes
Name |
Description |
The address of a basic block. |
|
Constant composed of other constants (for example arrays, structs, and vectors). |
|
Leaf constant with no operands (for example integers and floating‐point literals). |
|
A constant value that is initialized with an expression using other constant values. |
|
A signed pointer, in the ptrauth sense. |
|
Constant wrapper for a DSO‐local equivalent of a global value. |
|
Base class of globally definable objects such as functions, variables, and aliases. |
|
Wrapper for a value that won't be replaced with a CFI jump table pointer in LowerTypeTestsModule. |
Created with MrDocs