Add examples of linking and WASI (#1369)

* Add examples of linking and WASI

This commit adds two example programs, one for linking two modules
together and one for instantiating WASI. The linkage example
additionally uses WASI to get some meaningful output at this time.

cc #1272

* Add examples to the book as well

* More links!

* Ignore examples from rustdoc testsing

* More example updates

* More ignored

examples/linking.c

@@ -0,0 +1,194 @@
+/*
+Example of compiling, instantiating, and linking two WebAssembly modules
+together.
+
+You can compile and run this example on Linux with:
+
+   cargo build --release -p wasmtime
+   cc examples/linking.c \
+       -I crates/c-api/include \
+       -I crates/c-api/wasm-c-api/include \
+       target/release/libwasmtime.a \
+       -lpthread -ldl -lm \
+       -o linking
+   ./linking
+
+Note that on Windows and macOS the command will be similar, but you'll need
+to tweak the `-lpthread` and such annotations.
+*/
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <wasm.h>
+#include <wasi.h>
+#include <wasmtime.h>
+
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+
+static void print_trap(wasm_trap_t *trap);
+static void read_wat_file(wasm_engine_t *engine, wasm_byte_vec_t *bytes, const char *file);
+
+int main() {
+  int ret = 0;
+  // Set up our context
+  wasm_engine_t *engine = wasm_engine_new();
+  assert(engine != NULL);
+  wasm_store_t *store = wasm_store_new(engine);
+  assert(store != NULL);
+
+  wasm_byte_vec_t linking1_wasm, linking2_wasm;
+  read_wat_file(engine, &linking1_wasm, "examples/linking1.wat");
+  read_wat_file(engine, &linking2_wasm, "examples/linking2.wat");
+
+  // Compile our two modules
+  wasm_module_t *linking1_module = wasm_module_new(store, &linking1_wasm);
+  assert(linking1_module != NULL);
+  wasm_module_t *linking2_module = wasm_module_new(store, &linking2_wasm);
+  assert(linking2_module != NULL);
+  wasm_byte_vec_delete(&linking1_wasm);
+  wasm_byte_vec_delete(&linking2_wasm);
+
+  // Instantiate wasi
+  wasi_config_t *wasi_config = wasi_config_new();
+  assert(wasi_config);
+  wasi_config_inherit_argv(wasi_config);
+  wasi_config_inherit_env(wasi_config);
+  wasi_config_inherit_stdin(wasi_config);
+  wasi_config_inherit_stdout(wasi_config);
+  wasi_config_inherit_stderr(wasi_config);
+  wasm_trap_t *trap = NULL;
+  wasi_instance_t *wasi = wasi_instance_new(store, wasi_config, &trap);
+  if (wasi == NULL) {
+    print_trap(trap);
+    exit(1);
+  }
+
+  // Create imports for `linking2`
+  wasm_importtype_vec_t linking2_import_types;
+  wasm_module_imports(linking2_module, &linking2_import_types);
+  const wasm_extern_t **linking2_imports = calloc(linking2_import_types.size, sizeof(void*));
+  assert(linking2_imports);
+  for (int i = 0; i < linking2_import_types.size; i++) {
+    const wasm_extern_t *binding = wasi_instance_bind_import(wasi, linking2_import_types.data[i]);
+    if (binding != NULL) {
+      linking2_imports[i] = binding;
+    } else {
+      printf("> Failed to satisfy import\n");
+      exit(1);
+    }
+  }
+  wasm_importtype_vec_delete(&linking2_import_types);
+
+  // Instantiate `linking2`
+  wasm_instance_t *linking2 = wasm_instance_new(store, linking2_module, linking2_imports, &trap);
+  if (linking2 == NULL) {
+    print_trap(trap);
+    exit(1);
+  }
+  free(linking2_imports);
+  wasm_extern_vec_t linking2_externs;
+  wasm_instance_exports(linking2, &linking2_externs);
+  wasm_exporttype_vec_t linking2_exports;
+  wasm_module_exports(linking2_module, &linking2_exports);
+
+  // Create imports for `linking1`
+  wasm_importtype_vec_t linking1_import_types;
+  wasm_module_imports(linking1_module, &linking1_import_types);
+  const wasm_extern_t **linking1_imports = calloc(linking1_import_types.size, sizeof(void*));
+  assert(linking1_imports);
+  for (int i = 0; i < linking1_import_types.size; i++) {
+    const wasm_importtype_t *import = linking1_import_types.data[i];
+    const wasm_name_t *module = wasm_importtype_module(import);
+    const wasm_name_t *name = wasm_importtype_name(import);
+    if (strncmp(module->data, "linking2", module->size) == 0) {
+      const wasm_extern_t *e = NULL;
+      for (int j = 0; j < linking2_exports.size; j++) {
+        const wasm_name_t *export_name = wasm_exporttype_name(linking2_exports.data[j]);
+        if (name->size == export_name->size &&
+            strncmp(name->data, export_name->data, name->size) == 0) {
+          e = linking2_externs.data[j];
+          break;
+        }
+      }
+      if (e) {
+        linking1_imports[i] = e;
+        continue;
+      }
+    }
+
+    printf("> Failed to satisfy import\n");
+    exit(1);
+  }
+  wasm_importtype_vec_delete(&linking1_import_types);
+
+  // Instantiate `linking1`
+  wasm_instance_t *linking1 = wasm_instance_new(store, linking1_module, linking1_imports, &trap);
+  if (linking1 == NULL) {
+    print_trap(trap);
+    exit(1);
+  }
+
+  // Lookup our `run` export function
+  wasm_extern_vec_t linking1_externs;
+  wasm_instance_exports(linking1, &linking1_externs);
+  assert(linking1_externs.size == 1);
+  wasm_func_t *run = wasm_extern_as_func(linking1_externs.data[0]);
+  assert(run != NULL);
+  trap = wasm_func_call(run, NULL, NULL);
+  if (trap != NULL) {
+    print_trap(trap);
+    exit(1);
+  }
+
+  // Clean up after ourselves at this point
+  wasm_extern_vec_delete(&linking1_externs);
+  wasm_extern_vec_delete(&linking2_externs);
+  wasm_instance_delete(linking1);
+  wasm_instance_delete(linking2);
+  wasm_module_delete(linking1_module);
+  wasm_module_delete(linking2_module);
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+  return 0;
+}
+
+static void read_wat_file(
+  wasm_engine_t *engine,
+  wasm_byte_vec_t *bytes,
+  const char *filename
+) {
+  wasm_byte_vec_t wat;
+  // Load our input file to parse it next
+  FILE* file = fopen(filename, "r");
+  if (!file) {
+    printf("> Error loading file!\n");
+    exit(1);
+  }
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  wasm_byte_vec_new_uninitialized(&wat, file_size);
+  fseek(file, 0L, SEEK_SET);
+  if (fread(wat.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    exit(1);
+  }
+  fclose(file);
+
+  // Parse the wat into the binary wasm format
+  wasm_byte_vec_t error;
+  if (wasmtime_wat2wasm(engine, &wat, bytes, &error) == 0) {
+    fprintf(stderr, "failed to parse wat %.*s\n", (int) error.size, error.data);
+    exit(1);
+  }
+  wasm_byte_vec_delete(&wat);
+}
+
+static void print_trap(wasm_trap_t *trap) {
+  assert(trap != NULL);
+  wasm_message_t message;
+  wasm_trap_message(trap, &message);
+  fprintf(stderr, "failed to instantiate module %.*s\n", (int) message.size, message.data);
+  wasm_byte_vec_delete(&message);
+  wasm_trap_delete(trap);
+}

examples/linking.rs

@@ -0,0 +1,57 @@
+//! Example of instantiating two modules which link to each other.
+
+// You can execute this example with `cargo run --example linking`
+
+use anyhow::Result;
+use wasmtime::*;
+use wasmtime_wasi::{Wasi, WasiCtx};
+
+fn main() -> Result<()> {
+    let store = Store::default();
+
+    // Load and compile our two modules
+    let linking1 = Module::from_file(&store, "examples/linking1.wat")?;
+    let linking2 = Module::from_file(&store, "examples/linking2.wat")?;
+
+    // Instantiate the first, `linking2`, which uses WASI imports
+    let wasi = Wasi::new(&store, WasiCtx::new(std::env::args())?);
+    let mut imports = Vec::new();
+    for import in linking2.imports() {
+        if import.module() == "wasi_snapshot_preview1" {
+            if let Some(export) = wasi.get_export(import.name()) {
+                imports.push(Extern::from(export.clone()));
+                continue;
+            }
+        }
+        panic!(
+            "couldn't find import for `{}::{}`",
+            import.module(),
+            import.name()
+        );
+    }
+    let linking2 = Instance::new(&linking2, &imports)?;
+
+    // And using the previous instance we can create the imports for `linking1`,
+    // using the previous exports.
+    let mut imports = Vec::new();
+    for import in linking1.imports() {
+        if import.module() == "linking2" {
+            if let Some(export) = linking2.get_export(import.name()) {
+                imports.push(export.clone());
+                continue;
+            }
+        }
+        panic!(
+            "couldn't find import for `{}::{}`",
+            import.module(),
+            import.name()
+        );
+    }
+    let linking1 = Instance::new(&linking1, &imports)?;
+
+    // And once everything is instantiated we can run!
+    let run = linking1.get_export("run").and_then(|e| e.func()).unwrap();
+    let run = run.get0::<()>()?;
+    run()?;
+    Ok(())
+}

examples/linking1.wat

@@ -0,0 +1,23 @@
+(module
+  (import "linking2" "double" (func $double (param i32) (result i32)))
+  (import "linking2" "log" (func $log (param i32 i32)))
+  (import "linking2" "memory" (memory 1))
+  (import "linking2" "memory_offset" (global $offset i32))
+
+  (func (export "run")
+    ;; Call into the other module to double our number, and we could print it
+    ;; here but for now we just drop it
+    i32.const 2
+    call $double
+    drop
+
+    ;; Our `data` segment initialized our imported memory, so let's print the
+    ;; string there now.
+    global.get $offset
+    i32.const 14
+    call $log
+  )
+
+  (data (global.get $offset) "Hello, world!\n")
+)
+

examples/linking2.wat

@@ -0,0 +1,33 @@
+(module
+  (type $fd_write_ty (func (param i32 i32 i32 i32) (result i32)))
+  (import "wasi_snapshot_preview1" "fd_write" (func $fd_write (type $fd_write_ty)))
+
+  (func (export "double") (param i32) (result i32)
+    local.get 0
+    i32.const 2
+    i32.mul
+  )
+
+  (func (export "log") (param i32 i32)
+    ;; store the pointer in the first iovec field
+    i32.const 4
+    local.get 0
+    i32.store
+
+    ;; store the length in the first iovec field
+    i32.const 4
+    local.get 1
+    i32.store offset=4
+
+    ;; call the `fd_write` import
+    i32.const 1     ;; stdout fd
+    i32.const 4     ;; iovs start
+    i32.const 1     ;; number of iovs
+    i32.const 0     ;; where to write nwritten bytes
+    call $fd_write
+    drop
+  )
+
+  (memory (export "memory") 2)
+  (global (export "memory_offset") i32 (i32.const 65536))
+)

examples/wasi/main.c

@@ -0,0 +1,138 @@
+/*
+Example of instantiating a WebAssembly which uses WASI imports.
+
+You can compile and run this example on Linux with:
+
+   cargo build --release -p wasmtime
+   cc examples/wasi.c \
+       -I crates/c-api/include \
+       -I crates/c-api/wasm-c-api/include \
+       target/release/libwasmtime.a \
+       -lpthread -ldl -lm \
+       -o wasi
+   ./wasi
+
+Note that on Windows and macOS the command will be similar, but you'll need
+to tweak the `-lpthread` and such annotations.
+*/
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <wasm.h>
+#include <wasi.h>
+
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+
+static void print_trap(wasm_trap_t *trap);
+static void read_wat_file(wasm_engine_t *engine, wasm_byte_vec_t *bytes, const char *file);
+
+int main() {
+  int ret = 0;
+  // Set up our context
+  wasm_engine_t *engine = wasm_engine_new();
+  assert(engine != NULL);
+  wasm_store_t *store = wasm_store_new(engine);
+  assert(store != NULL);
+
+
+  wasm_byte_vec_t wasm;
+  // Load our input file to parse it next
+  FILE* file = fopen("target/wasm32-wasi/debug/wasi.wasm", "rb");
+  if (!file) {
+    printf("> Error loading file!\n");
+    exit(1);
+  }
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  wasm_byte_vec_new_uninitialized(&wasm, file_size);
+  fseek(file, 0L, SEEK_SET);
+  if (fread(wasm.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    exit(1);
+  }
+  fclose(file);
+
+  // Compile our modules
+  wasm_module_t *module = wasm_module_new(store, &wasm);
+  assert(module != NULL);
+  wasm_byte_vec_delete(&wasm);
+
+  // Instantiate wasi
+  wasi_config_t *wasi_config = wasi_config_new();
+  assert(wasi_config);
+  wasi_config_inherit_argv(wasi_config);
+  wasi_config_inherit_env(wasi_config);
+  wasi_config_inherit_stdin(wasi_config);
+  wasi_config_inherit_stdout(wasi_config);
+  wasi_config_inherit_stderr(wasi_config);
+  wasm_trap_t *trap = NULL;
+  wasi_instance_t *wasi = wasi_instance_new(store, wasi_config, &trap);
+  if (wasi == NULL) {
+    print_trap(trap);
+    exit(1);
+  }
+
+  // Create import list for our module using wasi
+  wasm_importtype_vec_t import_types;
+  wasm_module_imports(module, &import_types);
+  const wasm_extern_t **imports = calloc(import_types.size, sizeof(void*));
+  assert(imports);
+  for (int i = 0; i < import_types.size; i++) {
+    const wasm_extern_t *binding = wasi_instance_bind_import(wasi, import_types.data[i]);
+    if (binding != NULL) {
+      imports[i] = binding;
+    } else {
+      printf("> Failed to satisfy import\n");
+      exit(1);
+    }
+  }
+  wasm_importtype_vec_delete(&import_types);
+
+  // Instantiate the module
+  wasm_instance_t *instance = wasm_instance_new(store, module, imports, &trap);
+  if (instance == NULL) {
+    print_trap(trap);
+    exit(1);
+  }
+  free(imports);
+
+  // Lookup our `_start` export function
+  wasm_extern_vec_t externs;
+  wasm_instance_exports(instance, &externs);
+  wasm_exporttype_vec_t exports;
+  wasm_module_exports(module, &exports);
+  wasm_extern_t *start_extern = NULL;
+  for (int i = 0; i < exports.size; i++) {
+    const wasm_name_t *name = wasm_exporttype_name(exports.data[i]);
+    if (strncmp(name->data, "_start", name->size) == 0)
+      start_extern = externs.data[i];
+  }
+  assert(start_extern);
+  wasm_func_t *start = wasm_extern_as_func(start_extern);
+  assert(start != NULL);
+  trap = wasm_func_call(start, NULL, NULL);
+  if (trap != NULL) {
+    print_trap(trap);
+    exit(1);
+  }
+
+  // Clean up after ourselves at this point
+  wasm_exporttype_vec_delete(&exports);
+  wasm_extern_vec_delete(&externs);
+  wasm_instance_delete(instance);
+  wasm_module_delete(module);
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+  return 0;
+}
+
+static void print_trap(wasm_trap_t *trap) {
+  assert(trap != NULL);
+  wasm_message_t message;
+  wasm_trap_message(trap, &message);
+  fprintf(stderr, "failed to instantiate module %.*s\n", (int) message.size, message.data);
+  wasm_byte_vec_delete(&message);
+  wasm_trap_delete(trap);
+}
+

examples/wasi/main.rs

@@ -0,0 +1,43 @@
+//! Example of instantiating of instantiating a wasm module which uses WASI
+//! imports.
+
+// You can execute this example with `cargo run --example wasi`
+
+use anyhow::Result;
+use wasmtime::*;
+use wasmtime_wasi::{Wasi, WasiCtx};
+
+fn main() -> Result<()> {
+    let store = Store::default();
+    let module = Module::from_file(&store, "target/wasm32-wasi/debug/wasi.wasm")?;
+
+    // Create an instance of `Wasi` which contains a `WasiCtx`. Note that
+    // `WasiCtx` provides a number of ways to configure what the target program
+    // will have access to.
+    let wasi = Wasi::new(&store, WasiCtx::new(std::env::args())?);
+    let mut imports = Vec::new();
+    for import in module.imports() {
+        if import.module() == "wasi_snapshot_preview1" {
+            if let Some(export) = wasi.get_export(import.name()) {
+                imports.push(Extern::from(export.clone()));
+                continue;
+            }
+        }
+        panic!(
+            "couldn't find import for `{}::{}`",
+            import.module(),
+            import.name()
+        );
+    }
+
+    // Instance our module with the imports we've created, then we can run the
+    // standard wasi `_start` function.
+    let instance = Instance::new(&module, &imports)?;
+    let start = instance
+        .get_export("_start")
+        .and_then(|e| e.func())
+        .unwrap();
+    let start = start.get0::<()>()?;
+    start()?;
+    Ok(())
+}

examples/wasi/wasm/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "example-wasi-wasm"
+version = "0.1.0"
+authors = ["The Wasmtime Project Developers"]
+edition = "2018"
+publish = false
+
+[[bin]]
+path = "wasi.rs"
+name = "wasi"

examples/wasi/wasm/wasi.rs

@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello, world!");
+}