233 lines
8.4 KiB
Rust
233 lines
8.4 KiB
Rust
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<u8>) -> 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::<usize>() {
|
|
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(())
|
|
}
|
|
}
|