use anyhow::{Context, Result};
use rustc_demangle::demangle;
use std::collections::HashMap;
use std::path::Path;
use wasmparser::{ExternalKind, Parser, Payload};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
#[serde(rename_all = "snake_case")]
pub enum WasmItemKind {
Function,
Data,
Table,
Memory,
Global,
Element,
Export,
Import,
Type,
Custom,
Code,
ComponentExport,
ComponentImport,
ComponentInstance,
ComponentType,
}
impl std::fmt::Display for WasmItemKind {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
WasmItemKind::Function => write!(f, "function"),
WasmItemKind::Data => write!(f, "data"),
WasmItemKind::Table => write!(f, "table"),
WasmItemKind::Memory => write!(f, "memory"),
WasmItemKind::Global => write!(f, "global"),
WasmItemKind::Element => write!(f, "element"),
WasmItemKind::Export => write!(f, "export"),
WasmItemKind::Import => write!(f, "import"),
WasmItemKind::Type => write!(f, "type"),
WasmItemKind::Custom => write!(f, "custom"),
WasmItemKind::Code => write!(f, "code"),
WasmItemKind::ComponentExport => write!(f, "component-export"),
WasmItemKind::ComponentImport => write!(f, "component-import"),
WasmItemKind::ComponentInstance => write!(f, "component-instance"),
WasmItemKind::ComponentType => write!(f, "component-type"),
}
}
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct WasmItem {
pub id: u32,
pub kind: WasmItemKind,
pub name: String,
pub raw_name: String,
pub size: u64,
pub offset: usize,
pub func_index: Option<u32>,
}
impl WasmItem {
pub fn new(id: u32, kind: WasmItemKind, name: &str, size: u64, offset: usize) -> Self {
let demangled = demangle_name(name);
Self {
id,
kind,
name: demangled,
raw_name: name.to_string(),
size,
offset,
func_index: None,
}
}
pub fn with_func_index(mut self, index: u32) -> Self {
self.func_index = Some(index);
self
}
}
fn demangle_name(name: &str) -> String {
format!("{:#}", demangle(name))
}
#[derive(Debug, Default)]
pub struct ParsedWasm {
pub items: Vec<WasmItem>,
pub func_names: HashMap<u32, String>,
pub is_component: bool,
pub total_size: u64,
pub section_sizes: HashMap<String, u64>,
pub component_exports: Vec<ComponentExportInfo>,
pub call_graph: HashMap<u32, Vec<u32>>,
pub num_imported_funcs: u32,
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct ComponentExportInfo {
pub name: String,
pub kind: String,
pub size_estimate: u64,
}
pub fn parse_wasm(path: &Path) -> Result<ParsedWasm> {
let bytes =
std::fs::read(path).with_context(|| format!("Failed to read {}", path.display()))?;
parse_wasm_bytes(&bytes)
}
pub fn parse_wasm_bytes(bytes: &[u8]) -> Result<ParsedWasm> {
let mut parsed = ParsedWasm {
total_size: bytes.len() as u64,
..Default::default()
};
let mut next_id = 0u32;
let mut func_types: Vec<u32> = Vec::new();
let mut code_offsets: Vec<(usize, usize)> = Vec::new(); let mut current_func_index = 0u32;
for payload in Parser::new(0).parse_all(bytes) {
let payload = payload.context("Failed to parse WASM payload")?;
match payload {
Payload::Version { encoding, .. } => {
parsed.is_component = matches!(encoding, wasmparser::Encoding::Component);
}
Payload::TypeSection(reader) => {
let section_start = reader.range().start;
let section_size = reader.range().end - section_start;
parsed
.section_sizes
.insert("type".to_string(), section_size as u64);
}
Payload::ImportSection(reader) => {
let section_start = reader.range().start;
let section_size = reader.range().end - section_start;
parsed
.section_sizes
.insert("import".to_string(), section_size as u64);
for import in reader {
let import = import?;
let name = format!("{}::{}", import.module, import.name);
let item =
WasmItem::new(next_id, WasmItemKind::Import, &name, 0, section_start);
next_id += 1;
parsed.items.push(item);
if matches!(import.ty, wasmparser::TypeRef::Func(_)) {
parsed.num_imported_funcs += 1;
}
}
}
Payload::FunctionSection(reader) => {
let section_start = reader.range().start;
let section_size = reader.range().end - section_start;
parsed
.section_sizes
.insert("function".to_string(), section_size as u64);
for func_type_idx in reader {
let func_type_idx = func_type_idx?;
func_types.push(func_type_idx);
}
}
Payload::TableSection(reader) => {
let section_start = reader.range().start;
let section_size = reader.range().end - section_start;
parsed
.section_sizes
.insert("table".to_string(), section_size as u64);
for (i, _table) in reader.into_iter().enumerate() {
let item = WasmItem::new(
next_id,
WasmItemKind::Table,
&format!("table[{}]", i),
0,
section_start,
);
next_id += 1;
parsed.items.push(item);
}
}
Payload::MemorySection(reader) => {
let section_start = reader.range().start;
let section_size = reader.range().end - section_start;
parsed
.section_sizes
.insert("memory".to_string(), section_size as u64);
}
Payload::GlobalSection(reader) => {
let section_start = reader.range().start;
let section_size = reader.range().end - section_start;
parsed
.section_sizes
.insert("global".to_string(), section_size as u64);
for (i, _global) in reader.into_iter().enumerate() {
let item = WasmItem::new(
next_id,
WasmItemKind::Global,
&format!("global[{}]", i),
0,
section_start,
);
next_id += 1;
parsed.items.push(item);
}
}
Payload::ExportSection(reader) => {
let section_start = reader.range().start;
let section_size = reader.range().end - section_start;
parsed
.section_sizes
.insert("export".to_string(), section_size as u64);
for export in reader {
let export = export?;
let kind_str = match export.kind {
ExternalKind::Func => "func",
ExternalKind::Table => "table",
ExternalKind::Memory => "memory",
ExternalKind::Global => "global",
ExternalKind::Tag => "tag",
};
let name = format!("export:{} ({})", export.name, kind_str);
let item =
WasmItem::new(next_id, WasmItemKind::Export, &name, 0, section_start);
next_id += 1;
parsed.items.push(item);
}
}
Payload::ElementSection(reader) => {
let section_start = reader.range().start;
let section_size = reader.range().end - section_start;
parsed
.section_sizes
.insert("element".to_string(), section_size as u64);
}
Payload::DataSection(reader) => {
let section_start = reader.range().start;
let section_size = reader.range().end - section_start;
parsed
.section_sizes
.insert("data".to_string(), section_size as u64);
for (i, data) in reader.into_iter().enumerate() {
let data = data?;
let data_size = data.data.len() as u64;
let item = WasmItem::new(
next_id,
WasmItemKind::Data,
&format!("data[{}]", i),
data_size,
section_start,
);
next_id += 1;
parsed.items.push(item);
}
}
Payload::CodeSectionStart { range, .. } => {
let section_size = range.end - range.start;
parsed
.section_sizes
.insert("code".to_string(), section_size as u64);
}
Payload::CodeSectionEntry(body) => {
let body_range = body.range();
let func_size = body_range.end - body_range.start;
code_offsets.push((body_range.start, func_size));
let func_idx = parsed.num_imported_funcs + current_func_index;
let mut called_funcs = Vec::new();
let mut operators = body.get_operators_reader()?;
while !operators.eof() {
if let Ok(op) = operators.read() {
match op {
wasmparser::Operator::Call { function_index } => {
called_funcs.push(function_index);
}
wasmparser::Operator::CallIndirect { .. } => {
}
_ => {}
}
}
}
parsed.call_graph.insert(func_idx, called_funcs);
current_func_index += 1;
}
Payload::CustomSection(reader) => {
let section_size = reader.range().end - reader.range().start;
let name = reader.name();
if name == "name" {
let name_reader =
wasmparser::NameSectionReader::new(reader.data(), reader.data_offset());
for name_entry in name_reader.flatten() {
if let wasmparser::Name::Function(func_names) = name_entry {
for naming in func_names.into_iter().flatten() {
parsed
.func_names
.insert(naming.index, naming.name.to_string());
}
}
}
}
let existing = parsed
.section_sizes
.get(&format!("custom:{}", name))
.unwrap_or(&0);
parsed
.section_sizes
.insert(format!("custom:{}", name), existing + section_size as u64);
}
Payload::ComponentExportSection(reader) => {
for export in reader {
let export = export?;
let kind_str = match export.kind {
wasmparser::ComponentExternalKind::Module => "module",
wasmparser::ComponentExternalKind::Func => "func",
wasmparser::ComponentExternalKind::Value => "value",
wasmparser::ComponentExternalKind::Type => "type",
wasmparser::ComponentExternalKind::Instance => "instance",
wasmparser::ComponentExternalKind::Component => "component",
};
parsed.component_exports.push(ComponentExportInfo {
name: export.name.0.to_string(),
kind: kind_str.to_string(),
size_estimate: 0, });
}
}
Payload::ComponentImportSection(reader) => {
let section_start = reader.range().start;
for import in reader {
let import = import?;
let item = WasmItem::new(
next_id,
WasmItemKind::ComponentImport,
import.name.0,
0,
section_start,
);
next_id += 1;
parsed.items.push(item);
}
}
Payload::ModuleSection { range, .. } => {
let section_size = range.end - range.start;
parsed
.section_sizes
.insert("module".to_string(), section_size as u64);
}
Payload::InstanceSection(reader) => {
let section_start = reader.range().start;
let section_size = reader.range().end - section_start;
parsed
.section_sizes
.insert("instance".to_string(), section_size as u64);
}
Payload::CoreTypeSection(reader) => {
let section_start = reader.range().start;
let section_size = reader.range().end - section_start;
parsed
.section_sizes
.insert("core-type".to_string(), section_size as u64);
}
Payload::ComponentTypeSection(reader) => {
let section_start = reader.range().start;
let section_size = reader.range().end - section_start;
parsed
.section_sizes
.insert("component-type".to_string(), section_size as u64);
}
Payload::ComponentCanonicalSection(reader) => {
let section_start = reader.range().start;
let section_size = reader.range().end - section_start;
parsed
.section_sizes
.insert("canonical".to_string(), section_size as u64);
}
Payload::ComponentStartSection { .. } => {}
Payload::ComponentAliasSection(reader) => {
let section_start = reader.range().start;
let section_size = reader.range().end - section_start;
parsed
.section_sizes
.insert("alias".to_string(), section_size as u64);
}
_ => {}
}
}
for (local_idx, (offset, size)) in code_offsets.iter().enumerate() {
let func_idx = parsed.num_imported_funcs + local_idx as u32;
let name = parsed
.func_names
.get(&func_idx)
.cloned()
.unwrap_or_else(|| format!("func[{}]", func_idx));
let item = WasmItem::new(
next_id,
WasmItemKind::Function,
&name,
*size as u64,
*offset,
)
.with_func_index(func_idx);
next_id += 1;
parsed.items.push(item);
}
Ok(parsed)
}
pub fn parse_wasm_component(path: &Path) -> Result<ParsedWasm> {
parse_wasm(path)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_demangle_rust_name() {
let mangled = "_ZN4core3fmt5Write9write_fmt17h1234567890abcdefE";
let demangled = demangle_name(mangled);
assert!(demangled.contains("core::fmt"));
}
#[test]
fn test_wasm_item_creation() {
let item = WasmItem::new(0, WasmItemKind::Function, "test_func", 100, 0);
assert_eq!(item.size, 100);
assert_eq!(item.kind, WasmItemKind::Function);
}
}