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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use serde::{Deserialize, Serialize};

/// The location of a source in an encoding.
/// Either a memory address computation or dataflow.
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
pub enum FlowInputLocation {
    /// An input located in a dataflow.
    InputForOutput {
        /// The index of the dataflow.
        output_index: usize,

        /// The index of the input in the sources of the dataflow.
        input_index: usize,
    },
    /// An imput located in a memory access
    MemoryAddress {
        /// The index of the memory access
        memory_index: usize,

        /// The index of the input in the sources of the memory address computation.
        input_index: usize,
    },
}

/// The location of an output in an encoding.
/// Either a dataflow destination, or memory output.
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
pub enum FlowOutputLocation {
    /// Refers to the destination of the nth dataflow.
    Output(usize),

    /// Refers to the memory area accessed by the nth memory access.
    MemoryAccess(usize),
}

impl FlowOutputLocation {
    /// Converts an output location into an input location.
    /// This converts destinations to sources, and memory area's to memory address calculation inputs.
    pub fn input(&self, input_index: usize) -> FlowInputLocation {
        match *self {
            FlowOutputLocation::Output(output_index) => FlowInputLocation::InputForOutput {
                output_index,
                input_index,
            },
            FlowOutputLocation::MemoryAccess(memory_index) => FlowInputLocation::MemoryAddress {
                memory_index,
                input_index,
            },
        }
    }
}

/// The location of a source or destination in an encoding.
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
pub enum FlowValueLocation {
    /// The destination of the nth dataflow.
    Output(usize),

    /// The source in a dataflow.
    InputForOutput {
        /// The index of the dataflow
        output_index: usize,

        /// The index of the input in the sources of the dataflow.
        input_index: usize,
    },

    /// An input in a memory access
    MemoryAddress {
        /// The index of the memory access
        memory_index: usize,

        /// The index of the input in the sources of the memory address computation.
        input_index: usize,
    },
}
impl FlowValueLocation {
    /// Returns true if the location is a source in the inputs of a memory address computation.
    pub fn is_address(&self) -> bool {
        matches!(self, FlowValueLocation::MemoryAddress { .. })
    }

    /// Returns true if the location is the destination or one of the sources of the dataflow with index `index_to_find`.
    pub fn is_in_output(&self, index_to_find: usize) -> bool {
        match *self {
            FlowValueLocation::Output(output_index) => output_index == index_to_find,
            FlowValueLocation::InputForOutput {
                output_index, ..
            } => output_index == index_to_find,
            FlowValueLocation::MemoryAddress {
                ..
            } => false,
        }
    }
}

impl From<FlowInputLocation> for FlowValueLocation {
    fn from(location: FlowInputLocation) -> Self {
        match location {
            FlowInputLocation::InputForOutput {
                output_index,
                input_index,
            } => FlowValueLocation::InputForOutput {
                output_index,
                input_index,
            },
            FlowInputLocation::MemoryAddress {
                memory_index,
                input_index,
            } => FlowValueLocation::MemoryAddress {
                memory_index,
                input_index,
            },
        }
    }
}

impl TryFrom<FlowValueLocation> for FlowInputLocation {
    type Error = ();

    fn try_from(location: FlowValueLocation) -> Result<Self, ()> {
        Ok(match location {
            FlowValueLocation::Output(_) => return Err(()),
            FlowValueLocation::InputForOutput {
                output_index,
                input_index,
            } => FlowInputLocation::InputForOutput {
                output_index,
                input_index,
            },
            FlowValueLocation::MemoryAddress {
                memory_index,
                input_index,
            } => FlowInputLocation::MemoryAddress {
                memory_index,
                input_index,
            },
        })
    }
}

impl PartialEq<FlowValueLocation> for FlowInputLocation {
    fn eq(&self, other: &FlowValueLocation) -> bool {
        &FlowValueLocation::from(*self) == other
    }
}