use indexmap::IndexMap;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fmt;
use std::iter::ExactSizeIterator;
use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
use std::sync::Arc;
use wasmer_types::entity::{EntityRef, PrimaryMap};
use wasmer_types::{
CustomSectionIndex, DataIndex, ElemIndex, ExportIndex, ExportType, ExternType, FunctionIndex,
FunctionType, GlobalIndex, GlobalInit, GlobalType, ImportIndex, ImportType, LocalFunctionIndex,
LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex, MemoryType, SignatureIndex,
TableIndex, TableInitializer, TableType,
};
#[derive(Debug)]
pub struct ModuleId {
id: usize,
}
impl ModuleId {
pub fn id(&self) -> String {
format!("{}", &self.id)
}
}
impl Default for ModuleId {
fn default() -> Self {
static NEXT_ID: AtomicUsize = AtomicUsize::new(0);
Self {
id: NEXT_ID.fetch_add(1, SeqCst),
}
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ModuleInfo {
#[serde(skip_serializing, skip_deserializing)]
pub id: ModuleId,
pub name: Option<String>,
pub imports: IndexMap<(String, String, u32), ImportIndex>,
pub exports: IndexMap<String, ExportIndex>,
pub start_function: Option<FunctionIndex>,
pub table_initializers: Vec<TableInitializer>,
pub passive_elements: HashMap<ElemIndex, Box<[FunctionIndex]>>,
pub passive_data: HashMap<DataIndex, Arc<[u8]>>,
pub global_initializers: PrimaryMap<LocalGlobalIndex, GlobalInit>,
pub function_names: HashMap<FunctionIndex, String>,
pub signatures: PrimaryMap<SignatureIndex, FunctionType>,
pub functions: PrimaryMap<FunctionIndex, SignatureIndex>,
pub tables: PrimaryMap<TableIndex, TableType>,
pub memories: PrimaryMap<MemoryIndex, MemoryType>,
pub globals: PrimaryMap<GlobalIndex, GlobalType>,
pub custom_sections: IndexMap<String, CustomSectionIndex>,
pub custom_sections_data: PrimaryMap<CustomSectionIndex, Arc<[u8]>>,
pub num_imported_functions: usize,
pub num_imported_tables: usize,
pub num_imported_memories: usize,
pub num_imported_globals: usize,
}
impl ModuleInfo {
pub fn new() -> Self {
Self {
id: ModuleId::default(),
name: None,
imports: IndexMap::new(),
exports: IndexMap::new(),
start_function: None,
table_initializers: Vec::new(),
passive_elements: HashMap::new(),
passive_data: HashMap::new(),
global_initializers: PrimaryMap::new(),
function_names: HashMap::new(),
signatures: PrimaryMap::new(),
functions: PrimaryMap::new(),
tables: PrimaryMap::new(),
memories: PrimaryMap::new(),
globals: PrimaryMap::new(),
num_imported_functions: 0,
num_imported_tables: 0,
num_imported_memories: 0,
num_imported_globals: 0,
custom_sections: IndexMap::new(),
custom_sections_data: PrimaryMap::new(),
}
}
pub fn get_passive_element(&self, index: ElemIndex) -> Option<&[FunctionIndex]> {
self.passive_elements.get(&index).map(|es| &**es)
}
pub fn exported_signatures(&self) -> Vec<FunctionType> {
self.exports
.iter()
.filter_map(|(_name, export_index)| match export_index {
ExportIndex::Function(i) => {
let signature = self.functions.get(*i).unwrap();
let func_type = self.signatures.get(*signature).unwrap();
Some(func_type.clone())
}
_ => None,
})
.collect::<Vec<FunctionType>>()
}
pub fn exports<'a>(&'a self) -> ExportsIterator<impl Iterator<Item = ExportType> + 'a> {
let iter = self.exports.iter().map(move |(name, export_index)| {
let extern_type = match export_index {
ExportIndex::Function(i) => {
let signature = self.functions.get(*i).unwrap();
let func_type = self.signatures.get(*signature).unwrap();
ExternType::Function(func_type.clone())
}
ExportIndex::Table(i) => {
let table_type = self.tables.get(*i).unwrap();
ExternType::Table(*table_type)
}
ExportIndex::Memory(i) => {
let memory_type = self.memories.get(*i).unwrap();
ExternType::Memory(*memory_type)
}
ExportIndex::Global(i) => {
let global_type = self.globals.get(*i).unwrap();
ExternType::Global(*global_type)
}
};
ExportType::new(name, extern_type)
});
ExportsIterator {
iter,
size: self.exports.len(),
}
}
pub fn imports<'a>(&'a self) -> ImportsIterator<impl Iterator<Item = ImportType> + 'a> {
let iter = self
.imports
.iter()
.map(move |((module, field, _), import_index)| {
let extern_type = match import_index {
ImportIndex::Function(i) => {
let signature = self.functions.get(*i).unwrap();
let func_type = self.signatures.get(*signature).unwrap();
ExternType::Function(func_type.clone())
}
ImportIndex::Table(i) => {
let table_type = self.tables.get(*i).unwrap();
ExternType::Table(*table_type)
}
ImportIndex::Memory(i) => {
let memory_type = self.memories.get(*i).unwrap();
ExternType::Memory(*memory_type)
}
ImportIndex::Global(i) => {
let global_type = self.globals.get(*i).unwrap();
ExternType::Global(*global_type)
}
};
ImportType::new(module, field, extern_type)
});
ImportsIterator {
iter,
size: self.imports.len(),
}
}
pub fn custom_sections<'a>(&'a self, name: &'a str) -> impl Iterator<Item = Arc<[u8]>> + 'a {
self.custom_sections
.iter()
.filter_map(move |(section_name, section_index)| {
if name != section_name {
return None;
}
Some(self.custom_sections_data[*section_index].clone())
})
}
pub fn func_index(&self, local_func: LocalFunctionIndex) -> FunctionIndex {
FunctionIndex::new(self.num_imported_functions + local_func.index())
}
pub fn local_func_index(&self, func: FunctionIndex) -> Option<LocalFunctionIndex> {
func.index()
.checked_sub(self.num_imported_functions)
.map(LocalFunctionIndex::new)
}
pub fn is_imported_function(&self, index: FunctionIndex) -> bool {
index.index() < self.num_imported_functions
}
pub fn table_index(&self, local_table: LocalTableIndex) -> TableIndex {
TableIndex::new(self.num_imported_tables + local_table.index())
}
pub fn local_table_index(&self, table: TableIndex) -> Option<LocalTableIndex> {
table
.index()
.checked_sub(self.num_imported_tables)
.map(LocalTableIndex::new)
}
pub fn is_imported_table(&self, index: TableIndex) -> bool {
index.index() < self.num_imported_tables
}
pub fn memory_index(&self, local_memory: LocalMemoryIndex) -> MemoryIndex {
MemoryIndex::new(self.num_imported_memories + local_memory.index())
}
pub fn local_memory_index(&self, memory: MemoryIndex) -> Option<LocalMemoryIndex> {
memory
.index()
.checked_sub(self.num_imported_memories)
.map(LocalMemoryIndex::new)
}
pub fn is_imported_memory(&self, index: MemoryIndex) -> bool {
index.index() < self.num_imported_memories
}
pub fn global_index(&self, local_global: LocalGlobalIndex) -> GlobalIndex {
GlobalIndex::new(self.num_imported_globals + local_global.index())
}
pub fn local_global_index(&self, global: GlobalIndex) -> Option<LocalGlobalIndex> {
global
.index()
.checked_sub(self.num_imported_globals)
.map(LocalGlobalIndex::new)
}
pub fn is_imported_global(&self, index: GlobalIndex) -> bool {
index.index() < self.num_imported_globals
}
pub fn name(&self) -> String {
match self.name {
Some(ref name) => name.to_string(),
None => "<module>".to_string(),
}
}
pub fn imported_function_types<'a>(&'a self) -> impl Iterator<Item = FunctionType> + 'a {
self.functions
.values()
.take(self.num_imported_functions)
.map(move |sig_index| self.signatures[*sig_index].clone())
}
}
impl fmt::Display for ModuleInfo {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.name())
}
}
pub struct ExportsIterator<I: Iterator<Item = ExportType> + Sized> {
iter: I,
size: usize,
}
impl<I: Iterator<Item = ExportType> + Sized> ExactSizeIterator for ExportsIterator<I> {
fn len(&self) -> usize {
self.size
}
}
impl<I: Iterator<Item = ExportType> + Sized> ExportsIterator<I> {
pub fn functions(self) -> impl Iterator<Item = ExportType<FunctionType>> + Sized {
self.iter.filter_map(|extern_| match extern_.ty() {
ExternType::Function(ty) => Some(ExportType::new(extern_.name(), ty.clone())),
_ => None,
})
}
pub fn memories(self) -> impl Iterator<Item = ExportType<MemoryType>> + Sized {
self.iter.filter_map(|extern_| match extern_.ty() {
ExternType::Memory(ty) => Some(ExportType::new(extern_.name(), *ty)),
_ => None,
})
}
pub fn tables(self) -> impl Iterator<Item = ExportType<TableType>> + Sized {
self.iter.filter_map(|extern_| match extern_.ty() {
ExternType::Table(ty) => Some(ExportType::new(extern_.name(), *ty)),
_ => None,
})
}
pub fn globals(self) -> impl Iterator<Item = ExportType<GlobalType>> + Sized {
self.iter.filter_map(|extern_| match extern_.ty() {
ExternType::Global(ty) => Some(ExportType::new(extern_.name(), *ty)),
_ => None,
})
}
}
impl<I: Iterator<Item = ExportType> + Sized> Iterator for ExportsIterator<I> {
type Item = ExportType;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next()
}
}
pub struct ImportsIterator<I: Iterator<Item = ImportType> + Sized> {
iter: I,
size: usize,
}
impl<I: Iterator<Item = ImportType> + Sized> ExactSizeIterator for ImportsIterator<I> {
fn len(&self) -> usize {
self.size
}
}
impl<I: Iterator<Item = ImportType> + Sized> ImportsIterator<I> {
pub fn functions(self) -> impl Iterator<Item = ImportType<FunctionType>> + Sized {
self.iter.filter_map(|extern_| match extern_.ty() {
ExternType::Function(ty) => Some(ImportType::new(
extern_.module(),
extern_.name(),
ty.clone(),
)),
_ => None,
})
}
pub fn memories(self) -> impl Iterator<Item = ImportType<MemoryType>> + Sized {
self.iter.filter_map(|extern_| match extern_.ty() {
ExternType::Memory(ty) => Some(ImportType::new(extern_.module(), extern_.name(), *ty)),
_ => None,
})
}
pub fn tables(self) -> impl Iterator<Item = ImportType<TableType>> + Sized {
self.iter.filter_map(|extern_| match extern_.ty() {
ExternType::Table(ty) => Some(ImportType::new(extern_.module(), extern_.name(), *ty)),
_ => None,
})
}
pub fn globals(self) -> impl Iterator<Item = ImportType<GlobalType>> + Sized {
self.iter.filter_map(|extern_| match extern_.ty() {
ExternType::Global(ty) => Some(ImportType::new(extern_.module(), extern_.name(), *ty)),
_ => None,
})
}
}
impl<I: Iterator<Item = ImportType> + Sized> Iterator for ImportsIterator<I> {
type Item = ImportType;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next()
}
}