Struct node_testing::client::sc_executor::wasmi::Module

pub struct Module { /* fields omitted */ }

Deserialized module prepared for instantiation.

Implementations

impl Module

pub fn from_parity_wasm_module(module: Module) -> Result<Module, Error>

Create Module from parity_wasm::elements::Module.

This function will load, validate and prepare a parity_wasm’s Module.

Errors

Returns Err if provided Module is not valid.

Examples

extern crate parity_wasm;
extern crate wasmi;

use parity_wasm::builder;
use parity_wasm::elements;

fn main() {
    let parity_module =
        builder::module()
            .function()
                .signature().with_param(elements::ValueType::I32).build()
                .body().build()
            .build()
        .build();

    let module = wasmi::Module::from_parity_wasm_module(parity_module)
        .expect("parity-wasm builder generated invalid module!");

    // Instantiate `module`, etc...
}

pub fn deny_floating_point(&self) -> Result<(), Error>

Fail if the module contains any floating-point operations

Errors

Returns Err if provided Module is not valid.

Examples

let wasm_binary: Vec<u8> =
    wabt::wat2wasm(
        r#"
        (module
         (func $add (param $lhs i32) (param $rhs i32) (result i32)
               get_local $lhs
               get_local $rhs
               i32.add))
        "#,
    )
    .expect("failed to parse wat");

// Load wasm binary and prepare it for instantiation.
let module = wasmi::Module::from_buffer(&wasm_binary).expect("Parsing failed");
assert!(module.deny_floating_point().is_ok());

let wasm_binary: Vec<u8> =
    wabt::wat2wasm(
        r#"
        (module
         (func $add (param $lhs f32) (param $rhs f32) (result f32)
               get_local $lhs
               get_local $rhs
               f32.add))
        "#,
    )
    .expect("failed to parse wat");

let module = wasmi::Module::from_buffer(&wasm_binary).expect("Parsing failed");
assert!(module.deny_floating_point().is_err());

let wasm_binary: Vec<u8> =
    wabt::wat2wasm(
        r#"
        (module
         (func $add (param $lhs f32) (param $rhs f32) (result f32)
               get_local $lhs))
        "#,
    )
    .expect("failed to parse wat");

let module = wasmi::Module::from_buffer(&wasm_binary).expect("Parsing failed");
assert!(module.deny_floating_point().is_err());

pub fn from_buffer<B>(buffer: B) -> Result<Module, Error> where
    B: AsRef<[u8]>, 

Create Module from a given buffer.

This function will deserialize wasm module from a given module, validate and prepare it for instantiation.

Errors

Returns Err if wasm binary in provided buffer is not valid wasm binary.

Examples

extern crate wasmi;

fn main() {
    let module =
        wasmi::Module::from_buffer(
            // Minimal module:
            //   \0asm - magic
            //    0x01 - version (in little-endian)
            &[0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00]
        ).expect("Failed to load minimal module");

    // Instantiate `module`, etc...
}