Struct walrus::Module

pub struct Module {
    pub imports: ModuleImports,
    pub tables: ModuleTables,
    pub types: ModuleTypes,
    pub funcs: ModuleFunctions,
    pub globals: ModuleGlobals,
    pub locals: ModuleLocals,
    pub exports: ModuleExports,
    pub memories: ModuleMemories,
    pub data: ModuleData,
    pub elements: ModuleElements,
    pub start: Option<FunctionId>,
    pub producers: ModuleProducers,
    pub customs: ModuleCustomSections,
    pub name: Option<String>,
    // some fields omitted
}

A wasm module.

Fields

imports: ModuleImports

tables: ModuleTables

types: ModuleTypes

funcs: ModuleFunctions

globals: ModuleGlobals

locals: ModuleLocals

exports: ModuleExports

memories: ModuleMemories

data: ModuleData

Registration of passive data segments, if any

elements: ModuleElements

Registration of passive element segments, if any

start: Option<FunctionId>

The start function, if any

producers: ModuleProducers

Representation of the eventual custom section, producers

customs: ModuleCustomSections

Custom sections found in this module.

name: Option<String>

The name of this module, used for debugging purposes in the name custom section.

Methods

impl Module

pub fn write_graphviz_dot(&self, path: impl AsRef<Path>) -> Result<()>

Generate a GraphViz Dot file for this module, showing the relationship between various structures in the module and its instructions.

Example

First, generate a .dot file with this method:

let my_module: walrus::Module = get_module_from_somewhere();
my_module.write_graphviz_dot("my_module.dot")?;

Second, use the dot command-line tool to render an SVG (or PNG, etc...):

dot my_module.dot \       # Provide our generated `.dot`.
    -T svg \              # Generate an SVG image.
    -o my_module.svg      # Write to this output file.

impl Module

pub fn add_import_func(
    &mut self,
    module: &str,
    name: &str,
    ty: TypeId
) -> (FunctionId, ImportId)

Add an imported function to this module

pub fn add_import_memory(
    &mut self,
    module: &str,
    name: &str,
    shared: bool,
    initial: u32,
    maximum: Option<u32>
) -> (MemoryId, ImportId)

Add an imported memory to this module

pub fn add_import_table(
    &mut self,
    module: &str,
    name: &str,
    initial: u32,
    max: Option<u32>,
    kind: TableKind
) -> (TableId, ImportId)

Add an imported table to this module

pub fn add_import_global(
    &mut self,
    module: &str,
    name: &str,
    ty: ValType,
    mutable: bool
) -> (GlobalId, ImportId)

Add an imported global to this module

impl Module

pub fn with_config(config: ModuleConfig) -> Self

Create a default, empty module that uses the given configuration.

pub fn from_file<P>(path: P) -> Result<Module> where
    P: AsRef<Path>, 

Construct a new module from the given path with the default configuration.

pub fn from_file_with_config<P>(
    path: P,
    config: &ModuleConfig
) -> Result<Module> where
    P: AsRef<Path>, 

Construct a new module from the given path and configuration.

pub fn from_buffer(wasm: &[u8]) -> Result<Module>

Construct a new module from the in-memory wasm buffer with the default configuration.

pub fn emit_wasm_file<P>(&mut self, path: P) -> Result<()> where
    P: AsRef<Path>, 

Emit this module into a .wasm file at the given path.

pub fn emit_wasm(&mut self) -> Vec<u8>

Emit this module into an in-memory wasm buffer.

pub fn functions(&self) -> impl Iterator<Item = &Function>

Returns an iterator over all functions in this module

Trait Implementations

impl Default for Module

fn default() -> Module

Returns the "default value" for a type.

impl Debug for Module

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

Formats the value using the given formatter.