1 /* 2 Example of using `externref` values. 3 4 You can compile and run this example on Linux with: 5 6 cargo build --release -p wasmtime-c-api 7 cc examples/externref.c \ 8 -I crates/c-api/include \ 9 -I crates/c-api/wasm-c-api/include \ 10 target/release/libwasmtime.a \ 11 -lpthread -ldl -lm \ 12 -o externref 13 ./externref 14 15 Note that on Windows and macOS the command will be similar, but you'll need 16 to tweak the `-lpthread` and such annotations as well as the name of the 17 `libwasmtime.a` file on Windows. 18 */ 19 20 #include <assert.h> 21 #include <stdio.h> 22 #include <stdlib.h> 23 #include <string.h> 24 #include <wasm.h> 25 #include <wasmtime.h> 26 27 static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap); 28 29 int main() { 30 int ret = 0; 31 bool ok = true; 32 // Create a new configuration with Wasm reference types enabled. 33 printf("Initializing...\n"); 34 wasm_config_t *config = wasm_config_new(); 35 assert(config != NULL); 36 wasmtime_config_wasm_reference_types_set(config, true); 37 38 // Create an *engine*, which is a compilation context, with our configured 39 // options. 40 wasm_engine_t *engine = wasm_engine_new_with_config(config); 41 assert(engine != NULL); 42 43 // With an engine we can create a *store* which is a long-lived group of wasm 44 // modules. 45 wasm_store_t *store = wasm_store_new(engine); 46 assert(store != NULL); 47 48 // Read our input file, which in this case is a wasm text file. 49 FILE* file = fopen("examples/externref.wat", "r"); 50 assert(file != NULL); 51 fseek(file, 0L, SEEK_END); 52 size_t file_size = ftell(file); 53 fseek(file, 0L, SEEK_SET); 54 wasm_byte_vec_t wat; 55 wasm_byte_vec_new_uninitialized(&wat, file_size); 56 assert(fread(wat.data, file_size, 1, file) == 1); 57 fclose(file); 58 59 // Parse the wat into the binary wasm format 60 wasm_byte_vec_t wasm; 61 wasmtime_error_t *error = wasmtime_wat2wasm(&wat, &wasm); 62 if (error != NULL) 63 exit_with_error("failed to parse wat", error, NULL); 64 wasm_byte_vec_delete(&wat); 65 66 // Now that we've got our binary webassembly we can compile our module. 67 printf("Compiling module...\n"); 68 wasm_module_t *module = NULL; 69 error = wasmtime_module_new(engine, &wasm, &module); 70 wasm_byte_vec_delete(&wasm); 71 if (error != NULL) 72 exit_with_error("failed to compile module", error, NULL); 73 74 // Instantiate the module. 75 printf("Instantiating module...\n"); 76 wasm_trap_t *trap = NULL; 77 wasm_instance_t *instance = NULL; 78 wasm_extern_vec_t imports = WASM_EMPTY_VEC; 79 error = wasmtime_instance_new(store, module, &imports, &instance, &trap); 80 if (instance == NULL) 81 exit_with_error("failed to instantiate", error, trap); 82 83 printf("Creating new `externref`...\n"); 84 85 // Create a new `externref` value. 86 // 87 // Note that if you need clean up for after the externref is reclaimed, you 88 // can use `wasmtime_externref_new_with_finalizer`. 89 wasm_val_t externref; 90 wasmtime_externref_new("Hello, World!", &externref); 91 assert(externref.kind == WASM_ANYREF); 92 93 // The `externref`'s wrapped data should be the string "Hello, World!". 94 void* data = NULL; 95 ok = wasmtime_externref_data(&externref, &data); 96 assert(ok); 97 assert(strcmp((char*)data, "Hello, World!") == 0); 98 99 printf("Touching `externref` table...\n"); 100 101 // Lookup the `table` export. 102 wasm_extern_vec_t externs; 103 wasm_instance_exports(instance, &externs); 104 assert(externs.size == 3); 105 wasm_table_t *table = wasm_extern_as_table(externs.data[0]); 106 assert(table != NULL); 107 108 // Set `table[3]` to our `externref`. 109 wasm_val_t elem; 110 wasm_val_copy(&elem, &externref); 111 assert(elem.kind == WASM_ANYREF); 112 ok = wasm_table_set(table, 3, elem.of.ref); 113 assert(ok); 114 115 // `table[3]` should now be our `externref`. 116 wasm_ref_delete(elem.of.ref); 117 elem.of.ref = wasm_table_get(table, 3); 118 assert(elem.of.ref != NULL); 119 assert(wasm_ref_same(elem.of.ref, externref.of.ref)); 120 121 printf("Touching `externref` global...\n"); 122 123 // Lookup the `global` export. 124 wasm_global_t *global = wasm_extern_as_global(externs.data[1]); 125 assert(global != NULL); 126 127 // Set the global to our `externref`. 128 wasm_global_set(global, &externref); 129 130 // Get the global, and it should return our `externref` again. 131 wasm_val_t global_val; 132 wasm_global_get(global, &global_val); 133 assert(global_val.kind == WASM_ANYREF); 134 assert(wasm_ref_same(global_val.of.ref, externref.of.ref)); 135 136 printf("Calling `externref` func...\n"); 137 138 // Lookup the `func` export. 139 wasm_func_t *func = wasm_extern_as_func(externs.data[2]); 140 assert(func != NULL); 141 142 // And call it! 143 wasm_val_t args[1] = { externref }; 144 wasm_val_t results[1]; 145 wasm_val_vec_t args_vec = WASM_ARRAY_VEC(args); 146 wasm_val_vec_t results_vec = WASM_ARRAY_VEC(results); 147 error = wasmtime_func_call(func, &args_vec, &results_vec, &trap); 148 if (error != NULL || trap != NULL) 149 exit_with_error("failed to call function", error, trap); 150 151 // `func` returns the same reference we gave it, so `results[0]` should be our 152 // `externref`. 153 assert(results[0].kind == WASM_ANYREF); 154 assert(wasm_ref_same(results[0].of.ref, externref.of.ref)); 155 156 // We can GC any now-unused references to our externref that the store is 157 // holding. 158 printf("GCing within the store...\n"); 159 wasmtime_store_gc(store); 160 161 // Clean up after ourselves at this point 162 printf("All finished!\n"); 163 ret = 0; 164 165 wasm_val_delete(&results[0]); 166 wasm_val_delete(&global_val); 167 wasm_val_delete(&elem); 168 wasm_extern_vec_delete(&externs); 169 wasm_val_delete(&externref); 170 wasm_instance_delete(instance); 171 wasm_module_delete(module); 172 wasm_store_delete(store); 173 wasm_engine_delete(engine); 174 return ret; 175 } 176 177 static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap) { 178 fprintf(stderr, "error: %s\n", message); 179 wasm_byte_vec_t error_message; 180 if (error != NULL) { 181 wasmtime_error_message(error, &error_message); 182 wasmtime_error_delete(error); 183 } else { 184 wasm_trap_message(trap, &error_message); 185 wasm_trap_delete(trap); 186 } 187 fprintf(stderr, "%.*s\n", (int) error_message.size, error_message.data); 188 wasm_byte_vec_delete(&error_message); 189 exit(1); 190 } 191