wasm2js: override incoming memory's grow method

scripts/test/wasm2js.py

@@ -30,6 +30,9 @@
 
 
 def check_for_stale_files():
+    if shared.options.test_name_filter:
+        return
+
     # TODO(sbc): Generalize and apply other test suites
     all_tests = []
     for t in tests + spec_tests + wasm2js_tests:

scripts/wasm2js.js

@@ -6,12 +6,6 @@ var WebAssembly = {
   Memory: function(opts) {
     return {
       buffer: new ArrayBuffer(opts['initial'] * 64 * 1024),
-      grow: function(amount) {
-        var oldBuffer = this.buffer;
-        var ret = __growWasmMemory(amount);
-        assert(this.buffer !== oldBuffer); // the call should have updated us
-        return ret;
-      }
     };
   },
 

src/wasm2js.h

@@ -280,7 +280,7 @@ class Wasm2JSBuilder {
   void addExports(Ref ast, Module* wasm);
   void addGlobal(Ref ast, Global* global);
   void addMemoryFuncs(Ref ast, Module* wasm);
-  void addMemoryGrowthFuncs(Ref ast, Module* wasm);
+  void addMemoryGrowFunc(Ref ast, Module* wasm);
 
   Wasm2JSBuilder() = delete;
   Wasm2JSBuilder(const Wasm2JSBuilder&) = delete;
@@ -383,19 +383,43 @@ Ref Wasm2JSBuilder::processWasm(Module* wasm, Name funcName) {
   ret[1]->push_back(asmFunc);
   ValueBuilder::appendArgumentToFunction(asmFunc, GLOBAL);
   ValueBuilder::appendArgumentToFunction(asmFunc, ENV);
+
   if (wasm->memory.exists) {
-    ValueBuilder::appendArgumentToFunction(asmFunc, BUFFER);
-    // add memory import
     if (wasm->memory.imported()) {
+      // find memory and buffer in imports
       Ref theVar = ValueBuilder::makeVar();
       asmFunc[3]->push_back(theVar);
       ValueBuilder::appendToVar(
         theVar,
         "memory",
         ValueBuilder::makeDot(ValueBuilder::makeName(ENV),
                               ValueBuilder::makeName(wasm->memory.base)));
+
+      // Assign `buffer = memory.buffer`
+      Ref buf = ValueBuilder::makeVar();
+      asmFunc[3]->push_back(buf);
+      ValueBuilder::appendToVar(
+        buf,
+        BUFFER,
+        ValueBuilder::makeDot(ValueBuilder::makeName("memory"),
+                              ValueBuilder::makeName("buffer")));
+
+      // If memory is growable, override the imported memory's grow method to
+      // ensure so that when grow is called from the output it works as expected
+      if (wasm->memory.max > wasm->memory.initial) {
+        asmFunc[3]->push_back(
+          ValueBuilder::makeStatement(ValueBuilder::makeBinary(
+            ValueBuilder::makeDot(ValueBuilder::makeName("memory"),
+                                  ValueBuilder::makeName("grow")),
+            SET,
+            ValueBuilder::makeName(WASM_MEMORY_GROW))));
+      }
+    } else {
+      // find memory as third argument
+      ValueBuilder::appendArgumentToFunction(asmFunc, BUFFER);
     }
   }
+
   // add table import
   if (wasm->table.exists && wasm->table.imported()) {
     Ref theVar = ValueBuilder::makeVar();
@@ -2205,11 +2229,11 @@ void Wasm2JSBuilder::addMemoryFuncs(Ref ast, Module* wasm) {
   ast->push_back(memorySizeFunc);
 
   if (wasm->memory.max > wasm->memory.initial) {
-    addMemoryGrowthFuncs(ast, wasm);
+    addMemoryGrowFunc(ast, wasm);
   }
 }
 
-void Wasm2JSBuilder::addMemoryGrowthFuncs(Ref ast, Module* wasm) {
+void Wasm2JSBuilder::addMemoryGrowFunc(Ref ast, Module* wasm) {
   Ref memoryGrowFunc = ValueBuilder::makeFunction(WASM_MEMORY_GROW);
   ValueBuilder::appendArgumentToFunction(memoryGrowFunc, IString("pagesToAdd"));
 
@@ -2506,6 +2530,16 @@ void Wasm2JSGlue::emitPostES6() {
     out << ",\n    " << asmangle(import->base.str);
   });
 
+  ModuleUtils::iterImportedMemories(wasm, [&](Memory* import) {
+    // The special helpers are emitted in the glue, see code and comments
+    // below.
+    if (ABI::wasm2js::isHelper(import->base)) {
+      return;
+    }
+    out << ",\n    " << asmangle(import->base.str) << ": { buffer : mem"
+        << moduleName.str << " }";
+  });
+
   ModuleUtils::iterImportedTables(wasm, [&](Table* import) {
     // The special helpers are emitted in the glue, see code and comments
     // below.
@@ -2515,7 +2549,7 @@ void Wasm2JSGlue::emitPostES6() {
     out << ",\n    " << asmangle(import->base.str);
   });
 
-  if (wasm.memory.exists) {
+  if (wasm.memory.exists && !wasm.memory.imported()) {
     out << "\n  },\n  mem" << moduleName.str << "\n);\n";
   } else {
     out << "\n  });\n";

test/wasm2js/deterministic.2asm.js

@@ -1,6 +1,7 @@
 
-function asmFunc(global, env, buffer) {
+function asmFunc(global, env) {
  var memory = env.memory;
+ var buffer = memory.buffer;
  var HEAP8 = new global.Int8Array(buffer);
  var HEAP16 = new global.Int16Array(buffer);
  var HEAP32 = new global.Int32Array(buffer);
@@ -53,8 +54,7 @@ var retasmFunc = asmFunc({
     NaN,
     Infinity
   }, {
-    abort: function() { throw new Error('abort'); }
-  },
-  memasmFunc
-);
+    abort: function() { throw new Error('abort'); },
+    memory: { buffer : memasmFunc }
+  });
 export var foo = retasmFunc.foo;

test/wasm2js/deterministic.2asm.js.opt

@@ -1,6 +1,7 @@
 
-function asmFunc(global, env, buffer) {
+function asmFunc(global, env) {
  var memory = env.memory;
+ var buffer = memory.buffer;
  var HEAP8 = new global.Int8Array(buffer);
  var HEAP16 = new global.Int16Array(buffer);
  var HEAP32 = new global.Int32Array(buffer);
@@ -52,8 +53,7 @@ var retasmFunc = asmFunc({
     NaN,
     Infinity
   }, {
-    abort: function() { throw new Error('abort'); }
-  },
-  memasmFunc
-);
+    abort: function() { throw new Error('abort'); },
+    memory: { buffer : memasmFunc }
+  });
 export var foo = retasmFunc.foo;

test/wasm2js/dynamicLibrary.2asm.js

@@ -12,8 +12,9 @@ function Table(ret) {
   return ret;
 }
 
-function asmFunc(global, env, buffer) {
+function asmFunc(global, env) {
  var memory = env.memory;
+ var buffer = memory.buffer;
  var HEAP8 = new global.Int8Array(buffer);
  var HEAP16 = new global.Int16Array(buffer);
  var HEAP32 = new global.Int32Array(buffer);
@@ -96,8 +97,7 @@ var retasmFunc = asmFunc({
     NaN,
     Infinity
   }, {
-    abort: function() { throw new Error('abort'); }
-  },
-  memasmFunc
-);
+    abort: function() { throw new Error('abort'); },
+    memory: { buffer : memasmFunc }
+  });
 export var baz = retasmFunc.baz;

test/wasm2js/dynamicLibrary.2asm.js.opt

@@ -12,8 +12,9 @@ function Table(ret) {
   return ret;
 }
 
-function asmFunc(global, env, buffer) {
+function asmFunc(global, env) {
  var memory = env.memory;
+ var buffer = memory.buffer;
  var HEAP8 = new global.Int8Array(buffer);
  var HEAP16 = new global.Int16Array(buffer);
  var HEAP32 = new global.Int32Array(buffer);
@@ -88,8 +89,7 @@ var retasmFunc = asmFunc({
     NaN,
     Infinity
   }, {
-    abort: function() { throw new Error('abort'); }
-  },
-  memasmFunc
-);
+    abort: function() { throw new Error('abort'); },
+    memory: { buffer : memasmFunc }
+  });
 export var baz = retasmFunc.baz;

test/wasm2js/emscripten-grow-no.2asm.js

@@ -1,6 +1,7 @@
 function instantiate(asmLibraryArg, wasmMemory) {
-function asmFunc(global, env, buffer) {
+function asmFunc(global, env) {
  var memory = env.memory;
+ var buffer = memory.buffer;
  var HEAP8 = new global.Int8Array(buffer);
  var HEAP16 = new global.Int16Array(buffer);
  var HEAP32 = new global.Int32Array(buffer);

test/wasm2js/emscripten-grow-no.2asm.js.opt

@@ -1,6 +1,7 @@
 function instantiate(asmLibraryArg, wasmMemory) {
-function asmFunc(global, env, buffer) {
+function asmFunc(global, env) {
  var memory = env.memory;
+ var buffer = memory.buffer;
  var HEAP8 = new global.Int8Array(buffer);
  var HEAP16 = new global.Int16Array(buffer);
  var HEAP32 = new global.Int32Array(buffer);

test/wasm2js/emscripten-grow-yes.2asm.js

@@ -1,6 +1,8 @@
 function instantiate(asmLibraryArg, wasmMemory) {
-function asmFunc(global, env, buffer) {
+function asmFunc(global, env) {
  var memory = env.memory;
+ var buffer = memory.buffer;
+ memory.grow = __wasm_memory_grow;
  var HEAP8 = new global.Int8Array(buffer);
  var HEAP16 = new global.Int16Array(buffer);
  var HEAP32 = new global.Int32Array(buffer);

test/wasm2js/emscripten-grow-yes.2asm.js.opt

@@ -1,6 +1,8 @@
 function instantiate(asmLibraryArg, wasmMemory) {
-function asmFunc(global, env, buffer) {
+function asmFunc(global, env) {
  var memory = env.memory;
+ var buffer = memory.buffer;
+ memory.grow = __wasm_memory_grow;
  var HEAP8 = new global.Int8Array(buffer);
  var HEAP16 = new global.Int16Array(buffer);
  var HEAP32 = new global.Int32Array(buffer);

test/wasm2js/emscripten.2asm.js

@@ -1,6 +1,7 @@
 function instantiate(asmLibraryArg, wasmMemory) {
-function asmFunc(global, env, buffer) {
+function asmFunc(global, env) {
  var memory = env.memory;
+ var buffer = memory.buffer;
  var FUNCTION_TABLE = env.table;
  var HEAP8 = new global.Int8Array(buffer);
  var HEAP16 = new global.Int16Array(buffer);

test/wasm2js/emscripten.2asm.js.opt

@@ -1,6 +1,7 @@
 function instantiate(asmLibraryArg, wasmMemory) {
-function asmFunc(global, env, buffer) {
+function asmFunc(global, env) {
  var memory = env.memory;
+ var buffer = memory.buffer;
  var FUNCTION_TABLE = env.table;
  var HEAP8 = new global.Int8Array(buffer);
  var HEAP16 = new global.Int16Array(buffer);

test/wasm2js/minified-memory.2asm.js

@@ -1,6 +1,8 @@
 
-function asmFunc(global, env, buffer) {
+function asmFunc(global, env) {
  var memory = env.a;
+ var buffer = memory.buffer;
+ memory.grow = __wasm_memory_grow;
  var HEAP8 = new global.Int8Array(buffer);
  var HEAP16 = new global.Int16Array(buffer);
  var HEAP32 = new global.Int32Array(buffer);
@@ -72,8 +74,7 @@ var retasmFunc = asmFunc({
     NaN,
     Infinity
   }, {
-    abort: function() { throw new Error('abort'); }
-  },
-  memasmFunc
-);
+    abort: function() { throw new Error('abort'); },
+    a: { buffer : memasmFunc }
+  });
 export var foo = retasmFunc.foo;

test/wasm2js/minified-memory.2asm.js.opt

@@ -1,6 +1,8 @@
 
-function asmFunc(global, env, buffer) {
+function asmFunc(global, env) {
  var memory = env.a;
+ var buffer = memory.buffer;
+ memory.grow = __wasm_memory_grow;
  var HEAP8 = new global.Int8Array(buffer);
  var HEAP16 = new global.Int16Array(buffer);
  var HEAP32 = new global.Int32Array(buffer);
@@ -72,8 +74,7 @@ var retasmFunc = asmFunc({
     NaN,
     Infinity
   }, {
-    abort: function() { throw new Error('abort'); }
-  },
-  memasmFunc
-);
+    abort: function() { throw new Error('abort'); },
+    a: { buffer : memasmFunc }
+  });
 export var foo = retasmFunc.foo;