add debugger

This commit is contained in:
2026-03-24 13:40:16 +00:00
parent 71bb007499
commit cd68bb0d0a
10 changed files with 506 additions and 24 deletions
@@ -0,0 +1,86 @@
use serde::{Deserialize, Serialize};
use crate::model::AppMode;
#[derive(Debug, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum DebugCommand {
#[serde(rename = "ok")]
Ok,
#[serde(rename = "start")]
Start,
#[serde(rename = "pause")]
Pause,
#[serde(rename = "resume")]
Resume,
#[serde(rename = "step")]
Step,
#[serde(rename = "stepFrame")]
StepFrame,
#[serde(rename = "getState")]
GetState,
#[serde(rename = "setBreakpoint")]
SetBreakpoint { pc: usize },
#[serde(rename = "listBreakpoints")]
ListBreakpoints,
#[serde(rename = "clearBreakpoint")]
ClearBreakpoint { pc: usize },
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum DebugResponse {
#[serde(rename = "handshake")]
Handshake {
runtime_version: String,
cartridge: HandshakeCartridge,
},
#[serde(rename = "state")]
State {
pc: usize,
stack_top: Vec<i64>,
frame_index: u64,
app_id: u32,
},
#[serde(rename = "breakpoints")]
Breakpoints {
pcs: Vec<usize>,
},
}
#[derive(Debug, Serialize, Deserialize)]
pub struct HandshakeCartridge {
pub app_id: u32,
pub title: String,
pub app_version: String,
pub app_mode: AppMode,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(tag = "event")]
pub enum DebugEvent {
#[serde(rename = "breakpointHit")]
BreakpointHit {
pc: usize,
frame_index: u64,
},
#[serde(rename = "log")]
Log {
level: String,
source: String,
msg: String,
},
#[serde(rename = "telemetry")]
Telemetry {
frame_index: u64,
vm_steps: u32,
syscalls: u32,
cycles: u64,
},
#[serde(rename = "cert")]
Cert {
rule: String,
used: u64,
limit: u64,
frame_index: u64,
},
}
@@ -1,7 +1,7 @@
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum BootTarget {
Hub,
Cartridge { path: String, debug: bool },
Cartridge { path: String, debug: bool, debug_port: u16 },
}
impl Default for BootTarget {
@@ -14,7 +14,7 @@ impl LaunchHubStep {
}
pub fn on_update(&mut self, ctx: &mut PrometeuContext) -> Option<FirmwareState> {
if let BootTarget::Cartridge { path, debug } = ctx.boot_target {
if let BootTarget::Cartridge { path, .. } = ctx.boot_target {
match CartridgeLoader::load(path) {
Ok(cartridge) => {
// No caso de debug, aqui poderíamos pausar, mas o requisito diz
+1
View File
@@ -5,6 +5,7 @@ pub mod model;
pub mod firmware;
pub mod fs;
pub mod telemetry;
pub mod debugger_protocol;
mod prometeu_os;
mod prometeu_hub;
@@ -32,12 +32,17 @@ pub struct PrometeuOS {
// Log Service
pub log_service: LogService,
pub current_app_id: u32,
pub current_cartridge_title: String,
pub current_cartridge_app_version: String,
pub current_cartridge_app_mode: crate::model::AppMode,
pub logs_written_this_frame: HashMap<u32, u32>,
// Telemetria e Certificação
pub telemetry_current: TelemetryFrame,
pub telemetry_last: TelemetryFrame,
pub certifier: Certifier,
pub paused: bool,
pub debug_step_request: bool,
boot_time: Instant,
}
@@ -66,10 +71,15 @@ impl PrometeuOS {
next_handle: 1,
log_service: LogService::new(4096),
current_app_id: 0,
current_cartridge_title: String::new(),
current_cartridge_app_version: String::new(),
current_cartridge_app_mode: crate::model::AppMode::Game,
logs_written_this_frame: HashMap::new(),
telemetry_current: TelemetryFrame::default(),
telemetry_last: TelemetryFrame::default(),
certifier: Certifier::new(cap_config.unwrap_or_default()),
paused: false,
debug_step_request: false,
boot_time,
};
@@ -131,6 +141,21 @@ impl PrometeuOS {
// Determina o app_id numérico
self.current_app_id = cartridge.app_id;
self.current_cartridge_title = cartridge.title.clone();
self.current_cartridge_app_version = cartridge.app_version.clone();
self.current_cartridge_app_mode = cartridge.app_mode;
}
/// Executa uma única instrução da VM (Debug).
pub fn debug_step_instruction(&mut self, vm: &mut VirtualMachine, hw: &mut dyn HardwareBridge) -> Option<String> {
match vm.step(self, hw) {
Ok(_) => None,
Err(e) => {
let err_msg = format!("PVM Fault during Step: {:?}", e);
self.log(LogLevel::Error, LogSource::Vm, 0, err_msg.clone());
Some(err_msg)
}
}
}
/// Executa um tick do host (60Hz).
@@ -138,6 +163,10 @@ impl PrometeuOS {
let start = std::time::Instant::now();
self.tick_index += 1;
if self.paused && !self.debug_step_request {
return None;
}
self.update_fs();
if !self.logical_frame_active {
@@ -167,6 +196,12 @@ impl PrometeuOS {
self.telemetry_current.cycles_used += run.cycles_used;
self.telemetry_current.vm_steps += run.steps_executed;
if run.reason == crate::virtual_machine::LogicalFrameEndingReason::Breakpoint {
self.paused = true;
self.debug_step_request = false;
self.log(LogLevel::Info, LogSource::Vm, 0xDEB1, format!("Breakpoint hit at PC 0x{:X}", vm.pc));
}
if run.reason == crate::virtual_machine::LogicalFrameEndingReason::FrameSync {
hw.gfx_mut().render_all();
@@ -183,6 +218,11 @@ impl PrometeuOS {
self.logical_frame_index += 1;
self.logical_frame_active = false;
self.logical_frame_remaining_cycles = 0;
if self.debug_step_request {
self.paused = true;
self.debug_step_request = false;
}
}
}
Err(e) => {
@@ -11,6 +11,7 @@ pub enum LogicalFrameEndingReason {
BudgetExhausted,
Halted,
EndOfRom,
Breakpoint,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -29,6 +30,7 @@ pub struct VirtualMachine {
pub heap: Vec<Value>, // Simplificado para demo, futuramente RAM/Heap real
pub cycles: u64,
pub halted: bool,
pub breakpoints: std::collections::HashSet<usize>,
}
impl VirtualMachine {
@@ -42,13 +44,21 @@ impl VirtualMachine {
heap: Vec::new(),
cycles: 0,
halted: false,
breakpoints: std::collections::HashSet::new(),
}
}
pub fn initialize(&mut self, program_bytes: Vec<u8>, entrypoint: &str) {
// Por enquanto, tratamos os bytes como a ROM diretamente.
// TODO: Implementar parser de .pbc para extrair constant_pool e rom reais.
self.program = Program::new(program_bytes, vec![]);
if program_bytes.starts_with(b"PPBC") {
if let Ok((rom, cp)) = self.parse_pbc(&program_bytes) {
self.program = Program::new(rom, cp);
} else {
self.program = Program::new(program_bytes, vec![]);
}
} else {
// Por enquanto, tratamos os bytes como a ROM diretamente.
self.program = Program::new(program_bytes, vec![]);
}
// Se o entrypoint for numérico, podemos tentar usá-lo como PC inicial.
// Se não, por enquanto ignoramos ou começamos do 0.
@@ -65,6 +75,73 @@ impl VirtualMachine {
self.cycles = 0;
self.halted = false;
}
fn parse_pbc(&self, bytes: &[u8]) -> Result<(Vec<u8>, Vec<Value>), String> {
let mut cursor = 4; // Skip "PPBC"
let cp_count = self.read_u32_at(bytes, &mut cursor)? as usize;
let mut cp = Vec::with_capacity(cp_count);
for _ in 0..cp_count {
if cursor >= bytes.len() { return Err("Unexpected end of PBC".into()); }
let tag = bytes[cursor];
cursor += 1;
match tag {
1 => { // Integer
let val = self.read_i64_at(bytes, &mut cursor)?;
cp.push(Value::Integer(val));
}
2 => { // Float
let val = self.read_f64_at(bytes, &mut cursor)?;
cp.push(Value::Float(val));
}
3 => { // Boolean
if cursor >= bytes.len() { return Err("Unexpected end of PBC".into()); }
let val = bytes[cursor] != 0;
cursor += 1;
cp.push(Value::Boolean(val));
}
4 => { // String
let len = self.read_u32_at(bytes, &mut cursor)? as usize;
if cursor + len > bytes.len() { return Err("Unexpected end of PBC".into()); }
let s = String::from_utf8_lossy(&bytes[cursor..cursor + len]).into_owned();
cursor += len;
cp.push(Value::String(s));
}
_ => cp.push(Value::Null),
}
}
let rom_size = self.read_u32_at(bytes, &mut cursor)? as usize;
if cursor + rom_size > bytes.len() {
return Err("Invalid ROM size in PBC".into());
}
let rom = bytes[cursor..cursor + rom_size].to_vec();
Ok((rom, cp))
}
fn read_u32_at(&self, bytes: &[u8], cursor: &mut usize) -> Result<u32, String> {
if *cursor + 4 > bytes.len() { return Err("Unexpected end of PBC".into()); }
let val = u32::from_le_bytes(bytes[*cursor..*cursor + 4].try_into().unwrap());
*cursor += 4;
Ok(val)
}
fn read_i64_at(&self, bytes: &[u8], cursor: &mut usize) -> Result<i64, String> {
if *cursor + 8 > bytes.len() { return Err("Unexpected end of PBC".into()); }
let val = i64::from_le_bytes(bytes[*cursor..*cursor + 8].try_into().unwrap());
*cursor += 8;
Ok(val)
}
fn read_f64_at(&self, bytes: &[u8], cursor: &mut usize) -> Result<f64, String> {
if *cursor + 8 > bytes.len() { return Err("Unexpected end of PBC".into()); }
let val = f64::from_le_bytes(bytes[*cursor..*cursor + 8].try_into().unwrap());
*cursor += 8;
Ok(val)
}
}
impl Default for VirtualMachine {
@@ -88,6 +165,11 @@ impl VirtualMachine {
&& !self.halted
&& self.pc < self.program.rom.len()
{
if steps_executed > 0 && self.breakpoints.contains(&self.pc) {
ending_reason = Some(LogicalFrameEndingReason::Breakpoint);
break;
}
let pc_before = self.pc;
let cycles_before = self.cycles;