Struct Function

pub struct Function { /* private fields */ }

Implementations

impl Function

pub fn compile(&self)

Examples found in repository

examples/mult2.rs (line 9)

fn main() {
    let mut context = Context::new();
    context.build_start();
    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![]).unwrap();
    let zero = func.create_float64_constant(0.0);
    func.insn_return(&zero);
    func.compile();
    context.build_end();
    let function: fn() -> f64  = func.to_closure();
    println!("{}", function());
}

examples/mult.rs (line 18)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let int_type = Context::int_type();
    let params = vec![int_type, int_type, int_type];
    let mut func = context.function(Abi::Cdecl, int_type, params).unwrap();

    let x = func.arg(0).unwrap();
    let y = func.arg(1).unwrap();
    let z = func.arg(2).unwrap();
    let temp1 = func.insn_mult(&x, &y);
    let temp2 = func.insn_add(&temp1, &z);
    func.insn_return(&temp2);
    func.compile();
    context.build_end();

    let result: extern "C" fn(i32,i32,i32) -> i32 = func.to_closure();
    println!("3*5+2 = {}", result(3,5,2))
}

examples/load_and_store.rs (line 29)

fn main() {
    let mut context = Context::new();
    context.build_start();

    let float_type = Context::sbyte_type();
    let params = vec![float_type];
    let mut func = context.function(Abi::Cdecl, float_type, params).unwrap();

    let x = func.arg(0).unwrap();
    let ptr1 = func.alloca(1);
    let ptr2 = func.alloca(8);

    let tag = func.create_sbyte_constant(111);
    let value = func.create_float64_constant(111.0);

    func.insn_store(&ptr1, &tag);
    func.insn_store(&ptr2, &value);

    let res1 = func.insn_load(&ptr1);
    let res2 = func.insn_load(&ptr2);

    let res= func.insn_add(&res1, &res2);


    func.insn_return(&res);
    println!("{}", func.dump().unwrap());
    func.compile();
    context.build_end();

    let result: extern "C" fn(f64) -> u8 = func.to_closure();
    println!("{}", result(0.23))
}

examples/branching.rs (line 24)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let float_type = Context::float64_type();
    let mut func = context.function(Abi::Cdecl, float_type, vec![float_type]).unwrap();

    // Return 1 if arg0 == 4
    // else return 0
    let is_four_result = func.create_float64_constant(1.0);
    let not_four_result = func.create_float64_constant(0.0);

    let x = func.arg(0).unwrap();
    let four = func.create_float64_constant(4.0);
    let mut label = Label::new();
    let eq_to_4 = func.insn_eq(&x, &four);
    func.insn_branch_if(&eq_to_4, &mut label);
    func.insn_return(&not_four_result);
    func.insn_label(&mut label);
    func.insn_return(&is_four_result);
    func.compile();
    context.build_end();
    let result: extern "C" fn(f64) -> f64 = func.to_closure();
    println!("{}", result(4.0));
}

examples/function_calls.rs (line 15)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // This function multiplies int by 2
    let int_type = Context::int_type();
    let mut func_mult_by_2 = context.function(Abi::Cdecl, int_type, vec![int_type]).unwrap();
    let x = func_mult_by_2.arg(0).unwrap();
    let const_1 = func_mult_by_2.create_int_constant(2);
    let temp1 = func_mult_by_2.insn_mult(&x, &const_1);
    func_mult_by_2.insn_return(&temp1);
    func_mult_by_2.compile();

    // This main function has 1 arg, it adds 5 to the arg and calls func_mult_by_2 and returns that value.
    let mut func = context.function(Abi::Cdecl, int_type, vec![int_type]).unwrap();
    let arg0 = func.arg(0).unwrap();
    let five = func.create_int_constant(5);
    let arg0_plus_5 = func.insn_add(&arg0, &five);
    let res = func.insn_call(&func_mult_by_2, vec![arg0_plus_5]);
    func.insn_return(&res);
    func.compile();

    context.build_end();

    let result: extern "C" fn(i32) -> i32 = func.to_closure();
    println!("(100+5)*2 == {}", result(100))
}

examples/branch_with_result.rs (line 35)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let i32_type = Context::int_type();
    let mut func = context.function(Abi::Cdecl, i32_type, vec![i32_type, i32_type]).unwrap();


    let result = func.alloca(4);

    let a = func.arg(0).unwrap();
    let b = func.arg(1).unwrap();
    let a_eq_b = func.insn_eq(&a, &b);
    let mut done_label = Label::new();
    let mut eq_label = Label::new();

    func.insn_branch_if(&a_eq_b, &mut eq_label);
    let a_minus_b = func.insn_sub(&a, &b);
    func.insn_store(&result, &a_minus_b);
    func.insn_branch(&mut done_label);
    func.insn_label(&mut eq_label);
    let a_plus_b = func.insn_add(&a, &b);
    func.insn_store(&result, &a_plus_b);
    func.insn_label(&mut done_label);
    let ret = func.insn_load(&result);
    let hundred = func.create_int_constant(100);
    let ret = func.insn_add(&ret, &hundred);
    func.insn_return(&ret);

    println!("{}", func.dump().unwrap());

    func.compile();
    println!("{}", func.dump().unwrap());
    context.build_end();


    let result: extern "C" fn(i32, i32) -> i32 = func.to_closure();
    println!("{} == 102", result(1,1));
    println!("{} == 101", result(3,2));
}

Additional examples can be found in:

• examples/abis.rs

pub fn alloca(&self, size: c_long) -> Value

Examples found in repository

examples/load_and_store.rs (line 12)

fn main() {
    let mut context = Context::new();
    context.build_start();

    let float_type = Context::sbyte_type();
    let params = vec![float_type];
    let mut func = context.function(Abi::Cdecl, float_type, params).unwrap();

    let x = func.arg(0).unwrap();
    let ptr1 = func.alloca(1);
    let ptr2 = func.alloca(8);

    let tag = func.create_sbyte_constant(111);
    let value = func.create_float64_constant(111.0);

    func.insn_store(&ptr1, &tag);
    func.insn_store(&ptr2, &value);

    let res1 = func.insn_load(&ptr1);
    let res2 = func.insn_load(&ptr2);

    let res= func.insn_add(&res1, &res2);


    func.insn_return(&res);
    println!("{}", func.dump().unwrap());
    func.compile();
    context.build_end();

    let result: extern "C" fn(f64) -> u8 = func.to_closure();
    println!("{}", result(0.23))
}

examples/branch_with_result.rs (line 12)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let i32_type = Context::int_type();
    let mut func = context.function(Abi::Cdecl, i32_type, vec![i32_type, i32_type]).unwrap();


    let result = func.alloca(4);

    let a = func.arg(0).unwrap();
    let b = func.arg(1).unwrap();
    let a_eq_b = func.insn_eq(&a, &b);
    let mut done_label = Label::new();
    let mut eq_label = Label::new();

    func.insn_branch_if(&a_eq_b, &mut eq_label);
    let a_minus_b = func.insn_sub(&a, &b);
    func.insn_store(&result, &a_minus_b);
    func.insn_branch(&mut done_label);
    func.insn_label(&mut eq_label);
    let a_plus_b = func.insn_add(&a, &b);
    func.insn_store(&result, &a_plus_b);
    func.insn_label(&mut done_label);
    let ret = func.insn_load(&result);
    let hundred = func.create_int_constant(100);
    let ret = func.insn_add(&ret, &hundred);
    func.insn_return(&ret);

    println!("{}", func.dump().unwrap());

    func.compile();
    println!("{}", func.dump().unwrap());
    context.build_end();


    let result: extern "C" fn(i32, i32) -> i32 = func.to_closure();
    println!("{} == 102", result(1,1));
    println!("{} == 101", result(3,2));
}

pub fn dump(&self) -> Result<String, Error>

Examples found in repository

examples/load_and_store.rs (line 28)

fn main() {
    let mut context = Context::new();
    context.build_start();

    let float_type = Context::sbyte_type();
    let params = vec![float_type];
    let mut func = context.function(Abi::Cdecl, float_type, params).unwrap();

    let x = func.arg(0).unwrap();
    let ptr1 = func.alloca(1);
    let ptr2 = func.alloca(8);

    let tag = func.create_sbyte_constant(111);
    let value = func.create_float64_constant(111.0);

    func.insn_store(&ptr1, &tag);
    func.insn_store(&ptr2, &value);

    let res1 = func.insn_load(&ptr1);
    let res2 = func.insn_load(&ptr2);

    let res= func.insn_add(&res1, &res2);


    func.insn_return(&res);
    println!("{}", func.dump().unwrap());
    func.compile();
    context.build_end();

    let result: extern "C" fn(f64) -> u8 = func.to_closure();
    println!("{}", result(0.23))
}

examples/branch_with_result.rs (line 33)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let i32_type = Context::int_type();
    let mut func = context.function(Abi::Cdecl, i32_type, vec![i32_type, i32_type]).unwrap();


    let result = func.alloca(4);

    let a = func.arg(0).unwrap();
    let b = func.arg(1).unwrap();
    let a_eq_b = func.insn_eq(&a, &b);
    let mut done_label = Label::new();
    let mut eq_label = Label::new();

    func.insn_branch_if(&a_eq_b, &mut eq_label);
    let a_minus_b = func.insn_sub(&a, &b);
    func.insn_store(&result, &a_minus_b);
    func.insn_branch(&mut done_label);
    func.insn_label(&mut eq_label);
    let a_plus_b = func.insn_add(&a, &b);
    func.insn_store(&result, &a_plus_b);
    func.insn_label(&mut done_label);
    let ret = func.insn_load(&result);
    let hundred = func.create_int_constant(100);
    let ret = func.insn_add(&ret, &hundred);
    func.insn_return(&ret);

    println!("{}", func.dump().unwrap());

    func.compile();
    println!("{}", func.dump().unwrap());
    context.build_end();


    let result: extern "C" fn(i32, i32) -> i32 = func.to_closure();
    println!("{} == 102", result(1,1));
    println!("{} == 101", result(3,2));
}

examples/abis.rs (line 48)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // INNER FUNC
    // Tried messing with this ABI but it really made no difference *shrug*
    let mut inner_func = context.function(Abi::VarArg   , Context::float64_type(), vec![Context::float64_type(), Context::float64_type()]).unwrap();
    let arg = inner_func.arg(0).unwrap();
    let arg2 = inner_func.arg(1).unwrap();
    let arg_plus_arg = inner_func.insn_add(&arg, &arg2);
    inner_func.insn_return(&arg_plus_arg);
    inner_func.compile();

    // DONE


    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![Context::float64_type()]).unwrap();
    let arg = func.arg(0).unwrap();
    let zero = func.create_int_constant(0);
    let one = func.create_int_constant(1);
    let hundred_k = func.create_int_constant(50_000_000);
    let i = func.create_value_int();
    let f = func.create_value_float64();
    let zero_f = func.create_float64_constant(0.0);
    func.insn_store(&i, &zero);
    func.insn_store(&f, &zero_f);
    let mut done_lbl = Label::new();
    let mut test_lbl = Label::new();
    func.insn_label(&mut test_lbl);

    let is_greater = func.insn_gt(&i, &hundred_k);
    func.insn_branch_if(&is_greater, &mut done_lbl);

    let load_i = func.insn_load(&i);
    let i_plus_1 = func.insn_add(&load_i, &one);
    func.insn_store(&i, &i_plus_1);

    let res = func.insn_call(&inner_func, vec![f.clone(), arg.clone()]);
    func.insn_store(&f, &res);
    func.insn_branch(&mut test_lbl);

    func.insn_label(&mut done_lbl);

    func.insn_return(&f);
    println!("func: {}", func.dump().unwrap());
    func.compile();
    println!("func: {}", func.dump().unwrap());


    context.build_end();



    let func: extern "C" fn(f64) -> f64 =  func.to_closure();
    let now = Instant::now();
    println!("{}", func(1.1));
    println!("Elapsed: {}ms", now.elapsed().as_millis());
}

pub fn to_closure<T>(&self) -> T

Examples found in repository

examples/mult2.rs (line 11)

fn main() {
    let mut context = Context::new();
    context.build_start();
    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![]).unwrap();
    let zero = func.create_float64_constant(0.0);
    func.insn_return(&zero);
    func.compile();
    context.build_end();
    let function: fn() -> f64  = func.to_closure();
    println!("{}", function());
}

examples/mult.rs (line 21)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let int_type = Context::int_type();
    let params = vec![int_type, int_type, int_type];
    let mut func = context.function(Abi::Cdecl, int_type, params).unwrap();

    let x = func.arg(0).unwrap();
    let y = func.arg(1).unwrap();
    let z = func.arg(2).unwrap();
    let temp1 = func.insn_mult(&x, &y);
    let temp2 = func.insn_add(&temp1, &z);
    func.insn_return(&temp2);
    func.compile();
    context.build_end();

    let result: extern "C" fn(i32,i32,i32) -> i32 = func.to_closure();
    println!("3*5+2 = {}", result(3,5,2))
}

examples/load_and_store.rs (line 32)

fn main() {
    let mut context = Context::new();
    context.build_start();

    let float_type = Context::sbyte_type();
    let params = vec![float_type];
    let mut func = context.function(Abi::Cdecl, float_type, params).unwrap();

    let x = func.arg(0).unwrap();
    let ptr1 = func.alloca(1);
    let ptr2 = func.alloca(8);

    let tag = func.create_sbyte_constant(111);
    let value = func.create_float64_constant(111.0);

    func.insn_store(&ptr1, &tag);
    func.insn_store(&ptr2, &value);

    let res1 = func.insn_load(&ptr1);
    let res2 = func.insn_load(&ptr2);

    let res= func.insn_add(&res1, &res2);


    func.insn_return(&res);
    println!("{}", func.dump().unwrap());
    func.compile();
    context.build_end();

    let result: extern "C" fn(f64) -> u8 = func.to_closure();
    println!("{}", result(0.23))
}

examples/branching.rs (line 26)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let float_type = Context::float64_type();
    let mut func = context.function(Abi::Cdecl, float_type, vec![float_type]).unwrap();

    // Return 1 if arg0 == 4
    // else return 0
    let is_four_result = func.create_float64_constant(1.0);
    let not_four_result = func.create_float64_constant(0.0);

    let x = func.arg(0).unwrap();
    let four = func.create_float64_constant(4.0);
    let mut label = Label::new();
    let eq_to_4 = func.insn_eq(&x, &four);
    func.insn_branch_if(&eq_to_4, &mut label);
    func.insn_return(&not_four_result);
    func.insn_label(&mut label);
    func.insn_return(&is_four_result);
    func.compile();
    context.build_end();
    let result: extern "C" fn(f64) -> f64 = func.to_closure();
    println!("{}", result(4.0));
}

examples/function_calls.rs (line 28)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // This function multiplies int by 2
    let int_type = Context::int_type();
    let mut func_mult_by_2 = context.function(Abi::Cdecl, int_type, vec![int_type]).unwrap();
    let x = func_mult_by_2.arg(0).unwrap();
    let const_1 = func_mult_by_2.create_int_constant(2);
    let temp1 = func_mult_by_2.insn_mult(&x, &const_1);
    func_mult_by_2.insn_return(&temp1);
    func_mult_by_2.compile();

    // This main function has 1 arg, it adds 5 to the arg and calls func_mult_by_2 and returns that value.
    let mut func = context.function(Abi::Cdecl, int_type, vec![int_type]).unwrap();
    let arg0 = func.arg(0).unwrap();
    let five = func.create_int_constant(5);
    let arg0_plus_5 = func.insn_add(&arg0, &five);
    let res = func.insn_call(&func_mult_by_2, vec![arg0_plus_5]);
    func.insn_return(&res);
    func.compile();

    context.build_end();

    let result: extern "C" fn(i32) -> i32 = func.to_closure();
    println!("(100+5)*2 == {}", result(100))
}

examples/branch_with_result.rs (line 40)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let i32_type = Context::int_type();
    let mut func = context.function(Abi::Cdecl, i32_type, vec![i32_type, i32_type]).unwrap();


    let result = func.alloca(4);

    let a = func.arg(0).unwrap();
    let b = func.arg(1).unwrap();
    let a_eq_b = func.insn_eq(&a, &b);
    let mut done_label = Label::new();
    let mut eq_label = Label::new();

    func.insn_branch_if(&a_eq_b, &mut eq_label);
    let a_minus_b = func.insn_sub(&a, &b);
    func.insn_store(&result, &a_minus_b);
    func.insn_branch(&mut done_label);
    func.insn_label(&mut eq_label);
    let a_plus_b = func.insn_add(&a, &b);
    func.insn_store(&result, &a_plus_b);
    func.insn_label(&mut done_label);
    let ret = func.insn_load(&result);
    let hundred = func.create_int_constant(100);
    let ret = func.insn_add(&ret, &hundred);
    func.insn_return(&ret);

    println!("{}", func.dump().unwrap());

    func.compile();
    println!("{}", func.dump().unwrap());
    context.build_end();


    let result: extern "C" fn(i32, i32) -> i32 = func.to_closure();
    println!("{} == 102", result(1,1));
    println!("{} == 101", result(3,2));
}

Additional examples can be found in:

• examples/abis.rs

pub fn insn_call_native( &self, native_func: *mut c_void, params: Vec<Value>, return_type: Option<JitType>, ) -> Value

pub fn arg(&self, idx: i32) -> Result<Value, Exception>

Examples found in repository

examples/mult.rs (line 12)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let int_type = Context::int_type();
    let params = vec![int_type, int_type, int_type];
    let mut func = context.function(Abi::Cdecl, int_type, params).unwrap();

    let x = func.arg(0).unwrap();
    let y = func.arg(1).unwrap();
    let z = func.arg(2).unwrap();
    let temp1 = func.insn_mult(&x, &y);
    let temp2 = func.insn_add(&temp1, &z);
    func.insn_return(&temp2);
    func.compile();
    context.build_end();

    let result: extern "C" fn(i32,i32,i32) -> i32 = func.to_closure();
    println!("3*5+2 = {}", result(3,5,2))
}

examples/load_and_store.rs (line 11)

fn main() {
    let mut context = Context::new();
    context.build_start();

    let float_type = Context::sbyte_type();
    let params = vec![float_type];
    let mut func = context.function(Abi::Cdecl, float_type, params).unwrap();

    let x = func.arg(0).unwrap();
    let ptr1 = func.alloca(1);
    let ptr2 = func.alloca(8);

    let tag = func.create_sbyte_constant(111);
    let value = func.create_float64_constant(111.0);

    func.insn_store(&ptr1, &tag);
    func.insn_store(&ptr2, &value);

    let res1 = func.insn_load(&ptr1);
    let res2 = func.insn_load(&ptr2);

    let res= func.insn_add(&res1, &res2);


    func.insn_return(&res);
    println!("{}", func.dump().unwrap());
    func.compile();
    context.build_end();

    let result: extern "C" fn(f64) -> u8 = func.to_closure();
    println!("{}", result(0.23))
}

examples/branching.rs (line 16)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let float_type = Context::float64_type();
    let mut func = context.function(Abi::Cdecl, float_type, vec![float_type]).unwrap();

    // Return 1 if arg0 == 4
    // else return 0
    let is_four_result = func.create_float64_constant(1.0);
    let not_four_result = func.create_float64_constant(0.0);

    let x = func.arg(0).unwrap();
    let four = func.create_float64_constant(4.0);
    let mut label = Label::new();
    let eq_to_4 = func.insn_eq(&x, &four);
    func.insn_branch_if(&eq_to_4, &mut label);
    func.insn_return(&not_four_result);
    func.insn_label(&mut label);
    func.insn_return(&is_four_result);
    func.compile();
    context.build_end();
    let result: extern "C" fn(f64) -> f64 = func.to_closure();
    println!("{}", result(4.0));
}

examples/function_calls.rs (line 11)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // This function multiplies int by 2
    let int_type = Context::int_type();
    let mut func_mult_by_2 = context.function(Abi::Cdecl, int_type, vec![int_type]).unwrap();
    let x = func_mult_by_2.arg(0).unwrap();
    let const_1 = func_mult_by_2.create_int_constant(2);
    let temp1 = func_mult_by_2.insn_mult(&x, &const_1);
    func_mult_by_2.insn_return(&temp1);
    func_mult_by_2.compile();

    // This main function has 1 arg, it adds 5 to the arg and calls func_mult_by_2 and returns that value.
    let mut func = context.function(Abi::Cdecl, int_type, vec![int_type]).unwrap();
    let arg0 = func.arg(0).unwrap();
    let five = func.create_int_constant(5);
    let arg0_plus_5 = func.insn_add(&arg0, &five);
    let res = func.insn_call(&func_mult_by_2, vec![arg0_plus_5]);
    func.insn_return(&res);
    func.compile();

    context.build_end();

    let result: extern "C" fn(i32) -> i32 = func.to_closure();
    println!("(100+5)*2 == {}", result(100))
}

examples/branch_with_result.rs (line 14)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let i32_type = Context::int_type();
    let mut func = context.function(Abi::Cdecl, i32_type, vec![i32_type, i32_type]).unwrap();


    let result = func.alloca(4);

    let a = func.arg(0).unwrap();
    let b = func.arg(1).unwrap();
    let a_eq_b = func.insn_eq(&a, &b);
    let mut done_label = Label::new();
    let mut eq_label = Label::new();

    func.insn_branch_if(&a_eq_b, &mut eq_label);
    let a_minus_b = func.insn_sub(&a, &b);
    func.insn_store(&result, &a_minus_b);
    func.insn_branch(&mut done_label);
    func.insn_label(&mut eq_label);
    let a_plus_b = func.insn_add(&a, &b);
    func.insn_store(&result, &a_plus_b);
    func.insn_label(&mut done_label);
    let ret = func.insn_load(&result);
    let hundred = func.create_int_constant(100);
    let ret = func.insn_add(&ret, &hundred);
    func.insn_return(&ret);

    println!("{}", func.dump().unwrap());

    func.compile();
    println!("{}", func.dump().unwrap());
    context.build_end();


    let result: extern "C" fn(i32, i32) -> i32 = func.to_closure();
    println!("{} == 102", result(1,1));
    println!("{} == 101", result(3,2));
}

examples/abis.rs (line 11)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // INNER FUNC
    // Tried messing with this ABI but it really made no difference *shrug*
    let mut inner_func = context.function(Abi::VarArg   , Context::float64_type(), vec![Context::float64_type(), Context::float64_type()]).unwrap();
    let arg = inner_func.arg(0).unwrap();
    let arg2 = inner_func.arg(1).unwrap();
    let arg_plus_arg = inner_func.insn_add(&arg, &arg2);
    inner_func.insn_return(&arg_plus_arg);
    inner_func.compile();

    // DONE


    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![Context::float64_type()]).unwrap();
    let arg = func.arg(0).unwrap();
    let zero = func.create_int_constant(0);
    let one = func.create_int_constant(1);
    let hundred_k = func.create_int_constant(50_000_000);
    let i = func.create_value_int();
    let f = func.create_value_float64();
    let zero_f = func.create_float64_constant(0.0);
    func.insn_store(&i, &zero);
    func.insn_store(&f, &zero_f);
    let mut done_lbl = Label::new();
    let mut test_lbl = Label::new();
    func.insn_label(&mut test_lbl);

    let is_greater = func.insn_gt(&i, &hundred_k);
    func.insn_branch_if(&is_greater, &mut done_lbl);

    let load_i = func.insn_load(&i);
    let i_plus_1 = func.insn_add(&load_i, &one);
    func.insn_store(&i, &i_plus_1);

    let res = func.insn_call(&inner_func, vec![f.clone(), arg.clone()]);
    func.insn_store(&f, &res);
    func.insn_branch(&mut test_lbl);

    func.insn_label(&mut done_lbl);

    func.insn_return(&f);
    println!("func: {}", func.dump().unwrap());
    func.compile();
    println!("func: {}", func.dump().unwrap());


    context.build_end();



    let func: extern "C" fn(f64) -> f64 =  func.to_closure();
    let now = Instant::now();
    println!("{}", func(1.1));
    println!("Elapsed: {}ms", now.elapsed().as_millis());
}

pub fn insn_mult(&mut self, left: &Value, right: &Value) -> Value

Examples found in repository

examples/mult.rs (line 15)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let int_type = Context::int_type();
    let params = vec![int_type, int_type, int_type];
    let mut func = context.function(Abi::Cdecl, int_type, params).unwrap();

    let x = func.arg(0).unwrap();
    let y = func.arg(1).unwrap();
    let z = func.arg(2).unwrap();
    let temp1 = func.insn_mult(&x, &y);
    let temp2 = func.insn_add(&temp1, &z);
    func.insn_return(&temp2);
    func.compile();
    context.build_end();

    let result: extern "C" fn(i32,i32,i32) -> i32 = func.to_closure();
    println!("3*5+2 = {}", result(3,5,2))
}

examples/function_calls.rs (line 13)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // This function multiplies int by 2
    let int_type = Context::int_type();
    let mut func_mult_by_2 = context.function(Abi::Cdecl, int_type, vec![int_type]).unwrap();
    let x = func_mult_by_2.arg(0).unwrap();
    let const_1 = func_mult_by_2.create_int_constant(2);
    let temp1 = func_mult_by_2.insn_mult(&x, &const_1);
    func_mult_by_2.insn_return(&temp1);
    func_mult_by_2.compile();

    // This main function has 1 arg, it adds 5 to the arg and calls func_mult_by_2 and returns that value.
    let mut func = context.function(Abi::Cdecl, int_type, vec![int_type]).unwrap();
    let arg0 = func.arg(0).unwrap();
    let five = func.create_int_constant(5);
    let arg0_plus_5 = func.insn_add(&arg0, &five);
    let res = func.insn_call(&func_mult_by_2, vec![arg0_plus_5]);
    func.insn_return(&res);
    func.compile();

    context.build_end();

    let result: extern "C" fn(i32) -> i32 = func.to_closure();
    println!("(100+5)*2 == {}", result(100))
}

pub fn insn_add(&mut self, left: &Value, right: &Value) -> Value

Examples found in repository

examples/mult.rs (line 16)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let int_type = Context::int_type();
    let params = vec![int_type, int_type, int_type];
    let mut func = context.function(Abi::Cdecl, int_type, params).unwrap();

    let x = func.arg(0).unwrap();
    let y = func.arg(1).unwrap();
    let z = func.arg(2).unwrap();
    let temp1 = func.insn_mult(&x, &y);
    let temp2 = func.insn_add(&temp1, &z);
    func.insn_return(&temp2);
    func.compile();
    context.build_end();

    let result: extern "C" fn(i32,i32,i32) -> i32 = func.to_closure();
    println!("3*5+2 = {}", result(3,5,2))
}

examples/load_and_store.rs (line 24)

fn main() {
    let mut context = Context::new();
    context.build_start();

    let float_type = Context::sbyte_type();
    let params = vec![float_type];
    let mut func = context.function(Abi::Cdecl, float_type, params).unwrap();

    let x = func.arg(0).unwrap();
    let ptr1 = func.alloca(1);
    let ptr2 = func.alloca(8);

    let tag = func.create_sbyte_constant(111);
    let value = func.create_float64_constant(111.0);

    func.insn_store(&ptr1, &tag);
    func.insn_store(&ptr2, &value);

    let res1 = func.insn_load(&ptr1);
    let res2 = func.insn_load(&ptr2);

    let res= func.insn_add(&res1, &res2);


    func.insn_return(&res);
    println!("{}", func.dump().unwrap());
    func.compile();
    context.build_end();

    let result: extern "C" fn(f64) -> u8 = func.to_closure();
    println!("{}", result(0.23))
}

examples/function_calls.rs (line 21)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // This function multiplies int by 2
    let int_type = Context::int_type();
    let mut func_mult_by_2 = context.function(Abi::Cdecl, int_type, vec![int_type]).unwrap();
    let x = func_mult_by_2.arg(0).unwrap();
    let const_1 = func_mult_by_2.create_int_constant(2);
    let temp1 = func_mult_by_2.insn_mult(&x, &const_1);
    func_mult_by_2.insn_return(&temp1);
    func_mult_by_2.compile();

    // This main function has 1 arg, it adds 5 to the arg and calls func_mult_by_2 and returns that value.
    let mut func = context.function(Abi::Cdecl, int_type, vec![int_type]).unwrap();
    let arg0 = func.arg(0).unwrap();
    let five = func.create_int_constant(5);
    let arg0_plus_5 = func.insn_add(&arg0, &five);
    let res = func.insn_call(&func_mult_by_2, vec![arg0_plus_5]);
    func.insn_return(&res);
    func.compile();

    context.build_end();

    let result: extern "C" fn(i32) -> i32 = func.to_closure();
    println!("(100+5)*2 == {}", result(100))
}

examples/branch_with_result.rs (line 25)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let i32_type = Context::int_type();
    let mut func = context.function(Abi::Cdecl, i32_type, vec![i32_type, i32_type]).unwrap();


    let result = func.alloca(4);

    let a = func.arg(0).unwrap();
    let b = func.arg(1).unwrap();
    let a_eq_b = func.insn_eq(&a, &b);
    let mut done_label = Label::new();
    let mut eq_label = Label::new();

    func.insn_branch_if(&a_eq_b, &mut eq_label);
    let a_minus_b = func.insn_sub(&a, &b);
    func.insn_store(&result, &a_minus_b);
    func.insn_branch(&mut done_label);
    func.insn_label(&mut eq_label);
    let a_plus_b = func.insn_add(&a, &b);
    func.insn_store(&result, &a_plus_b);
    func.insn_label(&mut done_label);
    let ret = func.insn_load(&result);
    let hundred = func.create_int_constant(100);
    let ret = func.insn_add(&ret, &hundred);
    func.insn_return(&ret);

    println!("{}", func.dump().unwrap());

    func.compile();
    println!("{}", func.dump().unwrap());
    context.build_end();


    let result: extern "C" fn(i32, i32) -> i32 = func.to_closure();
    println!("{} == 102", result(1,1));
    println!("{} == 101", result(3,2));
}

examples/abis.rs (line 13)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // INNER FUNC
    // Tried messing with this ABI but it really made no difference *shrug*
    let mut inner_func = context.function(Abi::VarArg   , Context::float64_type(), vec![Context::float64_type(), Context::float64_type()]).unwrap();
    let arg = inner_func.arg(0).unwrap();
    let arg2 = inner_func.arg(1).unwrap();
    let arg_plus_arg = inner_func.insn_add(&arg, &arg2);
    inner_func.insn_return(&arg_plus_arg);
    inner_func.compile();

    // DONE


    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![Context::float64_type()]).unwrap();
    let arg = func.arg(0).unwrap();
    let zero = func.create_int_constant(0);
    let one = func.create_int_constant(1);
    let hundred_k = func.create_int_constant(50_000_000);
    let i = func.create_value_int();
    let f = func.create_value_float64();
    let zero_f = func.create_float64_constant(0.0);
    func.insn_store(&i, &zero);
    func.insn_store(&f, &zero_f);
    let mut done_lbl = Label::new();
    let mut test_lbl = Label::new();
    func.insn_label(&mut test_lbl);

    let is_greater = func.insn_gt(&i, &hundred_k);
    func.insn_branch_if(&is_greater, &mut done_lbl);

    let load_i = func.insn_load(&i);
    let i_plus_1 = func.insn_add(&load_i, &one);
    func.insn_store(&i, &i_plus_1);

    let res = func.insn_call(&inner_func, vec![f.clone(), arg.clone()]);
    func.insn_store(&f, &res);
    func.insn_branch(&mut test_lbl);

    func.insn_label(&mut done_lbl);

    func.insn_return(&f);
    println!("func: {}", func.dump().unwrap());
    func.compile();
    println!("func: {}", func.dump().unwrap());


    context.build_end();



    let func: extern "C" fn(f64) -> f64 =  func.to_closure();
    let now = Instant::now();
    println!("{}", func(1.1));
    println!("Elapsed: {}ms", now.elapsed().as_millis());
}

pub fn insn_pow(&mut self, left: &Value, right: &Value) -> Value

pub fn insn_rem(&mut self, left: &Value, right: &Value) -> Value

pub fn insn_div(&mut self, left: &Value, right: &Value) -> Value

pub fn insn_sub(&mut self, left: &Value, right: &Value) -> Value

Examples found in repository

examples/branch_with_result.rs (line 21)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let i32_type = Context::int_type();
    let mut func = context.function(Abi::Cdecl, i32_type, vec![i32_type, i32_type]).unwrap();


    let result = func.alloca(4);

    let a = func.arg(0).unwrap();
    let b = func.arg(1).unwrap();
    let a_eq_b = func.insn_eq(&a, &b);
    let mut done_label = Label::new();
    let mut eq_label = Label::new();

    func.insn_branch_if(&a_eq_b, &mut eq_label);
    let a_minus_b = func.insn_sub(&a, &b);
    func.insn_store(&result, &a_minus_b);
    func.insn_branch(&mut done_label);
    func.insn_label(&mut eq_label);
    let a_plus_b = func.insn_add(&a, &b);
    func.insn_store(&result, &a_plus_b);
    func.insn_label(&mut done_label);
    let ret = func.insn_load(&result);
    let hundred = func.create_int_constant(100);
    let ret = func.insn_add(&ret, &hundred);
    func.insn_return(&ret);

    println!("{}", func.dump().unwrap());

    func.compile();
    println!("{}", func.dump().unwrap());
    context.build_end();


    let result: extern "C" fn(i32, i32) -> i32 = func.to_closure();
    println!("{} == 102", result(1,1));
    println!("{} == 101", result(3,2));
}

pub fn insn_eq(&mut self, left: &Value, right: &Value) -> Value

Examples found in repository

examples/branching.rs (line 19)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let float_type = Context::float64_type();
    let mut func = context.function(Abi::Cdecl, float_type, vec![float_type]).unwrap();

    // Return 1 if arg0 == 4
    // else return 0
    let is_four_result = func.create_float64_constant(1.0);
    let not_four_result = func.create_float64_constant(0.0);

    let x = func.arg(0).unwrap();
    let four = func.create_float64_constant(4.0);
    let mut label = Label::new();
    let eq_to_4 = func.insn_eq(&x, &four);
    func.insn_branch_if(&eq_to_4, &mut label);
    func.insn_return(&not_four_result);
    func.insn_label(&mut label);
    func.insn_return(&is_four_result);
    func.compile();
    context.build_end();
    let result: extern "C" fn(f64) -> f64 = func.to_closure();
    println!("{}", result(4.0));
}

examples/branch_with_result.rs (line 16)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let i32_type = Context::int_type();
    let mut func = context.function(Abi::Cdecl, i32_type, vec![i32_type, i32_type]).unwrap();


    let result = func.alloca(4);

    let a = func.arg(0).unwrap();
    let b = func.arg(1).unwrap();
    let a_eq_b = func.insn_eq(&a, &b);
    let mut done_label = Label::new();
    let mut eq_label = Label::new();

    func.insn_branch_if(&a_eq_b, &mut eq_label);
    let a_minus_b = func.insn_sub(&a, &b);
    func.insn_store(&result, &a_minus_b);
    func.insn_branch(&mut done_label);
    func.insn_label(&mut eq_label);
    let a_plus_b = func.insn_add(&a, &b);
    func.insn_store(&result, &a_plus_b);
    func.insn_label(&mut done_label);
    let ret = func.insn_load(&result);
    let hundred = func.create_int_constant(100);
    let ret = func.insn_add(&ret, &hundred);
    func.insn_return(&ret);

    println!("{}", func.dump().unwrap());

    func.compile();
    println!("{}", func.dump().unwrap());
    context.build_end();


    let result: extern "C" fn(i32, i32) -> i32 = func.to_closure();
    println!("{} == 102", result(1,1));
    println!("{} == 101", result(3,2));
}

pub fn insn_and(&mut self, left: &Value, right: &Value) -> Value

pub fn insn_or(&mut self, left: &Value, right: &Value) -> Value

pub fn insn_xor(&mut self, left: &Value, right: &Value) -> Value

pub fn insn_le(&mut self, left: &Value, right: &Value) -> Value

pub fn insn_lt(&mut self, left: &Value, right: &Value) -> Value

pub fn insn_ge(&mut self, left: &Value, right: &Value) -> Value

pub fn insn_gt(&mut self, left: &Value, right: &Value) -> Value

Examples found in repository

examples/abis.rs (line 34)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // INNER FUNC
    // Tried messing with this ABI but it really made no difference *shrug*
    let mut inner_func = context.function(Abi::VarArg   , Context::float64_type(), vec![Context::float64_type(), Context::float64_type()]).unwrap();
    let arg = inner_func.arg(0).unwrap();
    let arg2 = inner_func.arg(1).unwrap();
    let arg_plus_arg = inner_func.insn_add(&arg, &arg2);
    inner_func.insn_return(&arg_plus_arg);
    inner_func.compile();

    // DONE


    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![Context::float64_type()]).unwrap();
    let arg = func.arg(0).unwrap();
    let zero = func.create_int_constant(0);
    let one = func.create_int_constant(1);
    let hundred_k = func.create_int_constant(50_000_000);
    let i = func.create_value_int();
    let f = func.create_value_float64();
    let zero_f = func.create_float64_constant(0.0);
    func.insn_store(&i, &zero);
    func.insn_store(&f, &zero_f);
    let mut done_lbl = Label::new();
    let mut test_lbl = Label::new();
    func.insn_label(&mut test_lbl);

    let is_greater = func.insn_gt(&i, &hundred_k);
    func.insn_branch_if(&is_greater, &mut done_lbl);

    let load_i = func.insn_load(&i);
    let i_plus_1 = func.insn_add(&load_i, &one);
    func.insn_store(&i, &i_plus_1);

    let res = func.insn_call(&inner_func, vec![f.clone(), arg.clone()]);
    func.insn_store(&f, &res);
    func.insn_branch(&mut test_lbl);

    func.insn_label(&mut done_lbl);

    func.insn_return(&f);
    println!("func: {}", func.dump().unwrap());
    func.compile();
    println!("func: {}", func.dump().unwrap());


    context.build_end();



    let func: extern "C" fn(f64) -> f64 =  func.to_closure();
    let now = Instant::now();
    println!("{}", func(1.1));
    println!("Elapsed: {}ms", now.elapsed().as_millis());
}

pub fn insn_ne(&mut self, left: &Value, right: &Value) -> Value

pub fn insn_acos(&mut self, value: &Value) -> Value

pub fn insn_asin(&mut self, value: &Value) -> Value

pub fn insn_atan(&mut self, value: &Value) -> Value

pub fn insn_cos(&mut self, value: &Value) -> Value

pub fn insn_cosh(&mut self, value: &Value) -> Value

pub fn insn_exp(&mut self, value: &Value) -> Value

pub fn insn_log(&mut self, value: &Value) -> Value

pub fn insn_log10(&mut self, value: &Value) -> Value

pub fn insn_sin(&mut self, value: &Value) -> Value

pub fn insn_sinh(&mut self, value: &Value) -> Value

pub fn insn_sqrt(&mut self, value: &Value) -> Value

pub fn insn_tan(&mut self, value: &Value) -> Value

pub fn insn_tanh(&mut self, value: &Value) -> Value

pub fn insn_return(&mut self, value: &Value)

Examples found in repository

examples/mult2.rs (line 8)

fn main() {
    let mut context = Context::new();
    context.build_start();
    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![]).unwrap();
    let zero = func.create_float64_constant(0.0);
    func.insn_return(&zero);
    func.compile();
    context.build_end();
    let function: fn() -> f64  = func.to_closure();
    println!("{}", function());
}

examples/mult.rs (line 17)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let int_type = Context::int_type();
    let params = vec![int_type, int_type, int_type];
    let mut func = context.function(Abi::Cdecl, int_type, params).unwrap();

    let x = func.arg(0).unwrap();
    let y = func.arg(1).unwrap();
    let z = func.arg(2).unwrap();
    let temp1 = func.insn_mult(&x, &y);
    let temp2 = func.insn_add(&temp1, &z);
    func.insn_return(&temp2);
    func.compile();
    context.build_end();

    let result: extern "C" fn(i32,i32,i32) -> i32 = func.to_closure();
    println!("3*5+2 = {}", result(3,5,2))
}

examples/load_and_store.rs (line 27)

fn main() {
    let mut context = Context::new();
    context.build_start();

    let float_type = Context::sbyte_type();
    let params = vec![float_type];
    let mut func = context.function(Abi::Cdecl, float_type, params).unwrap();

    let x = func.arg(0).unwrap();
    let ptr1 = func.alloca(1);
    let ptr2 = func.alloca(8);

    let tag = func.create_sbyte_constant(111);
    let value = func.create_float64_constant(111.0);

    func.insn_store(&ptr1, &tag);
    func.insn_store(&ptr2, &value);

    let res1 = func.insn_load(&ptr1);
    let res2 = func.insn_load(&ptr2);

    let res= func.insn_add(&res1, &res2);


    func.insn_return(&res);
    println!("{}", func.dump().unwrap());
    func.compile();
    context.build_end();

    let result: extern "C" fn(f64) -> u8 = func.to_closure();
    println!("{}", result(0.23))
}

examples/branching.rs (line 21)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let float_type = Context::float64_type();
    let mut func = context.function(Abi::Cdecl, float_type, vec![float_type]).unwrap();

    // Return 1 if arg0 == 4
    // else return 0
    let is_four_result = func.create_float64_constant(1.0);
    let not_four_result = func.create_float64_constant(0.0);

    let x = func.arg(0).unwrap();
    let four = func.create_float64_constant(4.0);
    let mut label = Label::new();
    let eq_to_4 = func.insn_eq(&x, &four);
    func.insn_branch_if(&eq_to_4, &mut label);
    func.insn_return(&not_four_result);
    func.insn_label(&mut label);
    func.insn_return(&is_four_result);
    func.compile();
    context.build_end();
    let result: extern "C" fn(f64) -> f64 = func.to_closure();
    println!("{}", result(4.0));
}

examples/function_calls.rs (line 14)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // This function multiplies int by 2
    let int_type = Context::int_type();
    let mut func_mult_by_2 = context.function(Abi::Cdecl, int_type, vec![int_type]).unwrap();
    let x = func_mult_by_2.arg(0).unwrap();
    let const_1 = func_mult_by_2.create_int_constant(2);
    let temp1 = func_mult_by_2.insn_mult(&x, &const_1);
    func_mult_by_2.insn_return(&temp1);
    func_mult_by_2.compile();

    // This main function has 1 arg, it adds 5 to the arg and calls func_mult_by_2 and returns that value.
    let mut func = context.function(Abi::Cdecl, int_type, vec![int_type]).unwrap();
    let arg0 = func.arg(0).unwrap();
    let five = func.create_int_constant(5);
    let arg0_plus_5 = func.insn_add(&arg0, &five);
    let res = func.insn_call(&func_mult_by_2, vec![arg0_plus_5]);
    func.insn_return(&res);
    func.compile();

    context.build_end();

    let result: extern "C" fn(i32) -> i32 = func.to_closure();
    println!("(100+5)*2 == {}", result(100))
}

examples/branch_with_result.rs (line 31)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let i32_type = Context::int_type();
    let mut func = context.function(Abi::Cdecl, i32_type, vec![i32_type, i32_type]).unwrap();


    let result = func.alloca(4);

    let a = func.arg(0).unwrap();
    let b = func.arg(1).unwrap();
    let a_eq_b = func.insn_eq(&a, &b);
    let mut done_label = Label::new();
    let mut eq_label = Label::new();

    func.insn_branch_if(&a_eq_b, &mut eq_label);
    let a_minus_b = func.insn_sub(&a, &b);
    func.insn_store(&result, &a_minus_b);
    func.insn_branch(&mut done_label);
    func.insn_label(&mut eq_label);
    let a_plus_b = func.insn_add(&a, &b);
    func.insn_store(&result, &a_plus_b);
    func.insn_label(&mut done_label);
    let ret = func.insn_load(&result);
    let hundred = func.create_int_constant(100);
    let ret = func.insn_add(&ret, &hundred);
    func.insn_return(&ret);

    println!("{}", func.dump().unwrap());

    func.compile();
    println!("{}", func.dump().unwrap());
    context.build_end();


    let result: extern "C" fn(i32, i32) -> i32 = func.to_closure();
    println!("{} == 102", result(1,1));
    println!("{} == 101", result(3,2));
}

Additional examples can be found in:

• examples/abis.rs

pub fn insn_not(&mut self, value: &Value) -> Value

pub fn insn_branch(&self, label: &mut Label)

Examples found in repository

examples/branch_with_result.rs (line 23)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let i32_type = Context::int_type();
    let mut func = context.function(Abi::Cdecl, i32_type, vec![i32_type, i32_type]).unwrap();


    let result = func.alloca(4);

    let a = func.arg(0).unwrap();
    let b = func.arg(1).unwrap();
    let a_eq_b = func.insn_eq(&a, &b);
    let mut done_label = Label::new();
    let mut eq_label = Label::new();

    func.insn_branch_if(&a_eq_b, &mut eq_label);
    let a_minus_b = func.insn_sub(&a, &b);
    func.insn_store(&result, &a_minus_b);
    func.insn_branch(&mut done_label);
    func.insn_label(&mut eq_label);
    let a_plus_b = func.insn_add(&a, &b);
    func.insn_store(&result, &a_plus_b);
    func.insn_label(&mut done_label);
    let ret = func.insn_load(&result);
    let hundred = func.create_int_constant(100);
    let ret = func.insn_add(&ret, &hundred);
    func.insn_return(&ret);

    println!("{}", func.dump().unwrap());

    func.compile();
    println!("{}", func.dump().unwrap());
    context.build_end();


    let result: extern "C" fn(i32, i32) -> i32 = func.to_closure();
    println!("{} == 102", result(1,1));
    println!("{} == 101", result(3,2));
}

examples/abis.rs (line 43)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // INNER FUNC
    // Tried messing with this ABI but it really made no difference *shrug*
    let mut inner_func = context.function(Abi::VarArg   , Context::float64_type(), vec![Context::float64_type(), Context::float64_type()]).unwrap();
    let arg = inner_func.arg(0).unwrap();
    let arg2 = inner_func.arg(1).unwrap();
    let arg_plus_arg = inner_func.insn_add(&arg, &arg2);
    inner_func.insn_return(&arg_plus_arg);
    inner_func.compile();

    // DONE


    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![Context::float64_type()]).unwrap();
    let arg = func.arg(0).unwrap();
    let zero = func.create_int_constant(0);
    let one = func.create_int_constant(1);
    let hundred_k = func.create_int_constant(50_000_000);
    let i = func.create_value_int();
    let f = func.create_value_float64();
    let zero_f = func.create_float64_constant(0.0);
    func.insn_store(&i, &zero);
    func.insn_store(&f, &zero_f);
    let mut done_lbl = Label::new();
    let mut test_lbl = Label::new();
    func.insn_label(&mut test_lbl);

    let is_greater = func.insn_gt(&i, &hundred_k);
    func.insn_branch_if(&is_greater, &mut done_lbl);

    let load_i = func.insn_load(&i);
    let i_plus_1 = func.insn_add(&load_i, &one);
    func.insn_store(&i, &i_plus_1);

    let res = func.insn_call(&inner_func, vec![f.clone(), arg.clone()]);
    func.insn_store(&f, &res);
    func.insn_branch(&mut test_lbl);

    func.insn_label(&mut done_lbl);

    func.insn_return(&f);
    println!("func: {}", func.dump().unwrap());
    func.compile();
    println!("func: {}", func.dump().unwrap());


    context.build_end();



    let func: extern "C" fn(f64) -> f64 =  func.to_closure();
    let now = Instant::now();
    println!("{}", func(1.1));
    println!("Elapsed: {}ms", now.elapsed().as_millis());
}

pub fn insn_branch_if(&self, value: &Value, label: &mut Label)

Examples found in repository

examples/branching.rs (line 20)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let float_type = Context::float64_type();
    let mut func = context.function(Abi::Cdecl, float_type, vec![float_type]).unwrap();

    // Return 1 if arg0 == 4
    // else return 0
    let is_four_result = func.create_float64_constant(1.0);
    let not_four_result = func.create_float64_constant(0.0);

    let x = func.arg(0).unwrap();
    let four = func.create_float64_constant(4.0);
    let mut label = Label::new();
    let eq_to_4 = func.insn_eq(&x, &four);
    func.insn_branch_if(&eq_to_4, &mut label);
    func.insn_return(&not_four_result);
    func.insn_label(&mut label);
    func.insn_return(&is_four_result);
    func.compile();
    context.build_end();
    let result: extern "C" fn(f64) -> f64 = func.to_closure();
    println!("{}", result(4.0));
}

examples/branch_with_result.rs (line 20)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let i32_type = Context::int_type();
    let mut func = context.function(Abi::Cdecl, i32_type, vec![i32_type, i32_type]).unwrap();


    let result = func.alloca(4);

    let a = func.arg(0).unwrap();
    let b = func.arg(1).unwrap();
    let a_eq_b = func.insn_eq(&a, &b);
    let mut done_label = Label::new();
    let mut eq_label = Label::new();

    func.insn_branch_if(&a_eq_b, &mut eq_label);
    let a_minus_b = func.insn_sub(&a, &b);
    func.insn_store(&result, &a_minus_b);
    func.insn_branch(&mut done_label);
    func.insn_label(&mut eq_label);
    let a_plus_b = func.insn_add(&a, &b);
    func.insn_store(&result, &a_plus_b);
    func.insn_label(&mut done_label);
    let ret = func.insn_load(&result);
    let hundred = func.create_int_constant(100);
    let ret = func.insn_add(&ret, &hundred);
    func.insn_return(&ret);

    println!("{}", func.dump().unwrap());

    func.compile();
    println!("{}", func.dump().unwrap());
    context.build_end();


    let result: extern "C" fn(i32, i32) -> i32 = func.to_closure();
    println!("{} == 102", result(1,1));
    println!("{} == 101", result(3,2));
}

examples/abis.rs (line 35)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // INNER FUNC
    // Tried messing with this ABI but it really made no difference *shrug*
    let mut inner_func = context.function(Abi::VarArg   , Context::float64_type(), vec![Context::float64_type(), Context::float64_type()]).unwrap();
    let arg = inner_func.arg(0).unwrap();
    let arg2 = inner_func.arg(1).unwrap();
    let arg_plus_arg = inner_func.insn_add(&arg, &arg2);
    inner_func.insn_return(&arg_plus_arg);
    inner_func.compile();

    // DONE


    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![Context::float64_type()]).unwrap();
    let arg = func.arg(0).unwrap();
    let zero = func.create_int_constant(0);
    let one = func.create_int_constant(1);
    let hundred_k = func.create_int_constant(50_000_000);
    let i = func.create_value_int();
    let f = func.create_value_float64();
    let zero_f = func.create_float64_constant(0.0);
    func.insn_store(&i, &zero);
    func.insn_store(&f, &zero_f);
    let mut done_lbl = Label::new();
    let mut test_lbl = Label::new();
    func.insn_label(&mut test_lbl);

    let is_greater = func.insn_gt(&i, &hundred_k);
    func.insn_branch_if(&is_greater, &mut done_lbl);

    let load_i = func.insn_load(&i);
    let i_plus_1 = func.insn_add(&load_i, &one);
    func.insn_store(&i, &i_plus_1);

    let res = func.insn_call(&inner_func, vec![f.clone(), arg.clone()]);
    func.insn_store(&f, &res);
    func.insn_branch(&mut test_lbl);

    func.insn_label(&mut done_lbl);

    func.insn_return(&f);
    println!("func: {}", func.dump().unwrap());
    func.compile();
    println!("func: {}", func.dump().unwrap());


    context.build_end();



    let func: extern "C" fn(f64) -> f64 =  func.to_closure();
    let now = Instant::now();
    println!("{}", func(1.1));
    println!("Elapsed: {}ms", now.elapsed().as_millis());
}

pub fn insn_branch_if_not(&self, value: &Value, label: &mut Label)

pub fn insn_load(&mut self, ptr: &Value) -> Value

Examples found in repository

examples/load_and_store.rs (line 21)

fn main() {
    let mut context = Context::new();
    context.build_start();

    let float_type = Context::sbyte_type();
    let params = vec![float_type];
    let mut func = context.function(Abi::Cdecl, float_type, params).unwrap();

    let x = func.arg(0).unwrap();
    let ptr1 = func.alloca(1);
    let ptr2 = func.alloca(8);

    let tag = func.create_sbyte_constant(111);
    let value = func.create_float64_constant(111.0);

    func.insn_store(&ptr1, &tag);
    func.insn_store(&ptr2, &value);

    let res1 = func.insn_load(&ptr1);
    let res2 = func.insn_load(&ptr2);

    let res= func.insn_add(&res1, &res2);


    func.insn_return(&res);
    println!("{}", func.dump().unwrap());
    func.compile();
    context.build_end();

    let result: extern "C" fn(f64) -> u8 = func.to_closure();
    println!("{}", result(0.23))
}

examples/branch_with_result.rs (line 28)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let i32_type = Context::int_type();
    let mut func = context.function(Abi::Cdecl, i32_type, vec![i32_type, i32_type]).unwrap();


    let result = func.alloca(4);

    let a = func.arg(0).unwrap();
    let b = func.arg(1).unwrap();
    let a_eq_b = func.insn_eq(&a, &b);
    let mut done_label = Label::new();
    let mut eq_label = Label::new();

    func.insn_branch_if(&a_eq_b, &mut eq_label);
    let a_minus_b = func.insn_sub(&a, &b);
    func.insn_store(&result, &a_minus_b);
    func.insn_branch(&mut done_label);
    func.insn_label(&mut eq_label);
    let a_plus_b = func.insn_add(&a, &b);
    func.insn_store(&result, &a_plus_b);
    func.insn_label(&mut done_label);
    let ret = func.insn_load(&result);
    let hundred = func.create_int_constant(100);
    let ret = func.insn_add(&ret, &hundred);
    func.insn_return(&ret);

    println!("{}", func.dump().unwrap());

    func.compile();
    println!("{}", func.dump().unwrap());
    context.build_end();


    let result: extern "C" fn(i32, i32) -> i32 = func.to_closure();
    println!("{} == 102", result(1,1));
    println!("{} == 101", result(3,2));
}

examples/abis.rs (line 37)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // INNER FUNC
    // Tried messing with this ABI but it really made no difference *shrug*
    let mut inner_func = context.function(Abi::VarArg   , Context::float64_type(), vec![Context::float64_type(), Context::float64_type()]).unwrap();
    let arg = inner_func.arg(0).unwrap();
    let arg2 = inner_func.arg(1).unwrap();
    let arg_plus_arg = inner_func.insn_add(&arg, &arg2);
    inner_func.insn_return(&arg_plus_arg);
    inner_func.compile();

    // DONE


    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![Context::float64_type()]).unwrap();
    let arg = func.arg(0).unwrap();
    let zero = func.create_int_constant(0);
    let one = func.create_int_constant(1);
    let hundred_k = func.create_int_constant(50_000_000);
    let i = func.create_value_int();
    let f = func.create_value_float64();
    let zero_f = func.create_float64_constant(0.0);
    func.insn_store(&i, &zero);
    func.insn_store(&f, &zero_f);
    let mut done_lbl = Label::new();
    let mut test_lbl = Label::new();
    func.insn_label(&mut test_lbl);

    let is_greater = func.insn_gt(&i, &hundred_k);
    func.insn_branch_if(&is_greater, &mut done_lbl);

    let load_i = func.insn_load(&i);
    let i_plus_1 = func.insn_add(&load_i, &one);
    func.insn_store(&i, &i_plus_1);

    let res = func.insn_call(&inner_func, vec![f.clone(), arg.clone()]);
    func.insn_store(&f, &res);
    func.insn_branch(&mut test_lbl);

    func.insn_label(&mut done_lbl);

    func.insn_return(&f);
    println!("func: {}", func.dump().unwrap());
    func.compile();
    println!("func: {}", func.dump().unwrap());


    context.build_end();



    let func: extern "C" fn(f64) -> f64 =  func.to_closure();
    let now = Instant::now();
    println!("{}", func(1.1));
    println!("Elapsed: {}ms", now.elapsed().as_millis());
}

pub fn insn_store(&mut self, ptr: &Value, value: &Value)

Examples found in repository

examples/load_and_store.rs (line 18)

fn main() {
    let mut context = Context::new();
    context.build_start();

    let float_type = Context::sbyte_type();
    let params = vec![float_type];
    let mut func = context.function(Abi::Cdecl, float_type, params).unwrap();

    let x = func.arg(0).unwrap();
    let ptr1 = func.alloca(1);
    let ptr2 = func.alloca(8);

    let tag = func.create_sbyte_constant(111);
    let value = func.create_float64_constant(111.0);

    func.insn_store(&ptr1, &tag);
    func.insn_store(&ptr2, &value);

    let res1 = func.insn_load(&ptr1);
    let res2 = func.insn_load(&ptr2);

    let res= func.insn_add(&res1, &res2);


    func.insn_return(&res);
    println!("{}", func.dump().unwrap());
    func.compile();
    context.build_end();

    let result: extern "C" fn(f64) -> u8 = func.to_closure();
    println!("{}", result(0.23))
}

examples/branch_with_result.rs (line 22)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let i32_type = Context::int_type();
    let mut func = context.function(Abi::Cdecl, i32_type, vec![i32_type, i32_type]).unwrap();


    let result = func.alloca(4);

    let a = func.arg(0).unwrap();
    let b = func.arg(1).unwrap();
    let a_eq_b = func.insn_eq(&a, &b);
    let mut done_label = Label::new();
    let mut eq_label = Label::new();

    func.insn_branch_if(&a_eq_b, &mut eq_label);
    let a_minus_b = func.insn_sub(&a, &b);
    func.insn_store(&result, &a_minus_b);
    func.insn_branch(&mut done_label);
    func.insn_label(&mut eq_label);
    let a_plus_b = func.insn_add(&a, &b);
    func.insn_store(&result, &a_plus_b);
    func.insn_label(&mut done_label);
    let ret = func.insn_load(&result);
    let hundred = func.create_int_constant(100);
    let ret = func.insn_add(&ret, &hundred);
    func.insn_return(&ret);

    println!("{}", func.dump().unwrap());

    func.compile();
    println!("{}", func.dump().unwrap());
    context.build_end();


    let result: extern "C" fn(i32, i32) -> i32 = func.to_closure();
    println!("{} == 102", result(1,1));
    println!("{} == 101", result(3,2));
}

examples/abis.rs (line 28)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // INNER FUNC
    // Tried messing with this ABI but it really made no difference *shrug*
    let mut inner_func = context.function(Abi::VarArg   , Context::float64_type(), vec![Context::float64_type(), Context::float64_type()]).unwrap();
    let arg = inner_func.arg(0).unwrap();
    let arg2 = inner_func.arg(1).unwrap();
    let arg_plus_arg = inner_func.insn_add(&arg, &arg2);
    inner_func.insn_return(&arg_plus_arg);
    inner_func.compile();

    // DONE


    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![Context::float64_type()]).unwrap();
    let arg = func.arg(0).unwrap();
    let zero = func.create_int_constant(0);
    let one = func.create_int_constant(1);
    let hundred_k = func.create_int_constant(50_000_000);
    let i = func.create_value_int();
    let f = func.create_value_float64();
    let zero_f = func.create_float64_constant(0.0);
    func.insn_store(&i, &zero);
    func.insn_store(&f, &zero_f);
    let mut done_lbl = Label::new();
    let mut test_lbl = Label::new();
    func.insn_label(&mut test_lbl);

    let is_greater = func.insn_gt(&i, &hundred_k);
    func.insn_branch_if(&is_greater, &mut done_lbl);

    let load_i = func.insn_load(&i);
    let i_plus_1 = func.insn_add(&load_i, &one);
    func.insn_store(&i, &i_plus_1);

    let res = func.insn_call(&inner_func, vec![f.clone(), arg.clone()]);
    func.insn_store(&f, &res);
    func.insn_branch(&mut test_lbl);

    func.insn_label(&mut done_lbl);

    func.insn_return(&f);
    println!("func: {}", func.dump().unwrap());
    func.compile();
    println!("func: {}", func.dump().unwrap());


    context.build_end();



    let func: extern "C" fn(f64) -> f64 =  func.to_closure();
    let now = Instant::now();
    println!("{}", func(1.1));
    println!("Elapsed: {}ms", now.elapsed().as_millis());
}

pub fn insn_call(&mut self, function: &Function, args: Vec<Value>) -> Value

Examples found in repository

examples/function_calls.rs (line 22)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // This function multiplies int by 2
    let int_type = Context::int_type();
    let mut func_mult_by_2 = context.function(Abi::Cdecl, int_type, vec![int_type]).unwrap();
    let x = func_mult_by_2.arg(0).unwrap();
    let const_1 = func_mult_by_2.create_int_constant(2);
    let temp1 = func_mult_by_2.insn_mult(&x, &const_1);
    func_mult_by_2.insn_return(&temp1);
    func_mult_by_2.compile();

    // This main function has 1 arg, it adds 5 to the arg and calls func_mult_by_2 and returns that value.
    let mut func = context.function(Abi::Cdecl, int_type, vec![int_type]).unwrap();
    let arg0 = func.arg(0).unwrap();
    let five = func.create_int_constant(5);
    let arg0_plus_5 = func.insn_add(&arg0, &five);
    let res = func.insn_call(&func_mult_by_2, vec![arg0_plus_5]);
    func.insn_return(&res);
    func.compile();

    context.build_end();

    let result: extern "C" fn(i32) -> i32 = func.to_closure();
    println!("(100+5)*2 == {}", result(100))
}

examples/abis.rs (line 41)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // INNER FUNC
    // Tried messing with this ABI but it really made no difference *shrug*
    let mut inner_func = context.function(Abi::VarArg   , Context::float64_type(), vec![Context::float64_type(), Context::float64_type()]).unwrap();
    let arg = inner_func.arg(0).unwrap();
    let arg2 = inner_func.arg(1).unwrap();
    let arg_plus_arg = inner_func.insn_add(&arg, &arg2);
    inner_func.insn_return(&arg_plus_arg);
    inner_func.compile();

    // DONE


    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![Context::float64_type()]).unwrap();
    let arg = func.arg(0).unwrap();
    let zero = func.create_int_constant(0);
    let one = func.create_int_constant(1);
    let hundred_k = func.create_int_constant(50_000_000);
    let i = func.create_value_int();
    let f = func.create_value_float64();
    let zero_f = func.create_float64_constant(0.0);
    func.insn_store(&i, &zero);
    func.insn_store(&f, &zero_f);
    let mut done_lbl = Label::new();
    let mut test_lbl = Label::new();
    func.insn_label(&mut test_lbl);

    let is_greater = func.insn_gt(&i, &hundred_k);
    func.insn_branch_if(&is_greater, &mut done_lbl);

    let load_i = func.insn_load(&i);
    let i_plus_1 = func.insn_add(&load_i, &one);
    func.insn_store(&i, &i_plus_1);

    let res = func.insn_call(&inner_func, vec![f.clone(), arg.clone()]);
    func.insn_store(&f, &res);
    func.insn_branch(&mut test_lbl);

    func.insn_label(&mut done_lbl);

    func.insn_return(&f);
    println!("func: {}", func.dump().unwrap());
    func.compile();
    println!("func: {}", func.dump().unwrap());


    context.build_end();



    let func: extern "C" fn(f64) -> f64 =  func.to_closure();
    let now = Instant::now();
    println!("{}", func(1.1));
    println!("Elapsed: {}ms", now.elapsed().as_millis());
}

pub fn insn_load_relative( &mut self, base_ptr: &Value, offset_bytes: c_long, typ: &JitType, ) -> Value

pub fn create_value_int(&mut self) -> Value

Examples found in repository

examples/abis.rs (line 25)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // INNER FUNC
    // Tried messing with this ABI but it really made no difference *shrug*
    let mut inner_func = context.function(Abi::VarArg   , Context::float64_type(), vec![Context::float64_type(), Context::float64_type()]).unwrap();
    let arg = inner_func.arg(0).unwrap();
    let arg2 = inner_func.arg(1).unwrap();
    let arg_plus_arg = inner_func.insn_add(&arg, &arg2);
    inner_func.insn_return(&arg_plus_arg);
    inner_func.compile();

    // DONE


    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![Context::float64_type()]).unwrap();
    let arg = func.arg(0).unwrap();
    let zero = func.create_int_constant(0);
    let one = func.create_int_constant(1);
    let hundred_k = func.create_int_constant(50_000_000);
    let i = func.create_value_int();
    let f = func.create_value_float64();
    let zero_f = func.create_float64_constant(0.0);
    func.insn_store(&i, &zero);
    func.insn_store(&f, &zero_f);
    let mut done_lbl = Label::new();
    let mut test_lbl = Label::new();
    func.insn_label(&mut test_lbl);

    let is_greater = func.insn_gt(&i, &hundred_k);
    func.insn_branch_if(&is_greater, &mut done_lbl);

    let load_i = func.insn_load(&i);
    let i_plus_1 = func.insn_add(&load_i, &one);
    func.insn_store(&i, &i_plus_1);

    let res = func.insn_call(&inner_func, vec![f.clone(), arg.clone()]);
    func.insn_store(&f, &res);
    func.insn_branch(&mut test_lbl);

    func.insn_label(&mut done_lbl);

    func.insn_return(&f);
    println!("func: {}", func.dump().unwrap());
    func.compile();
    println!("func: {}", func.dump().unwrap());


    context.build_end();



    let func: extern "C" fn(f64) -> f64 =  func.to_closure();
    let now = Instant::now();
    println!("{}", func(1.1));
    println!("Elapsed: {}ms", now.elapsed().as_millis());
}

pub fn create_value_void_ptr(&mut self) -> Value

pub fn create_value_float32(&mut self) -> Value

pub fn create_value_float64(&mut self) -> Value

Examples found in repository

examples/abis.rs (line 26)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // INNER FUNC
    // Tried messing with this ABI but it really made no difference *shrug*
    let mut inner_func = context.function(Abi::VarArg   , Context::float64_type(), vec![Context::float64_type(), Context::float64_type()]).unwrap();
    let arg = inner_func.arg(0).unwrap();
    let arg2 = inner_func.arg(1).unwrap();
    let arg_plus_arg = inner_func.insn_add(&arg, &arg2);
    inner_func.insn_return(&arg_plus_arg);
    inner_func.compile();

    // DONE


    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![Context::float64_type()]).unwrap();
    let arg = func.arg(0).unwrap();
    let zero = func.create_int_constant(0);
    let one = func.create_int_constant(1);
    let hundred_k = func.create_int_constant(50_000_000);
    let i = func.create_value_int();
    let f = func.create_value_float64();
    let zero_f = func.create_float64_constant(0.0);
    func.insn_store(&i, &zero);
    func.insn_store(&f, &zero_f);
    let mut done_lbl = Label::new();
    let mut test_lbl = Label::new();
    func.insn_label(&mut test_lbl);

    let is_greater = func.insn_gt(&i, &hundred_k);
    func.insn_branch_if(&is_greater, &mut done_lbl);

    let load_i = func.insn_load(&i);
    let i_plus_1 = func.insn_add(&load_i, &one);
    func.insn_store(&i, &i_plus_1);

    let res = func.insn_call(&inner_func, vec![f.clone(), arg.clone()]);
    func.insn_store(&f, &res);
    func.insn_branch(&mut test_lbl);

    func.insn_label(&mut done_lbl);

    func.insn_return(&f);
    println!("func: {}", func.dump().unwrap());
    func.compile();
    println!("func: {}", func.dump().unwrap());


    context.build_end();



    let func: extern "C" fn(f64) -> f64 =  func.to_closure();
    let now = Instant::now();
    println!("{}", func(1.1));
    println!("Elapsed: {}ms", now.elapsed().as_millis());
}

pub fn insn_label(&self, label: &mut Label)

Examples found in repository

examples/branching.rs (line 22)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let float_type = Context::float64_type();
    let mut func = context.function(Abi::Cdecl, float_type, vec![float_type]).unwrap();

    // Return 1 if arg0 == 4
    // else return 0
    let is_four_result = func.create_float64_constant(1.0);
    let not_four_result = func.create_float64_constant(0.0);

    let x = func.arg(0).unwrap();
    let four = func.create_float64_constant(4.0);
    let mut label = Label::new();
    let eq_to_4 = func.insn_eq(&x, &four);
    func.insn_branch_if(&eq_to_4, &mut label);
    func.insn_return(&not_four_result);
    func.insn_label(&mut label);
    func.insn_return(&is_four_result);
    func.compile();
    context.build_end();
    let result: extern "C" fn(f64) -> f64 = func.to_closure();
    println!("{}", result(4.0));
}

examples/branch_with_result.rs (line 24)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let i32_type = Context::int_type();
    let mut func = context.function(Abi::Cdecl, i32_type, vec![i32_type, i32_type]).unwrap();


    let result = func.alloca(4);

    let a = func.arg(0).unwrap();
    let b = func.arg(1).unwrap();
    let a_eq_b = func.insn_eq(&a, &b);
    let mut done_label = Label::new();
    let mut eq_label = Label::new();

    func.insn_branch_if(&a_eq_b, &mut eq_label);
    let a_minus_b = func.insn_sub(&a, &b);
    func.insn_store(&result, &a_minus_b);
    func.insn_branch(&mut done_label);
    func.insn_label(&mut eq_label);
    let a_plus_b = func.insn_add(&a, &b);
    func.insn_store(&result, &a_plus_b);
    func.insn_label(&mut done_label);
    let ret = func.insn_load(&result);
    let hundred = func.create_int_constant(100);
    let ret = func.insn_add(&ret, &hundred);
    func.insn_return(&ret);

    println!("{}", func.dump().unwrap());

    func.compile();
    println!("{}", func.dump().unwrap());
    context.build_end();


    let result: extern "C" fn(i32, i32) -> i32 = func.to_closure();
    println!("{} == 102", result(1,1));
    println!("{} == 101", result(3,2));
}

examples/abis.rs (line 32)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // INNER FUNC
    // Tried messing with this ABI but it really made no difference *shrug*
    let mut inner_func = context.function(Abi::VarArg   , Context::float64_type(), vec![Context::float64_type(), Context::float64_type()]).unwrap();
    let arg = inner_func.arg(0).unwrap();
    let arg2 = inner_func.arg(1).unwrap();
    let arg_plus_arg = inner_func.insn_add(&arg, &arg2);
    inner_func.insn_return(&arg_plus_arg);
    inner_func.compile();

    // DONE


    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![Context::float64_type()]).unwrap();
    let arg = func.arg(0).unwrap();
    let zero = func.create_int_constant(0);
    let one = func.create_int_constant(1);
    let hundred_k = func.create_int_constant(50_000_000);
    let i = func.create_value_int();
    let f = func.create_value_float64();
    let zero_f = func.create_float64_constant(0.0);
    func.insn_store(&i, &zero);
    func.insn_store(&f, &zero_f);
    let mut done_lbl = Label::new();
    let mut test_lbl = Label::new();
    func.insn_label(&mut test_lbl);

    let is_greater = func.insn_gt(&i, &hundred_k);
    func.insn_branch_if(&is_greater, &mut done_lbl);

    let load_i = func.insn_load(&i);
    let i_plus_1 = func.insn_add(&load_i, &one);
    func.insn_store(&i, &i_plus_1);

    let res = func.insn_call(&inner_func, vec![f.clone(), arg.clone()]);
    func.insn_store(&f, &res);
    func.insn_branch(&mut test_lbl);

    func.insn_label(&mut done_lbl);

    func.insn_return(&f);
    println!("func: {}", func.dump().unwrap());
    func.compile();
    println!("func: {}", func.dump().unwrap());


    context.build_end();



    let func: extern "C" fn(f64) -> f64 =  func.to_closure();
    let now = Instant::now();
    println!("{}", func(1.1));
    println!("Elapsed: {}ms", now.elapsed().as_millis());
}

pub fn insn_ceil(&self, value: &Value) -> Value

pub fn insn_floor(&self, value: &Value) -> Value

pub fn insn_rint(&self, value: &Value) -> Value

pub fn insn_round(&self, value: &Value) -> Value

pub fn insn_trunc(&self, value: &Value) -> Value

pub fn insn_load_elem_address( &self, base_addr: &Value, index: &Value, elem_type: &JitType, ) -> Value

pub fn create_float32_constant(&mut self, constant_value: c_float) -> Value

pub fn create_float64_constant(&mut self, constant_value: c_double) -> Value

Examples found in repository

examples/mult2.rs (line 7)

fn main() {
    let mut context = Context::new();
    context.build_start();
    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![]).unwrap();
    let zero = func.create_float64_constant(0.0);
    func.insn_return(&zero);
    func.compile();
    context.build_end();
    let function: fn() -> f64  = func.to_closure();
    println!("{}", function());
}

examples/load_and_store.rs (line 16)

fn main() {
    let mut context = Context::new();
    context.build_start();

    let float_type = Context::sbyte_type();
    let params = vec![float_type];
    let mut func = context.function(Abi::Cdecl, float_type, params).unwrap();

    let x = func.arg(0).unwrap();
    let ptr1 = func.alloca(1);
    let ptr2 = func.alloca(8);

    let tag = func.create_sbyte_constant(111);
    let value = func.create_float64_constant(111.0);

    func.insn_store(&ptr1, &tag);
    func.insn_store(&ptr2, &value);

    let res1 = func.insn_load(&ptr1);
    let res2 = func.insn_load(&ptr2);

    let res= func.insn_add(&res1, &res2);


    func.insn_return(&res);
    println!("{}", func.dump().unwrap());
    func.compile();
    context.build_end();

    let result: extern "C" fn(f64) -> u8 = func.to_closure();
    println!("{}", result(0.23))
}

examples/branching.rs (line 13)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let float_type = Context::float64_type();
    let mut func = context.function(Abi::Cdecl, float_type, vec![float_type]).unwrap();

    // Return 1 if arg0 == 4
    // else return 0
    let is_four_result = func.create_float64_constant(1.0);
    let not_four_result = func.create_float64_constant(0.0);

    let x = func.arg(0).unwrap();
    let four = func.create_float64_constant(4.0);
    let mut label = Label::new();
    let eq_to_4 = func.insn_eq(&x, &four);
    func.insn_branch_if(&eq_to_4, &mut label);
    func.insn_return(&not_four_result);
    func.insn_label(&mut label);
    func.insn_return(&is_four_result);
    func.compile();
    context.build_end();
    let result: extern "C" fn(f64) -> f64 = func.to_closure();
    println!("{}", result(4.0));
}

examples/abis.rs (line 27)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // INNER FUNC
    // Tried messing with this ABI but it really made no difference *shrug*
    let mut inner_func = context.function(Abi::VarArg   , Context::float64_type(), vec![Context::float64_type(), Context::float64_type()]).unwrap();
    let arg = inner_func.arg(0).unwrap();
    let arg2 = inner_func.arg(1).unwrap();
    let arg_plus_arg = inner_func.insn_add(&arg, &arg2);
    inner_func.insn_return(&arg_plus_arg);
    inner_func.compile();

    // DONE


    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![Context::float64_type()]).unwrap();
    let arg = func.arg(0).unwrap();
    let zero = func.create_int_constant(0);
    let one = func.create_int_constant(1);
    let hundred_k = func.create_int_constant(50_000_000);
    let i = func.create_value_int();
    let f = func.create_value_float64();
    let zero_f = func.create_float64_constant(0.0);
    func.insn_store(&i, &zero);
    func.insn_store(&f, &zero_f);
    let mut done_lbl = Label::new();
    let mut test_lbl = Label::new();
    func.insn_label(&mut test_lbl);

    let is_greater = func.insn_gt(&i, &hundred_k);
    func.insn_branch_if(&is_greater, &mut done_lbl);

    let load_i = func.insn_load(&i);
    let i_plus_1 = func.insn_add(&load_i, &one);
    func.insn_store(&i, &i_plus_1);

    let res = func.insn_call(&inner_func, vec![f.clone(), arg.clone()]);
    func.insn_store(&f, &res);
    func.insn_branch(&mut test_lbl);

    func.insn_label(&mut done_lbl);

    func.insn_return(&f);
    println!("func: {}", func.dump().unwrap());
    func.compile();
    println!("func: {}", func.dump().unwrap());


    context.build_end();



    let func: extern "C" fn(f64) -> f64 =  func.to_closure();
    let now = Instant::now();
    println!("{}", func(1.1));
    println!("Elapsed: {}ms", now.elapsed().as_millis());
}

pub fn create_long_constant(&mut self, constant_value: c_long) -> Value

pub fn create_sbyte_constant(&mut self, constant_value: c_char) -> Value

Examples found in repository

examples/load_and_store.rs (line 15)

fn main() {
    let mut context = Context::new();
    context.build_start();

    let float_type = Context::sbyte_type();
    let params = vec![float_type];
    let mut func = context.function(Abi::Cdecl, float_type, params).unwrap();

    let x = func.arg(0).unwrap();
    let ptr1 = func.alloca(1);
    let ptr2 = func.alloca(8);

    let tag = func.create_sbyte_constant(111);
    let value = func.create_float64_constant(111.0);

    func.insn_store(&ptr1, &tag);
    func.insn_store(&ptr2, &value);

    let res1 = func.insn_load(&ptr1);
    let res2 = func.insn_load(&ptr2);

    let res= func.insn_add(&res1, &res2);


    func.insn_return(&res);
    println!("{}", func.dump().unwrap());
    func.compile();
    context.build_end();

    let result: extern "C" fn(f64) -> u8 = func.to_closure();
    println!("{}", result(0.23))
}

pub fn create_ubyte_constant(&mut self, constant_value: c_uchar) -> Value

pub fn create_short_constant(&mut self, constant_value: c_long) -> Value

pub fn create_ushort_constant(&mut self, constant_value: c_ulong) -> Value

pub fn create_int_constant(&mut self, constant_value: c_int) -> Value

Examples found in repository

examples/function_calls.rs (line 12)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // This function multiplies int by 2
    let int_type = Context::int_type();
    let mut func_mult_by_2 = context.function(Abi::Cdecl, int_type, vec![int_type]).unwrap();
    let x = func_mult_by_2.arg(0).unwrap();
    let const_1 = func_mult_by_2.create_int_constant(2);
    let temp1 = func_mult_by_2.insn_mult(&x, &const_1);
    func_mult_by_2.insn_return(&temp1);
    func_mult_by_2.compile();

    // This main function has 1 arg, it adds 5 to the arg and calls func_mult_by_2 and returns that value.
    let mut func = context.function(Abi::Cdecl, int_type, vec![int_type]).unwrap();
    let arg0 = func.arg(0).unwrap();
    let five = func.create_int_constant(5);
    let arg0_plus_5 = func.insn_add(&arg0, &five);
    let res = func.insn_call(&func_mult_by_2, vec![arg0_plus_5]);
    func.insn_return(&res);
    func.compile();

    context.build_end();

    let result: extern "C" fn(i32) -> i32 = func.to_closure();
    println!("(100+5)*2 == {}", result(100))
}

examples/branch_with_result.rs (line 29)

fn main() {
    let mut context = Context::new();
    context.build_start();


    let i32_type = Context::int_type();
    let mut func = context.function(Abi::Cdecl, i32_type, vec![i32_type, i32_type]).unwrap();


    let result = func.alloca(4);

    let a = func.arg(0).unwrap();
    let b = func.arg(1).unwrap();
    let a_eq_b = func.insn_eq(&a, &b);
    let mut done_label = Label::new();
    let mut eq_label = Label::new();

    func.insn_branch_if(&a_eq_b, &mut eq_label);
    let a_minus_b = func.insn_sub(&a, &b);
    func.insn_store(&result, &a_minus_b);
    func.insn_branch(&mut done_label);
    func.insn_label(&mut eq_label);
    let a_plus_b = func.insn_add(&a, &b);
    func.insn_store(&result, &a_plus_b);
    func.insn_label(&mut done_label);
    let ret = func.insn_load(&result);
    let hundred = func.create_int_constant(100);
    let ret = func.insn_add(&ret, &hundred);
    func.insn_return(&ret);

    println!("{}", func.dump().unwrap());

    func.compile();
    println!("{}", func.dump().unwrap());
    context.build_end();


    let result: extern "C" fn(i32, i32) -> i32 = func.to_closure();
    println!("{} == 102", result(1,1));
    println!("{} == 101", result(3,2));
}

examples/abis.rs (line 22)

fn main() {
    let mut context = Context::new();
    context.build_start();

    // INNER FUNC
    // Tried messing with this ABI but it really made no difference *shrug*
    let mut inner_func = context.function(Abi::VarArg   , Context::float64_type(), vec![Context::float64_type(), Context::float64_type()]).unwrap();
    let arg = inner_func.arg(0).unwrap();
    let arg2 = inner_func.arg(1).unwrap();
    let arg_plus_arg = inner_func.insn_add(&arg, &arg2);
    inner_func.insn_return(&arg_plus_arg);
    inner_func.compile();

    // DONE


    let mut func = context.function(Abi::Cdecl, Context::float64_type(), vec![Context::float64_type()]).unwrap();
    let arg = func.arg(0).unwrap();
    let zero = func.create_int_constant(0);
    let one = func.create_int_constant(1);
    let hundred_k = func.create_int_constant(50_000_000);
    let i = func.create_value_int();
    let f = func.create_value_float64();
    let zero_f = func.create_float64_constant(0.0);
    func.insn_store(&i, &zero);
    func.insn_store(&f, &zero_f);
    let mut done_lbl = Label::new();
    let mut test_lbl = Label::new();
    func.insn_label(&mut test_lbl);

    let is_greater = func.insn_gt(&i, &hundred_k);
    func.insn_branch_if(&is_greater, &mut done_lbl);

    let load_i = func.insn_load(&i);
    let i_plus_1 = func.insn_add(&load_i, &one);
    func.insn_store(&i, &i_plus_1);

    let res = func.insn_call(&inner_func, vec![f.clone(), arg.clone()]);
    func.insn_store(&f, &res);
    func.insn_branch(&mut test_lbl);

    func.insn_label(&mut done_lbl);

    func.insn_return(&f);
    println!("func: {}", func.dump().unwrap());
    func.compile();
    println!("func: {}", func.dump().unwrap());


    context.build_end();



    let func: extern "C" fn(f64) -> f64 =  func.to_closure();
    let now = Instant::now();
    println!("{}", func(1.1));
    println!("Elapsed: {}ms", now.elapsed().as_millis());
}

pub fn create_ulong_constant(&mut self, constant_value: c_ulong) -> Value

pub fn create_uint_constant(&mut self, constant_value: c_uint) -> Value

pub fn create_nint_constant(&mut self, constant_value: c_int) -> Value

pub fn create_nuint_constant(&mut self, constant_value: c_int) -> Value

pub fn create_void_ptr_constant(&mut self, constant_value: *mut c_void) -> Value

Trait Implementations

impl Clone for Function

fn clone(&self) -> Function

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.