liblisa 0.1.4

A tool for automated discovery and analysis of the ISA of a CPU.
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
108

use std::fmt::Debug;
use std::marker::PhantomData;

use super::{Observation, Oracle, OracleError};
use crate::arch::Arch;
use crate::state::{Addr, AsSystemState, SystemState};

/// An oracle that counts how many times it was invoked.
pub struct InvocationCountingOracle<A: Arch, O: Oracle<A>> {
    oracle: O,
    observations: usize,
    _phantom: PhantomData<A>,
}

impl<A: Arch, O: Oracle<A>> Oracle<A> for InvocationCountingOracle<A, O> {
    type MappableArea = O::MappableArea;

    fn mappable_area(&self) -> Self::MappableArea {
        self.oracle.mappable_area()
    }

    fn page_size(&mut self) -> u64 {
        self.oracle.page_size()
    }

    fn observe(&mut self, before: &SystemState<A>) -> Result<SystemState<A>, OracleError> {
        self.observations += 1;
        self.oracle.observe(before)
    }

    fn debug_dump(&mut self) {
        self.oracle.debug_dump()
    }

    fn scan_memory_accesses(&mut self, before: &SystemState<A>) -> Result<Vec<Addr>, OracleError> {
        self.observations += 1;
        self.oracle.scan_memory_accesses(before)
    }

    fn restart(&mut self) {
        self.oracle.restart()
    }

    fn kill(self) {
        self.oracle.kill()
    }

    fn batch_observe_iter<'a, S: AsSystemState<A> + 'a, I: IntoIterator<Item = S> + 'a>(
        &'a mut self, states: I,
    ) -> impl Iterator<Item = Observation<S, A>> {
        InvocationCounterIter {
            iter: self.oracle.batch_observe_iter(states),
            num_invocations: &mut self.observations,
            _phantom: PhantomData,
        }
    }

    fn batch_observe_gpreg_only_iter<'a, S: AsSystemState<A> + 'a, I: IntoIterator<Item = S> + 'a>(
        &'a mut self, states: I,
    ) -> impl Iterator<Item = Observation<S, A>> {
        InvocationCounterIter {
            iter: self.oracle.batch_observe_gpreg_only_iter(states),
            num_invocations: &mut self.observations,
            _phantom: PhantomData,
        }
    }

    const UNRELIABLE_INSTRUCTION_FETCH_ERRORS: bool = O::UNRELIABLE_INSTRUCTION_FETCH_ERRORS;
}

struct InvocationCounterIter<'a, A: Arch, S, I: Iterator<Item = Observation<S, A>>> {
    iter: I,
    num_invocations: &'a mut usize,
    _phantom: PhantomData<A>,
}

impl<A: Arch, S, I: Iterator<Item = Observation<S, A>>> Iterator for InvocationCounterIter<'_, A, S, I> {
    type Item = Observation<S, A>;

    fn next(&mut self) -> Option<Self::Item> {
        match self.iter.next() {
            Some(item) => {
                *self.num_invocations += 1;
                Some(item)
            },
            None => None,
        }
    }
}

impl<A: Arch, O: Oracle<A>> Debug for InvocationCountingOracle<A, O> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("InvocationCountingOracle")
            .field("observations", &self.observations)
            .finish()
    }
}

impl<A: Arch, O: Oracle<A>> InvocationCountingOracle<A, O> {
    /// Wraps `oracle` in an invocation-counting oracle.
    pub fn new(oracle: O) -> Self {
        InvocationCountingOracle {
            oracle,
            observations: 0,
            _phantom: Default::default(),
        }
    }
}