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
|
use crate::*;
use inked::{ink, InkedString};
pub struct DebugState {
pub enabled: bool,
last_cycle: usize,
mark: Instant,
symbols: DebugSymbols,
}
impl DebugState {
pub fn new<P: AsRef<Path>>(enabled: bool, symbols_path: Option<P>) -> Self {
Self {
enabled,
last_cycle: 0,
mark: Instant::now(),
symbols: DebugSymbols::from_path(symbols_path),
}
}
pub fn debug_full(&mut self, core: &BedrockCore) {
if self.enabled {
let prev_pc = core.mem.pc.wrapping_sub(1);
let cycle = core.cycle;
let delta = core.cycle.saturating_sub(self.last_cycle);
let elapsed = self.mark.elapsed();
eprintln!(" PC: 0x{prev_pc:04x} Cycle: {cycle} (+{delta} in {elapsed:.2?})");
eprint!("WST: "); debug_stack(&core.wst);
eprint!("RST: "); debug_stack(&core.rst);
// Print information about the nearest symbol.
if let Some(symbol) = self.symbols.for_address(prev_pc) {
let name = &symbol.name;
let address = &symbol.address;
let mut string = InkedString::new();
string.push(ink!("SYM: "));
string.push(ink!("@{name}").blue());
string.push(ink!(" 0x{address:04X}"));
if let Some(location) = &symbol.location {
string.push(ink!(" "));
string.push(ink!("{location}").dim());
}
string.eprintln();
}
}
self.last_cycle = core.cycle;
self.mark = Instant::now();
}
pub fn debug_timing(&mut self, core: &BedrockCore) {
if self.enabled {
let cycle = core.cycle;
let delta = core.cycle.saturating_sub(self.last_cycle);
let elapsed = self.mark.elapsed();
eprintln!("Cycle: {cycle} (+{delta} in {elapsed:.2?})");
}
self.last_cycle = core.cycle;
self.mark = Instant::now();
}
}
fn debug_stack(stack: &Stack) {
for i in 0..(stack.sp as usize) {
eprint!("{:02X} ", stack.mem[i]);
}
eprintln!();
}
pub struct DebugSymbols {
pub symbols: Vec<DebugSymbol>
}
impl DebugSymbols {
/// Load debug symbols from a symbols file.
pub fn from_path<P: AsRef<Path>>(path: Option<P>) -> Self {
let mut symbols = Vec::new();
if let Some(path) = path {
if let Ok(string) = std::fs::read_to_string(path) {
for line in string.lines() {
if let Some(symbol) = DebugSymbol::from_line(line) {
symbols.push(symbol);
}
}
}
}
symbols.sort_by_key(|s| s.address);
Self { symbols }
}
/// Return the symbol matching a given program address.
pub fn for_address(&self, address: u16) -> Option<&DebugSymbol> {
if self.symbols.is_empty() { return None; }
match self.symbols.binary_search_by_key(&address, |s| s.address) {
Ok(index) => self.symbols.get(index),
Err(index) => self.symbols.get(index.checked_sub(1)?),
}
}
}
pub struct DebugSymbol {
pub address: u16,
pub name: String,
pub location: Option<String>,
}
impl DebugSymbol {
pub fn from_line(line: &str) -> Option<Self> {
let (address, line) = line.split_once(' ')?;
let address = u16::from_str_radix(address, 16).ok()?;
if let Some((name, location)) = line.split_once(' ') {
let name = name.to_string();
let location = Some(location.to_string());
Some( DebugSymbol { address, name, location } )
} else {
let name = line.to_string();
Some( DebugSymbol { address, name, location: None } )
}
}
}
|
