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 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(store, &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 error = wasmtime_instance_new(store, module, NULL, 0, &instance, &trap); 79 if (instance == NULL) 80 exit_with_error("failed to instantiate", error, trap); 81 82 printf("Creating new `externref`...\n"); 83 84 // Create a new `externref` value. 85 wasm_val_t externref = wasmtime_externref_new("Hello, World!"); 86 assert(externref.kind == WASM_ANYREF); 87 88 // The `externref`'s wrapped data should be the string "Hello, World!". 89 void* data = NULL; 90 ok = wasmtime_externref_data(&externref, &data); 91 assert(ok); 92 assert(strcmp((char*)data, "Hello, World!") == 0); 93 94 printf("Touching `externref` table...\n"); 95 96 // Lookup the `table` export. 97 wasm_extern_vec_t externs; 98 wasm_instance_exports(instance, &externs); 99 assert(externs.size == 3); 100 wasm_table_t *table = wasm_extern_as_table(externs.data[0]); 101 assert(table != NULL); 102 103 // Set `table[3]` to our `externref`. 104 wasm_val_t elem; 105 wasm_val_copy(&elem, &externref); 106 assert(elem.kind == WASM_ANYREF); 107 ok = wasm_table_set(table, 3, elem.of.ref); 108 assert(ok); 109 elem.of.ref = NULL; 110 111 // `table[3]` should now be our `externref`. 112 elem.of.ref = wasm_table_get(table, 3); 113 assert(elem.of.ref != NULL); 114 assert(wasm_ref_same(elem.of.ref, externref.of.ref)); 115 116 printf("Touching `externref` global...\n"); 117 118 // Lookup the `global` export. 119 wasm_global_t *global = wasm_extern_as_global(externs.data[1]); 120 assert(global != NULL); 121 122 // Set the global to our `externref`. 123 wasm_global_set(global, &externref); 124 125 // Get the global, and it should return our `externref` again. 126 wasm_val_t global_val; 127 wasm_global_get(global, &global_val); 128 assert(global_val.kind == WASM_ANYREF); 129 assert(wasm_ref_same(global_val.of.ref, externref.of.ref)); 130 131 printf("Calling `externref` func...\n"); 132 133 // Lookup the `func` export. 134 wasm_func_t *func = wasm_extern_as_func(externs.data[2]); 135 assert(func != NULL); 136 137 // And call it! 138 wasm_val_t args[1]; 139 wasm_val_copy(&args[0], &externref); 140 wasm_val_t results[1]; 141 error = wasmtime_func_call(func, args, 1, results, 1, &trap); 142 if (error != NULL || trap != NULL) 143 exit_with_error("failed to call function", error, trap); 144 145 // `func` returns the same reference we gave it, so `results[0]` should be our 146 // `externref`. 147 assert(results[0].kind == WASM_ANYREF); 148 assert(wasm_ref_same(results[0].of.ref, externref.of.ref)); 149 150 // Clean up after ourselves at this point 151 printf("All finished!\n"); 152 ret = 0; 153 154 wasm_val_delete(&results[0]); 155 wasm_val_delete(&args[0]); 156 wasm_val_delete(&global_val); 157 wasm_val_delete(&elem); 158 wasm_extern_vec_delete(&externs); 159 wasm_val_delete(&externref); 160 wasm_instance_delete(instance); 161 wasm_module_delete(module); 162 wasm_store_delete(store); 163 wasm_engine_delete(engine); 164 wasm_config_delete(config); 165 return ret; 166 } 167 168 static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap) { 169 fprintf(stderr, "error: %s\n", message); 170 wasm_byte_vec_t error_message; 171 if (error != NULL) { 172 wasmtime_error_message(error, &error_message); 173 wasmtime_error_delete(error); 174 } else { 175 wasm_trap_message(trap, &error_message); 176 wasm_trap_delete(trap); 177 } 178 fprintf(stderr, "%.*s\n", (int) error_message.size, error_message.data); 179 wasm_byte_vec_delete(&error_message); 180 exit(1); 181 } 182