Struct Module

pub struct Module<'a> {
    pub orig_bytes: Option<&'a [u8]>,
    pub funcs: EntityVec<Func, FuncDecl<'a>>,
    pub signatures: EntityVec<Signature, SignatureData>,
    pub globals: EntityVec<Global, GlobalData>,
    pub tables: EntityVec<Table, TableData>,
    pub imports: Vec<Import>,
    pub exports: Vec<Export>,
    pub memories: EntityVec<Memory, MemoryData>,
    pub start_func: Option<Func>,
    pub debug: Debug,
    pub debug_map: DebugMap,
    pub custom_sections: BTreeMap<String, &'a [u8]>,
}

A Wasm module, represented as a collection of IR entities.

The module retains a reference to the original Wasm module’s bytes in memory, so that function bodies can optionally refer to ranges of bytecode in the original module without parsing, lifting to IR, and recompiling them. A new module may be built without original bytes (i.e., a Module<'static> with orig_bytes: &[]) using Module::empty().

The ordinary flow for a tool that processes a Wasm module is:

• Parse an existing Wasm module using Module::from_wasm_bytes().
• For any functions where IR is required, parse the original bytecode into IR using Module::expand_func().
• Modify these function bodies (update the FuncDecl), and/or append new function bodies to funcs.
• Compile the IR to a new Wasm module with Module::to_wasm_bytes().

Fields

orig_bytes: Option<&'a [u8]>

The original Wasm module this module was parsed from, if any. Used only for “lazy function bodies”, which retain a range that can refer into this slice.

funcs: EntityVec<Func, FuncDecl<'a>>

The functions in this module: imports, un-expanded (“lazily parsed”) functions, functions as IR, or IR compiled into new bytecode.

signatures: EntityVec<Signature, SignatureData>

Type signatures, referred to by funcs, imports and exports.

globals: EntityVec<Global, GlobalData>

Global variables in this module.

tables: EntityVec<Table, TableData>

Tables in this module.

imports: Vec<Import>

Imports into this module. Function imports must also have an entry at the appropriate function index in funcs.

exports: Vec<Export>

Exports from this module.

memories: EntityVec<Memory, MemoryData>

Memories/heapds that this module contains.

start_func: Option<Func>

The “start function” invoked at instantiation, if any.

debug: Debug

Debug-info associated with function bodies: interning pools for source file names and locations in those files.

debug_map: DebugMap

Maps from original Wasm bytecode offsets to source locations.

custom_sections: BTreeMap<String, &'a [u8]>

Other custom sections retained for re-serialization.

Implementations

impl<'a> Module<'a>

pub fn empty() -> Module<'static>

Create a new empty Wasm module, ready for entities to be added.

pub fn from_wasm_bytes( bytes: &'a [u8], options: &FrontendOptions, ) -> Result<Self>

Parse a WebAssembly module, as a slice of bytes in memory, into a waffle Module ready to be manipulated and recompile.

pub fn without_orig_bytes(self) -> Module<'static>

Take this module and strip its reference to the original bytes, producing a module with the same logical contents.

Note that this has a few side-effects:

• Any (non-debug) custom sections are lost; i.e., they will not be roundtripped from the original Wasm module.
• All function bodies are expanded to IR so they can be recompiled into new bytecode. The bytecode should be equivalent, but will not literally be the same bytecode as the original module.

pub fn to_wasm_bytes(&self) -> Result<Vec<u8>>

Compile the module to Wasm bytecode.

pub fn per_func_body<F: Fn(&mut FunctionBody)>(&mut self, f: F)

Perform some work on each function body with IR.

pub fn expand_func<'b>(&'b mut self, id: Func) -> Result<&'b mut FuncDecl<'a>>

Expand a function body, parsing its lazy reference to original bytecode into IR if needed.

pub fn clone_and_expand_body(&self, id: Func) -> Result<FunctionBody>

Clone a function body without expanding it, and return a new function body with IR expanded. Useful when a tool appends new functions that are processed versions of an original function (which itself must remain as well).

pub fn expand_all_funcs(&mut self) -> Result<()>

For all functions that are lazy references to initial bytecode, expand them into IR.

pub fn display<'b>(&'b self) -> ModuleDisplay<'b>

where 'b: 'a,

Return a wrapper that implements Display on this module, pretty-printing it as textual IR.

Trait Implementations

impl<'a> Clone for Module<'a>

fn clone(&self) -> Module<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Module<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.