Struct jit::UncompiledFunction
[−]
[src]
pub struct UncompiledFunction<'a> {
// some fields omitted
}A function which has not been compiled yet, so it can have instructions added to it.
A function persists for the lifetime of its containing context. This represents
the function in the "building" state, where the user constructs instructions
that represents the function body. Once the build process is complete, the
user calls function.compile() to convert it into its executable form.
Methods
impl<'a> UncompiledFunction<'a>
fn new<T>(context: &'a mut Context<T>, signature: &Ty) -> UncompiledFunction<'a>[−]
Create a new function block and associate it with a JIT context.
It is recommended that you call Function::new and function.compile()
in the closure you give to context.build(...).
This will protect the JIT's internal data structures within a multi-threaded environment.
use jit::*; let mut ctx = Context::<()>::new(); let func = UncompiledFunction::new(&mut ctx, &get::<fn(f64) -> f64>());
fn new_nested<T>(context: &'a mut Context<T>, signature: &Ty, parent: &'a UncompiledFunction<'a>) -> UncompiledFunction<'a>[−]
Create a new function block and associate it with a JIT context. In addition, this function is nested inside the specified parent function and is able to access its parent's (and grandparent's) local variables.
The front end is responsible for ensuring that the nested function can never be called by anyone except its parent and sibling functions. The front end is also responsible for ensuring that the nested function is compiled before its parent.
fn insn_convert(&self, v: &'a Val, t: &Ty, overflow_check: bool) -> &'a Val[−]
Make an instruction that converts the value to the type given
fn insn_of<T>(&self, val: T) -> &'a Val where T: Compile<'a>[−]
Make an instructional representation of a Rust value
rust use jit::*; let mut ctx = Context::<()>::new(); let func = UncompiledFunction::new(&mut ctx, &get::<fn() -> i32>()); func.insn_return(func.insn_of(42i32));
fn insn_uses_catcher(&self)[−]
Notify the function building process that this function has a catch block in it. This must be called before any code that is part of a try block
fn insn_throw(&self, retval: &'a Val)[−]
Make an instruction to throw an exception from the function with the value given
fn insn_return(&self, retval: &'a Val)[−]
Make an instruction that will return from the function with the value given
fn insn_default_return(&self)[−]
Return from the function
fn insn_mul(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that multiplies the values
fn insn_mul_ovf(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that multiplies the values and throws upon overflow
fn insn_add(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that adds the values
You can also just use v1 + v2 in your code instead of running this method,
&Val has the Add trait implemented so it can be added with normal operators.
fn insn_add_ovf(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that adds the values and throws upon overflow
fn insn_sub(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that subtracts the second value from the first
You can also just use v1 - v2 in your code instead of running this method,
&Val has the Sub trait implemented so it can be subtracted with normal operators.
fn insn_sub_ovf(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that subtracts the second value from the first and throws upon overflow
fn insn_div(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that divides the first number by the second
You can also just use v1 / v2 in your code instead of running this method,
&Val has the Div trait implemented so it can be divided with normal operators.
fn insn_rem(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that finds the remainder when the first number is divided by the second
You can also just use v1 % v2 in your code instead of running this method,
&Val has the Rem trait implemented so it can be done with normal operators.
fn insn_leq(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that checks if the first value is lower than or equal to the second
fn insn_geq(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that checks if the first value is greater than or equal to the second
fn insn_lt(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that checks if the first value is lower than the second
fn insn_gt(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that checks if the first value is greater than the second
fn insn_eq(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that checks if the values are equal
fn insn_neq(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that checks if the values are not equal
fn insn_and(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that performs a bitwise and on the two values
You can also just use v1 & v2 in your code instead of running this method,
&Val has the BitAnd trait implemented so it can be done with normal operators.
fn insn_or(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that performs a bitwise or on the two values
You can also just use v1 | v2 in your code instead of running this method,
&Val has the BitOr trait implemented so it can be done with normal operators.
fn insn_xor(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that performs a bitwise xor on the two values
You can also just use v1 ^ v2 in your code instead of running this method,
&Val has the BitXor trait implemented so it can be done with normal operators.
fn insn_not(&self, value: &'a Val) -> &'a Val[−]
Make an instruction that performs a bitwise not on the two values
You can also just use !value in your code instead of running this method.
&Val has the Not trait implemented so it can be inversed with normal operators.
fn insn_shl(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that performs a left bitwise shift on the first value by the second value
You can also just use v1 << v2 in your code instead of running this method,
&Val has the Shl trait implemented so it can be shifted with normal operators.
fn insn_shr(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that performs a right bitwise shift on the first value by the second value
You can also just use v1 >> v2 in your code instead of running this method,
&Val has the Shr trait implemented so it can be shifted with normal operators.
fn insn_ushr(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that performs a right bitwise shift on the first value by the second value
fn insn_neg(&self, value: &'a Val) -> &'a Val[−]
Make an instruction that performs a negation on the value
You can also just use -value in your code instead of running this method.
&Val has the Neg trait implemented so it can be negatedd with normal operators.
fn insn_dup(&self, value: &'a Val) -> &'a Val[−]
Make an instruction that duplicates the value given
This is the same as load
fn insn_load(&self, src: &'a Val) -> &'a Val[−]
Make an instruction that loads the contents of src into a temporary
fn insn_load_relative(&self, value: &'a Val, offset: usize, ty: &Ty) -> &'a Val[−]
Make an instruction that loads a value of the given type from value + offset, where
value must be a pointer
fn insn_store(&self, dest: &'a Val, val: &'a Val)[−]
Make an instruction that stores the contents of val into dest, where dest is a
temporary value or local value
fn insn_store_relative(&self, dest: &'a Val, offset: usize, value: &'a Val)[−]
Make an instruction that stores the value at the address dest + offset, where dest
must be a pointer
fn insn_label(&self, label: &mut Label<'a>)[−]
Make an instruction that sets a label
fn insn_branch(&self, label: &mut Label<'a>)[−]
Make an instruction that branches to a certain label
fn insn_branch_if(&self, value: &'a Val, label: &mut Label<'a>)[−]
Make an instruction that branches to a certain label if the value is true
fn insn_branch_if_not(&self, value: &'a Val, label: &mut Label<'a>)[−]
Make an instruction that branches to a certain label if the value is false
fn insn_jump_table(&self, value: &'a Val, labels: &mut [Label<'a>])[−]
Make an instruction that branches to a label in the table
fn insn_acos(&self, v: &'a Val) -> &'a Val[−]
Make an instruction that gets the inverse cosine of the number given
fn insn_asin(&self, v: &'a Val) -> &'a Val[−]
Make an instruction that gets the inverse sine of the number given
fn insn_atan(&self, v: &'a Val) -> &'a Val[−]
Make an instruction that gets the inverse tangent of the number given
fn insn_atan2(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that gets the inverse tangent of the numbers given
fn insn_ceil(&self, v: &'a Val) -> &'a Val[−]
Make an instruction that finds the nearest integer above a number
fn insn_cos(&self, v: &'a Val) -> &'a Val[−]
Make an instruction that gets the consine of the number given
fn insn_cosh(&self, v: &'a Val) -> &'a Val[−]
Make an instruction that gets the hyperbolic consine of the number given
fn insn_exp(&self, v: &'a Val) -> &'a Val[−]
Make an instruction that gets the natural logarithm rased to the power of the number
fn insn_floor(&self, v: &'a Val) -> &'a Val[−]
Make an instruction that finds the nearest integer below a number
fn insn_log(&self, v: &'a Val) -> &'a Val[−]
Make an instruction that gets the natural logarithm of the number
fn insn_log10(&self, v: &'a Val) -> &'a Val[−]
Make an instruction that gets the base 10 logarithm of the number
fn insn_pow(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction the gets the result of raising the first value to the power of the second value
fn insn_rint(&self, v: &'a Val) -> &'a Val[−]
Make an instruction the gets the result of rounding the value to the nearest integer
fn insn_round(&self, v: &'a Val) -> &'a Val[−]
Make an instruction the gets the result of rounding the value to the nearest integer
fn insn_sin(&self, v: &'a Val) -> &'a Val[−]
Make an instruction the gets the sine of the number
fn insn_sinh(&self, v: &'a Val) -> &'a Val[−]
Make an instruction the gets the hyperbolic sine of the number
fn insn_sqrt(&self, value: &'a Val) -> &'a Val[−]
Make an instruction the gets the square root of a number
fn insn_tan(&self, v: &'a Val) -> &'a Val[−]
Make an instruction the gets the tangent of a number
fn insn_tanh(&self, v: &'a Val) -> &'a Val[−]
Make an instruction the gets the hyperbolic tangent of a number
fn insn_trunc(&self, v: &'a Val) -> &'a Val[−]
Make an instruction that truncates the value
fn insn_is_nan(&self, v: &'a Val) -> &'a Val[−]
Make an instruction that checks if the number is NaN
fn insn_is_finite(&self, v: &'a Val) -> &'a Val[−]
Make an instruction that checks if the number is finite
fn insn_is_inf(&self, v: &'a Val) -> &'a Val[−]
Make an instruction that checks if the number is infinite
fn insn_abs(&self, v: &'a Val) -> &'a Val[−]
Make an instruction that gets the absolute value of a number
fn insn_min(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that gets the smallest of two numbers
fn insn_max(&self, v1: &'a Val, v2: &'a Val) -> &'a Val[−]
Make an instruction that gets the biggest of two numbers
fn insn_sign(&self, v: &'a Val) -> &'a Val[−]
Make an instruction that gets the sign of a number
fn insn_call(&self, name: Option<&str>, func: &Func, sig: Option<&Ty>, args: &mut [&'a Val], flags: CallFlags) -> &'a Val[−]
Call the function, which may or may not be translated yet
fn insn_call_indirect(&self, func: &'a Val, signature: &Ty, args: &mut [&'a Val], flags: CallFlags) -> &'a Val[−]
Make an instruction that calls a function that has the signature given with some arguments through a pointer to the fucntion
fn insn_call_native0<R>(&self, name: Option<&str>, native_func: extern "C" fn() -> R, signature: &Ty, flags: CallFlags) -> &'a Val[−]
Make an instruction that calls a Rust function that has the signature given with no arguments and expects a return value
fn insn_call_native1<A, R>(&self, name: Option<&str>, native_func: extern "C" fn(A) -> R, signature: &Ty, args: [&'a Val; 1], flags: CallFlags) -> &'a Val[−]
Make an instruction that calls a Rust function that has the signature given with a single argument and expects a return value
fn insn_call_native2<A, B, R>(&self, name: Option<&str>, native_func: extern "C" fn(A, B) -> R, signature: &Ty, args: [&'a Val; 2], flags: CallFlags) -> &'a Val[−]
Make an instruction that calls a Rust function that has the signature given with two arguments and expects a return value
fn insn_call_native3<A, B, C, R>(&self, name: Option<&str>, native_func: extern "C" fn(A, B, C) -> R, signature: &Ty, args: [&'a Val; 3], flags: CallFlags) -> &'a Val[−]
Make an instruction that calls a Rust function that has the signature given with three arguments and expects a return value
fn insn_call_native4<A, B, C, D, R>(&self, name: Option<&str>, native_func: extern "C" fn(A, B, C, D) -> R, signature: &Ty, args: [&'a Val; 4], flags: CallFlags) -> &'a Val[−]
Make an instruction that calls a Rust function that has the signature given with four arguments and expects a return value
fn insn_memcpy(&self, dest: &'a Val, source: &'a Val, size: &'a Val) -> bool[−]
Make an instruction that copies size bytes from the source address to the dest address
fn insn_memmove(&self, dest: &'a Val, source: &'a Val, size: &'a Val) -> bool[−]
Make an instruction that moves memory from a source address to a destination address
fn insn_memset(&self, dest: &'a Val, source: &'a Val, size: &'a Val) -> bool[−]
Make an instruction that sets memory at the destination address
fn insn_alloca(&self, size: &'a Val) -> &'a Val[−]
Make an instruction that allocates size bytes of memory from the stack
fn insn_address_of(&self, value: &'a Val) -> &'a Val[−]
Make an instruction that gets the address of a value
fn insn_if<B>(&self, cond: &'a Val, block: B) where B: FnOnce()[−]
Make instructions to run the block if the condition is met
fn insn_if_not<B>(&self, cond: &'a Val, block: B) where B: FnOnce()[−]
Make instructions to run the block if the condition is not met
fn insn_if_else<A, B>(&self, cond: &'a Val, if_block: A, else_block: B) where A: FnOnce(), B: FnOnce()[−]
Make instructions to run the block if the condition is met
fn insn_loop<B>(&self, block: B) where B: FnOnce()[−]
Make instructions to run the block forever
fn insn_while<C, B>(&self, cond: C, block: B) where C: FnOnce() -> &'a Val, B: FnOnce()[−]
Make instructions to run the block and continue running it so long as the condition is met
fn set_optimization_level(&self, level: c_uint)[−]
Set the optimization level of the function, where the bigger the level, the more effort should be spent optimising
fn get_max_optimization_level() -> c_uint[−]
Get the max optimization level
fn set_recompilable(&self)[−]
Make this function a candidate for recompilation
fn get_entry(&self) -> Option<Block<'a>>[−]
Get the entry block of this function
fn get_current(&self) -> Option<Block<'a>>[−]
Get the current block of this function
fn compile(self) -> CompiledFunction<'a>[−]
Compile the function
fn compile_with<A, R, F>(self, cb: F) -> CompiledFunction<'a> where F: FnOnce( extern "C" fn(A) -> R)[−]
Compile the function and call a closure with it directly
Methods from Deref<Target=Func>
fn is_compiled(&self) -> bool[−]
Check if the given function has been compiled
fn get_signature(&self) -> &Ty[−]
Get the signature of the given function