[vm/wasm] Wasm module instantiation and function calling

Add support for instantiating modules, getting their exported functions,
and calling those functions.

Function calling is tricky to implement, because we need to put the args
in an array to pass to wasm, and Dart doesn't have variadic functions.
So I implemented it by overriding noSuchMethod. Users can call
WasmFunction like a regular function, and the args will be dynamically
type checked and put in the array to pass to wasm.

WasmImports is a placeholder for now. Also, it's not possible to get
the function names until FFI supports passing structs by value, so for
now you can only get functions by their export index. If by-value
structs are delayed, I can add an intermediate C++ layer to the wasmer
library work around this.

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

Author: liamappelbe

.dart_tool/package_config.json

@@ -11,7 +11,7 @@
     "constraint, update this by running tools/generate_package_config.dart."
   ],
   "configVersion": 2,
-  "generated": "2020-08-18T11:26:08.472483",
+  "generated": "2020-08-18T15:38:52.410101",
   "generator": "tools/generate_package_config.dart",
   "packages": [
     {
@@ -719,7 +719,7 @@
       "name": "wasm",
       "rootUri": "../pkg/wasm",
       "packageUri": "lib/",
-      "languageVersion": "2.6"
+      "languageVersion": "2.10"
     },
     {
       "name": "watcher",

pkg/wasm/lib/module.dart

@@ -0,0 +1,81 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'runtime.dart';
+import 'wasmer_api.dart';
+import 'dart:ffi';
+import 'package:ffi/ffi.dart';
+
+/// WasmFunction is a callable function from a WasmInstance.
+class WasmFunction {
+  Pointer<WasmerExportFunc> _func;
+  List<int> _argTypes;
+  int _returnType;
+  Pointer<WasmerValue> _args;
+  Pointer<WasmerValue> _result;
+
+  WasmFunction(this._func, this._argTypes, this._returnType) {
+    _args = allocate<WasmerValue>(count: _argTypes.length);
+    _result = allocate<WasmerValue>();
+    for (var i = 0; i < _argTypes.length; ++i) {
+      _args[i].tag = _argTypes[i];
+    }
+  }
+
+  bool _fillArg(dynamic arg, int i) {
+    switch (_argTypes[i]) {
+      case WasmerValueTagI32:
+        if (arg is! int) return false;
+        _args[i].i32 = arg;
+        return true;
+      case WasmerValueTagI64:
+        if (arg is! int) return false;
+        _args[i].i64 = arg;
+        return true;
+      case WasmerValueTagF32:
+        if (arg is! num) return false;
+        _args[i].f32 = arg;
+        return true;
+      case WasmerValueTagF64:
+        if (arg is! num) return false;
+        _args[i].f64 = arg;
+        return true;
+    }
+  }
+
+  dynamic apply(List<dynamic> args) {
+    if (args.length != _argTypes.length) {
+      throw Exception("Wrong number arguments for WASM function");
+    }
+    for (var i = 0; i < args.length; ++i) {
+      if (!_fillArg(args[i], i)) {
+        throw Exception("Bad argument type for WASM function");
+      }
+    }
+    WasmRuntime().call(_func, _args, _argTypes.length, _result,
+        _returnType == WasmerValueTagVoid ? 0 : 1);
+
+    if (_returnType == WasmerValueTagVoid) {
+      return null;
+    }
+    assert(_returnType == _result.ref.tag);
+    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;
+    }
+  }
+
+  dynamic noSuchMethod(Invocation invocation) {
+    if (invocation.memberName == #call) {
+      return apply(invocation.positionalArguments);
+    }
+    return super.noSuchMethod(invocation);
+  }
+}

pkg/wasm/lib/runtime.dart

@@ -0,0 +1,64 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'runtime.dart';
+import 'function.dart';
+import 'wasmer_api.dart';
+import 'dart:typed_data';
+import 'dart:ffi';
+import 'package:ffi/ffi.dart';
+
+/// WasmModule is a compiled module that can be instantiated.
+class WasmModule {
+  Pointer<WasmerModule> _module;
+
+  /// Compile a module.
+  WasmModule(Uint8List data) {
+    _module = WasmRuntime().compile(data);
+  }
+
+  /// Instantiate the module with the given imports.
+  WasmInstance instantiate(WasmImports imports) {
+    return WasmInstance(_module, imports);
+  }
+}
+
+/// WasmImports holds all the imports for a WasmInstance.
+class WasmImports {
+  Pointer<WasmerImport> _imports;
+  int _capacity;
+  int _length;
+
+  /// Create an imports object.
+  WasmImports([this._capacity = 4]) : _length = 0 {
+    _imports = allocate<WasmerImport>(count: this._capacity);
+  }
+
+  /// Returns the number of imports.
+  int get length => _length;
+}
+
+/// WasmInstance is an instantiated WasmModule.
+class WasmInstance {
+  Pointer<WasmerModule> _module;
+  Pointer<WasmerInstance> _instance;
+  List<WasmFunction> _functions;
+
+  WasmInstance(this._module, WasmImports imports) {
+    var runtime = WasmRuntime();
+    _instance = runtime.instantiate(_module, imports._imports, imports.length);
+    _functions = [];
+    var exps = runtime.exports(_instance);
+    for (var e in exps) {
+      var kind = runtime.exportKind(e);
+      if (kind == WasmerImpExpKindFunction) {
+        var f = runtime.exportToFunction(e);
+        _functions.add(
+            WasmFunction(f, runtime.getArgTypes(f), runtime.getReturnType(f)));
+      }
+    }
+  }
+
+  List<dynamic> get functions => _functions;
+}