/// Resolved execution widths derived from sealed Registry metadata. /// This cache is never serialized as a PBX function signature. #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)] pub struct ExecutionFunction { pub code_offset: u32, pub code_len: u32, pub param_slots: u16, pub local_slots: u16, pub return_slots: u16, pub max_stack_slots: u16, } use crate::abi::TrapInfo; use crate::model::DebugInfo; use crate::value::Value; use serde::{Deserialize, Serialize}; use std::collections::HashMap; use std::sync::Arc; /// Immutable execution payload/cache, produced during sealed image publication. /// This container does not authorize execution. VM sessions require the private /// ValidatedProgramImage factory, including bounded Registry/ISA/native checks. #[derive(Debug, Clone, Default)] pub struct ProgramImage { pub rom: Arc<[u8]>, pub constant_pool: Arc<[Value]>, pub functions: Arc<[ExecutionFunction]>, pub debug_info: Option>, pub exports: Arc>, } impl ProgramImage { pub fn create_trap(&self, code: u32, opcode: u16, mut message: String, pc: u32) -> TrapInfo { let span = self .debug_info .as_ref() .and_then(|di| di.pc_to_span.iter().find(|(p, _)| *p == pc).map(|(_, s)| s.clone())); if let Some(func_idx) = self.find_function_index(pc) { if let Some(func_name) = self.get_function_name(func_idx) { message = format!("{} (in function {})", message, func_name); } } TrapInfo { code, opcode, message, pc, span, resource: None } } pub fn find_function_index(&self, pc: u32) -> Option { self.functions.iter().position(|f| pc >= f.code_offset && pc < (f.code_offset + f.code_len)) } pub fn get_function_name(&self, func_idx: usize) -> Option<&str> { self.debug_info .as_ref() .and_then(|di| di.function_names.iter().find(|(idx, _)| *idx as usize == func_idx)) .map(|(_, name)| name.as_str()) } }