mijit 0.2.4

Experimental JIT compiler generator
Documentation 
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
103
104
105
106
107

use std::ops::{Deref, DerefMut};
use memmap::{MmapMut, Mmap as MmapExec};
use super::{Buffer};

/// Represents a block of memory claimed from the operating system using
/// `mmap()`. Memory allocated in this way can be made executable.
pub enum Mmap {
    Mut(MmapMut),
    Exec(MmapExec),
    Poisoned,
}

impl Mmap {
    /// Make this [`Mmap`] executable if necessary, and pass it to `callback`.
    ///
    /// Panics if it can't change the buffer permissions. In this case the
    /// `Mmap` will be poisoned.
    pub fn execute<T>(&mut self, callback: impl FnOnce(&[u8]) -> T) -> T {
        let m: &mut MmapExec = self.as_mut();
        callback(&*m)
    }
}

impl AsMut<MmapMut> for Mmap {
    fn as_mut(&mut self) -> &mut MmapMut {
        let mut new_self = Self::Poisoned;
        std::mem::swap(self, &mut new_self);
        *self = match new_self {
            Self::Exec(m) => Self::Mut(m.make_mut().expect("mprotect failed")),
            x => x,
        };
        match self {
            Self::Mut(ref mut m) => m,
            _ => panic!("Poisoned by an earlier error"),
        }
    }
}

impl AsMut<MmapExec> for Mmap {
    fn as_mut(&mut self) -> &mut MmapExec {
        let mut new_self = Self::Poisoned;
        std::mem::swap(self, &mut new_self);
        *self = match new_self {
            Self::Mut(m) => Self::Exec(m.make_exec().expect("mprotect failed")),
            x => x,
        };
        match self {
            Self::Exec(ref mut m) => m,
            _ => panic!("Poisoned by an earlier error"),
        }
    }
}

impl Deref for Mmap {
    type Target = [u8];

    fn deref(&self) -> &Self::Target {
        match self {
            Self::Mut(ref m) => m,
            Self::Exec(ref m) => m,
            Self::Poisoned => panic!("Poisoned by an earlier error"),
        }
    }
}

impl DerefMut for Mmap {
    fn deref_mut(&mut self) -> &mut Self::Target {
        let m: &mut MmapMut = self.as_mut();
        &mut *m
    }
}

impl Buffer for Mmap {
    fn new() -> Self {
        let memory = MmapMut::map_anon(0x1000).expect("Out of memory");
        Self::Mut(memory)
    }

    fn resize(&mut self, min_length: usize) {
        let memory: &mut MmapMut = self.as_mut();
        if min_length > memory.len() {
            let mut new_memory = MmapMut::map_anon(min_length).expect("Out of memory");
            new_memory[..memory.len()].copy_from_slice(memory);
            *memory = new_memory;
        }
    }
}

//-----------------------------------------------------------------------------

#[cfg(test)]
pub mod tests {
    use super::*;

    #[test]
    fn api() {
        let buffer = Mmap::new();
        super::super::tests::api(buffer)
    }

    #[test]
    fn execute() {
        let mut buffer = Mmap::new();
        let result = buffer.execute(|_bytes| 42);
        assert_eq!(result, 42);
    }
}