Files
prometeu-runtime/crates/console/prometeu-vm/tests/support/identity.rs
T

115 lines
3.8 KiB
Rust

#![allow(dead_code)]
use prometeu_bytecode::{
assemble, load_limits::LoadBudget, model::ConstantPoolEntry, registry::*,
registry_codec::PbxModule,
};
use prometeu_vm::{
HostContext, HostReturn, LogicalFrameEndingReason, NativeInterface, ValidatedProgramImage,
VirtualMachine, VmInitError,
};
use std::sync::Arc;
pub struct Native;
impl NativeInterface for Native {
fn syscall(
&mut self,
_: u32,
_: &[prometeu_bytecode::Value],
_: &mut HostReturn,
_: &mut HostContext,
) -> Result<(), prometeu_hal::vm_fault::VmFault> {
panic!("identity corpus uses no host syscall")
}
}
pub fn sig(parameters: &[u32], results: &[u32]) -> Signature {
Signature {
parameters: parameters
.iter()
.map(|&id| NamedType { type_id: TypeId(id), name: None })
.collect(),
results: results.iter().copied().map(TypeId).collect(),
}
}
pub fn types() -> Vec<TypeDecl> {
let field = || NamedType { type_id: TypeId(0), name: None };
vec![
TypeKind::Builtin(BuiltinId::INT64),
TypeKind::Builtin(BuiltinId::FLOAT),
TypeKind::Builtin(BuiltinId::BOOL),
TypeKind::Builtin(BuiltinId::STRING),
TypeKind::Builtin(BuiltinId::DYNAMIC),
TypeKind::Struct(vec![field()]),
TypeKind::Array(TypeId(0)),
TypeKind::Trait(vec![]),
TypeKind::Trait(vec![]),
TypeKind::Fn(sig(&[], &[])),
TypeKind::Builtin(BuiltinId::RANDOM),
TypeKind::Struct(vec![field()]),
TypeKind::Builtin(BuiltinId::COLOR),
TypeKind::Builtin(BuiltinId::VEC2),
TypeKind::Builtin(BuiltinId::PIXEL),
TypeKind::Builtin(BuiltinId::INT32),
]
.into_iter()
.map(|kind| TypeDecl { name: None, kind })
.collect()
}
pub fn image(
bodies: &[(&str, Signature)],
constants: &[ConstantPoolEntry],
) -> Result<Arc<ValidatedProgramImage>, VmInitError> {
let mut code = vec![];
let mut functions = vec![];
for (source, signature) in bodies {
let body = assemble(source).unwrap();
functions.push(FunctionDecl {
signature: signature.clone(),
local_slots: 8,
max_stack_slots: 64,
code_offset: code.len() as u32,
code_len: body.len() as u32,
..Default::default()
});
code.extend(body);
}
let mut budget = LoadBudget::new(Default::default());
let registry = Registry::resolve(
RegistryDeclarations {
types: types(),
functions,
implementations: vec![
ImplementationDecl { owner: TypeId(5), trait_id: TypeId(7), methods: vec![] },
ImplementationDecl { owner: TypeId(5), trait_id: TypeId(8), methods: vec![] },
],
},
code.len(),
&mut budget,
)
.unwrap();
let bytes = PbxModule {
registry: &registry,
code: &code,
constants,
debug: None,
exports: &[],
syscalls: &[],
}
.serialize(&mut budget)
.unwrap();
ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(Default::default()), 0)
}
pub fn vm(bodies: &[(&str, Signature)], constants: &[ConstantPoolEntry]) -> VirtualMachine {
let mut vm = VirtualMachine::from_image(image(bodies, constants).unwrap(), Default::default());
vm.prepare_boot_call().unwrap();
vm
}
pub fn run(vm: &mut VirtualMachine) -> prometeu_vm::BudgetReport {
vm.run_budget(1_000_000, &mut Native, &mut HostContext::new(None)).unwrap()
}
pub fn step(vm: &mut VirtualMachine) -> Result<(), LogicalFrameEndingReason> {
vm.step(&mut Native, &mut HostContext::new(None))
}
pub fn hex_bytes(value: &str) -> Vec<u8> {
(0..value.len()).step_by(2).map(|i| u8::from_str_radix(&value[i..i + 2], 16).unwrap()).collect()
}