module ExecutionEngine: sig
.. end
type
t
An execution engine is either a JIT compiler or an interpreter, capable of
directly loading an LLVM module and executing its functions without first
invoking a static compiler and generating a native executable.
val create : Llvm.llmodule -> t
create m
creates a new execution engine, taking ownership of the
module m
if successful. Creates a JIT if possible, else falls back to an
interpreter. Raises Error msg
if an error occurrs. The execution engine
is not garbage collected and must be destroyed with dispose ee
.
See the function llvm::EngineBuilder::create
.
val create_interpreter : Llvm.llmodule -> t
create_interpreter m
creates a new interpreter, taking ownership of the
module m
if successful. Raises Error msg
if an error occurrs. The
execution engine is not garbage collected and must be destroyed with
dispose ee
.
See the function llvm::EngineBuilder::create
.
val create_jit : Llvm.llmodule -> int -> t
create_jit m optlevel
creates a new JIT (just-in-time compiler), taking
ownership of the module m
if successful with the desired optimization
level optlevel
. Raises Error msg
if an error occurrs. The execution
engine is not garbage collected and must be destroyed with dispose ee
.
See the function llvm::EngineBuilder::create
.
val dispose : t -> unit
dispose ee
releases the memory used by the execution engine and must be
invoked to avoid memory leaks.
val add_module : Llvm.llmodule -> t -> unit
add_module m ee
adds the module m
to the execution engine ee
.
val remove_module : Llvm.llmodule -> t -> Llvm.llmodule
remove_module m ee
removes the module m
from the execution engine
ee
, disposing of m
and the module referenced by mp
. Raises
Error msg
if an error occurs.
val find_function : string -> t -> Llvm.llvalue option
find_function n ee
finds the function named n
defined in any of the
modules owned by the execution engine ee
. Returns None
if the function
is not found and Some f
otherwise.
val run_function : Llvm.llvalue ->
Llvm_executionengine.GenericValue.t array ->
t -> Llvm_executionengine.GenericValue.t
run_function f args ee
synchronously executes the function f
with the
arguments args
, which must be compatible with the parameter types.
val run_static_ctors : t -> unit
run_static_ctors ee
executes the static constructors of each module in
the execution engine ee
.
val run_static_dtors : t -> unit
run_static_dtors ee
executes the static destructors of each module in
the execution engine ee
.
val run_function_as_main : Llvm.llvalue ->
string array ->
(string * string) array -> t -> int
run_function_as_main f args env ee
executes the function f
as a main
function, passing it argv
and argc
according to the string array
args
, and envp
as specified by the array env
. Returns the integer
return value of the function.
val free_machine_code : Llvm.llvalue -> t -> unit
free_machine_code f ee
releases the memory in the execution engine ee
used to store the machine code for the function f
.
val data_layout : t -> Llvm_target.DataLayout.t
data_layout ee
is the data layout of the execution engine ee
.