Using linear memory
You can also browse this source code online and clone the wasmtime repository to run the example locally:
This example shows off how to interact with wasm memory in a module. Be sure to read the documentation for Memory as well.
Wasm Source
(module (memory (export "memory") 2 3) (func (export "size") (result i32) (memory.size)) (func (export "load") (param i32) (result i32) (i32.load8_s (local.get 0)) ) (func (export "store") (param i32 i32) (i32.store8 (local.get 0) (local.get 1)) ) (data (i32.const 0x1000) "\01\02\03\04") ) Host Source
//! An example of how to interact with wasm memory. //! //! Here a small wasm module is used to show how memory is initialized, how to //! read and write memory through the `Memory` object, and how wasm functions //! can trap when dealing with out-of-bounds addresses. // You can execute this example with `cargo run --example memory` use wasmtime::*; fn main() -> Result<()> { // Create our `store_fn` context and then compile a module and create an // instance from the compiled module all in one go. let mut store: Store<()> = Store::default(); let module = Module::from_file(store.engine(), "examples/memory.wat")?; let instance = Instance::new(&mut store, &module, &[])?; // load_fn up our exports from the instance let memory = instance .get_memory(&mut store, "memory") .ok_or(wasmtime::format_err!("failed to find `memory` export"))?; let size = instance.get_typed_func::<(), i32>(&mut store, "size")?; let load_fn = instance.get_typed_func::<i32, i32>(&mut store, "load")?; let store_fn = instance.get_typed_func::<(i32, i32), ()>(&mut store, "store")?; println!("Checking memory..."); assert_eq!(memory.size(&store), 2); assert_eq!(memory.data_size(&store), 0x20000); assert_eq!(memory.data_mut(&mut store)[0], 0); assert_eq!(memory.data_mut(&mut store)[0x1000], 1); assert_eq!(memory.data_mut(&mut store)[0x1003], 4); assert_eq!(size.call(&mut store, ())?, 2); assert_eq!(load_fn.call(&mut store, 0)?, 0); assert_eq!(load_fn.call(&mut store, 0x1000)?, 1); assert_eq!(load_fn.call(&mut store, 0x1003)?, 4); assert_eq!(load_fn.call(&mut store, 0x1ffff)?, 0); assert!(load_fn.call(&mut store, 0x20000).is_err()); // out of bounds trap println!("Mutating memory..."); memory.data_mut(&mut store)[0x1003] = 5; store_fn.call(&mut store, (0x1002, 6))?; assert!(store_fn.call(&mut store, (0x20000, 0)).is_err()); // out of bounds trap assert_eq!(memory.data(&store)[0x1002], 6); assert_eq!(memory.data(&store)[0x1003], 5); assert_eq!(load_fn.call(&mut store, 0x1002)?, 6); assert_eq!(load_fn.call(&mut store, 0x1003)?, 5); // Grow memory. println!("Growing memory..."); memory.grow(&mut store, 1)?; assert_eq!(memory.size(&store), 3); assert_eq!(memory.data_size(&store), 0x30000); assert_eq!(load_fn.call(&mut store, 0x20000)?, 0); store_fn.call(&mut store, (0x20000, 0))?; assert!(load_fn.call(&mut store, 0x30000).is_err()); assert!(store_fn.call(&mut store, (0x30000, 0)).is_err()); assert!(memory.grow(&mut store, 1).is_err()); assert!(memory.grow(&mut store, 0).is_ok()); println!("Creating stand-alone memory..."); let memorytype = MemoryType::new(5, Some(5)); let memory2 = Memory::new(&mut store, memorytype)?; assert_eq!(memory2.size(&store), 5); assert!(memory2.grow(&mut store, 1).is_err()); assert!(memory2.grow(&mut store, 0).is_ok()); Ok(()) }
/* Example of instantiating of the WebAssembly module and invoking its exported function. You can build using cmake: mkdir build && cd build && cmake .. && cmake --build . --target wasmtime-memory Also note that this example was taken from https://github.com/WebAssembly/wasm-c-api/blob/master/example/memory.c originally */ #include <inttypes.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <wasm.h> #include <wasmtime.h> static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap); void check(bool success) { if (!success) { printf("> Error, expected success\n"); exit(1); } } void check_call(wasmtime_context_t *store, wasmtime_func_t *func, const wasmtime_val_t *args, size_t nargs, int32_t expected) { wasmtime_val_t results[1]; wasm_trap_t *trap = NULL; wasmtime_error_t *error = wasmtime_func_call(store, func, args, nargs, results, 1, &trap); if (error != NULL || trap != NULL) exit_with_error("failed to call function", error, trap); if (results[0].of.i32 != expected) { printf("> Error on result\n"); exit(1); } } void check_call0(wasmtime_context_t *store, wasmtime_func_t *func, int32_t expected) { check_call(store, func, NULL, 0, expected); } void check_call1(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg, int32_t expected) { wasmtime_val_t args[1]; args[0].kind = WASMTIME_I32; args[0].of.i32 = arg; check_call(store, func, args, 1, expected); } void check_call2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1, int32_t arg2, int32_t expected) { wasmtime_val_t args[2]; args[0].kind = WASMTIME_I32; args[0].of.i32 = arg1; args[1].kind = WASMTIME_I32; args[1].of.i32 = arg2; check_call(store, func, args, 2, expected); } void check_ok(wasmtime_context_t *store, wasmtime_func_t *func, const wasmtime_val_t *args, size_t nargs) { wasm_trap_t *trap = NULL; wasmtime_error_t *error = wasmtime_func_call(store, func, args, nargs, NULL, 0, &trap); if (error != NULL || trap != NULL) exit_with_error("failed to call function", error, trap); } void check_ok2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1, int32_t arg2) { wasmtime_val_t args[2]; args[0].kind = WASMTIME_I32; args[0].of.i32 = arg1; args[1].kind = WASMTIME_I32; args[1].of.i32 = arg2; check_ok(store, func, args, 2); } void check_trap(wasmtime_context_t *store, wasmtime_func_t *func, const wasmtime_val_t *args, size_t nargs, size_t num_results) { assert(num_results <= 1); wasmtime_val_t results[1]; wasm_trap_t *trap = NULL; wasmtime_error_t *error = wasmtime_func_call(store, func, args, nargs, results, num_results, &trap); if (error != NULL) exit_with_error("failed to call function", error, NULL); if (trap == NULL) { printf("> Error on result, expected trap\n"); exit(1); } wasm_trap_delete(trap); } void check_trap1(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg) { wasmtime_val_t args[1]; args[0].kind = WASMTIME_I32; args[0].of.i32 = arg; check_trap(store, func, args, 1, 1); } void check_trap2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1, int32_t arg2) { wasmtime_val_t args[2]; args[0].kind = WASMTIME_I32; args[0].of.i32 = arg1; args[1].kind = WASMTIME_I32; args[1].of.i32 = arg2; check_trap(store, func, args, 2, 0); } int main() { // Initialize. printf("Initializing...\n"); wasm_engine_t *engine = wasm_engine_new(); wasmtime_store_t *store = wasmtime_store_new(engine, NULL, NULL); wasmtime_context_t *context = wasmtime_store_context(store); // Load our input file to parse it next FILE *file = fopen("examples/memory.wat", "r"); if (!file) { printf("> Error loading file!\n"); return 1; } fseek(file, 0L, SEEK_END); size_t file_size = ftell(file); fseek(file, 0L, SEEK_SET); wasm_byte_vec_t wat; wasm_byte_vec_new_uninitialized(&wat, file_size); if (fread(wat.data, file_size, 1, file) != 1) { printf("> Error loading module!\n"); return 1; } fclose(file); // Parse the wat into the binary wasm format wasm_byte_vec_t binary; wasmtime_error_t *error = wasmtime_wat2wasm(wat.data, wat.size, &binary); if (error != NULL) exit_with_error("failed to parse wat", error, NULL); wasm_byte_vec_delete(&wat); // Compile. printf("Compiling module...\n"); wasmtime_module_t *module = NULL; error = wasmtime_module_new(engine, (uint8_t *)binary.data, binary.size, &module); if (error) exit_with_error("failed to compile module", error, NULL); wasm_byte_vec_delete(&binary); // Instantiate. printf("Instantiating module...\n"); wasmtime_instance_t instance; wasm_trap_t *trap = NULL; error = wasmtime_instance_new(context, module, NULL, 0, &instance, &trap); if (error != NULL || trap != NULL) exit_with_error("failed to instantiate", error, trap); wasmtime_module_delete(module); // Extract export. printf("Extracting exports...\n"); wasmtime_memory_t memory; wasmtime_func_t size_func, load_func, store_func; wasmtime_extern_t item; bool ok; ok = wasmtime_instance_export_get(context, &instance, "memory", strlen("memory"), &item); assert(ok && item.kind == WASMTIME_EXTERN_MEMORY); memory = item.of.memory; ok = wasmtime_instance_export_get(context, &instance, "size", strlen("size"), &item); assert(ok && item.kind == WASMTIME_EXTERN_FUNC); size_func = item.of.func; ok = wasmtime_instance_export_get(context, &instance, "load", strlen("load"), &item); assert(ok && item.kind == WASMTIME_EXTERN_FUNC); load_func = item.of.func; ok = wasmtime_instance_export_get(context, &instance, "store", strlen("store"), &item); assert(ok && item.kind == WASMTIME_EXTERN_FUNC); store_func = item.of.func; // Check initial memory. printf("Checking memory...\n"); check(wasmtime_memory_size(context, &memory) == 2); check(wasmtime_memory_data_size(context, &memory) == 0x20000); check(wasmtime_memory_data(context, &memory)[0] == 0); check(wasmtime_memory_data(context, &memory)[0x1000] == 1); check(wasmtime_memory_data(context, &memory)[0x1003] == 4); check_call0(context, &size_func, 2); check_call1(context, &load_func, 0, 0); check_call1(context, &load_func, 0x1000, 1); check_call1(context, &load_func, 0x1003, 4); check_call1(context, &load_func, 0x1ffff, 0); check_trap1(context, &load_func, 0x20000); // Mutate memory. printf("Mutating memory...\n"); wasmtime_memory_data(context, &memory)[0x1003] = 5; check_ok2(context, &store_func, 0x1002, 6); check_trap2(context, &store_func, 0x20000, 0); check(wasmtime_memory_data(context, &memory)[0x1002] == 6); check(wasmtime_memory_data(context, &memory)[0x1003] == 5); check_call1(context, &load_func, 0x1002, 6); check_call1(context, &load_func, 0x1003, 5); // Grow memory. printf("Growing memory...\n"); uint64_t old_size; error = wasmtime_memory_grow(context, &memory, 1, &old_size); if (error != NULL) exit_with_error("failed to grow memory", error, trap); check(wasmtime_memory_size(context, &memory) == 3); check(wasmtime_memory_data_size(context, &memory) == 0x30000); check_call1(context, &load_func, 0x20000, 0); check_ok2(context, &store_func, 0x20000, 0); check_trap1(context, &load_func, 0x30000); check_trap2(context, &store_func, 0x30000, 0); error = wasmtime_memory_grow(context, &memory, 1, &old_size); assert(error != NULL); wasmtime_error_delete(error); error = wasmtime_memory_grow(context, &memory, 0, &old_size); if (error != NULL) exit_with_error("failed to grow memory", error, trap); // Create stand-alone memory. printf("Creating stand-alone memory...\n"); wasm_limits_t limits = {5, 5}; wasm_memorytype_t *memorytype = wasm_memorytype_new(&limits); wasmtime_memory_t memory2; error = wasmtime_memory_new(context, memorytype, &memory2); if (error != NULL) exit_with_error("failed to create memory", error, trap); wasm_memorytype_delete(memorytype); check(wasmtime_memory_size(context, &memory2) == 5); // Shut down. printf("Shutting down...\n"); wasmtime_store_delete(store); wasm_engine_delete(engine); // All done. printf("Done.\n"); return 0; } static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap) { fprintf(stderr, "error: %s\n", message); wasm_byte_vec_t error_message; if (error != NULL) { wasmtime_error_message(error, &error_message); wasmtime_error_delete(error); } else { wasm_trap_message(trap, &error_message); wasm_trap_delete(trap); } fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data); wasm_byte_vec_delete(&error_message); exit(1); } #undef NDEBUG #include <fstream> #include <iostream> #include <sstream> #include <wasmtime.hh> using namespace wasmtime; std::string readFile(const char *name) { std::ifstream watFile; watFile.open(name); std::stringstream strStream; strStream << watFile.rdbuf(); return strStream.str(); } int main() { // Create our `store` context and then compile a module and create an // instance from the compiled module all in one go. Engine engine; Module module = Module::compile(engine, readFile("examples/memory.wat")).unwrap(); Store store(engine); Instance instance = Instance::create(store, module, {}).unwrap(); // load_fn up our exports from the instance auto memory = std::get<Memory>(*instance.get(store, "memory")); auto size = std::get<Func>(*instance.get(store, "size")); auto load_fn = std::get<Func>(*instance.get(store, "load")); auto store_fn = std::get<Func>(*instance.get(store, "store")); std::cout << "Checking memory...\n"; assert(memory.size(store) == 2); auto data = memory.data(store); assert(data.size() == 0x20000); assert(data[0] == 0); assert(data[0x1000] == 1); assert(data[0x1003] == 4); assert(size.call(store, {}).unwrap()[0].i32() == 2); assert(load_fn.call(store, {0}).unwrap()[0].i32() == 0); assert(load_fn.call(store, {0x1000}).unwrap()[0].i32() == 1); assert(load_fn.call(store, {0x1003}).unwrap()[0].i32() == 4); assert(load_fn.call(store, {0x1ffff}).unwrap()[0].i32() == 0); load_fn.call(store, {0x20000}).err(); // out of bounds trap std::cout << "Mutating memory...\n"; memory.data(store)[0x1003] = 5; store_fn.call(store, {0x1002, 6}).unwrap(); store_fn.call(store, {0x20000, 0}).err(); // out of bounds trap assert(memory.data(store)[0x1002] == 6); assert(memory.data(store)[0x1003] == 5); assert(load_fn.call(store, {0x1002}).unwrap()[0].i32() == 6); assert(load_fn.call(store, {0x1003}).unwrap()[0].i32() == 5); // Grow memory. std::cout << "Growing memory...\n"; memory.grow(store, 1).unwrap(); assert(memory.size(store) == 3); assert(memory.data(store).size() == 0x30000); assert(load_fn.call(store, {0x20000}).unwrap()[0].i32() == 0); store_fn.call(store, {0x20000, 0}).unwrap(); load_fn.call(store, {0x30000}).err(); store_fn.call(store, {0x30000, 0}).err(); memory.grow(store, 1).err(); memory.grow(store, 0).ok(); std::cout << "Creating stand-alone memory...\n"; MemoryType ty(5, 5); Memory memory2 = Memory::create(store, ty).unwrap(); assert(memory2.size(store) == 5); memory2.grow(store, 1).err(); memory2.grow(store, 0).ok(); }