use super::*; fn patch_module_hostcalls( module: &mut BytecodeModule, capabilities: prometeu_hal::syscalls::CapFlags, ) -> Result<(), LoaderPatchError> { let resolved = prometeu_hal::syscalls::resolve_declared_program_syscalls(&module.syscalls, capabilities) .map_err(LoaderPatchError::ResolveFailed)?; let mut used = vec![false; module.syscalls.len()]; let mut pc = 0usize; while pc < module.code.len() { let instr = decode_next(pc, &module.code).map_err(LoaderPatchError::DecodeFailed)?; let next_pc = instr.next_pc; match instr.opcode { OpCode::Hostcall => { let sysc_index = instr.imm_u32().map_err(LoaderPatchError::DecodeFailed)?; let Some(resolved_syscall) = resolved.get(sysc_index as usize) else { return Err(LoaderPatchError::HostcallIndexOutOfBounds { pc, sysc_index, syscalls_len: resolved.len(), }); }; used[sysc_index as usize] = true; module.code[pc..pc + 2].copy_from_slice(&(OpCode::Syscall as u16).to_le_bytes()); module.code[pc + 2..pc + 6].copy_from_slice(&resolved_syscall.id.to_le_bytes()); } OpCode::Syscall => { return Err(LoaderPatchError::RawSyscallInPreloadArtifact { pc, syscall_id: instr.imm_u32().map_err(LoaderPatchError::DecodeFailed)?, }); } _ => {} } pc = next_pc; } for (index, (was_used, decl)) in used.iter().zip(&module.syscalls).enumerate() { if !was_used { return Err(LoaderPatchError::UnusedSyscallDecl { sysc_index: index as u32, module: decl.module.clone(), name: decl.name.clone(), version: decl.version, }); } } let mut pc = 0usize; while pc < module.code.len() { let instr = decode_next(pc, &module.code).map_err(LoaderPatchError::DecodeFailed)?; if instr.opcode == OpCode::Hostcall { return Err(LoaderPatchError::HostcallRemaining { pc, sysc_index: instr.imm_u32().map_err(LoaderPatchError::DecodeFailed)?, }); } pc = instr.next_pc; } Ok(()) } impl VirtualMachine { pub fn initialize(&mut self, program_bytes: Vec) -> Result<(), VmInitError> { self.program = ProgramImage::default(); self.validated_image = None; self.strings = None; self.pc = 0; self.operand_stack.clear(); self.call_stack.clear(); self.globals.clear(); self.heap = Heap::with_budget(&self.budget); self.cycles = 0; self.halted = true; self.last_gc_live_count = 0; self.current_tick = 0; self.sleep_requested_until = None; self.scheduler = Scheduler::with_budget(&self.budget); self.current_coro = None; let program = match prometeu_bytecode::BytecodeLoader::load(&program_bytes) { Ok(mut module) => { patch_module_hostcalls(&mut module, self.capabilities) .map_err(VmInitError::LoaderPatchFailed)?; let max_stacks = Verifier::verify(&module.code, &module.functions) .map_err(VmInitError::VerificationFailed)?; let mut program = ProgramImage::from(module); let mut functions = program.functions.as_ref().to_vec(); for (func, max_stack) in functions.iter_mut().zip(max_stacks) { func.max_stack_slots = max_stack; } program.functions = std::sync::Arc::from(functions); program } Err(prometeu_bytecode::LoadError::InvalidVersion) => { return Err(VmInitError::UnsupportedFormat); } Err(prometeu_bytecode::LoadError::InvalidMagic) => { return Err(VmInitError::InvalidFormat); } Err(prometeu_bytecode::LoadError::UnexpectedEof) if program_bytes.len() < 32 => { return Err(VmInitError::InvalidFormat); } Err(e) => return Err(VmInitError::ImageLoadFailed(e)), }; let pc = program .functions .first() .map(|f| f.code_offset as usize) .ok_or(VmInitError::EntrypointNotFound)?; self.program = program; self.pc = pc; self.halted = false; Ok(()) } pub fn set_capabilities(&mut self, caps: prometeu_hal::syscalls::CapFlags) { self.capabilities = caps; } pub fn prepare_boot_call(&mut self) -> Result<(), VmInitError> { self.prepare_call_by_index(0, &[]) } pub fn prepare_call(&mut self, entrypoint: &str) -> Result<(), VmInitError> { self.prepare_call_with_args(entrypoint, &[]) } pub fn prepare_call_with_args( &mut self, entrypoint: &str, arguments: &[Value], ) -> Result<(), VmInitError> { let func_idx = if let Ok(idx) = entrypoint.parse::() { idx } else if let Some(image) = &self.validated_image { image .exports() .iter() .rfind(|export| export.symbol == entrypoint) .map(|export| export.func_idx as usize) .ok_or(VmInitError::EntrypointNotFound)? } else { self.program.exports.get(entrypoint).map(|&idx| idx as usize).ok_or(()).unwrap_or(0) }; self.prepare_call_by_index(func_idx, arguments) } fn prepare_call_by_index( &mut self, func_idx: usize, arguments: &[Value], ) -> Result<(), VmInitError> { if self.validated_image.is_some() { self.check_signature_group(func_idx, false, arguments).map_err(|(slot, error)| { if self.program.functions.get(func_idx).is_none() { VmInitError::EntrypointNotFound } else { VmInitError::EntrypointArgumentsInvalid { function: func_idx as u32, slot: slot as u32, trap_code: Self::value_error_code(error), } } })?; } self.budget.check(RuntimeResource::CallDepth, 1)?; let mut imported = BudgetVec::new(&self.budget, RuntimeResource::TemporaryBytes); if self.validated_image.is_some() { imported.reserve(arguments.len())?; for value in arguments { imported.push(self.import_string_value(value)?)?; } } let callee = self.program.functions.get(func_idx).cloned().unwrap_or_default(); let total_slots = callee.param_slots as usize + callee.local_slots as usize; let stack_growth = self .operand_stack .prepare_growth(total_slots.saturating_sub(self.operand_stack.len()))?; let frame_growth = self.call_stack.prepare_growth(1usize.saturating_sub(self.call_stack.len()))?; let main_href = self.heap.allocate_coroutine( callee.code_offset as usize, CoroutineState::Running, 0, BudgetVec::new(&self.budget, RuntimeResource::AuxiliaryBytes), BudgetVec::new(&self.budget, RuntimeResource::AuxiliaryBytes), )?; self.operand_stack.commit_growth(stack_growth); self.call_stack.commit_growth(frame_growth); self.pc = callee.code_offset as usize; self.halted = false; self.operand_stack.clear(); self.call_stack.clear(); if let Some(func) = self.program.functions.get(func_idx) { let typed = self.validated_image.is_some(); if typed { self.operand_stack.extend_from_slice(&imported)?; } let null_slots = func.local_slots as usize + if typed { 0 } else { func.param_slots as usize }; for _ in 0..null_slots { self.operand_stack.push(Value::Null)?; } } self.call_stack.push(CallFrame { return_pc: self.program.rom.len() as u32, stack_base: 0, func_idx, })?; self.current_coro = Some(main_href); self.scheduler.set_current(self.current_coro); Ok(()) } }