libmwemu 0.24.1

x86 32/64bits and system internals emulator, for securely emulating malware and other stuff.
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
150
151
152
153
154
155
156
157
158
159

use crate::fpu::F80;
use log::info;
use serde::{Deserialize, Serialize};

#[derive(Copy, Clone, Serialize, Deserialize)]
pub struct FPUStack {
    regs: [F80; 8],
    top: u8,
    depth: u8,
    log: bool,
    invalid_flag: u8,
}

impl FPUStack {
    pub fn new() -> Self {
        Self {
            regs: [F80::new(); 8],
            top: 0,
            depth: 0,
            log: false,
            invalid_flag: 0,
        }
    }

    pub fn len(&self) -> usize {
        8
    }

    pub fn print(&self) {
        info!("top: {}", self.top);
        info!("depth: {}", self.depth);
        for i in (0..8).rev() {
            info!(
                "ST({}) 0x{:x} {}",
                i,
                self.regs[i].get(),
                self.regs[i].get_f64()
            );
        }
        info!("invalid_flag: {:b}", self.invalid_flag);
    }

    pub fn get_top(&mut self) -> u8 {
        self.top
    }

    pub fn inc_top(&mut self) {
        self.top = (self.top + 1) & 7;
    }

    pub fn dec_top(&mut self) {
        self.top = (self.top.wrapping_sub(1)) & 7;
    }

    pub fn set_invalid(&mut self, idx: usize) {
        assert!(idx < 8);
        self.invalid_flag |= 1 << idx;
    }

    pub fn clear_invalid(&mut self, idx: usize) {
        assert!(idx < 8);
        self.invalid_flag &= !(1 << idx);
    }

    pub fn is_invalid(&self, idx: usize) -> bool {
        assert!(idx < 8);
        (self.invalid_flag & (1 << idx)) != 0
    }

    pub fn push_f64(&mut self, value: f64) {
        if self.depth >= 8 {
            panic!("FPU stack overflow");
            // in linux: terminated by signal SIGFPE (Floating point exception)
        }
        self.top = (self.top.wrapping_sub(1)) & 7;
        self.regs[self.top as usize].set_f64(value);
        self.depth += 1;
        self.clear_invalid(self.top.into());
    }

    pub fn push_f80(&mut self, value: F80) {
        if self.depth >= 8 {
            panic!("FPU stack overflow");
            // in linux: terminated by signal SIGFPE (Floating point exception)
        }
        self.top = (self.top.wrapping_sub(1)) & 7;
        self.regs[self.top as usize].set(value.get());
        self.depth += 1;
        self.clear_invalid(self.top.into());
    }

    pub fn pop(&mut self) -> Option<F80> {
        if self.depth == 0 {
            return None;
        }
        let val = self.regs[self.top as usize].clone();
        self.top = (self.top.wrapping_add(1)) & 7;
        self.depth -= 1;
        //println!("depth decremented to {}", self.depth);
        Some(val)
    }

    // only for tests.rs, this acces directly to index, it's not using self.top
    pub fn peek(&self, n: usize) -> F80 {
        self.regs[n].clone()
    }

    pub fn get(&mut self, n: usize) -> F80 {
        let idx = (self.top as usize + n) % 8;

        if self.depth == 0 || n >= self.depth as usize {
            self.set_invalid(idx);
        }
        self.regs[idx]
    }

    pub fn get_ref(&mut self, n: usize) -> &F80 {
        let idx = (self.top as usize + n) % 8;

        if self.depth == 0 || n >= self.depth as usize {
            self.set_invalid(idx);
        }
        &self.regs[idx]
    }

    pub fn get_mut(&mut self, n: usize) -> Option<&mut F80> {
        let idx = (self.top as usize + n) % 8;

        if self.depth == 0 || n >= self.depth as usize {
            self.set_invalid(idx);
        }

        if self.is_invalid(idx) {
            self.regs[idx].set_real_indefinite();
            None
        } else {
            Some(&mut self.regs[idx])
        }
    }

    /*
    pub fn st0(&self) -> &F80 {
        &self.regs[self.top as usize]
    }*/

    pub fn get_depth(&self) -> u8 {
        self.depth
    }

    pub fn physical_index(&self, n: usize) -> usize {
        (self.top as usize + n) % 8
    }

    pub fn swap(&mut self, a: usize, b: usize) {
        let a = self.top as usize + a;
        let b = (self.top as usize + b) % 8;
        self.regs.swap(a, b);
    }
}