1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
//! Small example of how to serialize compiled wasm module to the disk,
//! and then instantiate it from the compilation artifacts.
// You can execute this example with `cargo run --example serialize`
use wasmtime::*;
fn serialize() -> Result<Vec<u8>> {
// Configure the initial compilation environment, creating the global
// `Store` structure. Note that you can also tweak configuration settings
// with a `Config` and an `Engine` if desired.
println!("Initializing...");
let engine = Engine::default();
// Compile the wasm binary into an in-memory instance of a `Module`.
println!("Compiling module...");
let module = Module::from_file(&engine, "examples/hello.wat")?;
let serialized = module.serialize()?;
println!("Serialized.");
Ok(serialized)
}
fn deserialize(buffer: &[u8]) -> Result<()> {
// Configure the initial compilation environment, creating the global
// `Store` structure. Note that you can also tweak configuration settings
// with a `Config` and an `Engine` if desired.
println!("Initializing...");
let mut store: Store<()> = Store::default();
// Compile the wasm binary into an in-memory instance of a `Module`. Note
// that this is `unsafe` because it is our responsibility for guaranteeing
// that these bytes are valid precompiled module bytes. We know that from
// the structure of this example program.
println!("Deserialize module...");
let module = unsafe { Module::deserialize(store.engine(), buffer)? };
// Here we handle the imports of the module, which in this case is our
// `HelloCallback` type and its associated implementation of `Callback.
println!("Creating callback...");
let hello_func = Func::wrap(&mut store, || {
println!("Calling back...");
println!("> Hello World!");
});
// Once we've got that all set up we can then move to the instantiation
// phase, pairing together a compiled module as well as a set of imports.
// Note that this is where the wasm `start` function, if any, would run.
println!("Instantiating module...");
let imports = [hello_func.into()];
let instance = Instance::new(&mut store, &module, &imports)?;
// Next we poke around a bit to extract the `run` function from the module.
println!("Extracting export...");
let run = instance.get_typed_func::<(), ()>(&mut store, "run")?;
// And last but not least we can call it!
println!("Calling export...");
run.call(&mut store, ())?;
println!("Done.");
Ok(())
}
fn main() -> Result<()> {
let file = serialize()?;
deserialize(&file)
}
|
