| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <inttypes.h> |
| |
| #include "wasm.h" |
| |
| #define own |
| |
| |
| // A function to be called from Wasm code. |
| own wasm_trap_t* callback( |
| const wasm_val_t args[], wasm_val_t results[] |
| ) { |
| printf("Calling back...\n> "); |
| printf("> %p\n", |
| args[0].of.ref ? wasm_ref_get_host_info(args[0].of.ref) : NULL); |
| wasm_val_copy(&results[0], &args[0]); |
| return NULL; |
| } |
| |
| |
| wasm_func_t* get_export_func(const wasm_extern_vec_t* exports, size_t i) { |
| if (exports->size <= i || !wasm_extern_as_func(exports->data[i])) { |
| printf("> Error accessing function export %zu!\n", i); |
| exit(1); |
| } |
| return wasm_extern_as_func(exports->data[i]); |
| } |
| |
| wasm_global_t* get_export_global(const wasm_extern_vec_t* exports, size_t i) { |
| if (exports->size <= i || !wasm_extern_as_global(exports->data[i])) { |
| printf("> Error accessing global export %zu!\n", i); |
| exit(1); |
| } |
| return wasm_extern_as_global(exports->data[i]); |
| } |
| |
| wasm_table_t* get_export_table(const wasm_extern_vec_t* exports, size_t i) { |
| if (exports->size <= i || !wasm_extern_as_table(exports->data[i])) { |
| printf("> Error accessing table export %zu!\n", i); |
| exit(1); |
| } |
| return wasm_extern_as_table(exports->data[i]); |
| } |
| |
| |
| own wasm_ref_t* call_v_r(const wasm_func_t* func) { |
| printf("call_v_r... "); fflush(stdout); |
| wasm_val_t results[1]; |
| if (wasm_func_call(func, NULL, results)) { |
| printf("> Error calling function!\n"); |
| exit(1); |
| } |
| printf("okay\n"); |
| return results[0].of.ref; |
| } |
| |
| void call_r_v(const wasm_func_t* func, wasm_ref_t* ref) { |
| printf("call_r_v... "); fflush(stdout); |
| wasm_val_t args[1]; |
| args[0].kind = WASM_ANYREF; |
| args[0].of.ref = ref; |
| if (wasm_func_call(func, args, NULL)) { |
| printf("> Error calling function!\n"); |
| exit(1); |
| } |
| printf("okay\n"); |
| } |
| |
| own wasm_ref_t* call_r_r(const wasm_func_t* func, wasm_ref_t* ref) { |
| printf("call_r_r... "); fflush(stdout); |
| wasm_val_t args[1]; |
| args[0].kind = WASM_ANYREF; |
| args[0].of.ref = ref; |
| wasm_val_t results[1]; |
| if (wasm_func_call(func, args, results)) { |
| printf("> Error calling function!\n"); |
| exit(1); |
| } |
| printf("okay\n"); |
| return results[0].of.ref; |
| } |
| |
| void call_ir_v(const wasm_func_t* func, int32_t i, wasm_ref_t* ref) { |
| printf("call_ir_v... "); fflush(stdout); |
| wasm_val_t args[2]; |
| args[0].kind = WASM_I32; |
| args[0].of.i32 = i; |
| args[1].kind = WASM_ANYREF; |
| args[1].of.ref = ref; |
| if (wasm_func_call(func, args, NULL)) { |
| printf("> Error calling function!\n"); |
| exit(1); |
| } |
| printf("okay\n"); |
| } |
| |
| own wasm_ref_t* call_i_r(const wasm_func_t* func, int32_t i) { |
| printf("call_i_r... "); fflush(stdout); |
| wasm_val_t args[1]; |
| args[0].kind = WASM_I32; |
| args[0].of.i32 = i; |
| wasm_val_t results[1]; |
| if (wasm_func_call(func, args, results)) { |
| printf("> Error calling function!\n"); |
| exit(1); |
| } |
| printf("okay\n"); |
| return results[0].of.ref; |
| } |
| |
| void check(own wasm_ref_t* actual, const wasm_ref_t* expected) { |
| if (actual != expected && |
| !(actual && expected && wasm_ref_same(actual, expected))) { |
| printf("> Error reading reference, expected %p, got %p\n", |
| expected ? wasm_ref_get_host_info(expected) : NULL, |
| actual ? wasm_ref_get_host_info(actual) : NULL); |
| exit(1); |
| } |
| if (actual) wasm_ref_delete(actual); |
| } |
| |
| |
| int main(int argc, const char* argv[]) { |
| // Initialize. |
| printf("Initializing...\n"); |
| wasm_engine_t* engine = wasm_engine_new(); |
| wasm_store_t* store = wasm_store_new(engine); |
| |
| // Load binary. |
| printf("Loading binary...\n"); |
| FILE* file = fopen("hostref.wasm", "r"); |
| if (!file) { |
| printf("> Error loading module!\n"); |
| return 1; |
| } |
| fseek(file, 0L, SEEK_END); |
| size_t file_size = ftell(file); |
| fseek(file, 0L, SEEK_SET); |
| wasm_byte_vec_t binary; |
| wasm_byte_vec_new_uninitialized(&binary, file_size); |
| if (fread(binary.data, file_size, 1, file) != 1) { |
| printf("> Error loading module!\n"); |
| return 1; |
| } |
| fclose(file); |
| |
| // Compile. |
| printf("Compiling module...\n"); |
| own wasm_module_t* module = wasm_module_new(store, &binary); |
| if (!module) { |
| printf("> Error compiling module!\n"); |
| return 1; |
| } |
| |
| wasm_byte_vec_delete(&binary); |
| |
| // Create external callback function. |
| printf("Creating callback...\n"); |
| own wasm_functype_t* callback_type = wasm_functype_new_1_1( |
| wasm_valtype_new(WASM_ANYREF), wasm_valtype_new(WASM_ANYREF)); |
| own wasm_func_t* callback_func = |
| wasm_func_new(store, callback_type, callback); |
| |
| wasm_functype_delete(callback_type); |
| |
| // Instantiate. |
| printf("Instantiating module...\n"); |
| const wasm_extern_t* imports[] = { wasm_func_as_extern(callback_func) }; |
| own wasm_instance_t* instance = |
| wasm_instance_new(store, module, imports, NULL); |
| if (!instance) { |
| printf("> Error instantiating module!\n"); |
| return 1; |
| } |
| |
| wasm_func_delete(callback_func); |
| wasm_module_delete(module); |
| |
| // Extract export. |
| printf("Extracting exports...\n"); |
| own wasm_extern_vec_t exports; |
| wasm_instance_exports(instance, &exports); |
| size_t i = 0; |
| wasm_global_t* global = get_export_global(&exports, i++); |
| wasm_table_t* table = get_export_table(&exports, i++); |
| wasm_func_t* global_set = get_export_func(&exports, i++); |
| wasm_func_t* global_get = get_export_func(&exports, i++); |
| wasm_func_t* table_set = get_export_func(&exports, i++); |
| wasm_func_t* table_get = get_export_func(&exports, i++); |
| wasm_func_t* func_call = get_export_func(&exports, i++); |
| |
| wasm_instance_delete(instance); |
| |
| // Create host references. |
| printf("Creating host references...\n"); |
| own wasm_ref_t* host1 = wasm_foreign_as_ref(wasm_foreign_new(store)); |
| own wasm_ref_t* host2 = wasm_foreign_as_ref(wasm_foreign_new(store)); |
| wasm_ref_set_host_info(host1, (void*)1); |
| wasm_ref_set_host_info(host2, (void*)2); |
| |
| // Some sanity checks. |
| check(NULL, NULL); |
| check(wasm_ref_copy(host1), host1); |
| check(wasm_ref_copy(host2), host2); |
| |
| own wasm_val_t val; |
| val.kind = WASM_ANYREF; |
| val.of.ref = wasm_ref_copy(host1); |
| check(wasm_ref_copy(val.of.ref), host1); |
| own wasm_ref_t* ref = val.of.ref; |
| check(wasm_ref_copy(ref), host1); |
| wasm_val_delete(&val); |
| |
| // Interact. |
| printf("Accessing global...\n"); |
| check(call_v_r(global_get), NULL); |
| call_r_v(global_set, host1); |
| check(call_v_r(global_get), host1); |
| call_r_v(global_set, host2); |
| check(call_v_r(global_get), host2); |
| call_r_v(global_set, NULL); |
| check(call_v_r(global_get), NULL); |
| |
| wasm_global_get(global, &val); |
| assert(val.kind == WASM_ANYREF); |
| check(val.of.ref, NULL); |
| val.of.ref = host2; |
| wasm_global_set(global, &val); |
| check(call_v_r(global_get), host2); |
| wasm_global_get(global, &val); |
| assert(val.kind == WASM_ANYREF); |
| check(val.of.ref, host2); |
| |
| printf("Accessing table...\n"); |
| check(call_i_r(table_get, 0), NULL); |
| check(call_i_r(table_get, 1), NULL); |
| call_ir_v(table_set, 0, host1); |
| call_ir_v(table_set, 1, host2); |
| check(call_i_r(table_get, 0), host1); |
| check(call_i_r(table_get, 1), host2); |
| call_ir_v(table_set, 0, NULL); |
| check(call_i_r(table_get, 0), NULL); |
| |
| check(wasm_table_get(table, 2), NULL); |
| wasm_table_set(table, 2, host1); |
| check(call_i_r(table_get, 2), host1); |
| check(wasm_table_get(table, 2), host1); |
| |
| printf("Accessing function...\n"); |
| check(call_r_r(func_call, NULL), NULL); |
| check(call_r_r(func_call, host1), host1); |
| check(call_r_r(func_call, host2), host2); |
| |
| wasm_ref_delete(host1); |
| wasm_ref_delete(host2); |
| |
| wasm_extern_vec_delete(&exports); |
| |
| // Shut down. |
| printf("Shutting down...\n"); |
| wasm_store_delete(store); |
| wasm_engine_delete(engine); |
| |
| // All done. |
| printf("Done.\n"); |
| return 0; |
| } |