rsleigh 0.3.0

SLEIGH (.slaspec) parser and Rust decoder/P-code emitter codegen — Ghidra-compatible disassembly in pure Rust
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

use std::collections::HashSet;

use proc_macro2::{Ident, TokenStream};
use quote::{format_ident, quote};

use super::{formater::*, Disassembler};

#[derive(Clone, Debug)]
pub struct RegistersEnum {
    pub name: Ident,
    pub registers: Vec<Ident>,
}

impl RegistersEnum {
    pub fn from_all(name: Ident, sleigh: &crate::Sleigh) -> Self {
        Self::from_iterator(name, sleigh.varnodes().iter())
    }

    //enum from only the Registers that can be printed
    #[allow(dead_code)]
    pub fn from_printable(name: Ident, sleigh: &crate::Sleigh) -> Self {
        use crate::display::DisplayElement::*;
        use crate::token::TokenFieldAttach;
        use crate::varnode::ContextAttach;
        let mut vars = HashSet::new();
        let add_varnodes = |vars: &mut HashSet<_>, id| {
            for (_i, var) in sleigh.attach_varnode(id).0.iter() {
                vars.insert(*var);
            }
        };
        for table in sleigh.tables().iter() {
            for constructor in table.constructors().iter() {
                for element in constructor.display.elements() {
                    match element {
                        Varnode(var) => {
                            vars.insert(*var);
                        }
                        Context(context) => match sleigh.context(*context).attach {
                            ContextAttach::NoAttach(_) | ContextAttach::Literal(_) => {}
                            ContextAttach::Varnode(id) => add_varnodes(&mut vars, id),
                        },
                        TokenField(token_field) => match sleigh.token_field(*token_field).attach {
                            TokenFieldAttach::NoAttach(_)
                            | TokenFieldAttach::Literal(_)
                            | TokenFieldAttach::Number(_, _) => {}
                            TokenFieldAttach::Varnode(id) => add_varnodes(&mut vars, id),
                        },
                        InstStart(_) | InstNext(_) | Disassembly(_) | Table(_) | Literal(_)
                        | Space => {}
                    }
                }
            }
        }
        //TODO: from meaning, with could use the meaning to display
        Self::from_iterator(name, vars.into_iter().map(|id| sleigh.varnode(id)))
    }

    pub fn from_iterator<'a>(
        name: Ident,
        registers: impl Iterator<Item = &'a crate::varnode::Varnode>,
    ) -> Self {
        let registers = registers
            .map(|varnode| format_ident!("{}", from_sleigh(varnode.name())))
            .collect();
        Self { name, registers }
    }
    pub fn name(&self) -> &Ident {
        &self.name
    }
    pub fn registers(&self) -> impl Iterator<Item = (&Ident, crate::VarnodeId)> {
        self.registers
            .iter()
            .enumerate()
            .map(|(i, name)| (name, unsafe { crate::VarnodeId::from_raw(i) }))
    }
    pub fn register(&self, id: crate::VarnodeId) -> &Ident {
        &self.registers[id.to_raw()]
    }
    pub fn to_tokens(&self, tokens: &mut TokenStream, disassembler: &Disassembler) {
        let name = self.name();
        let elements_names = self.registers.iter();
        let elements_names2 = self.registers.iter();
        let elements_display = self
            .registers()
            .map(|(_name, id)| disassembler.sleigh.varnode(id).name());

        // Build (offset, size) -> name lookup table
        let reg_entries: Vec<_> = self
            .registers()
            .map(|(_ident, id)| {
                let vn = disassembler.sleigh.varnode(id);
                let offset = vn.address;
                let size = vn.len_bytes.get();
                let name_str = vn.name();
                (offset, size, name_str.to_string())
            })
            .collect();
        let entry_offsets = reg_entries.iter().map(|(o, _, _)| *o);
        let entry_sizes = reg_entries.iter().map(|(_, s, _)| {
            let s = *s as u32;
            quote! { #s }
        });
        let entry_names = reg_entries.iter().map(|(_, _, n)| n.as_str());

        tokens.extend(quote! {
            #[derive(Clone, Copy, Debug)]
            pub enum #name {
                #(#elements_names),*
            }
            impl #name {
                pub fn as_str(&self) -> &'static str {
                    match self {
                        #(Self::#elements_names2 => #elements_display,)*
                    }
                }
            }
            impl core::fmt::Display for #name {
                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> std::fmt::Result {
                    write!(f, "{}", self.as_str())
                }
            }

            /// Look up a register name by its Ghidra offset and size in bytes.
            /// Returns `None` if no register matches.
            pub fn register_name(offset: u64, size: u32) -> Option<&'static str> {
                static TABLE: &[(u64, u32, &str)] = &[
                    #((#entry_offsets, #entry_sizes, #entry_names),)*
                ];
                TABLE.iter()
                    .find(|(o, s, _)| *o == offset && *s == size)
                    .map(|(_, _, name)| *name)
            }
        })
    }
}