Execution

GenericValue

A generic value that can be passed to or returned from a function in the execution engine.

Note that only simple types are supported, and for most use cases it is recommended to look up the address of the compiled function and ccall it directly.

This object needs to be disposed of using dispose.

dispose(val::GenericValue)

Dispose of the given generic value.

GenericValue(typ::LLVM.IntegerType, N::Integer)

Create a generic value from an integer of the given type.

intwidth(val::GenericValue)

Get the bit width of the integer value stored in the generic value.

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

Convert a generic value to an integer of the given type.

GenericValue(typ::LLVM.FloatingPointType, N::AbstractFloat)

Create a generic value from a floating point number of the given type.

convert(::Type{<:AbstractFloat}, val::GenericValue, typ::LLVM.FloatingPointType)

Convert a generic value to a floating point number of the given type.

Contrary to the integer conversion, the LLVM type is also required to be passed explicitly.

GenericValue(ptr::Ptr)

Create a generic value from a pointer.

convert(::Type{Ptr{T}}, val::GenericValue)

Convert a generic value to a pointer.

LLVM.ExecutionEngine

An execution engine that can run functions in a module.

Interpreter(mod::Module)

Create an interpreter for the given module.

This object needs to be disposed of using dispose.

JIT(mod::Module)

Create a JIT compiler for the given module.

This object needs to be disposed of using dispose.

dispose(engine::ExecutionEngine)

Dispose of the given execution engine.

push!(engine::LLVM.ExecutionEngine, mod::Module)

Add another module to the execution engine.

This takes ownership of the module.

delete!(engine::ExecutionEngine, mod::Module)

Remove a module from the execution engine.

Ownership of the module is transferred back to the user.

run(engine::ExecutionEngine, f::Function, [args::Vector{GenericValue}])

Run the given function with the given arguments in the execution engine.

lookup(engine::ExecutionEngine, fn::String)

Look up the address of the given function in the execution engine.

functions(engine::ExecutionEngine)

Get an iterator over the functions in the execution engine.

The iterator object is not actually iterable, but supports get and haskey queries with function names, and getindex to get the function object.

ThreadSafeContext

A thread-safe version of Context.

ThreadSafeContext(; opaque_pointers=nothing)

Create a new thread-safe context. The behavior of opaque_pointers is the same as in Context.

This object needs to be disposed of using dispose(::ThreadSafeContext).

context(ts_ctx::ThreadSafeContext)

Obtain the context associated with a thread-safe context.

dispose(ctx::ThreadSafeContext)

Dispose of the thread-safe context, releasing all resources associated with it.

ThreadSafeModule

A thread-safe version of LLVM.Module.

ThreadSafeModule(name::String)

Create a thread-safe module with the given name.

This object needs to be disposed of using dispose(::ThreadSafeModule).

(mod::ThreadSafeModule)(f)

Apply f to the LLVM module contained within mod, after locking the module and activating its context.

dispose(mod::ThreadSafeModule)

Dispose of the thread-safe module, releasing all resources associated with it.

LLJIT(::LLJITBuilder)

Creates a LLJIT stack based on the provided builder.

LLJIT(;tm::Union{Nothing, TargetMachine})

Use the provided TargetMachine and construct an LLJIT from it.

JITDylib(lljit::LLJIT)

Get the main JITDylib

JITDylib(es::ExecutionSession, name; bare=false)

Adds a new JITDylib to the ExecutionSession. The name must be unique and the bare=true no standard platform symbols are made available.

JITDylib(jljit::JuliaOJIT)

Get the external JITDylib from the Julia JIT

lookup(lljit::LLJIT, name)

Takes an unmangled symbol names and searches for it in the LLJIT.

linkinglayercreator!(builder::LLJITBuilder, creator::ObjectLinkingLayerCreator)