[wasm] Use wasm traps to handle exceptions

The Dart exception is converted to a string, stored in a trap which
is passed through wasm, then converted back to a Dart exception.

Module instantiation can also throw a trap, because it internally
invokes the initialization function, if the module defines one. So I'm
handling this too.

Also, update to the new version of the wasm C API, which replaces some
foo_t** with foo_vec_t*.

Bug: #37882
Change-Id: I1e6952a191134734a892c42b2fb8ba3506bb0844
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/169784
Reviewed-by: Ryan Macnak <[email protected]>
Commit-Queue: Liam Appelbe <[email protected]>

Author: liamappelbe

pkg/wasm/lib/src/function.dart

@@ -13,17 +13,19 @@ class WasmFunction {
   Pointer<WasmerFunc> _func;
   List<int> _argTypes;
   int _returnType;
-  Pointer<WasmerVal> _args;
-  Pointer<WasmerVal> _results;
+  Pointer<WasmerValVec> _args = allocate<WasmerValVec>();
+  Pointer<WasmerValVec> _results = allocate<WasmerValVec>();
 
-  WasmFunction(this._name, this._func, this._argTypes, this._returnType)
-      : _args = _argTypes.length == 0
-            ? nullptr
-            : allocate<WasmerVal>(count: _argTypes.length),
-        _results =
-            _returnType == WasmerValKindVoid ? nullptr : allocate<WasmerVal>() {
+  WasmFunction(this._name, this._func, this._argTypes, this._returnType) {
+    _args.ref.length = _argTypes.length;
+    _args.ref.data = _argTypes.length == 0
+        ? nullptr
+        : allocate<WasmerVal>(count: _argTypes.length);
+    _results.ref.length = _returnType == WasmerValKindVoid ? 0 : 1;
+    _results.ref.data =
+        _returnType == WasmerValKindVoid ? nullptr : allocate<WasmerVal>();
     for (var i = 0; i < _argTypes.length; ++i) {
-      _args[i].kind = _argTypes[i];
+      _args.ref.data[i].kind = _argTypes[i];
     }
   }
 
@@ -35,19 +37,19 @@ class WasmFunction {
     switch (_argTypes[i]) {
       case WasmerValKindI32:
         if (arg is! int) return false;
-        _args[i].i32 = arg;
+        _args.ref.data[i].i32 = arg;
         return true;
       case WasmerValKindI64:
         if (arg is! int) return false;
-        _args[i].i64 = arg;
+        _args.ref.data[i].i64 = arg;
         return true;
       case WasmerValKindF32:
         if (arg is! num) return false;
-        _args[i].f32 = arg;
+        _args.ref.data[i].f32 = arg;
         return true;
       case WasmerValKindF64:
         if (arg is! num) return false;
-        _args[i].f64 = arg;
+        _args.ref.data[i].f64 = arg;
         return true;
     }
     return false;
@@ -62,12 +64,12 @@ class WasmFunction {
         throw ArgumentError("Bad argument type for WASM function: $this");
       }
     }
-    WasmRuntime().call(_func, _args, _results);
+    WasmRuntime().call(_func, _args, _results, toString());
 
     if (_returnType == WasmerValKindVoid) {
       return null;
     }
-    var result = _results[0];
+    var result = _results.ref.data[0];
     assert(_returnType == result.kind);
     switch (_returnType) {
       case WasmerValKindI32:

pkg/wasm/lib/src/module.dart

@@ -49,13 +49,11 @@ class WasmModule {
 }
 
 Pointer<WasmerTrap> _wasmFnImportTrampoline(Pointer<_WasmFnImport> imp,
-    Pointer<WasmerVal> args, Pointer<WasmerVal> results) {
+    Pointer<WasmerValVec> args, Pointer<WasmerValVec> results) {
   try {
     _WasmFnImport._call(imp, args, results);
-  } catch (e) {
-    // TODO: Use WasmerTrap to handle this case. For now just print the
-    // exception (if we ignore it, FFI will silently return a default result).
-    print(e);
+  } catch (exception) {
+    return WasmRuntime().newTrap(imp.ref.store, exception);
   }
   return nullptr;
 }
@@ -66,43 +64,45 @@ void _wasmFnImportFinalizer(Pointer<_WasmFnImport> imp) {
 }
 
 final _wasmFnImportTrampolineNative = Pointer.fromFunction<
-    Pointer<WasmerTrap> Function(Pointer<_WasmFnImport>, Pointer<WasmerVal>,
-        Pointer<WasmerVal>)>(_wasmFnImportTrampoline);
+    Pointer<WasmerTrap> Function(Pointer<_WasmFnImport>, Pointer<WasmerValVec>,
+        Pointer<WasmerValVec>)>(_wasmFnImportTrampoline);
 final _wasmFnImportToFn = <int, Function>{};
 final _wasmFnImportFinalizerNative =
     Pointer.fromFunction<Void Function(Pointer<_WasmFnImport>)>(
         _wasmFnImportFinalizer);
 
 class _WasmFnImport extends Struct {
-  @Int32()
-  external int numArgs;
-
   @Int32()
   external int returnType;
 
-  static void _call(Pointer<_WasmFnImport> imp, Pointer<WasmerVal> rawArgs,
-      Pointer<WasmerVal> rawResult) {
+  external Pointer<WasmerStore> store;
+
+  static void _call(Pointer<_WasmFnImport> imp, Pointer<WasmerValVec> rawArgs,
+      Pointer<WasmerValVec> rawResult) {
     Function fn = _wasmFnImportToFn[imp.address] as Function;
     var args = [];
-    for (var i = 0; i < imp.ref.numArgs; ++i) {
-      args.add(rawArgs[i].toDynamic);
+    for (var i = 0; i < rawArgs.ref.length; ++i) {
+      args.add(rawArgs.ref.data[i].toDynamic);
     }
+    assert(
+        rawResult.ref.length == 1 || imp.ref.returnType == WasmerValKindVoid);
     var result = Function.apply(fn, args);
-    switch (imp.ref.returnType) {
-      case WasmerValKindI32:
-        rawResult.ref.i32 = result;
-        break;
-      case WasmerValKindI64:
-        rawResult.ref.i64 = result;
-        break;
-      case WasmerValKindF32:
-        rawResult.ref.f32 = result;
-        break;
-      case WasmerValKindF64:
-        rawResult.ref.f64 = result;
-        break;
-      case WasmerValKindVoid:
-      // Do nothing.
+    if (imp.ref.returnType != WasmerValKindVoid) {
+      rawResult.ref.data[0].kind = imp.ref.returnType;
+      switch (imp.ref.returnType) {
+        case WasmerValKindI32:
+          rawResult.ref.data[0].i32 = result;
+          break;
+        case WasmerValKindI64:
+          rawResult.ref.data[0].i64 = result;
+          break;
+        case WasmerValKindF32:
+          rawResult.ref.data[0].f32 = result;
+          break;
+        case WasmerValKindF64:
+          rawResult.ref.data[0].f64 = result;
+          break;
+      }
     }
   }
 }
@@ -113,24 +113,26 @@ class WasmInstanceBuilder {
   WasmModule _module;
   late List<WasmImportDescriptor> _importDescs;
   Map<String, int> _importIndex;
-  late Pointer<Pointer<WasmerExtern>> _imports;
+  Pointer<WasmerExternVec> _imports = allocate<WasmerExternVec>();
   Pointer<WasmerWasiEnv> _wasiEnv = nullptr;
 
   WasmInstanceBuilder(this._module) : _importIndex = {} {
     _importDescs = WasmRuntime().importDescriptors(_module._module);
-    _imports = allocate<Pointer<WasmerExtern>>(count: _importDescs.length);
+    _imports.ref.length = _importDescs.length;
+    _imports.ref.data =
+        allocate<Pointer<WasmerExtern>>(count: _importDescs.length);
     for (var i = 0; i < _importDescs.length; ++i) {
       var imp = _importDescs[i];
       _importIndex["${imp.moduleName}::${imp.name}"] = i;
-      _imports[i] = nullptr;
+      _imports.ref.data[i] = nullptr;
     }
   }
 
   int _getIndex(String moduleName, String name) {
     var index = _importIndex["${moduleName}::${name}"];
     if (index == null) {
       throw Exception("Import not found: ${moduleName}::${name}");
-    } else if (_imports[index] != nullptr) {
+    } else if (_imports.ref.data[index] != nullptr) {
       throw Exception("Import already filled: ${moduleName}::${name}");
     } else {
       return index;
@@ -145,7 +147,7 @@ class WasmInstanceBuilder {
     if (imp.kind != WasmerExternKindMemory) {
       throw Exception("Import is not a memory: $imp");
     }
-    _imports[index] = WasmRuntime().memoryToExtern(memory._mem);
+    _imports.ref.data[index] = WasmRuntime().memoryToExtern(memory._mem);
     return this;
   }
 
@@ -162,16 +164,16 @@ class WasmInstanceBuilder {
     var argTypes = runtime.getArgTypes(imp.funcType);
     var returnType = runtime.getReturnType(imp.funcType);
     var wasmFnImport = allocate<_WasmFnImport>();
-    wasmFnImport.ref.numArgs = argTypes.length;
     wasmFnImport.ref.returnType = returnType;
+    wasmFnImport.ref.store = _module._store;
     _wasmFnImportToFn[wasmFnImport.address] = fn;
     var fnImp = runtime.newFunc(
         _module._store,
         imp.funcType,
         _wasmFnImportTrampolineNative,
         wasmFnImport,
         _wasmFnImportFinalizerNative);
-    _imports[index] = runtime.functionToExtern(fnImp);
+    _imports.ref.data[index] = runtime.functionToExtern(fnImp);
     return this;
   }
 
@@ -193,7 +195,7 @@ class WasmInstanceBuilder {
   /// Build the module instance.
   WasmInstance build() {
     for (var i = 0; i < _importDescs.length; ++i) {
-      if (_imports[i] == nullptr) {
+      if (_imports.ref.data[i] == nullptr) {
         throw Exception("Missing import: ${_importDescs[i]}");
       }
     }
@@ -211,8 +213,7 @@ class WasmInstance {
   Stream<List<int>>? _stderr;
   Map<String, WasmFunction> _functions = {};
 
-  WasmInstance(
-      this._module, Pointer<Pointer<WasmerExtern>> imports, this._wasiEnv)
+  WasmInstance(this._module, Pointer<WasmerExternVec> imports, this._wasiEnv)
       : _instance = WasmRuntime()
             .instantiate(_module._store, _module._module, imports) {
     var runtime = WasmRuntime();

pkg/wasm/lib/src/runtime.dart

@@ -59,6 +59,7 @@ class WasmRuntime {
 
   DynamicLibrary _lib;
   late Pointer<WasmerEngine> _engine;
+  Map<int, dynamic> traps = {};
   late WasmerWasiConfigInheritStderrFn _wasi_config_inherit_stderr;
   late WasmerWasiConfigInheritStdoutFn _wasi_config_inherit_stdout;
   late WasmerWasiConfigNewFn _wasi_config_new;
@@ -124,6 +125,8 @@ class WasmRuntime {
   late WasmerStoreDeleteFn _store_delete;
   late WasmerStoreNewFn _store_new;
   late WasmerTrapDeleteFn _trap_delete;
+  late WasmerTrapMessageFn _trap_message;
+  late WasmerTrapNewFn _trap_new;
   late WasmerValtypeDeleteFn _valtype_delete;
   late WasmerValtypeKindFn _valtype_kind;
   late WasmerValtypeVecDeleteFn _valtype_vec_delete;
@@ -344,6 +347,11 @@ class WasmRuntime {
     _trap_delete =
         _lib.lookupFunction<NativeWasmerTrapDeleteFn, WasmerTrapDeleteFn>(
             'wasm_trap_delete');
+    _trap_message =
+        _lib.lookupFunction<NativeWasmerTrapMessageFn, WasmerTrapMessageFn>(
+            'wasm_trap_message');
+    _trap_new = _lib.lookupFunction<NativeWasmerTrapNewFn, WasmerTrapNewFn>(
+        'wasm_trap_new');
     _valtype_delete =
         _lib.lookupFunction<NativeWasmerValtypeDeleteFn, WasmerValtypeDeleteFn>(
             'wasm_valtype_delete');
@@ -432,10 +440,31 @@ class WasmRuntime {
     return imps;
   }
 
+  void maybeThrowTrap(Pointer<WasmerTrap> trap, String source) {
+    if (trap != nullptr) {
+      var stashedException = traps[trap.address];
+      if (stashedException != null) {
+        traps.remove(stashedException);
+        throw stashedException;
+      } else {
+        var trapMessage = allocate<WasmerByteVec>();
+        _trap_message(trap, trapMessage);
+        var message = "Wasm trap when calling $source: ${trapMessage.ref}";
+        free(trapMessage.ref.data);
+        free(trapMessage);
+        throw Exception(message);
+      }
+    }
+  }
+
   Pointer<WasmerInstance> instantiate(Pointer<WasmerStore> store,
-      Pointer<WasmerModule> module, Pointer<Pointer<WasmerExtern>> imports) {
-    return _checkNotEqual(_instance_new(store, module, imports, nullptr),
-        nullptr, "Wasm module instantiation failed.");
+      Pointer<WasmerModule> module, Pointer<WasmerExternVec> imports) {
+    var trap = allocate<Pointer<WasmerTrap>>();
+    trap.value = nullptr;
+    var inst = _instance_new(store, module, imports, trap);
+    maybeThrowTrap(trap.value, "module initialization function");
+    free(trap);
+    return _checkNotEqual(inst, nullptr, "Wasm module instantiation failed.");
   }
 
   Pointer<WasmerExternVec> exports(Pointer<WasmerInstance> instancePtr) {
@@ -475,9 +504,9 @@ class WasmRuntime {
     return _valtype_kind(rets.ref.data[0]);
   }
 
-  void call(Pointer<WasmerFunc> func, Pointer<WasmerVal> args,
-      Pointer<WasmerVal> results) {
-    _func_call(func, args, results);
+  void call(Pointer<WasmerFunc> func, Pointer<WasmerValVec> args,
+      Pointer<WasmerValVec> results, String source) {
+    maybeThrowTrap(_func_call(func, args, results), source);
   }
 
   Pointer<WasmerMemory> externToMemory(Pointer<WasmerExtern> extern) {
@@ -522,6 +551,18 @@ class WasmRuntime {
         store, funcType, func.cast(), env.cast(), finalizer.cast());
   }
 
+  Pointer<WasmerTrap> newTrap(Pointer<WasmerStore> store, dynamic exception) {
+    var msg = allocate<WasmerByteVec>();
+    msg.ref.data = allocate<Uint8>();
+    msg.ref.data[0] = 0;
+    msg.ref.length = 0;
+    var trap = _trap_new(store, msg);
+    traps[trap.address] = exception;
+    free(msg.ref.data);
+    free(msg);
+    return _checkNotEqual(trap, nullptr, "Failed to create trap.");
+  }
+
   Pointer<WasmerWasiConfig> newWasiConfig() {
     var name = allocate<Uint8>();
     name[0] = 0;
@@ -549,7 +590,7 @@ class WasmRuntime {
   }
 
   void getWasiImports(Pointer<WasmerStore> store, Pointer<WasmerModule> mod,
-      Pointer<WasmerWasiEnv> env, Pointer<Pointer<WasmerExtern>> imports) {
+      Pointer<WasmerWasiEnv> env, Pointer<WasmerExternVec> imports) {
     _checkNotEqual(_wasi_get_imports(store, mod, env, imports), 0,
         "Failed to fill WASI imports.");
   }

pkg/wasm/lib/src/tools/generate_ffi_boilerplate.py

@@ -155,6 +155,7 @@ def match(r, s):
     ('own', ''),
     ('WASM_API_EXTERN', ''),
     ('wasm_name_t', 'wasm_byte_vec_t'),
+    ('wasm_message_t', 'wasm_byte_vec_t'),
     ('wasm_memory_pages_t', 'uint32_t'),
     ('wasm_externkind_t', 'uint8_t'),
     ('wasm_valkind_t', 'uint8_t'),
@@ -290,7 +291,7 @@ def declareType(name, withCopy=True):
 WASM_API_EXTERN const wasm_name_t* wasm_exporttype_name(const wasm_exporttype_t*);
 WASM_API_EXTERN const wasm_externtype_t* wasm_exporttype_type(const wasm_exporttype_t*);
 WASM_API_EXTERN wasm_externkind_t wasm_externtype_kind(const wasm_externtype_t*);
-WASM_API_EXTERN own wasm_instance_t* wasm_instance_new(wasm_store_t*, const wasm_module_t*, const wasm_extern_t* const imports[], own wasm_trap_t**);
+WASM_API_EXTERN own wasm_instance_t* wasm_instance_new(wasm_store_t*, const wasm_module_t*, const wasm_extern_vec_t* imports, own wasm_trap_t**);
 WASM_API_EXTERN void wasm_instance_exports(const wasm_instance_t*, own wasm_extern_vec_t* out);
 WASM_API_EXTERN own wasm_memory_t* wasm_memory_new(wasm_store_t*, const wasm_memorytype_t*);
 WASM_API_EXTERN byte_t* wasm_memory_data(wasm_memory_t*);
@@ -305,11 +306,13 @@ def declareType(name, withCopy=True):
 WASM_API_EXTERN const wasm_valtype_vec_t* wasm_functype_params(const wasm_functype_t*);
 WASM_API_EXTERN const wasm_valtype_vec_t* wasm_functype_results(const wasm_functype_t*);
 WASM_API_EXTERN own wasm_func_t* wasm_func_new_with_env( wasm_store_t*, const wasm_functype_t* type, void* fn, void* env, void *finalizer);
-WASM_API_EXTERN own wasm_trap_t* wasm_func_call(const wasm_func_t*, const wasm_val_t args[], wasm_val_t results[]);
+WASM_API_EXTERN own wasm_trap_t* wasm_func_call(const wasm_func_t*, const wasm_val_vec_t* args, wasm_val_vec_t* results);
+WASM_API_EXTERN own wasm_trap_t* wasm_trap_new(wasm_store_t* store, const wasm_message_t*);
+WASM_API_EXTERN void wasm_trap_message(const wasm_trap_t*, own wasm_message_t* out);
 WASM_API_EXTERN wasm_valkind_t wasm_valtype_kind(const wasm_valtype_t*);
 wasi_config_t* wasi_config_new(const uint8_t* program_name);
 wasi_env_t* wasi_env_new(wasi_config_t* config);
-bool wasi_get_imports(const wasm_store_t* store, const wasm_module_t* module, const wasi_env_t* wasi_env, wasm_extern_t** imports);
+bool wasi_get_imports(const wasm_store_t* store, const wasm_module_t* module, const wasi_env_t* wasi_env, wasm_extern_vec_t* imports);
 int wasmer_last_error_message(uint8_t* buffer, int length);
 int wasmer_last_error_length();
 void wasi_env_set_memory(wasi_env_t* env, const wasm_memory_t* memory);