92ba4929e5
This drops the text format (%.wat) and renames InstantiateModuleFromCode to InstantiateModuleFromBinary as it is no longer ambiguous. We decided to stop supporting the text format as it isn't typically used in production, yet costs a lot of work to develop. Given the resources available and the increased work added with WebAssembly 2.0 and soon WASI 2, we can't afford to spend the time on it. The old parser is used only internally and will eventually be moved to its own repository named watzero, possibly towards archival. See #59 Signed-off-by: Adrian Cole <adrian@tetrate.io>
108 lines
3.3 KiB
Go
108 lines
3.3 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
_ "embed"
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
|
|
"github.com/tetratelabs/wazero"
|
|
"github.com/tetratelabs/wazero/api"
|
|
)
|
|
|
|
// greetWasm was compiled using `cargo build --release --target wasm32-unknown-unknown`
|
|
//go:embed testdata/greet.wasm
|
|
var greetWasm []byte
|
|
|
|
// main shows how to interact with a WebAssembly function that was compiled
|
|
// from Rust.
|
|
//
|
|
// See README.md for a full description.
|
|
func main() {
|
|
// Choose the context to use for function calls.
|
|
ctx := context.Background()
|
|
|
|
// Create a new WebAssembly Runtime.
|
|
r := wazero.NewRuntime()
|
|
defer r.Close(ctx) // This closes everything this Runtime created.
|
|
|
|
// Instantiate a Go-defined module named "env" that exports a function to
|
|
// log to the console.
|
|
_, err := r.NewModuleBuilder("env").
|
|
ExportFunction("log", logString).
|
|
Instantiate(ctx, r)
|
|
if err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
|
|
// Instantiate a WebAssembly module that imports the "log" function defined
|
|
// in "env" and exports "memory" and functions we'll use in this example.
|
|
mod, err := r.InstantiateModuleFromBinary(ctx, greetWasm)
|
|
if err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
|
|
// Get references to WebAssembly functions we'll use in this example.
|
|
greet := mod.ExportedFunction("greet")
|
|
greeting := mod.ExportedFunction("greeting")
|
|
allocate := mod.ExportedFunction("allocate")
|
|
deallocate := mod.ExportedFunction("deallocate")
|
|
|
|
// Let's use the argument to this main function in Wasm.
|
|
name := os.Args[1]
|
|
nameSize := uint64(len(name))
|
|
|
|
// Instead of an arbitrary memory offset, use Rust's allocator. Notice
|
|
// there is nothing string-specific in this allocation function. The same
|
|
// function could be used to pass binary serialized data to Wasm.
|
|
results, err := allocate.Call(ctx, nameSize)
|
|
if err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
namePtr := results[0]
|
|
// This pointer was allocated by Rust, but owned by Go, So, we have to
|
|
// deallocate it when finished
|
|
defer deallocate.Call(ctx, namePtr, nameSize)
|
|
|
|
// The pointer is a linear memory offset, which is where we write the name.
|
|
if !mod.Memory().Write(ctx, uint32(namePtr), []byte(name)) {
|
|
log.Panicf("Memory.Write(%d, %d) out of range of memory size %d",
|
|
namePtr, nameSize, mod.Memory().Size(ctx))
|
|
}
|
|
|
|
// Now, we can call "greet", which reads the string we wrote to memory!
|
|
_, err = greet.Call(ctx, namePtr, nameSize)
|
|
if err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
|
|
// Finally, we get the greeting message "greet" printed. This shows how to
|
|
// read-back something allocated by Rust.
|
|
ptrSize, err := greeting.Call(ctx, namePtr, nameSize)
|
|
if err != nil {
|
|
log.Panicln(err)
|
|
}
|
|
greetingPtr := uint32(ptrSize[0] >> 32)
|
|
greetingSize := uint32(ptrSize[0])
|
|
// This pointer was allocated by Rust, but owned by Go, So, we have to
|
|
// deallocate it when finished
|
|
defer deallocate.Call(ctx, uint64(greetingPtr), uint64(greetingSize))
|
|
|
|
// The pointer is a linear memory offset, which is where we write the name.
|
|
if bytes, ok := mod.Memory().Read(ctx, greetingPtr, greetingSize); !ok {
|
|
log.Panicf("Memory.Read(%d, %d) out of range of memory size %d",
|
|
greetingPtr, greetingSize, mod.Memory().Size(ctx))
|
|
} else {
|
|
fmt.Println("go >>", string(bytes))
|
|
}
|
|
}
|
|
|
|
func logString(ctx context.Context, m api.Module, offset, byteCount uint32) {
|
|
buf, ok := m.Memory().Read(ctx, offset, byteCount)
|
|
if !ok {
|
|
log.Panicf("Memory.Read(%d, %d) out of range", offset, byteCount)
|
|
}
|
|
fmt.Println(string(buf))
|
|
}
|