Struct ModuleBuilder 

pub struct ModuleBuilder<F = Identity> { /* private fields */ }

Module builder

Implementations

impl ModuleBuilder

pub fn new() -> Self

New empty module builder

impl<F> ModuleBuilder<F>

where F: Invoke<Module>,

pub fn with_callback(callback: F) -> Self

New module builder with bound callback

pub fn with_module(self, module: Module) -> Self

Builder from raw module

pub fn with_sections<I>(self, sections: I) -> Self

where I: IntoIterator<Item = Section>,

Fill module with sections from iterator

pub fn with_section(self, section: Section) -> Self

Add additional section

pub fn with_signatures(self, bindings: Vec<Signature>) -> Self

Binds to the type section, creates additional types when required

pub fn push_function(&mut self, func: FunctionDefinition) -> CodeLocation

Push stand-alone function definition, creating sections, signature and code blocks in corresponding sections. FunctionDefinition can be build using builder::function builder

pub fn push_memory(&mut self, memory: MemoryDefinition) -> u32

Push linear memory region

pub fn push_table(&mut self, table: TableDefinition) -> u32

Push table

pub fn push_signature(&mut self, signature: Signature) -> u32

Push one function signature, returning it’s calling index. Can create corresponding type in type section.

Examples found in repository

examples/inject.rs (lines 49-55)

fn main() {
    let args = env::args().collect::<Vec<_>>();
    if args.len() != 3 {
        println!("Usage: {} input_file.wasm output_file.wasm", args[0]);
        return;
    }

    let mut module = sophon_wasm::deserialize_file(&args[1]).unwrap();

    for section in module.sections_mut() {
        match section {
            &mut elements::Section::Code(ref mut code_section) => {
                for ref mut func_body in code_section.bodies_mut() {
                    inject_nop(func_body.code_mut());
                }
            },
            _ => { }
        }
    }

    let mut build = builder::from_module(module);
    let import_sig = build.push_signature(
        builder::signature()
            .param().i32()
            .param().i32()
            .return_type().i32()
            .build_sig()
    );
    let build = build.import()
        .module("env")
        .field("log")
        .external().func(import_sig)
        .build();

    sophon_wasm::serialize_to_file(&args[2], build.build()).unwrap();
}

pub fn push_signatures(&mut self, signatures: Vec<Signature>) -> Vec<u32>

Push signatures in the module, returning corresponding indices of pushed signatures

pub fn push_import(&mut self, import: ImportEntry) -> u32

Push import entry to module. Not that it does not update calling indices in function bodies.

pub fn push_export(&mut self, export: ExportEntry) -> u32

Push export entry to module.

pub fn function(self) -> FunctionBuilder<Self>

Add new function using dedicated builder

Examples found in repository

examples/build.rs (line 29)

fn main() {

    // Example binary accepts one parameter which is the output file
    // where generated wasm module will be written at the end of execution
    let args = env::args().collect::<Vec<_>>();
    if args.len() != 2 {
        println!("Usage: {} output_file.wasm", args[0]);
        return;
    }

    // Main entry for the builder api is the module function
    // It returns empty module builder structure which can be further
    // appended with various wasm artefacts
    let module = builder::module()
        // Here we append function to the builder
        // function() function returns a function builder attached
        // to the module builder.
        .function()
            // We describe signature for the function via signature()
            // function. In our simple example it's just one input
            // argument of type 'i32' without return value
            .signature().with_param(elements::ValueType::I32).build()
            // body() without any further arguments means that the body
            // of the function will be empty
            .body().build()
            // This is the end of the function builder. When `build()` is
            // invoked, function builder returns original module builder
            // from which it was invoked
            .build()
        // And finally we finish our module builder to produce actual
        // wasm module.
        .build();

    // Module structure can be serialzed to produce a valid wasm file
    sophon_wasm::serialize_to_file(&args[1], module).unwrap();
}

pub fn memory(self) -> MemoryBuilder<Self>

Add new linear memory using dedicated builder

pub fn table(self) -> TableBuilder<Self>

Add new table using dedicated builder

pub fn functions(self) -> SignaturesBuilder<Self>

Define functions section

pub fn with_export(self, entry: ExportEntry) -> Self

With inserted export entry

pub fn with_import(self, entry: ImportEntry) -> Self

With inserted import entry

pub fn import(self) -> ImportBuilder<Self>

Import entry builder

Examples

use sophon_wasm::builder::module;

let module = module()
   .import()
       .module("env")
       .field("memory")
       .external().memory(256, Some(256))
       .build()
   .build();

assert_eq!(module.import_section().expect("import section to exist").entries().len(), 1);

Examples found in repository

examples/inject.rs (line 56)

fn main() {
    let args = env::args().collect::<Vec<_>>();
    if args.len() != 3 {
        println!("Usage: {} input_file.wasm output_file.wasm", args[0]);
        return;
    }

    let mut module = sophon_wasm::deserialize_file(&args[1]).unwrap();

    for section in module.sections_mut() {
        match section {
            &mut elements::Section::Code(ref mut code_section) => {
                for ref mut func_body in code_section.bodies_mut() {
                    inject_nop(func_body.code_mut());
                }
            },
            _ => { }
        }
    }

    let mut build = builder::from_module(module);
    let import_sig = build.push_signature(
        builder::signature()
            .param().i32()
            .param().i32()
            .return_type().i32()
            .build_sig()
    );
    let build = build.import()
        .module("env")
        .field("log")
        .external().func(import_sig)
        .build();

    sophon_wasm::serialize_to_file(&args[2], build.build()).unwrap();
}

pub fn with_global(self, global: GlobalEntry) -> Self

With global variable

pub fn with_table(self, table: TableType) -> Self

With table

pub fn export(self) -> ExportBuilder<Self>

Export entry builder

Examples

use sophon_wasm::builder::module;
use sophon_wasm::elements::Opcode::*;

let module = module()
   .global()
        .value_type().i32()
        .init_expr(I32Const(0))
        .build()
   .export()
       .field("_zero")
       .internal().global(0)
       .build()
   .build();

assert_eq!(module.export_section().expect("export section to exist").entries().len(), 1);

pub fn global(self) -> GlobalBuilder<Self>

Glboal entry builder

Examples

use sophon_wasm::builder::module;
use sophon_wasm::elements::Opcode::*;

let module = module()
   .global()
        .value_type().i32()
        .init_expr(I32Const(0))
        .build()
   .build();

assert_eq!(module.global_section().expect("global section to exist").entries().len(), 1);

pub fn with_data_segment(self, segment: DataSegment) -> Self

Add data segment to the builder

pub fn data(self) -> DataSegmentBuilder<Self>

Data entry builder

pub fn build(self) -> F::Result

Build module (final step)

Examples found in repository

examples/inject.rs (line 62)

fn main() {
    let args = env::args().collect::<Vec<_>>();
    if args.len() != 3 {
        println!("Usage: {} input_file.wasm output_file.wasm", args[0]);
        return;
    }

    let mut module = sophon_wasm::deserialize_file(&args[1]).unwrap();

    for section in module.sections_mut() {
        match section {
            &mut elements::Section::Code(ref mut code_section) => {
                for ref mut func_body in code_section.bodies_mut() {
                    inject_nop(func_body.code_mut());
                }
            },
            _ => { }
        }
    }

    let mut build = builder::from_module(module);
    let import_sig = build.push_signature(
        builder::signature()
            .param().i32()
            .param().i32()
            .return_type().i32()
            .build_sig()
    );
    let build = build.import()
        .module("env")
        .field("log")
        .external().func(import_sig)
        .build();

    sophon_wasm::serialize_to_file(&args[2], build.build()).unwrap();
}

examples/build.rs (line 43)

fn main() {

    // Example binary accepts one parameter which is the output file
    // where generated wasm module will be written at the end of execution
    let args = env::args().collect::<Vec<_>>();
    if args.len() != 2 {
        println!("Usage: {} output_file.wasm", args[0]);
        return;
    }

    // Main entry for the builder api is the module function
    // It returns empty module builder structure which can be further
    // appended with various wasm artefacts
    let module = builder::module()
        // Here we append function to the builder
        // function() function returns a function builder attached
        // to the module builder.
        .function()
            // We describe signature for the function via signature()
            // function. In our simple example it's just one input
            // argument of type 'i32' without return value
            .signature().with_param(elements::ValueType::I32).build()
            // body() without any further arguments means that the body
            // of the function will be empty
            .body().build()
            // This is the end of the function builder. When `build()` is
            // invoked, function builder returns original module builder
            // from which it was invoked
            .build()
        // And finally we finish our module builder to produce actual
        // wasm module.
        .build();

    // Module structure can be serialzed to produce a valid wasm file
    sophon_wasm::serialize_to_file(&args[1], module).unwrap();
}