Skip to main content

remu/
debugger.rs

1use jit::{ExitReason, GuestMemory, GuestState, JitRuntime, ProgramImage};
2
3use std::{
4    io::{self, Write as _},
5    sync::atomic::Ordering,
6};
7
8pub fn run_debugger<L>(runtime: &mut JitRuntime<L>) -> Result<ExitReason, Box<dyn std::error::Error>>
9where
10    L: Fn(&GuestMemory, u64) -> Result<liil::nnil::Nnil, Box<dyn std::error::Error>>,
11{
12    let pause = runtime.pause_flag();
13
14    ctrlc::set_handler(move || pause.store(true, Ordering::Relaxed))?;
15
16    let mut checkpoint = None;
17    let mut reason = ExitReason::Paused;
18
19    print_stop(runtime, reason);
20
21    loop {
22        print!("(remu) ");
23
24        io::stdout().flush()?;
25        let mut line = String::new();
26
27        if io::stdin().read_line(&mut line)? == 0 {
28            return Ok(reason);
29        }
30
31        let mut words = line.split_whitespace();
32
33        let Some(command) = words.next() else {
34            continue;
35        };
36
37        match command {
38            "continue" | "c" => {
39                reason = match runtime.run_for_blocks(u64::MAX) {
40                    Ok(reason) => reason,
41                    Err(err) => {
42                        println!("execution error: {err}");
43                        print_stop(runtime, runtime.state().exit_reason);
44                        continue;
45                    }
46                };
47
48                print_stop(runtime, reason);
49
50                if reason == ExitReason::GuestExit {
51                    return Ok(reason);
52                }
53            }
54
55            "step" | "s" => {
56                reason = match runtime.run_for_blocks(1) {
57                    Ok(reason) => reason,
58                    Err(err) => {
59                        println!("execution error: {err}");
60                        print_stop(runtime, runtime.state().exit_reason);
61                        continue;
62                    }
63                };
64
65                print_stop(runtime, reason);
66            }
67
68            "break" | "b" => {
69                if let Some(value) = words.next() {
70                    match parse_address(runtime.program(), value) {
71                        Some(address) => {
72                            runtime.add_breakpoint(address);
73                            println!("breakpoint at 0x{address:x}");
74                        }
75                        None => println!("unknown address or symbol: {value}"),
76                    }
77                } else {
78                    for address in runtime.breakpoints() {
79                        println!("0x{address:x}");
80                    }
81                }
82            }
83
84            "delete" => match words.next() {
85                Some("all") => runtime.clear_breakpoints(),
86                Some(value) => match parse_address(runtime.program(), value) {
87                    Some(address) => runtime.remove_breakpoint(address),
88                    None => println!("unknown address or symbol: {value}"),
89                },
90                None => println!("usage: delete <address|symbol|all>"),
91            },
92
93            "regs" => print_registers(runtime.state()),
94
95            "mem" => {
96                let Some(value) = words.next() else {
97                    println!("usage: mem <address> [length]");
98                    continue;
99                };
100
101                let Some(address) = parse_address(runtime.program(), value) else {
102                    println!("unknown address or symbol: {value}");
103                    continue;
104                };
105
106                let length = words.next().and_then(parse_number).unwrap_or(64).min(4096) as usize;
107                print_memory(runtime.memory(), address, length);
108            }
109
110            "maps" => {
111                for (start, end, perms) in runtime.memory().mappings() {
112                    println!(
113                        "0x{start:016x}-0x{end:016x} {}{}{}",
114                        if perms.contains(jit::PagePerms::READ) { 'r' } else { '-' },
115                        if perms.contains(jit::PagePerms::WRITE) { 'w' } else { '-' },
116                        if perms.contains(jit::PagePerms::EXEC) { 'x' } else { '-' },
117                    );
118                }
119            }
120
121            "where" => print_stop(runtime, reason),
122
123            "nnil" => match runtime.lift_at(runtime.state().pc) {
124                Ok(nnil) => println!("{nnil:?}"),
125                Err(err) => println!("error: {err}"),
126            },
127
128            "trace" => {
129                for pc in runtime.trace() {
130                    println!("0x{pc:016x}");
131                }
132            }
133
134            "snapshot" => {
135                checkpoint = Some(runtime.snapshot()?);
136                println!("snapshot saved");
137            }
138
139            "restore" => match &checkpoint {
140                Some(snapshot) => {
141                    runtime.restore(snapshot)?;
142                    reason = ExitReason::Paused;
143                    print_stop(runtime, reason);
144                }
145                None => println!("wip! no snapshot saved"),
146            },
147
148            "reset" => {
149                runtime.reset()?;
150                reason = ExitReason::Paused;
151                print_stop(runtime, reason);
152            }
153
154            "help" | "h" => println!(
155                "ACHTUNG, NOCH WORK-IN-PROGRES. Commands: continue, step, break <address oder symbol>, delete <address oder symbol oder all>, regs, mem <address> [length], maps, where, nnil, trace, snapshot, restore, reset, quit"
156            ),
157
158            "quit" | "q" => return Ok(reason),
159            _ => println!("unknown command, use help"),
160        }
161    }
162}
163
164fn parse_number(value: &str) -> Option<u64> {
165    value.strip_prefix("0x").and_then(|value| u64::from_str_radix(value, 16).ok()).or_else(|| value.parse().ok())
166}
167
168fn parse_address(program: &ProgramImage, value: &str) -> Option<u64> {
169    parse_number(value).or_else(|| program.find_symbol(value).map(|symbol| symbol.value))
170}
171
172fn print_stop<L>(runtime: &JitRuntime<L>, reason: ExitReason)
173where
174    L: Fn(&GuestMemory, u64) -> Result<liil::nnil::Nnil, Box<dyn std::error::Error>>,
175{
176    let state = runtime.state();
177    print!("stopped: {reason:?}, pc=0x{:x}", state.pc);
178
179    if let Some(symbol) = runtime.program().symbol_at(state.pc) {
180        print!(" <{}+0x{:x}>", symbol.name, state.pc - symbol.value);
181    }
182
183    println!();
184
185    if let Some(half) = runtime.memory().fetch_u16(state.pc) {
186        if half & 3 == 3 {
187            if let Some(word) = runtime.memory().fetch_u32(state.pc) {
188                println!("instruction: 0x{word:08x}");
189            }
190        } else {
191            println!("instruction: 0x{half:04x}");
192        }
193    }
194
195    if state.fault_access != jit::AccessKind::None {
196        println!("fault: {:?} at 0x{:x}", state.fault_access, state.fault_addr);
197    }
198
199    if let Some([nr, pc, a0, a1, a2, a3, a4, a5]) = runtime.last_syscall() {
200        println!("last syscall: {nr} at 0x{pc:x} (0x{a0:x}, 0x{a1:x}, 0x{a2:x}, 0x{a3:x}, 0x{a4:x}, 0x{a5:x})");
201    }
202}
203
204fn print_registers(state: &GuestState) {
205    const NAMES: [&str; 32] = [
206        "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
207        "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6",
208    ];
209
210    println!("pc   0x{:016x}", state.pc);
211
212    for (index, name) in NAMES.iter().enumerate() {
213        println!("x{index:<2} {name:<4} 0x{:016x}", state.regs[index]);
214    }
215
216    for index in 0..32 {
217        println!("f{index:<2}      0x{:016x}", state.regs[32 + index]);
218    }
219}
220
221fn print_memory(memory: &GuestMemory, address: u64, length: usize) {
222    for offset in (0..length).step_by(16) {
223        let count = 16.min(length - offset);
224
225        let Some(bytes) = memory.load_bytes(address + offset as u64, count) else {
226            println!("0x{:016x}: <unreadable>", address + offset as u64);
227            return;
228        };
229
230        print!("0x{:016x}:", address + offset as u64);
231
232        for byte in &bytes {
233            print!(" {byte:02x}");
234        }
235
236        println!();
237    }
238}