use crate::engine::error::LinkError;
use crate::types::target::{PointerWidth, Target};
use std::ptr::NonNull;
use wasmer_types::entity::{EntityRef, PrimaryMap};
use wasmer_types::{
GlobalType, LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex, MemoryType,
ModuleInfo, Pages, TableIndex, TableType,
};
use wasmer_vm::{InternalStoreHandle, MemoryError, StoreObjects};
use wasmer_vm::{MemoryStyle, TableStyle};
use wasmer_vm::{VMConfig, VMGlobal, VMMemory, VMTable};
use wasmer_vm::{VMMemoryDefinition, VMTableDefinition};
pub trait Tunables {
fn memory_style(&self, memory: &MemoryType) -> MemoryStyle;
fn table_style(&self, table: &TableType) -> TableStyle;
fn create_host_memory(
&self,
ty: &MemoryType,
style: &MemoryStyle,
) -> Result<VMMemory, MemoryError>;
unsafe fn create_vm_memory(
&self,
ty: &MemoryType,
style: &MemoryStyle,
vm_definition_location: NonNull<VMMemoryDefinition>,
) -> Result<VMMemory, MemoryError>;
fn create_host_table(&self, ty: &TableType, style: &TableStyle) -> Result<VMTable, String>;
unsafe fn create_vm_table(
&self,
ty: &TableType,
style: &TableStyle,
vm_definition_location: NonNull<VMTableDefinition>,
) -> Result<VMTable, String>;
fn create_global(&self, ty: GlobalType) -> Result<VMGlobal, String> {
Ok(VMGlobal::new(ty))
}
#[allow(clippy::result_large_err)]
unsafe fn create_memories(
&self,
context: &mut StoreObjects,
module: &ModuleInfo,
memory_styles: &PrimaryMap<MemoryIndex, MemoryStyle>,
memory_definition_locations: &[NonNull<VMMemoryDefinition>],
) -> Result<PrimaryMap<LocalMemoryIndex, InternalStoreHandle<VMMemory>>, LinkError> {
let num_imports = module.num_imported_memories;
let mut memories: PrimaryMap<LocalMemoryIndex, _> =
PrimaryMap::with_capacity(module.memories.len() - num_imports);
for (index, mdl) in memory_definition_locations
.iter()
.enumerate()
.take(module.memories.len())
.skip(num_imports)
{
let mi = MemoryIndex::new(index);
let ty = &module.memories[mi];
let style = &memory_styles[mi];
memories.push(InternalStoreHandle::new(
context,
self.create_vm_memory(ty, style, *mdl)
.map_err(|e| LinkError::Resource(format!("Failed to create memory: {}", e)))?,
));
}
Ok(memories)
}
#[allow(clippy::result_large_err)]
unsafe fn create_tables(
&self,
context: &mut StoreObjects,
module: &ModuleInfo,
table_styles: &PrimaryMap<TableIndex, TableStyle>,
table_definition_locations: &[NonNull<VMTableDefinition>],
) -> Result<PrimaryMap<LocalTableIndex, InternalStoreHandle<VMTable>>, LinkError> {
let num_imports = module.num_imported_tables;
let mut tables: PrimaryMap<LocalTableIndex, _> =
PrimaryMap::with_capacity(module.tables.len() - num_imports);
for (index, tdl) in table_definition_locations
.iter()
.enumerate()
.take(module.tables.len())
.skip(num_imports)
{
let ti = TableIndex::new(index);
let ty = &module.tables[ti];
let style = &table_styles[ti];
tables.push(InternalStoreHandle::new(
context,
self.create_vm_table(ty, style, *tdl)
.map_err(LinkError::Resource)?,
));
}
Ok(tables)
}
#[allow(clippy::result_large_err)]
fn create_globals(
&self,
context: &mut StoreObjects,
module: &ModuleInfo,
) -> Result<PrimaryMap<LocalGlobalIndex, InternalStoreHandle<VMGlobal>>, LinkError> {
let num_imports = module.num_imported_globals;
let mut vmctx_globals = PrimaryMap::with_capacity(module.globals.len() - num_imports);
for &global_type in module.globals.values().skip(num_imports) {
vmctx_globals.push(InternalStoreHandle::new(
context,
self.create_global(global_type)
.map_err(LinkError::Resource)?,
));
}
Ok(vmctx_globals)
}
fn vmconfig(&self) -> &VMConfig {
&VMConfig {
wasm_stack_size: None,
}
}
}
#[derive(Clone)]
pub struct BaseTunables {
pub static_memory_bound: Pages,
pub static_memory_offset_guard_size: u64,
pub dynamic_memory_offset_guard_size: u64,
}
impl BaseTunables {
pub fn for_target(target: &Target) -> Self {
let triple = target.triple();
let pointer_width: PointerWidth = triple.pointer_width().unwrap();
let (static_memory_bound, static_memory_offset_guard_size): (Pages, u64) =
match pointer_width {
PointerWidth::U16 => (0x400.into(), 0x1000),
PointerWidth::U32 => (0x4000.into(), 0x1_0000),
PointerWidth::U64 => (0x1_0000.into(), 0x8000_0000),
};
#[cfg(target_os = "windows")]
let dynamic_memory_offset_guard_size: u64 = 0x2_0000;
#[cfg(not(target_os = "windows"))]
let dynamic_memory_offset_guard_size: u64 = 0x1_0000;
Self {
static_memory_bound,
static_memory_offset_guard_size,
dynamic_memory_offset_guard_size,
}
}
}
impl Tunables for BaseTunables {
fn memory_style(&self, memory: &MemoryType) -> MemoryStyle {
let maximum = memory.maximum.unwrap_or_else(Pages::max_value);
if maximum <= self.static_memory_bound {
MemoryStyle::Static {
bound: self.static_memory_bound,
offset_guard_size: self.static_memory_offset_guard_size,
}
} else {
MemoryStyle::Dynamic {
offset_guard_size: self.dynamic_memory_offset_guard_size,
}
}
}
fn table_style(&self, _table: &TableType) -> TableStyle {
TableStyle::CallerChecksSignature
}
fn create_host_memory(
&self,
ty: &MemoryType,
style: &MemoryStyle,
) -> Result<VMMemory, MemoryError> {
VMMemory::new(ty, style)
}
unsafe fn create_vm_memory(
&self,
ty: &MemoryType,
style: &MemoryStyle,
vm_definition_location: NonNull<VMMemoryDefinition>,
) -> Result<VMMemory, MemoryError> {
VMMemory::from_definition(ty, style, vm_definition_location)
}
fn create_host_table(&self, ty: &TableType, style: &TableStyle) -> Result<VMTable, String> {
VMTable::new(ty, style)
}
unsafe fn create_vm_table(
&self,
ty: &TableType,
style: &TableStyle,
vm_definition_location: NonNull<VMTableDefinition>,
) -> Result<VMTable, String> {
VMTable::from_definition(ty, style, vm_definition_location)
}
}
impl Tunables for Box<dyn Tunables + Send + Sync> {
fn memory_style(&self, memory: &MemoryType) -> MemoryStyle {
self.as_ref().memory_style(memory)
}
fn table_style(&self, table: &TableType) -> TableStyle {
self.as_ref().table_style(table)
}
fn create_host_memory(
&self,
ty: &MemoryType,
style: &MemoryStyle,
) -> Result<VMMemory, MemoryError> {
self.as_ref().create_host_memory(ty, style)
}
unsafe fn create_vm_memory(
&self,
ty: &MemoryType,
style: &MemoryStyle,
vm_definition_location: NonNull<VMMemoryDefinition>,
) -> Result<VMMemory, MemoryError> {
self.as_ref()
.create_vm_memory(ty, style, vm_definition_location)
}
fn create_host_table(&self, ty: &TableType, style: &TableStyle) -> Result<VMTable, String> {
self.as_ref().create_host_table(ty, style)
}
unsafe fn create_vm_table(
&self,
ty: &TableType,
style: &TableStyle,
vm_definition_location: NonNull<VMTableDefinition>,
) -> Result<VMTable, String> {
self.as_ref()
.create_vm_table(ty, style, vm_definition_location)
}
}
impl Tunables for std::sync::Arc<dyn Tunables + Send + Sync> {
fn memory_style(&self, memory: &MemoryType) -> MemoryStyle {
self.as_ref().memory_style(memory)
}
fn table_style(&self, table: &TableType) -> TableStyle {
self.as_ref().table_style(table)
}
fn create_host_memory(
&self,
ty: &MemoryType,
style: &MemoryStyle,
) -> Result<VMMemory, MemoryError> {
self.as_ref().create_host_memory(ty, style)
}
unsafe fn create_vm_memory(
&self,
ty: &MemoryType,
style: &MemoryStyle,
vm_definition_location: NonNull<VMMemoryDefinition>,
) -> Result<VMMemory, MemoryError> {
self.as_ref()
.create_vm_memory(ty, style, vm_definition_location)
}
fn create_host_table(&self, ty: &TableType, style: &TableStyle) -> Result<VMTable, String> {
self.as_ref().create_host_table(ty, style)
}
unsafe fn create_vm_table(
&self,
ty: &TableType,
style: &TableStyle,
vm_definition_location: NonNull<VMTableDefinition>,
) -> Result<VMTable, String> {
self.as_ref()
.create_vm_table(ty, style, vm_definition_location)
}
}