Values

LLVM.Value

Abstract type representing an LLVM value.

value_type(val::Value)

Get the type of the given value.

context(val::LLVM.Value)

Return the context in which the given value was created.

name(val::Value)

Get the name of the given value.

name!(val::Value, name::String)

Set the name of the given value.

isconstant(val::LLVM.Value)

Check if the given value is a constant value.

isundef(val::LLVM.Value)

Check if the given value is an undef value.

ispoison(val::LLVM.Value)

Check if the given value is a poison value.

isnull(val::LLVM.Value)

Check if the given value is a null constant.

LLVM.User <: LLVM.Value

A value that uses other values.

See also: operands.

operands(user::LLVM.User)

Get an iterator over the operands of the given user.

LLVM.Constant <: LLVM.User

Abstract supertype for all constant values.

null(typ::LLVMType)

Create a null constant of the given type.

all_ones(typ::LLVMType)

Create a constant with all bits set to one of the given type.

PointerNull <: LLVM.ConstantData

A null pointer constant.

UndefValue <: LLVM.ConstantData

An undefined constant value.

PoisonValue <: LLVM.ConstantData

A poison constant value.

ConstantInt <: LLVM.ConstantData

A constant integer value.

convert(::Type{<:Integer}, val::ConstantInt)

Convert a constant integer value back to a Julia integer.

ConstantFP <: LLVM.ConstantData

A constant floating point value.

convert(::Type{<:AbstractFloat}, val::ConstantFP)

Convert a constant floating point value back to a Julia floating point number.

ConstantStruct <: LLVM.ConstantAggregate

A constant struct of values.

ConstantDataArray <: LLVM.ConstantDataSequential

A constant array of simple data values, i.e., whose element type is a simple 1/2/4/8-byte integer or half/bfloat/float/double, and whose elements are just simple data values

See also: ConstantArray

ConstantDataArray(typ::LLVMType, data::AbstractVector)

Create a constant array of simple data values of the given type and data.

ConstantDataArray(data::AbstractVector)

Create a constant array of simple data values from a Julia vector.

ConstantDataVector <: LLVM.ConstantDataSequential

A constant vector of simple data values, i.e., whose element type is a simple 1/2/4/8-byte integer or half/bfloat/float/double, and whose elements are just simple data values

ConstantArray <: LLVM.ConstantAggregate

A constant array of values.

This type implements the Julia array interface, so (to some extent) it can be used as a regular Julia array.

ConstantArray(typ::LLVMType, data::AbstractArray)

Create a constant array of values of the given type and data.

ConstantArray(data::AbstractArray)

Create a constant array of values from a Julia array, using the appropriate constant type.

collect(ca::ConstantArray)

Convert a constant array back to a Julia array.

InlineAsm <: LLVM.Constant

A constant inline assembly block.

LLVM.ConstantExpr <: LLVM.Constant

A constant value that is initialized with an expression using other constant values.

Constant expressions are created using const_-prefixed functions, which correspond to the LLVM IR instructions: const_neg, const_not, etc.

LLVM.GlobalValue <: LLVM.Constant

Abstract supertype for all global values.

global_value_type(val::LLVM.GlobalValue)

Get the type of the global value.

This differs from value_type in that it returns the type of the contained value, not the type of the global value itself which is always a pointer type.

parent(val::LLVM.GlobalValue)

Get the parent module of the global value.

isdeclaration(val::LLVM.GlobalValue)

Check if the global value is a declaration, i.e. it does not have a definition.

linkage(val::LLVM.GlobalValue)

Get the linkage of the global value.

linkage!(val::LLVM.GlobalValue, linkage::LLVM.LLVMLinkage)

Set the linkage of the global value.

section(val::LLVM.GlobalValue)

Get the section of the global value.

section!(val::LLVM.GlobalValue, sec::String)

Set the section of the global value.

visibility(val::LLVM.GlobalValue)

Get the visibility of the global value.

visibility!(val::LLVM.GlobalValue, viz::LLVM.LLVMVisibility)

Set the visibility of the global value.

dllstorage(val::LLVM.GlobalValue)

Get the DLL storage class of the global value.

dllstorage!(val::LLVM.GlobalValue, storage::LLVM.LLVMDLLStorageClass)

Set the DLL storage class of the global value.

unnamed_addr(val::LLVM.GlobalValue)

Check if the global value has the unnamed address flag set.

unnamed_addr!(val::LLVM.GlobalValue, flag::Bool)

Set the unnamed address flag of the global value.

local_unnamed_addr(val::LLVM.GlobalValue)

Check if the global value has the local unnamed address flag set.

local_unnamed_addr!(val::LLVM.GlobalValue, flag::Bool)

Set the local unnamed address flag of the global value.

GlobalVariable <: LLVM.GlobalObject

A global variable.

erase!(gv::GlobalVariable)

Remove the global variable from its parent module and delete it.

initializer(gv::GlobalVariable)

Get the initializer of the global variable.

initializer!(gv::GlobalVariable, val::Constant)

Set the initializer of the global variable. Setting the value to nothing removes the current initializer.

isthreadlocal(gv::GlobalVariable)

Check if the global variable is thread-local.

threadlocal!(gv::GlobalVariable, flag::Bool)

Set the thread-local flag of the global variable.

threadlocalmode(gv::GlobalVariable)

Get the thread-local mode of the global variable.

threadlocalmode!(gv::GlobalVariable, mode::LLVM.LLVMThreadLocalMode)

Set the thread-local mode of the global variable.

isconstant(gv::GlobalVariable)

Check if the global variable is a global constant, i.e., its value is immutable throughout the runtime execution of the program.

constant!(gv::GlobalVariable, flag::Bool)

Set the constant flag of the global variable.

isextinit(gv::GlobalVariable)

Check if the global variable is externally initialized.

extinit!(gv::GlobalVariable, flag::Bool)

Set the externally initialized flag of the global variable.

alignment(gv::GlobalVariable)

Get the alignment of the global variable.

alignment!(gv::GlobalVariable, bytes::Integer)

Set the alignment of the global variable.

replace_uses!(old::LLVM.Value, new::LLVM.Value)

Replace all uses of an old value in the IR with new.

This does not replace uses in metadata, which must be done separately with replace_metadata_uses!.

replace_metadata_uses!(old::LLVM.Value, new::LLVM.Value)

Replace all uses of an old value in metadata with new.

uses(val::LLVM.Value)

Get an iterator over the uses of the given value.

See also: LLVM.Use.

LLVM.Use

A use of a value in the IR. Knows both the user and the used value.

See also: user, value.

user(use::LLVM.Use)

Get the user of the given use.

value(use::LLVM.Use)

Get the used value of the given use.