Switch wasmer FFI boilerplate to new API

Broadly speaking, the new API is very similar to the old one. The only
public facing change is that you can't make a memory by itself anymore.
You need to construct if from a store, which is owned by a module.

The new API no longer passes structs by value, so I was able to delete
the wasmer_wrapper.cc, and the files I had copied from the wasmer repo.

The new API is also a lot more verbose, so it made more sense to write
a script to generate the FFI boilerplate, rather that write it all
manually.

All the migrated tests that were passing before this refactor are still
passing.

Bug: #37882
Change-Id: I52ca54b982a27f1d851c630d3e09833b8810060c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/164081
Reviewed-by: Siva Annamalai <[email protected]>
Commit-Queue: Liam Appelbe <[email protected]>

Author: liamappelbe

pkg/wasm/lib/src/function.dart

@@ -10,35 +10,43 @@ import 'package:ffi/ffi.dart';
 /// WasmFunction is a callable function from a WasmInstance.
 class WasmFunction {
   String _name;
-  Pointer<WasmerExportFunc> _func;
+  Pointer<WasmerFunc> _func;
   List<int> _argTypes;
   int _returnType;
-  Pointer<WasmerValue> _args;
-  Pointer<WasmerValue> _result;
+  Pointer<WasmerVal> _args;
+  Pointer<WasmerVal> _results;
 
   WasmFunction(this._name, this._func, this._argTypes, this._returnType)
-      : _args = allocate<WasmerValue>(count: _argTypes.length),
-        _result = allocate<WasmerValue>() {
+      : _args = _argTypes.length == 0
+            ? nullptr
+            : allocate<WasmerVal>(count: _argTypes.length),
+        _results =
+            _returnType == WasmerValKindVoid ? nullptr : allocate<WasmerVal>() {
     for (var i = 0; i < _argTypes.length; ++i) {
-      _args[i].tag = _argTypes[i];
+      _args[i].kind = _argTypes[i];
     }
   }
 
+  String toString() {
+    return "${wasmerValKindName(_returnType)} $_name" +
+        "(${_argTypes.map(wasmerValKindName).join(", ")})";
+  }
+
   bool _fillArg(dynamic arg, int i) {
     switch (_argTypes[i]) {
-      case WasmerValueTagI32:
+      case WasmerValKindI32:
         if (arg is! int) return false;
         _args[i].i32 = arg;
         return true;
-      case WasmerValueTagI64:
+      case WasmerValKindI64:
         if (arg is! int) return false;
         _args[i].i64 = arg;
         return true;
-      case WasmerValueTagF32:
+      case WasmerValKindF32:
         if (arg is! num) return false;
         _args[i].f32 = arg;
         return true;
-      case WasmerValueTagF64:
+      case WasmerValKindF64:
         if (arg is! num) return false;
         _args[i].f64 = arg;
         return true;
@@ -48,29 +56,29 @@ class WasmFunction {
 
   dynamic apply(List<dynamic> args) {
     if (args.length != _argTypes.length) {
-      throw ArgumentError("Wrong number arguments for WASM function: $_name");
+      throw ArgumentError("Wrong number arguments for WASM function: $this");
     }
     for (var i = 0; i < args.length; ++i) {
       if (!_fillArg(args[i], i)) {
-        throw ArgumentError("Bad argument type for WASM function: $_name");
+        throw ArgumentError("Bad argument type for WASM function: $this");
       }
     }
-    WasmRuntime().call(_func, _args, _argTypes.length, _result,
-        _returnType == WasmerValueTagVoid ? 0 : 1);
+    WasmRuntime().call(_func, _args, _results);
 
-    if (_returnType == WasmerValueTagVoid) {
+    if (_returnType == WasmerValKindVoid) {
       return null;
     }
-    assert(_returnType == _result.ref.tag);
+    var result = _results[0];
+    assert(_returnType == result.kind);
     switch (_returnType) {
-      case WasmerValueTagI32:
-        return _result.ref.i32;
-      case WasmerValueTagI64:
-        return _result.ref.i64;
-      case WasmerValueTagF32:
-        return _result.ref.f32;
-      case WasmerValueTagF64:
-        return _result.ref.f64;
+      case WasmerValKindI32:
+        return result.i32;
+      case WasmerValKindI64:
+        return result.i64;
+      case WasmerValKindF32:
+        return result.f32;
+      case WasmerValKindF64:
+        return result.f64;
     }
   }
 

pkg/wasm/lib/src/module.dart

@@ -11,14 +11,23 @@ import 'package:ffi/ffi.dart';
 
 /// WasmModule is a compiled module that can be instantiated.
 class WasmModule {
-  Pointer<WasmerModule> _module;
+  Pointer<WasmerStore> _store;
+  late Pointer<WasmerModule> _module;
 
   /// Compile a module.
-  WasmModule(Uint8List data) : _module = WasmRuntime().compile(data) {}
+  WasmModule(Uint8List data) : _store = WasmRuntime().newStore() {
+    _module = WasmRuntime().compile(_store, data);
+  }
 
   /// Instantiate the module with the given imports.
   WasmInstance instantiate(WasmImports imports) {
-    return WasmInstance(_module, imports);
+    return WasmInstance(_store, _module, imports);
+  }
+
+  /// Create a new memory with the given number of initial pages, and optional
+  /// maximum number of pages.
+  WasmMemory createMemory(int pages, [int? maxPages]) {
+    return WasmMemory._create(_store, pages, maxPages);
   }
 
   /// Returns a description of all of the module's imports and exports, for
@@ -28,12 +37,12 @@ class WasmModule {
     var runtime = WasmRuntime();
     var imports = runtime.importDescriptors(_module);
     for (var imp in imports) {
-      var kind = wasmerImpExpKindName(imp.kind);
+      var kind = wasmerExternKindName(imp.kind);
       description.write('import $kind: ${imp.moduleName}::${imp.name}\n');
     }
     var exports = runtime.exportDescriptors(_module);
     for (var exp in exports) {
-      var kind = wasmerImpExpKindName(exp.kind);
+      var kind = wasmerExternKindName(exp.kind);
       description.write('export $kind: ${exp.name}\n');
     }
     return description.toString();
@@ -42,13 +51,13 @@ class WasmModule {
 
 /// WasmImports holds all the imports for a WasmInstance.
 class WasmImports {
-  Pointer<WasmerImport> _imports;
+  Pointer<Pointer<WasmerExtern>> _imports;
   int _capacity;
   int _length;
 
   /// Create an imports object.
   WasmImports([this._capacity = 4])
-      : _imports = allocate<WasmerImport>(count: _capacity),
+      : _imports = allocate<Pointer<WasmerExtern>>(count: _capacity),
         _length = 0 {}
 
   /// Returns the number of imports.
@@ -57,26 +66,31 @@ class WasmImports {
 
 /// WasmInstance is an instantiated WasmModule.
 class WasmInstance {
+  Pointer<WasmerStore> _store;
   Pointer<WasmerModule> _module;
   Pointer<WasmerInstance> _instance;
   Pointer<WasmerMemory>? _exportedMemory;
   Map<String, WasmFunction> _functions = {};
 
-  WasmInstance(this._module, WasmImports imports)
+  WasmInstance(this._store, this._module, WasmImports imports)
       : _instance = WasmRuntime()
-            .instantiate(_module, imports._imports, imports.length) {
+            .instantiate(_store, _module, imports._imports, imports.length) {
     var runtime = WasmRuntime();
-    var exps = runtime.exports(_instance);
-    for (var e in exps) {
-      var kind = runtime.exportKind(e);
-      String name = runtime.exportName(e);
-      if (kind == WasmerImpExpKindFunction) {
-        var f = runtime.exportToFunction(e);
+    var exports = runtime.exports(_instance);
+    var exportDescs = runtime.exportDescriptors(_module);
+    assert(exports.ref.length == exportDescs.length);
+    for (var i = 0; i < exports.ref.length; ++i) {
+      var e = exports.ref.data[i];
+      var kind = runtime.externKind(exports.ref.data[i]);
+      String name = exportDescs[i].name;
+      if (kind == WasmerExternKindFunction) {
+        var f = runtime.externToFunction(e);
+        var ft = exportDescs[i].funcType;
         _functions[name] = WasmFunction(
-            name, f, runtime.getArgTypes(f), runtime.getReturnType(f));
-      } else if (kind == WasmerImpExpKindMemory) {
+            name, f, runtime.getArgTypes(ft), runtime.getReturnType(ft));
+      } else if (kind == WasmerExternKindMemory) {
         // WASM currently allows only one memory per module.
-        _exportedMemory = runtime.exportToMemory(e);
+        _exportedMemory = runtime.externToMemory(e);
       }
     }
   }
@@ -107,8 +121,8 @@ class WasmMemory {
 
   /// Create a new memory with the given number of initial pages, and optional
   /// maximum number of pages.
-  WasmMemory(int pages, [int? maxPages])
-      : _mem = WasmRuntime().newMemory(pages, maxPages) {
+  WasmMemory._create(Pointer<WasmerStore> store, int pages, int? maxPages)
+      : _mem = WasmRuntime().newMemory(store, pages, maxPages) {
     _view = WasmRuntime().memoryView(_mem);
   }