Struct holochain_wasmer_host::prelude::Module [−][src]
pub struct Module { /* fields omitted */ }
Expand description
A WebAssembly Module contains stateless WebAssembly code that has already been compiled and can be instantiated multiple times.
Cloning a module
Cloning a module is cheap: it does a shallow copy of the compiled contents rather than a deep copy.
Implementations
Creates a new WebAssembly Module given the configuration in the store.
If the provided bytes are not WebAssembly-like (start with b"\0asm"
),
and the “wat” feature is enabled for this crate, this function will try to
to convert the bytes assuming they correspond to the WebAssembly text
format.
Security
Before the code is compiled, it will be validated using the store features.
Errors
Creating a WebAssembly module from bytecode can result in a
CompileError
since this operation requires to transorm the Wasm
bytecode into code the machine can easily execute.
Example
Reading from a WAT file.
use wasmer::*; let wat = "(module)"; let module = Module::new(&store, wat)?;
Reading from bytes:
use wasmer::*; // The following is the same as: // (module // (type $t0 (func (param i32) (result i32))) // (func $add_one (export "add_one") (type $t0) (param $p0 i32) (result i32) // get_local $p0 // i32.const 1 // i32.add) // ) let bytes: Vec<u8> = vec![ 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x06, 0x01, 0x60, 0x01, 0x7f, 0x01, 0x7f, 0x03, 0x02, 0x01, 0x00, 0x07, 0x0b, 0x01, 0x07, 0x61, 0x64, 0x64, 0x5f, 0x6f, 0x6e, 0x65, 0x00, 0x00, 0x0a, 0x09, 0x01, 0x07, 0x00, 0x20, 0x00, 0x41, 0x01, 0x6a, 0x0b, 0x00, 0x1a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x01, 0x0a, 0x01, 0x00, 0x07, 0x61, 0x64, 0x64, 0x5f, 0x6f, 0x6e, 0x65, 0x02, 0x07, 0x01, 0x00, 0x01, 0x00, 0x02, 0x70, 0x30, ]; let module = Module::new(&store, bytes)?;
Creates a new WebAssembly module from a file path.
Creates a new WebAssembly module from a binary.
Opposed to Module::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(
store: &Store,
binary: &[u8]
) -> Result<Module, CompileError>
pub unsafe fn from_binary_unchecked(
store: &Store,
binary: &[u8]
) -> Result<Module, CompileError>
Creates a new WebAssembly module skipping any kind of validation.
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.
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.
Serializes a module into a binary representation that the Engine
can later process via Module::deserialize
.
Usage
let serialized = module.serialize()?;
Serializes a module into a file that the Engine
can later process via Module::deserialize_from_file
.
Usage
module.serialize_to_file("path/to/foo.so")?;
Deserializes a serialized Module binary into a Module
.
Note: the module has to be serialized before with the
serialize
method.
Safety
This function is inherently unsafe as the provided bytes:
- Are going to be deserialized directly into Rust objects.
- Contains the function assembly bodies and, if intercepted, a malicious actor could inject code into executable memory.
And as such, the deserialize
method is unsafe.
Usage
let module = Module::deserialize(&store, serialized_data)?;
pub unsafe fn deserialize_from_file(
store: &Store,
path: impl AsRef<Path>
) -> Result<Module, DeserializeError>
pub unsafe fn deserialize_from_file(
store: &Store,
path: impl AsRef<Path>
) -> Result<Module, DeserializeError>
Deserializes a a serialized Module located in a Path
into a Module
.
Note: the module has to be serialized before with the
serialize
method.
Safety
Please check Module::deserialize
.
Usage
let module = Module::deserialize_from_file(&store, path)?;
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 Module::set_name
method.
Example
let wat = "(module $moduleName)"; let module = Module::new(&store, wat)?; assert_eq!(module.name(), Some("moduleName"));
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 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(
&'a self
) -> ImportsIterator<impl Iterator<Item = ImportType<ExternType>> + 'a>
pub fn imports(
&'a self
) -> ImportsIterator<impl Iterator<Item = ImportType<ExternType>> + 'a>
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(
&'a self
) -> ExportsIterator<impl Iterator<Item = ExportType<ExternType>> + 'a>
pub fn exports(
&'a self
) -> ExportsIterator<impl Iterator<Item = ExportType<ExternType>> + 'a>
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(); }
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
Auto Trait Implementations
impl !RefUnwindSafe for Module
impl !UnwindSafe for Module
Blanket Implementations
type ArchivedMetadata = ()
type ArchivedMetadata = ()
The archived version of the pointer metadata for this type.
pub fn pointer_metadata(
&<T as ArchivePointee>::ArchivedMetadata
) -> <T as Pointee>::Metadata
pub fn pointer_metadata(
&<T as ArchivePointee>::ArchivedMetadata
) -> <T as Pointee>::Metadata
Converts some archived metadata to the pointer metadata for itself.
Mutably borrows from an owned value. Read more
Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
pub fn vzip(self) -> V