Struct ExecutionEngine 

pub struct ExecutionEngine(/* private fields */);

Rust wrapper around [LLVMExecutionEngineRef]

Implementations

impl ExecutionEngine

pub fn new_for_module( module: LLVMModule, kind: EngineKind, ) -> Result<Self, String>

Creates a new ExecutionEngine for the given module.

Example usage:

use pliron_llvm::llvm_sys::{
    core::{LLVMMemoryBuffer, LLVMContext, LLVMModule},
    execution_engine::{ExecutionEngine, EngineKind, MCJITCompilerOptions},
    target::initialize_native,
};
fn main() -> Result<(), String> {
    let llvm_ctx = LLVMContext::default();
    ExecutionEngine::link_in_mcjit();
    initialize_native()?;

    let llvm_ir = r#"
        define i32 @main() {
            ret i32 0
        }"#;
    let ir_mb = LLVMMemoryBuffer::from_str(llvm_ir, "test_buffer");
    let module = LLVMModule::from_ir_in_memory_buffer(&llvm_ctx, ir_mb)?;

    let mcjit_options = MCJITCompilerOptions::default();
    let ee = ExecutionEngine::new_for_module(module, EngineKind::MCJIT(mcjit_options))?;
    let main = ee
        .find_function("main")
        .ok_or("Function 'main' not found")?;
    let ret_gv = unsafe { ee.run_function_as_main(main, &[]) };
    assert_eq!(ret_gv, 0);
    Ok(())
}

pub unsafe fn run_static_constructors(&self)

Runs static constructors.

Safety

This function executes arbitrary code.

pub unsafe fn run_static_destructors(&self)

Runs static destructors.

Safety

This function executes arbitrary code.

pub fn find_function(&self, name: &str) -> Option<LLVMValue>

Find a function by name.

pub fn add_global_mapping<T>(&self, function: LLVMValue, addr: *mut T)

Map an external global into the execution engine.

Example usage:

use pliron_llvm::llvm_sys::{
    core::{LLVMMemoryBuffer, LLVMContext, LLVMModule, llvm_get_named_function},
    execution_engine::{ExecutionEngine, EngineKind, CodeGenOptLevel},
    target::initialize_native,
};
fn main() -> Result<(), String> {
    let llvm_ctx = LLVMContext::default();
    ExecutionEngine::link_in_mcjit();
    initialize_native()?;

    let llvm_ir = r#"
        declare i32 @external_function()

        define i32 @call_external() {
            %result = call i32 @external_function()
            ret i32 %result
        }"#;
    let ir_mb = LLVMMemoryBuffer::from_str(llvm_ir, "test_buffer");
    let module = LLVMModule::from_ir_in_memory_buffer(&llvm_ctx, ir_mb)?;
    let ext_fn_value = llvm_get_named_function(&module, "external_function")
        .ok_or("Function 'external_function' not found")?;

    let ee =
        ExecutionEngine::new_for_module(module, EngineKind::JIT(CodeGenOptLevel::Default))?;
    let call_external_fn = ee
        .find_function("call_external")
        .ok_or("Function 'call_external' not found")?;

    extern "C" fn external_function() -> i32 {
        1234
    }

    ee.add_global_mapping(ext_fn_value, external_function as *mut fn() -> i32);

    let ret_gv = unsafe { ee.run_function(call_external_fn, &[]) };
    let ret_val = ret_gv.to_u64();
    assert_eq!(ret_val, 1234);
    Ok(())
}

pub unsafe fn run_function( &self, function: LLVMValue, args: &[GenericValue], ) -> GenericValue

Execute the function with the given arguments.

Safety

This function executes arbitrary code.

Example usage:

use pliron_llvm::llvm_sys::{
    core::{LLVMMemoryBuffer, LLVMContext, LLVMModule, llvm_int_type_in_context},
    execution_engine::{ExecutionEngine, EngineKind, GenericValue},
    target::initialize_native,
};
fn main() -> Result<(), String> {
    let llvm_ctx = LLVMContext::default();
    ExecutionEngine::link_in_interpreter();
    initialize_native()?;

    let llvm_ir = r#"
        define i32 @add(i32 %a, i32 %b) {
            %sum = add i32 %a, %b
            ret i32 %sum
        }"#;
    let ir_mb = LLVMMemoryBuffer::from_str(llvm_ir, "test_buffer");
    let module = LLVMModule::from_ir_in_memory_buffer(&llvm_ctx, ir_mb)?;
    let ee = ExecutionEngine::new_for_module(module, EngineKind::Interpreter)?;
    let add_fn = ee.find_function("add").ok_or("Function 'add' not found")?;

    let i32_type = llvm_int_type_in_context(&llvm_ctx, 32);
    let arg1 = GenericValue::from_u64(i32_type, 10, false);
    let arg2 = GenericValue::from_u64(i32_type, 32, false);
    let ret_gv = unsafe { ee.run_function(add_fn, &[arg1, arg2]) };
    let ret_val = ret_gv.to_u64();
    assert_eq!(ret_val, 42);
    Ok(())
}

pub unsafe fn run_function_as_main( &self, function: LLVMValue, args: &[&str], ) -> i32

Execute a function as main.

Safety

This function executes arbitrary code.

Example usage:

use pliron_llvm::llvm_sys::{
    core::{LLVMMemoryBuffer, LLVMContext, LLVMModule},
    execution_engine::{ExecutionEngine, EngineKind},
    target::initialize_native,
};
fn main() -> Result<(), String> {
    let llvm_ctx = LLVMContext::default();
    ExecutionEngine::link_in_interpreter();
    initialize_native()?;

    let llvm_ir = r#"
        define i32 @main() {
            ret i32 42
        }"#;
    let ir_mb = LLVMMemoryBuffer::from_str(llvm_ir, "test_buffer");
    let module = LLVMModule::from_ir_in_memory_buffer(&llvm_ctx, ir_mb)?;
    let ee = ExecutionEngine::new_for_module(module, EngineKind::Interpreter)?;
    let main = ee
        .find_function("main")
        .ok_or("Function 'main' not found")?;
    let ret_gv = unsafe { ee.run_function_as_main(main, &[]) };
    assert_eq!(ret_gv, 42);
    Ok(())
}

pub fn link_in_interpreter()

Link in Interpreter.

pub fn link_in_mcjit()

Link in MCJIT.

Trait Implementations

impl Drop for ExecutionEngine

fn drop(&mut self)

Executes the destructor for this type.