Enum BackendModule 

pub enum BackendModule {
    Sys(Module),
}

Variants

Sys(Module)

The implementation from the sys backend.

Implementations

impl BackendModule

pub fn unwrap_sys(self) -> Module

Unwraps this value to the BackendModule::Sys variant. Panics if this value is of any other type.

pub fn unwrap_sys_ref(&self) -> &Module

Unwraps this reference to the BackendModule::Sys variant. Panics if this value is of any other type.

pub fn unwrap_sys_mut(&mut self) -> &mut Module

Unwraps this mutable reference to the BackendModule::Sys variant. Panics if this value is of any other type.

impl BackendModule

pub fn new( engine: &impl AsEngineRef, bytes: impl AsRef<[u8]>, ) -> Result<Self, CompileError>

pub fn new_with_progress( engine: &impl AsEngineRef, bytes: impl AsRef<[u8]>, callback: CompilationProgressCallback, ) -> Result<Self, CompileError>

pub fn from_file( engine: &impl AsEngineRef, file: impl AsRef<Path>, ) -> Result<Self, IoCompileError>

Creates a new WebAssembly module from a file path.

pub fn from_binary( engine: &impl AsEngineRef, binary: &[u8], ) -> Result<Self, CompileError>

Creates a new WebAssembly module from a Wasm binary.

Opposed to Self::new, this function is not compatible with the WebAssembly text format (if the “wat” feature is enabled for this crate).

pub unsafe fn from_binary_unchecked( engine: &impl AsEngineRef, binary: &[u8], ) -> Result<Self, CompileError>

Creates a new WebAssembly module from a Wasm binary, skipping any kind of validation on the WebAssembly file.

Safety

This can speed up compilation time a bit, but it should be only used in environments where the WebAssembly modules are trusted and validated beforehand.

pub fn validate( engine: &impl AsEngineRef, binary: &[u8], ) -> Result<(), CompileError>

Validates a new WebAssembly Module given the configuration in the Store.

This validation is normally pretty fast and checks the enabled WebAssembly features in the Store Engine to assure deterministic validation of the Module.

pub fn serialize(&self) -> Result<Bytes, SerializeError>

Serializes a module into a binary representation that the Engine can later process via Self::deserialize.

Important

This function will return a custom binary format that will be different than the wasm binary format, but faster to load in Native hosts.

Usage

let serialized = module.serialize()?;

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

Serializes a module into a file that the Engine can later process via Self::deserialize_from_file.

Usage

module.serialize_to_file("path/to/foo.so")?;

pub unsafe fn deserialize_unchecked( engine: &impl AsEngineRef, bytes: impl IntoBytes, ) -> Result<Self, DeserializeError>

Deserializes a serialized module binary into a Module.

Note: You should usually prefer the safer Self::deserialize.

Important

This function only accepts a custom binary format, which will be different than the wasm binary format and may change among Wasmer versions. (it should be the result of the serialization of a Module via the Module::serialize method.).

Safety

This function is inherently unsafe as the provided bytes:

1. Are going to be deserialized directly into Rust objects.
2. Contains the function assembly bodies and, if intercepted, a malicious actor could inject code into executable memory.

And as such, the deserialize_unchecked method is unsafe.

Usage

let module = Module::deserialize_unchecked(&store, serialized_data)?;

pub unsafe fn deserialize( engine: &impl AsEngineRef, bytes: impl IntoBytes, ) -> Result<Self, DeserializeError>

Deserializes a serialized Module binary into a Module.

Important

This function only accepts a custom binary format, which will be different than the wasm binary format and may change among Wasmer versions. (it should be the result of the serialization of a Module via the Self::serialize method.).

Usage

let module = Module::deserialize(&store, serialized_data)?;

Safety

This function is inherently unsafe, because it loads executable code into memory. The loaded bytes must be trusted to contain a valid artifact previously built with Self::serialize.

pub unsafe fn deserialize_from_file( engine: &impl AsEngineRef, path: impl AsRef<Path>, ) -> Result<Self, DeserializeError>

Deserializes a serialized Module located in a Path into a Module.

Note: the module has to be serialized before with the serialize method.

Usage

let module = Module::deserialize_from_file(&store, path)?;

Safety

See Self::deserialize.

pub unsafe fn deserialize_from_file_unchecked( engine: &impl AsEngineRef, path: impl AsRef<Path>, ) -> Result<Self, DeserializeError>

Deserializes a serialized Module located in a Path into a Module.

Note: the module has to be serialized before with the serialize method.

You should usually prefer the safer Self::deserialize_from_file.

Safety

Please check Self::deserialize_unchecked.

Usage

let module = Module::deserialize_from_file_unchecked(&store, path)?;

pub fn name(&self) -> Option<&str>

Returns the name of the current module.

This name is normally set in the WebAssembly bytecode by some compilers, but can be also overwritten using the Self::set_name method.

Example

let wat = "(module $moduleName)";
let module = Module::new(&store, wat)?;
assert_eq!(module.name(), Some("moduleName"));

pub fn set_name(&mut self, name: &str) -> bool

Sets the name of the current module. This is normally useful for stacktraces and debugging.

It will return true if the module name was changed successfully, and return false otherwise (in case the module is cloned or already instantiated).

Example

let wat = "(module)";
let mut module = Module::new(&store, wat)?;
assert_eq!(module.name(), None);
module.set_name("foo");
assert_eq!(module.name(), Some("foo"));

pub fn imports( &self, ) -> ImportsIterator<Box<dyn Iterator<Item = ImportType> + '_>>

Returns an iterator over the imported types in the Module.

The order of the imports is guaranteed to be the same as in the WebAssembly bytecode.

Example

let wat = r#"(module
    (import "host" "func1" (func))
    (import "host" "func2" (func))
)"#;
let module = Module::new(&store, wat)?;
for import in module.imports() {
    assert_eq!(import.module(), "host");
    assert!(import.name().contains("func"));
    import.ty();
}

pub fn exports( &self, ) -> ExportsIterator<Box<dyn Iterator<Item = ExportType> + '_>>

Returns an iterator over the exported types in the Module.

The order of the exports is guaranteed to be the same as in the WebAssembly bytecode.

Example

let wat = r#"(module
    (func (export "namedfunc"))
    (memory (export "namedmemory") 1)
)"#;
let module = Module::new(&store, wat)?;
for export_ in module.exports() {
    assert!(export_.name().contains("named"));
    export_.ty();
}

pub fn custom_sections<'a>( &'a self, name: &'a str, ) -> impl Iterator<Item = Box<[u8]>> + 'a

Get the custom sections of the module given a name.

Important

Following the WebAssembly spec, one name can have multiple custom sections. That’s why an iterator (rather than one element) is returned.

Trait Implementations

impl Clone for BackendModule

fn clone(&self) -> BackendModule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BackendModule

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

Formats the value using the given formatter.

impl From<BackendModule> for Module

fn from(value: BackendModule) -> Self

Converts to this type from the input type.

impl From<Module> for BackendModule

fn from(value: Module) -> Self

Converts to this type from the input type.

impl PartialEq for BackendModule

fn eq(&self, other: &BackendModule) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for BackendModule

impl StructuralPartialEq for BackendModule