use crate::StaticlibArtifact;
use loupe::MemoryUsage;
use std::io::Read;
use std::path::Path;
use std::sync::{Arc, Mutex};
#[cfg(feature = "compiler")]
use wasmer_compiler::Compiler;
use wasmer_compiler::{CompileError, Target};
use wasmer_engine::{Artifact, DeserializeError, Engine, EngineId, Tunables};
#[cfg(feature = "compiler")]
use wasmer_types::Features;
use wasmer_types::FunctionType;
use wasmer_vm::{
FuncDataRegistry, SignatureRegistry, VMCallerCheckedAnyfunc, VMFuncRef, VMSharedSignatureIndex,
};
#[derive(Clone, MemoryUsage)]
pub struct StaticlibEngine {
inner: Arc<Mutex<StaticlibEngineInner>>,
target: Arc<Target>,
engine_id: EngineId,
}
impl StaticlibEngine {
#[cfg(feature = "compiler")]
pub fn new(compiler: Box<dyn Compiler>, target: Target, features: Features) -> Self {
Self {
inner: Arc::new(Mutex::new(StaticlibEngineInner {
compiler: Some(compiler),
signatures: SignatureRegistry::new(),
func_data: Arc::new(FuncDataRegistry::new()),
prefixer: None,
features,
})),
target: Arc::new(target),
engine_id: EngineId::default(),
}
}
pub fn headless() -> Self {
Self {
inner: Arc::new(Mutex::new(StaticlibEngineInner {
#[cfg(feature = "compiler")]
compiler: None,
#[cfg(feature = "compiler")]
features: Features::default(),
signatures: SignatureRegistry::new(),
func_data: Arc::new(FuncDataRegistry::new()),
prefixer: None,
})),
target: Arc::new(Target::default()),
engine_id: EngineId::default(),
}
}
pub fn set_deterministic_prefixer<F>(&mut self, prefixer: F)
where
F: Fn(&[u8]) -> String + Send + 'static,
{
let mut inner = self.inner_mut();
inner.prefixer = Some(Box::new(prefixer));
}
pub(crate) fn inner(&self) -> std::sync::MutexGuard<'_, StaticlibEngineInner> {
self.inner.lock().unwrap()
}
pub(crate) fn inner_mut(&self) -> std::sync::MutexGuard<'_, StaticlibEngineInner> {
self.inner.lock().unwrap()
}
}
impl Engine for StaticlibEngine {
fn target(&self) -> &Target {
&self.target
}
fn register_signature(&self, func_type: &FunctionType) -> VMSharedSignatureIndex {
let compiler = self.inner();
compiler.signatures().register(func_type)
}
fn register_function_metadata(&self, func_data: VMCallerCheckedAnyfunc) -> VMFuncRef {
let compiler = self.inner();
compiler.func_data().register(func_data)
}
fn lookup_signature(&self, sig: VMSharedSignatureIndex) -> Option<FunctionType> {
let compiler = self.inner();
compiler.signatures().lookup(sig)
}
fn validate(&self, binary: &[u8]) -> Result<(), CompileError> {
self.inner().validate(binary)
}
#[cfg(feature = "compiler")]
fn compile(
&self,
binary: &[u8],
tunables: &dyn Tunables,
) -> Result<Arc<dyn Artifact>, CompileError> {
Ok(Arc::new(StaticlibArtifact::new(&self, binary, tunables)?))
}
#[cfg(not(feature = "compiler"))]
fn compile(
&self,
_binary: &[u8],
_tunables: &dyn Tunables,
) -> Result<Arc<dyn Artifact>, CompileError> {
Err(CompileError::Codegen(
"The `StaticlibEngine` is operating in headless mode, so it cannot compile a module."
.to_string(),
))
}
unsafe fn deserialize(&self, bytes: &[u8]) -> Result<Arc<dyn Artifact>, DeserializeError> {
Ok(Arc::new(StaticlibArtifact::deserialize(&self, &bytes)?))
}
unsafe fn deserialize_from_file(
&self,
file_ref: &Path,
) -> Result<Arc<dyn Artifact>, DeserializeError> {
let mut f = std::fs::File::open(file_ref)?;
let mut vec = vec![];
f.read_to_end(&mut vec)?;
self.deserialize(&vec[..])
}
fn id(&self) -> &EngineId {
&self.engine_id
}
fn cloned(&self) -> Arc<dyn Engine + Send + Sync> {
Arc::new(self.clone())
}
}
#[derive(MemoryUsage)]
pub struct StaticlibEngineInner {
#[cfg(feature = "compiler")]
compiler: Option<Box<dyn Compiler>>,
#[cfg(feature = "compiler")]
features: Features,
signatures: SignatureRegistry,
func_data: Arc<FuncDataRegistry>,
#[loupe(skip)]
prefixer: Option<Box<dyn Fn(&[u8]) -> String + Send>>,
}
impl StaticlibEngineInner {
#[cfg(feature = "compiler")]
pub fn compiler(&self) -> Result<&dyn Compiler, CompileError> {
if self.compiler.is_none() {
return Err(CompileError::Codegen("The `StaticlibEngine` is operating in headless mode, so it can only execute already compiled Modules.".to_string()));
}
Ok(&**self
.compiler
.as_ref()
.expect("Can't get compiler reference"))
}
#[cfg(feature = "compiler")]
pub(crate) fn get_prefix(&self, bytes: &[u8]) -> String {
if let Some(prefixer) = &self.prefixer {
prefixer(&bytes)
} else {
"".to_string()
}
}
#[cfg(feature = "compiler")]
pub(crate) fn features(&self) -> &Features {
&self.features
}
#[cfg(feature = "compiler")]
pub fn validate<'data>(&self, data: &'data [u8]) -> Result<(), CompileError> {
self.compiler()?.validate_module(self.features(), data)
}
#[cfg(not(feature = "compiler"))]
pub fn validate<'data>(&self, _data: &'data [u8]) -> Result<(), CompileError> {
Err(CompileError::Validate(
"The `StaticlibEngine` is not compiled with compiler support, which is required for validating".to_string(),
))
}
pub fn signatures(&self) -> &SignatureRegistry {
&self.signatures
}
pub(crate) fn func_data(&self) -> &Arc<FuncDataRegistry> {
&self.func_data
}
}