jit 0.9.1

Just-In-Time Compilation in Rust using LibJIT bindings
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use raw::*;
use function::UncompiledFunction;
use types::*;
use util::from_ptr;
use std::marker::PhantomData;
use std::fmt;
use std::ops::*;
/// Vals form the backbone of the storage system in `LibJIT`
///
/// Every value in the system, be it a constant, a local variable, or a
/// temporary result, is represented by an object of type `Val`. The JIT then
/// allocates registers or memory locations to the values as appropriate. This is
/// why `Val` is always behind a reference
pub struct Val(PhantomData<[()]>);
native_ref!(&Val = jit_value_t);
impl fmt::Debug for Val {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "v({:?})", self.get_type())
    }
}
impl Val {
    #[inline(always)]
    /// Create a new value in the context of a function's current block.
    ///
    /// The value initially starts off as a block-specific temporary. It will be
    /// converted into a function-wide local variable if it is ever referenced
    /// from a different block.
    pub fn new<'a>(func:&UncompiledFunction<'a>, value_type:&Ty) -> &'a Val {
        unsafe {
            from_ptr(jit_value_create(func.into(), value_type.into()))
        }
    }
    /// Get the type of the value
    pub fn get_type(&self) -> &Ty {
        unsafe {
            from_ptr(jit_value_get_type(self.into()))
        }
    }
    /// Get the function which made this value
    pub fn get_function(&self) -> UncompiledFunction {
        unsafe {
            from_ptr(jit_value_get_function(self.into()))
        }
    }
    /// Determine if a value is temporary.  i.e. its scope extends over a single
    /// block within its function.
    #[inline]
    pub fn is_temp(&self) -> bool {
        unsafe {
            jit_value_is_temporary(self.into()) != 0
        }
    }
    /// Determine if a value is addressable.
    #[inline]
    pub fn is_addressable(&self) -> bool {
        unsafe {
            jit_value_is_addressable(self.into()) != 0
        }
    }
    /// Set a flag on a value to indicate that it is addressable.
    /// This should be used when you want to take the address of a value (e.g.
    /// `&variable` in Rust/C).  The value is guaranteed to not be stored in a
    /// register across a function call.
    #[inline]
    pub fn set_addressable(&self) -> () {
        unsafe {
            jit_value_set_addressable(self.into())
        }
    }
}
macro_rules! bin_op {
    ($trait_ty:ident, $trait_func:ident, $func:ident) => (
        impl<'a> $trait_ty<&'a Val> for &'a Val {
            type Output = &'a Val;
            fn $trait_func(self, other: &'a Val) -> &'a Val {
                self.get_function().$func(self, other)
            }
        }
    )
}
macro_rules! un_op {
    ($trait_ty:ident, $trait_func:ident, $func:ident) => (
        impl<'a> $trait_ty for &'a Val {
            type Output = &'a Val;
            fn $trait_func(self) -> &'a Val {
                self.get_function().$func(self)
            }
        }
    )
}
bin_op!{Add, add, insn_add}
bin_op!{BitAnd, bitand, insn_and}
bin_op!{BitOr, bitor, insn_or}
bin_op!{BitXor, bitxor, insn_xor}
bin_op!{Div, div, insn_div}
bin_op!{Mul, mul, insn_mul}
bin_op!{Rem, rem, insn_rem}
bin_op!{Shl, shl, insn_shl}
bin_op!{Shr, shr, insn_shr}
bin_op!{Sub, sub, insn_sub}
un_op!{Neg, neg, insn_neg}
un_op!{Not, not, insn_not}