rsleigh 0.4.1

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

use crate::pattern::BitConstraint;
use crate::semantic::pattern::{CmpOp, ConstraintValue};
use crate::FieldBits;

impl BitConstraint {
    pub fn define(self, bit: bool) -> Option<Self> {
        match self {
            Self::Unrestrained => Some(Self::Defined(bit)),
            Self::Defined(old_bit) if old_bit == bit => Some(self),
            Self::Defined(_old_bit) => None,
            // TODO this may not be possible, we are unable to verify that now
            Self::Restrained => Some(Self::Defined(bit)),
        }
    }
    /// select the most restrictive from both, None if they conflict
    pub fn most_restrictive(self, other: Self) -> Option<Self> {
        match (self, other) {
            //if one is unrestrained, just return the other
            (Self::Unrestrained, other) | (other, Self::Unrestrained) => Some(other),
            // both have the same value
            (Self::Restrained, Self::Restrained) => Some(self),
            (Self::Defined(self_value), Self::Defined(other_value))
                if self_value == other_value =>
            {
                Some(self)
            }
            // conflicting values
            (Self::Defined(_), Self::Defined(_)) => None,
            // TODO this may not be possible, we are unable to verify that now
            (other @ Self::Defined(_), Self::Restrained)
            | (Self::Restrained, other @ Self::Defined(_)) => Some(other),
        }
    }
    /// select the least restrictive from both
    pub fn least_restrictive(self, other: Self) -> Self {
        match (self, other) {
            (Self::Unrestrained, _other) | (_other, Self::Unrestrained) => Self::Unrestrained,
            (Self::Defined(self_value), Self::Defined(other_value))
                if self_value != other_value =>
            {
                Self::Restrained
            }
            //both have the same value
            (Self::Defined(_), Self::Defined(_)) => self,
            (Self::Restrained, Self::Restrained)
            | (Self::Defined(_), Self::Restrained)
            | (Self::Restrained, Self::Defined(_)) => Self::Restrained,
        }
    }
}

pub fn apply_value(
    constraint: &mut [BitConstraint],
    field_order: fn(usize, usize) -> usize,
    value_order: fn(usize, usize) -> usize,
    field_bits: FieldBits,
    op: CmpOp,
    value: &ConstraintValue,
) -> Option<()> {
    //only set the value, if its Eq and the value is known at compile time
    use crate::semantic::disassembly::{ExprElement, ReadScope};
    // TODO allow multiple expressions that can be evaulated at compile time,
    // or make sure the optimations prior to this only produces values
    let value = match (op, value.expr()) {
        (
            CmpOp::Eq,
            crate::disassembly::Expr::Value(ExprElement::Value {
                value: ReadScope::Integer(value),
                location: _,
            }),
        ) => Some(value.signed_super()),
        _ => None,
    };

    let field_bits_len = field_bits.len().get().try_into().unwrap();
    for (value_bit, field_bit) in field_bits.0.enumerate() {
        let field_bit = field_bit.try_into().unwrap();
        let field_bit = field_order(field_bit, constraint.len());
        let bit = &mut constraint[field_bit];
        if let Some(value) = value {
            let value_bit = value_order(value_bit, field_bits_len);
            let value_bit = (value >> value_bit) & 1 != 0;
            *bit = bit.define(value_bit)?;
        } else {
            //error never happen with `BitConstraint::Restrained`
            *bit = bit.most_restrictive(BitConstraint::Restrained).unwrap();
        }
    }
    Some(())
}