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 wasmtime_store_t *store = wasmtime_store_new(engine, NULL, NULL); 46 assert(store != NULL); 47 wasmtime_context_t *context = wasmtime_store_context(store); 48 49 // Read our input file, which in this case is a wasm text file. 50 FILE* file = fopen("examples/externref.wat", "r"); 51 assert(file != NULL); 52 fseek(file, 0L, SEEK_END); 53 size_t file_size = ftell(file); 54 fseek(file, 0L, SEEK_SET); 55 wasm_byte_vec_t wat; 56 wasm_byte_vec_new_uninitialized(&wat, file_size); 57 assert(fread(wat.data, file_size, 1, file) == 1); 58 fclose(file); 59 60 // Parse the wat into the binary wasm format 61 wasm_byte_vec_t wasm; 62 wasmtime_error_t *error = wasmtime_wat2wasm(wat.data, wat.size, &wasm); 63 if (error != NULL) 64 exit_with_error("failed to parse wat", error, NULL); 65 wasm_byte_vec_delete(&wat); 66 67 // Now that we've got our binary webassembly we can compile our module. 68 printf("Compiling module...\n"); 69 wasmtime_module_t *module = NULL; 70 error = wasmtime_module_new(engine, (uint8_t*) wasm.data, wasm.size, &module); 71 wasm_byte_vec_delete(&wasm); 72 if (error != NULL) 73 exit_with_error("failed to compile module", error, NULL); 74 75 // Instantiate the module. 76 printf("Instantiating module...\n"); 77 wasm_trap_t *trap = NULL; 78 wasmtime_instance_t instance; 79 error = wasmtime_instance_new(context, module, NULL, 0, &instance, &trap); 80 if (error != NULL || trap != 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 the NULL here is a finalizer callback, but we don't need one for 88 // this example. 89 wasmtime_externref_t *externref = wasmtime_externref_new("Hello, World!", NULL); 90 91 // The `externref`'s wrapped data should be the string "Hello, World!". 92 void* data = wasmtime_externref_data(externref); 93 assert(strcmp((char*)data, "Hello, World!") == 0); 94 95 printf("Touching `externref` table...\n"); 96 97 wasmtime_extern_t item; 98 99 // Lookup the `table` export. 100 ok = wasmtime_instance_export_get(context, &instance, "table", strlen("table"), &item); 101 assert(ok); 102 assert(item.kind == WASMTIME_EXTERN_TABLE); 103 104 // Set `table[3]` to our `externref`. 105 wasmtime_val_t externref_val; 106 externref_val.kind = WASMTIME_EXTERNREF; 107 externref_val.of.externref = externref; 108 error = wasmtime_table_set(context, &item.of.table, 3, &externref_val); 109 if (error != NULL) 110 exit_with_error("failed to set table", error, NULL); 111 112 // `table[3]` should now be our `externref`. 113 wasmtime_val_t elem; 114 ok = wasmtime_table_get(context, &item.of.table, 3, &elem); 115 assert(ok); 116 assert(elem.kind == WASMTIME_EXTERNREF); 117 assert(strcmp((char*)wasmtime_externref_data(elem.of.externref), "Hello, World!") == 0); 118 wasmtime_val_delete(&elem); 119 120 printf("Touching `externref` global...\n"); 121 122 // Lookup the `global` export. 123 ok = wasmtime_instance_export_get(context, &instance, "global", strlen("global"), &item); 124 assert(ok); 125 assert(item.kind == WASMTIME_EXTERN_GLOBAL); 126 127 // Set the global to our `externref`. 128 error = wasmtime_global_set(context, &item.of.global, &externref_val); 129 if (error != NULL) 130 exit_with_error("failed to set global", error, NULL); 131 132 // Get the global, and it should return our `externref` again. 133 wasmtime_val_t global_val; 134 wasmtime_global_get(context, &item.of.global, &global_val); 135 assert(global_val.kind == WASMTIME_EXTERNREF); 136 assert(strcmp((char*)wasmtime_externref_data(elem.of.externref), "Hello, World!") == 0); 137 wasmtime_val_delete(&global_val); 138 139 printf("Calling `externref` func...\n"); 140 141 // Lookup the `func` export. 142 ok = wasmtime_instance_export_get(context, &instance, "func", strlen("func"), &item); 143 assert(ok); 144 assert(item.kind == WASMTIME_EXTERN_FUNC); 145 146 // And call it! 147 wasmtime_val_t results[1]; 148 error = wasmtime_func_call(context, &item.of.func, &externref_val, 1, results, 1, &trap); 149 if (error != NULL || trap != NULL) 150 exit_with_error("failed to call function", error, trap); 151 152 // `func` returns the same reference we gave it, so `results[0]` should be our 153 // `externref`. 154 assert(results[0].kind == WASMTIME_EXTERNREF); 155 assert(strcmp((char*)wasmtime_externref_data(results[0].of.externref), "Hello, World!") == 0); 156 wasmtime_val_delete(&results[0]); 157 158 // We can GC any now-unused references to our externref that the store is 159 // holding. 160 printf("GCing within the store...\n"); 161 wasmtime_context_gc(context); 162 163 // Clean up after ourselves at this point 164 printf("All finished!\n"); 165 ret = 0; 166 167 wasmtime_store_delete(store); 168 wasmtime_module_delete(module); 169 wasm_engine_delete(engine); 170 return 0; 171 } 172 173 static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap) { 174 fprintf(stderr, "error: %s\n", message); 175 wasm_byte_vec_t error_message; 176 if (error != NULL) { 177 wasmtime_error_message(error, &error_message); 178 wasmtime_error_delete(error); 179 } else { 180 wasm_trap_message(trap, &error_message); 181 wasm_trap_delete(trap); 182 } 183 fprintf(stderr, "%.*s\n", (int) error_message.size, error_message.data); 184 wasm_byte_vec_delete(&error_message); 185 exit(1); 186 } 187