Have WasmModule free it's own memory.

src/wasm/wasm-module.cc

 // Copyright 2015 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.
 
 #include "src/macro-assembler.h"
 #include "src/objects.h"
 #include "src/v8.h"
 
 #include "src/simulator.h"
 
@@ skipping 184 matching lines @@
 
 
 Handle<JSArrayBuffer> NewArrayBuffer(Isolate* isolate, int size,
                                      byte** backing_store) {
   void* memory = isolate->array_buffer_allocator()->Allocate(size);
   if (!memory) return Handle<JSArrayBuffer>::null();
   *backing_store = reinterpret_cast<byte*>(memory);
 
 #if DEBUG
   // Double check the API allocator actually zero-initialized the memory.
-  for (uint32_t i = 0; i < size; i++) {
+  for (int i = 0; i < size; i++) {
     DCHECK_EQ(0, (*backing_store)[i]);
   }
 #endif
 
   Handle<JSArrayBuffer> buffer = isolate->factory()->NewJSArrayBuffer();
-  JSArrayBuffer::Setup(buffer, isolate, true, memory, size);
+  JSArrayBuffer::Setup(buffer, isolate, false, memory, size);
   buffer->set_is_neuterable(false);
   return buffer;
 }
 }  // namespace
 
 
+WasmModule::WasmModule()
+    : globals(nullptr),
+      signatures(nullptr),
+      functions(nullptr),
+      data_segments(nullptr),
+      function_table(nullptr) {}
+
+
+WasmModule::~WasmModule() {
+  if (globals) delete globals;
+  if (signatures) delete signatures;
+  if (functions) delete functions;
+  if (data_segments) delete data_segments;
+  if (function_table) delete function_table;
+}
+
+
 // Instantiates a wasm module as a JSObject.
 //  * allocates a backing store of {mem_size} bytes.
 //  * installs a named property "memory" for that buffer if exported
 //  * installs named properties on the object for exported functions
 //  * compiles wasm code to machine code
 MaybeHandle<JSObject> WasmModule::Instantiate(Isolate* isolate,
                                               Handle<JSObject> ffi,
                                               Handle<JSArrayBuffer> memory) {
   this->shared_isolate = isolate;  // TODO(titzer): have a real shared isolate.
   ErrorThrower thrower(isolate, "WasmModule::Instantiate()");
@@ skipping 117 matching lines @@
     } else {
       // Compile the function.
       code = compiler::CompileWasmFunction(thrower, isolate, &module_env, func,
                                            index);
       if (code.is_null()) {
         thrower.Error("Compilation of #%d:%s failed.", index, cstr);
         return MaybeHandle<JSObject>();
       }
       if (func.exported) {
         function = compiler::CompileJSToWasmWrapper(isolate, &module_env, name,
-                                                    code, index);
+                                                    code, module, index);
       }
     }
     if (!code.is_null()) {
       // Install the code into the linker table.
       linker.Finish(index, code);
       code_table->set(index, *code);
     }
     if (func.exported) {
       // Exported functions are installed as read-only properties on the module.
       JSObject::AddProperty(module, name, function, READ_ONLY);
@@ skipping 105 matching lines @@
     Simulator::CallArgument args[] = {Simulator::CallArgument(0),
                                       Simulator::CallArgument::End()};
     return static_cast<int32_t>(simulator->CallInt64(main_code->entry(), args));
 #elif USE_SIMULATOR
     // Run the main code on simulator.
     Simulator* simulator = Simulator::current(isolate);
     return static_cast<int32_t>(
         simulator->Call(main_code->entry(), 4, 0, 0, 0, 0));
 #else
     // Run the main code as raw machine code.
-    int32_t (*raw_func)() = reinterpret_cast<int (*)()>(main_code->entry());
+    int32_t (*raw_func)() = reinterpret_cast<int32_t (*)()>(
+        reinterpret_cast<uintptr_t>(main_code->entry()));
     return raw_func();
 #endif
   } else {
     // No main code was found.
     isolate->Throw(*isolate->factory()->NewStringFromStaticChars(
         "WASM.compileRun() failed: no valid main code produced."));
   }
   return -1;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8