[wasm] reuse the first compiled module

test/mjsunit/wasm/compiled-module-management.js

Index: test/mjsunit/wasm/compiled-module-management.js
diff --git a/test/mjsunit/wasm/compiled-module-management.js b/test/mjsunit/wasm/compiled-module-management.js
new file mode 100644
index 0000000000000000000000000000000000000000..5b64e00f4139e8993ed28ce62a8b4aab62aa3c5a
--- /dev/null
+++ b/test/mjsunit/wasm/compiled-module-management.js
@@ -0,0 +1,50 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// TODO (mtrofin): re-enable ignition (v8:5345)
+// Flags: --no-ignition --no-ignition-staging
+// Flags: --expose-wasm --expose-gc --allow-natives-syntax
+
+load("test/mjsunit/wasm/wasm-constants.js");
+load("test/mjsunit/wasm/wasm-module-builder.js");
+
+
+(function CompiledModuleInstancesAreGCed() {
+  var builder = new WasmModuleBuilder();
+
+  builder.addMemory(1,1, true);
+  builder.addImport("getValue", kSig_i);
+  builder.addFunction("f", kSig_i)
+    .addBody([
+      kExprCallImport, kArity0, 0
+    ]).exportFunc();
+
+  var module = new WebAssembly.Module(builder.toBuffer());
+  %ValidateWasmModuleState(module);
+  %ValidateWasmInstancesChain(module, 0);
+  var i1 = new WebAssembly.Instance(module, {getValue: () => 1});
+  %ValidateWasmInstancesChain(module, 1);
+  var i2 = new WebAssembly.Instance(module, {getValue: () => 2});
+  %ValidateWasmInstancesChain(module, 2);
+  var i3 = new WebAssembly.Instance(module, {getValue: () => 3});
+  %ValidateWasmInstancesChain(module, 3);
+
+  assertEquals(1, i1.exports.f());
+  i1 = null;
+  gc();

[Michael Starzinger, 2016/09/07 12:56:59]

The failure in Ignition is working as intended. Object lifetime is not specified
by JavaScript and is not observable via normal JavaScript code. Therefore it is
perfectly legal to hold on to hidden temporary variables and extend lifetime
until the end of the function body (which Ignition does).

If we want to stick with observing lifetime here, then I would vote for changing
the test so that "i1", "i2" and so forth are stored in a global structure and
nulled out there. The initialization (i.e. lines 23 till 31) can then life in a
separate function from the one which nulls out the instances (making them
unreachable). By splitting up initialization and mutation into two different
functions, Ignition shouldn't keep the instance alive any longer.

Note that even that is just a best effort approach. I could very well imaging
that inlining could combine those two function bodies again and (accidentally)
extend the lifetime again.

+  %ValidateWasmInstancesChain(module, 2);
+  assertEquals(3, i3.exports.f());
+  i3 = null;
+  gc();
+  %ValidateWasmInstancesChain(module, 1);
+  assertEquals(2, i2.exports.f());
+  i2 = null;
+  gc();
+  %ValidateWasmModuleState(module);
+  var i4 = new WebAssembly.Instance(module, {getValue: () => 4});
+  assertEquals(4, i4.exports.f());
+  module = null;
+  gc();
+  %ValidateWasmOrphanedInstance(i4);
+})();