Implement RFC 11: Redesigning Wasmtime's APIs (#2897)

Implement Wasmtime's new API as designed by RFC 11. This is quite a large commit which has had lots of discussion externally, so for more information it's best to read the RFC thread and the PR thread.

examples/multi.c

@@ -32,27 +32,37 @@ static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_t
 
 // A function to be called from Wasm code.
 wasm_trap_t* callback(
-  const wasm_val_vec_t* args, wasm_val_vec_t* results
+  void *env,
+  wasmtime_caller_t *caller,
+  const wasmtime_val_t* args,
+  size_t nargs,
+  wasmtime_val_t* results,
+  size_t nresults
 ) {
   printf("Calling back...\n");
-  printf("> %"PRIu32" %"PRIu64"\n", args->data[0].of.i32, args->data[1].of.i64);
+  printf("> %"PRIu32" %"PRIu64"\n", args[0].of.i32, args[1].of.i64);
   printf("\n");
 
-  wasm_val_copy(&results->data[0], &args->data[1]);
-  wasm_val_copy(&results->data[1], &args->data[0]);
+  results[0] = args[1];
+  results[1] = args[0];
   return NULL;
 }
 
 
 // A function closure.
 wasm_trap_t* closure_callback(
-  void* env, const wasm_val_t args[], wasm_val_t results[]
+  void* env,
+  wasmtime_caller_t *caller,
+  const wasmtime_val_t* args,
+  size_t nargs,
+  wasmtime_val_t* results,
+  size_t nresults
 ) {
   int i = *(int*)env;
   printf("Calling back closure...\n");
   printf("> %d\n", i);
 
-  results[0].kind = WASM_I32;
+  results[0].kind = WASMTIME_I32;
   results[0].of.i32 = (int32_t)i;
   return NULL;
 }
@@ -62,7 +72,8 @@ 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);
+  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/multi.wat", "r");
@@ -83,18 +94,17 @@ int main(int argc, const char* argv[]) {
 
   // Parse the wat into the binary wasm format
   wasm_byte_vec_t binary;
-  wasmtime_error_t *error = wasmtime_wat2wasm(&wat, &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");
-  wasm_module_t* module = NULL;
-  error = wasmtime_module_new(engine, &binary, &module);
+  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);
 
   // Create external print functions.
@@ -105,65 +115,54 @@ int main(int argc, const char* argv[]) {
       wasm_valtype_new_i64(),
       wasm_valtype_new_i32()
   );
-  wasm_func_t* callback_func =
-    wasm_func_new(store, callback_type, callback);
-
+  wasmtime_func_t callback_func;
+  wasmtime_func_new(context, callback_type, callback, NULL, NULL, &callback_func);
   wasm_functype_delete(callback_type);
 
   // Instantiate.
   printf("Instantiating module...\n");
-  wasm_extern_t* imports[] = {wasm_func_as_extern(callback_func)};
-  wasm_extern_vec_t imports_vec = WASM_ARRAY_VEC(imports);
-  wasm_instance_t* instance = NULL;
+  wasmtime_extern_t imports[1];
+  imports[0].kind = WASMTIME_EXTERN_FUNC;
+  imports[0].of.func = callback_func;
+  wasmtime_instance_t instance;
   wasm_trap_t* trap = NULL;
-  error = wasmtime_instance_new(store, module, &imports_vec, &instance, &trap);
-  if (!instance)
+  error = wasmtime_instance_new(context, module, imports, 1, &instance, &trap);
+  if (error != NULL || trap != NULL)
     exit_with_error("failed to instantiate", error, trap);
-
-  wasm_func_delete(callback_func);
+  wasmtime_module_delete(module);
 
   // Extract export.
   printf("Extracting export...\n");
-  wasm_extern_vec_t exports;
-  wasm_instance_exports(instance, &exports);
-  if (exports.size == 0) {
-    printf("> Error accessing exports!\n");
-    return 1;
-  }
-  wasm_func_t* run_func = wasm_extern_as_func(exports.data[0]);
-  if (run_func == NULL) {
-    printf("> Error accessing export!\n");
-    return 1;
-  }
-
-  wasm_module_delete(module);
-  wasm_instance_delete(instance);
+  wasmtime_extern_t run;
+  bool ok = wasmtime_instance_export_get(context, &instance, "g", 1, &run);
+  assert(ok);
+  assert(run.kind == WASMTIME_EXTERN_FUNC);
 
   // Call.
   printf("Calling export...\n");
-  wasm_val_t args[2] = { WASM_I32_VAL(1), WASM_I64_VAL(2) };
-  wasm_val_t results[2];
-  wasm_val_vec_t args_vec = WASM_ARRAY_VEC(args);
-  wasm_val_vec_t results_vec = WASM_ARRAY_VEC(results);
-  error = wasmtime_func_call(run_func, &args_vec, &results_vec, &trap);
+  wasmtime_val_t args[2];
+  args[0].kind = WASMTIME_I32;
+  args[0].of.i32 = 1;
+  args[1].kind = WASMTIME_I64;
+  args[1].of.i64 = 2;
+  wasmtime_val_t results[2];
+  error = wasmtime_func_call(context, &run.of.func, args, 2, results, 2, &trap);
   if (error != NULL || trap != NULL)
     exit_with_error("failed to call run", error, trap);
 
-  wasm_extern_vec_delete(&exports);
-
   // Print result.
   printf("Printing result...\n");
   printf("> %"PRIu64" %"PRIu32"\n",
     results[0].of.i64, results[1].of.i32);
 
-  assert(results[0].kind == WASM_I64);
+  assert(results[0].kind == WASMTIME_I64);
   assert(results[0].of.i64 == 2);
-  assert(results[1].kind == WASM_I32);
+  assert(results[1].kind == WASMTIME_I32);
   assert(results[1].of.i32 == 1);
 
   // Shut down.
   printf("Shutting down...\n");
-  wasm_store_delete(store);
+  wasmtime_store_delete(store);
   wasm_engine_delete(engine);
 
   // All done.