[wasm] Add WasmMemory class.

Also, port the old wasm memory tests, and fix some NNBD issues.

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

Author: liamappelbe

pkg/wasm/lib/src/function.dart

@@ -16,9 +16,9 @@ class WasmFunction {
   Pointer<WasmerValue> _args;
   Pointer<WasmerValue> _result;
 
-  WasmFunction(this._name, this._func, this._argTypes, this._returnType) {
-    _args = allocate<WasmerValue>(count: _argTypes.length);
-    _result = allocate<WasmerValue>();
+  WasmFunction(this._name, 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];
     }
@@ -43,6 +43,7 @@ class WasmFunction {
         _args[i].f64 = arg;
         return true;
     }
+    return false;
   }
 
   dynamic apply(List<dynamic> args) {

pkg/wasm/lib/src/module.dart

@@ -14,9 +14,7 @@ class WasmModule {
   Pointer<WasmerModule> _module;
 
   /// Compile a module.
-  WasmModule(Uint8List data) {
-    _module = WasmRuntime().compile(data);
-  }
+  WasmModule(Uint8List data) : _module = WasmRuntime().compile(data) {}
 
   /// Instantiate the module with the given imports.
   WasmInstance instantiate(WasmImports imports) {
@@ -49,9 +47,9 @@ class WasmImports {
   int _length;
 
   /// Create an imports object.
-  WasmImports([this._capacity = 4]) : _length = 0 {
-    _imports = allocate<WasmerImport>(count: this._capacity);
-  }
+  WasmImports([this._capacity = 4])
+      : _imports = allocate<WasmerImport>(count: _capacity),
+        _length = 0 {}
 
   /// Returns the number of imports.
   int get length => _length;
@@ -61,12 +59,13 @@ class WasmImports {
 class WasmInstance {
   Pointer<WasmerModule> _module;
   Pointer<WasmerInstance> _instance;
-  Map<String, WasmFunction> _functions;
+  Pointer<WasmerMemory>? _exportedMemory;
+  Map<String, WasmFunction> _functions = {};
 
-  WasmInstance(this._module, WasmImports imports) {
+  WasmInstance(this._module, WasmImports imports)
+      : _instance = WasmRuntime()
+            .instantiate(_module, imports._imports, imports.length) {
     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);
@@ -75,6 +74,9 @@ class WasmInstance {
         var f = runtime.exportToFunction(e);
         _functions[name] = WasmFunction(
             name, f, runtime.getArgTypes(f), runtime.getReturnType(f));
+      } else if (kind == WasmerImpExpKindMemory) {
+        // WASM currently allows only one memory per module.
+        _exportedMemory = runtime.exportToMemory(e);
       }
     }
   }
@@ -84,4 +86,55 @@ class WasmInstance {
   dynamic lookupFunction(String name) {
     return _functions[name];
   }
+
+  /// Returns the memory exported from this instance.
+  WasmMemory get memory {
+    if (_exportedMemory == null) {
+      throw Exception("Wasm module did not export its memory.");
+    }
+    return WasmMemory._fromExport(_exportedMemory as Pointer<WasmerMemory>);
+  }
+}
+
+/// WasmMemory contains the memory of a WasmInstance.
+class WasmMemory {
+  Pointer<WasmerMemory> _mem;
+  late Uint8List _view;
+
+  WasmMemory._fromExport(this._mem) {
+    _view = WasmRuntime().memoryView(_mem);
+  }
+
+  /// 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) {
+    _view = WasmRuntime().memoryView(_mem);
+  }
+
+  /// The WASM spec defines the page size as 64KiB.
+  static const int kPageSizeInBytes = 64 * 1024;
+
+  /// Returns the length of the memory in pages.
+  int get lengthInPages {
+    return WasmRuntime().memoryLength(_mem);
+  }
+
+  /// Returns the length of the memory in bytes.
+  int get lengthInBytes => _view.lengthInBytes;
+
+  /// Returns the byte at the given index.
+  int operator [](int index) => _view[index];
+
+  /// Sets the byte at the given index to value.
+  void operator []=(int index, int value) {
+    _view[index] = value;
+  }
+
+  /// Grow the memory by deltaPages.
+  void grow(int deltaPages) {
+    var runtime = WasmRuntime();
+    runtime.growMemory(_mem, deltaPages);
+    _view = runtime.memoryView(_mem);
+  }
 }

pkg/wasm/lib/src/runtime.dart

@@ -24,41 +24,47 @@ class WasmExportDescriptor {
 }
 
 class WasmRuntime {
-  static WasmRuntime _inst;
+  static WasmRuntime? _inst;
 
   DynamicLibrary _lib;
-  WasmerCompileFn _compile;
-  WasmerInstantiateFn _instantiate;
-  WasmerInstanceExportsFn _instance_exports;
-  WasmerExportsLenFn _exports_len;
-  WasmerExportsGetFn _exports_get;
-  WasmerExportKindFn _export_kind;
-  WasmerExportToFuncFn _export_to_func;
-  WasmerExportFuncReturnsArityFn _export_func_returns_arity;
-  WasmerExportFuncReturnsFn _export_func_returns;
-  WasmerExportFuncParamsArityFn _export_func_params_arity;
-  WasmerExportFuncParamsFn _export_func_params;
-  WasmerExportFuncCallFn _export_func_call;
-  WasmerExportNamePtrFn _export_name_ptr;
-  WasmerExportDescriptorsFn _export_descriptors;
-  WasmerExportDescriptorsDestroyFn _export_descriptors_destroy;
-  WasmerExportDescriptorsLenFn _export_descriptors_len;
-  WasmerExportDescriptorsGetFn _export_descriptors_get;
-  WasmerExportDescriptorKindFn _export_descriptor_kind;
-  WasmerExportDescriptorNamePtrFn _export_descriptor_name_ptr;
-  WasmerImportDescriptorModuleNamePtrFn _import_descriptor_module_name_ptr;
-  WasmerImportDescriptorNamePtrFn _import_descriptor_name_ptr;
-  WasmerImportDescriptorsFn _import_descriptors;
-  WasmerImportDescriptorsDestroyFn _import_descriptors_destroy;
-  WasmerImportDescriptorsLenFn _import_descriptors_len;
-  WasmerImportDescriptorsGetFn _import_descriptors_get;
-  WasmerImportDescriptorKindFn _import_descriptor_kind;
+  late WasmerCompileFn _compile;
+  late WasmerInstantiateFn _instantiate;
+  late WasmerInstanceExportsFn _instance_exports;
+  late WasmerExportsLenFn _exports_len;
+  late WasmerExportsGetFn _exports_get;
+  late WasmerExportKindFn _export_kind;
+  late WasmerExportToFuncFn _export_to_func;
+  late WasmerExportFuncReturnsArityFn _export_func_returns_arity;
+  late WasmerExportFuncReturnsFn _export_func_returns;
+  late WasmerExportFuncParamsArityFn _export_func_params_arity;
+  late WasmerExportFuncParamsFn _export_func_params;
+  late WasmerExportFuncCallFn _export_func_call;
+  late WasmerExportNamePtrFn _export_name_ptr;
+  late WasmerExportDescriptorsFn _export_descriptors;
+  late WasmerExportDescriptorsDestroyFn _export_descriptors_destroy;
+  late WasmerExportDescriptorsLenFn _export_descriptors_len;
+  late WasmerExportDescriptorsGetFn _export_descriptors_get;
+  late WasmerExportDescriptorKindFn _export_descriptor_kind;
+  late WasmerExportDescriptorNamePtrFn _export_descriptor_name_ptr;
+  late WasmerImportDescriptorModuleNamePtrFn _import_descriptor_module_name_ptr;
+  late WasmerImportDescriptorNamePtrFn _import_descriptor_name_ptr;
+  late WasmerImportDescriptorsFn _import_descriptors;
+  late WasmerImportDescriptorsDestroyFn _import_descriptors_destroy;
+  late WasmerImportDescriptorsLenFn _import_descriptors_len;
+  late WasmerImportDescriptorsGetFn _import_descriptors_get;
+  late WasmerImportDescriptorKindFn _import_descriptor_kind;
+  late WasmerExportToMemoryFn _export_to_memory;
+  late WasmerMemoryNewPtrFn _memory_new_ptr;
+  late WasmerMemoryGrowFn _memory_grow;
+  late WasmerMemoryLengthFn _memory_length;
+  late WasmerMemoryDataFn _memory_data;
+  late WasmerMemoryDataLengthFn _memory_data_length;
 
   factory WasmRuntime() {
     if (_inst == null) {
       _inst = WasmRuntime._init();
     }
-    return _inst;
+    return _inst as WasmRuntime;
   }
 
   static String _getLibName() {
@@ -96,9 +102,8 @@ class WasmRuntime {
     return commonLibDir;
   }
 
-  WasmRuntime._init() {
-    var libPath = path.join(_getLibDir(), _getLibName());
-    _lib = DynamicLibrary.open(libPath);
+  WasmRuntime._init()
+      : _lib = DynamicLibrary.open(path.join(_getLibDir(), _getLibName())) {
     _compile = _lib.lookupFunction<NativeWasmerCompileFn, WasmerCompileFn>(
         'wasmer_compile');
     _instantiate =
@@ -171,6 +176,22 @@ class WasmRuntime {
     _import_descriptor_name_ptr = _lib.lookupFunction<
         NativeWasmerImportDescriptorNamePtrFn,
         WasmerImportDescriptorNamePtrFn>('wasmer_import_descriptor_name_ptr');
+    _export_to_memory = _lib.lookupFunction<NativeWasmerExportToMemoryFn,
+        WasmerExportToMemoryFn>('wasmer_export_to_memory');
+    _memory_new_ptr =
+        _lib.lookupFunction<NativeWasmerMemoryNewPtrFn, WasmerMemoryNewPtrFn>(
+            'wasmer_memory_new_ptr');
+    _memory_grow =
+        _lib.lookupFunction<NativeWasmerMemoryGrowFn, WasmerMemoryGrowFn>(
+            'wasmer_memory_grow');
+    _memory_length =
+        _lib.lookupFunction<NativeWasmerMemoryLengthFn, WasmerMemoryLengthFn>(
+            'wasmer_memory_length');
+    _memory_data =
+        _lib.lookupFunction<NativeWasmerMemoryDataFn, WasmerMemoryDataFn>(
+            'wasmer_memory_data');
+    _memory_data_length = _lib.lookupFunction<NativeWasmerMemoryDataLengthFn,
+        WasmerMemoryDataLengthFn>('wasmer_memory_data_length');
   }
 
   Pointer<WasmerModule> compile(Uint8List data) {
@@ -331,4 +352,48 @@ class WasmRuntime {
       throw Exception("Failed to call WASM function");
     }
   }
+
+  Pointer<WasmerMemory> exportToMemory(Pointer<WasmerExport> export) {
+    var memPtrPtr = allocate<Pointer<WasmerMemory>>();
+    var result = _export_to_memory(export, memPtrPtr);
+    if (result != WasmerResultOk) {
+      free(memPtrPtr);
+      throw Exception("Failed to get exported memory");
+    }
+    Pointer<WasmerMemory> memPtr = memPtrPtr.value;
+    free(memPtrPtr);
+    return memPtr;
+  }
+
+  Pointer<WasmerMemory> newMemory(int pages, int? maxPages) {
+    var memPtrPtr = allocate<Pointer<WasmerMemory>>();
+    var limPtr = allocate<WasmerLimits>();
+    limPtr.ref.min = pages;
+    limPtr.ref.has_max = maxPages != null ? 1 : 0;
+    limPtr.ref.max = maxPages ?? 0;
+    var result = _memory_new_ptr(memPtrPtr, limPtr);
+    free(limPtr);
+    if (result != WasmerResultOk) {
+      free(memPtrPtr);
+      throw Exception("Failed to create memory");
+    }
+    Pointer<WasmerMemory> memPtr = memPtrPtr.value;
+    free(memPtrPtr);
+    return memPtr;
+  }
+
+  void growMemory(Pointer<WasmerMemory> memory, int deltaPages) {
+    var result = _memory_grow(memory, deltaPages);
+    if (result != WasmerResultOk) {
+      throw Exception("Failed to grow memory");
+    }
+  }
+
+  int memoryLength(Pointer<WasmerMemory> memory) {
+    return _memory_length(memory);
+  }
+
+  Uint8List memoryView(Pointer<WasmerMemory> memory) {
+    return _memory_data(memory).asTypedList(_memory_data_length(memory));
+  }
 }