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}