[wasm] Refactor import handling for 0xC.

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 <memory>
 
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
 
 #include "src/macro-assembler.h"
@@ skipping 47 matching lines @@
   // TODO(clemensh): Remove function name array, extract names from module
   // bytes.
   kWasmFunctionNamesArray,
   kWasmModuleBytesString,
   kWasmDebugInfo,
   kWasmNumImportedFunctions,
   kWasmModuleInternalFieldCount
 };
 
 enum WasmImportData {
+  kImportKind,         // Smi. an ExternalKind
+  kImportGlobalType,   // Smi. Type for globals.
+  kImportIndex,        // Smi. index for the import.
   kModuleName,         // String
   kFunctionName,       // maybe String
   kOutputCount,        // Smi. an uint32_t
   kSignature,          // ByteArray. A copy of the data in FunctionSig
   kWasmImportDataSize  // Sentinel value.
 };
 
 enum WasmExportData {
-  kExportName,             // String
-  kExportArity,            // Smi, an int
-  kExportedFunctionIndex,  // Smi, an uint32_t
-  kExportedSignature,      // ByteArray. A copy of the data in FunctionSig
-  kWasmExportDataSize      // Sentinel value.
+  kExportKind,         // Smi. an ExternalKind
+  kExportGlobalType,   // Smi. Type for globals.
+  kExportName,         // String
+  kExportArity,        // Smi, an int
+  kExportIndex,        // Smi, an uint32_t
+  kExportedSignature,  // ByteArray. A copy of the data in FunctionSig
+  kWasmExportDataSize  // Sentinel value.
+};
+
+enum WasmGlobalInitData {
+  kGlobalInitKind,   // 0 = constant, 1 = global index
+  kGlobalInitType,   // Smi. Type for globals.
+  kGlobalInitIndex,  // Smi, an uint32_t
+  kGlobalInitValue,  // Number.
+  kWasmGlobalInitDataSize
 };
 
 enum WasmSegmentInfo {
-  kDestAddr,            // Smi. an uint32_t
+  kDestInitKind,        // 0 = constant, 1 = global index
+  kDestAddrValue,       // Smi. an uint32_t
   kSourceSize,          // Smi. an uint32_t
   kWasmSegmentInfoSize  // Sentinel value.
 };
 
 enum WasmIndirectFunctionTableData {
   kSize,                              // Smi. an uint32_t
   kTable,                             // FixedArray of indirect function table
   kWasmIndirectFunctionTableDataSize  // Sentinel value.
 };
 
+byte* raw_buffer_ptr(MaybeHandle<JSArrayBuffer> buffer, int offset) {

[Mircea Trofin, 2016/10/05 16:21:09]

The name strikes me as too generic. How about GetRawPointerToOffset?

[titzer, 2016/10/05 18:29:38]

Not sure that name is better, it's just longer.

Note that I went with hacker_style, since this is essentially a simple getter
with no side-effects.

+  return static_cast<byte*>(buffer.ToHandleChecked()->backing_store()) + offset;
+}
+
 uint32_t GetMinModuleMemSize(const WasmModule* module) {
   return WasmModule::kPageSize * module->min_mem_pages;
 }
 
-void LoadDataSegments(Handle<WasmCompiledModule> compiled_module,
-                      Address mem_addr, size_t mem_size) {
-  CHECK(compiled_module->has_data_segments() ==
-        compiled_module->has_data_segments_info());
-
-  // If we have neither, we're done.
-  if (!compiled_module->has_data_segments()) return;
-
-  Handle<ByteArray> data = compiled_module->data_segments();
-  Handle<FixedArray> segments = compiled_module->data_segments_info();
-
-  uint32_t last_extraction_pos = 0;
-  for (int i = 0; i < segments->length(); ++i) {
-    Handle<ByteArray> segment =
-        Handle<ByteArray>(ByteArray::cast(segments->get(i)));
-    uint32_t dest_addr = static_cast<uint32_t>(segment->get_int(kDestAddr));
-    uint32_t source_size = static_cast<uint32_t>(segment->get_int(kSourceSize));
-    CHECK_LT(dest_addr, mem_size);
-    CHECK_LE(source_size, mem_size);
-    CHECK_LE(dest_addr, mem_size - source_size);
-    byte* addr = mem_addr + dest_addr;
-    data->copy_out(last_extraction_pos, addr, source_size);
-    last_extraction_pos += source_size;
-  }
-}
-
 void SaveDataSegmentInfo(Factory* factory, const WasmModule* module,
                          Handle<WasmCompiledModule> compiled_module) {
   Handle<FixedArray> segments = factory->NewFixedArray(
       static_cast<int>(module->data_segments.size()), TENURED);
   uint32_t data_size = 0;
   for (const WasmDataSegment& segment : module->data_segments) {
     if (segment.source_size == 0) continue;
     data_size += segment.source_size;
   }
   Handle<ByteArray> data = factory->NewByteArray(data_size, TENURED);
 
   uint32_t last_insertion_pos = 0;
   for (uint32_t i = 0; i < module->data_segments.size(); ++i) {
     const WasmDataSegment& segment = module->data_segments[i];
     if (segment.source_size == 0) continue;
     Handle<ByteArray> js_segment =
         factory->NewByteArray(kWasmSegmentInfoSize * sizeof(uint32_t), TENURED);
     // TODO(titzer): add support for global offsets for dest_addr
     CHECK_EQ(WasmInitExpr::kI32Const, segment.dest_addr.kind);
-    js_segment->set_int(kDestAddr, segment.dest_addr.val.i32_const);
+    js_segment->set_int(kDestAddrValue, segment.dest_addr.val.i32_const);
     js_segment->set_int(kSourceSize, segment.source_size);
     segments->set(i, *js_segment);
     data->copy_in(last_insertion_pos,
                   module->module_start + segment.source_offset,
                   segment.source_size);
     last_insertion_pos += segment.source_size;
   }
   compiled_module->set_data_segments_info(segments);
   compiled_module->set_data_segments(data);
 }
@@ skipping 43 matching lines @@
     AllowDeferredHandleDereference embedding_raw_address;
     int mask = (1 << RelocInfo::WASM_MEMORY_REFERENCE) |
                (1 << RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
     for (RelocIterator it(*function, mask); !it.done(); it.next()) {
       it.rinfo()->update_wasm_memory_reference(old_start, start, prev_size,
                                                new_size);
     }
   }
 }
 
-// Allocate memory for a module instance as a new JSArrayBuffer.
-Handle<JSArrayBuffer> AllocateMemory(ErrorThrower* thrower, Isolate* isolate,
-                                     uint32_t min_mem_pages) {
-  if (min_mem_pages > WasmModule::kMaxMemPages) {
-    thrower->Error("Out of memory: wasm memory too large");
-    return Handle<JSArrayBuffer>::null();
-  }
-  Handle<JSArrayBuffer> mem_buffer =
-      NewArrayBuffer(isolate, min_mem_pages * WasmModule::kPageSize);
-
-  if (mem_buffer.is_null()) {
-    thrower->Error("Out of memory: wasm memory");
-  }
-  return mem_buffer;
-}
-
 void RelocateGlobals(Handle<JSObject> instance, Address old_start,
                      Address globals_start) {
   Handle<FixedArray> functions = Handle<FixedArray>(
       FixedArray::cast(instance->GetInternalField(kWasmModuleCodeTable)));
   uint32_t function_count = static_cast<uint32_t>(functions->length());
   for (uint32_t i = 0; i < function_count; ++i) {
     Handle<Code> function = Handle<Code>(Code::cast(functions->get(i)));
     AllowDeferredHandleDereference embedding_raw_address;
     int mask = 1 << RelocInfo::WASM_GLOBAL_REFERENCE;
     for (RelocIterator it(*function, mask); !it.done(); it.next()) {
@@ skipping 134 matching lines @@
                                               JSObject* owner) {
   Address old_address = nullptr;
   Object* stored_value = owner->GetInternalField(kWasmGlobalsArrayBuffer);
   if (stored_value != undefined) {
     old_address = static_cast<Address>(
         JSArrayBuffer::cast(stored_value)->backing_store());
   }
   return old_address;
 }
 
-Handle<FixedArray> GetImportsData(Factory* factory, const WasmModule* module) {
+Handle<FixedArray> EncodeImports(Factory* factory, const WasmModule* module) {
   Handle<FixedArray> ret = factory->NewFixedArray(
       static_cast<int>(module->import_table.size()), TENURED);
+
   for (size_t i = 0; i < module->import_table.size(); ++i) {
     const WasmImport& import = module->import_table[i];
-    if (import.kind != kExternalFunction) continue;
+    Handle<FixedArray> encoded_import =
+        factory->NewFixedArray(kWasmImportDataSize, TENURED);
+    encoded_import->set(kImportKind, Smi::FromInt(import.kind));
+    encoded_import->set(kImportIndex, Smi::FromInt(import.index));
+
+    // Add the module and function name.
     WasmName module_name = module->GetNameOrNull(import.module_name_offset,
                                                  import.module_name_length);
     WasmName function_name = module->GetNameOrNull(import.field_name_offset,
                                                    import.field_name_length);
 
     Handle<String> module_name_string =
         factory->InternalizeUtf8String(module_name);
-    Handle<String> function_name_string =
-        function_name.is_empty()
-            ? Handle<String>::null()
-            : factory->InternalizeUtf8String(function_name);
-    FunctionSig* fsig = module->functions[import.index].sig;
-    Handle<ByteArray> sig = factory->NewByteArray(
-        static_cast<int>(fsig->parameter_count() + fsig->return_count()),
-        TENURED);
-    sig->copy_in(0, reinterpret_cast<const byte*>(fsig->raw_data()),
-                 sig->length());
-    Handle<FixedArray> encoded_import =
-        factory->NewFixedArray(kWasmImportDataSize, TENURED);
     encoded_import->set(kModuleName, *module_name_string);
-    if (!function_name_string.is_null()) {
+    if (!function_name.is_empty()) {
+      Handle<String> function_name_string =
+          factory->InternalizeUtf8String(function_name);
       encoded_import->set(kFunctionName, *function_name_string);
     }
-    encoded_import->set(kOutputCount,
-                        Smi::FromInt(static_cast<int>(fsig->return_count())));
-    encoded_import->set(kSignature, *sig);
+
+    switch (import.kind) {
+      case kExternalFunction: {
+        // Encode the signature into the import.
+        FunctionSig* fsig = module->functions[import.index].sig;
+        Handle<ByteArray> sig = factory->NewByteArray(
+            static_cast<int>(fsig->parameter_count() + fsig->return_count()),
+            TENURED);
+        sig->copy_in(0, reinterpret_cast<const byte*>(fsig->raw_data()),
+                     sig->length());
+        encoded_import->set(
+            kOutputCount, Smi::FromInt(static_cast<int>(fsig->return_count())));
+        encoded_import->set(kSignature, *sig);
+        break;
+      }
+      case kExternalTable:
+        // Nothing extra required for imported tables.
+        break;
+      case kExternalMemory:
+        // Nothing extra required for imported memories.
+        break;
+      case kExternalGlobal: {
+        // Encode the offset and the global type into the import.
+        const WasmGlobal& global = module->globals[import.index];
+        TRACE("import[%zu].type = %s\n", i, WasmOpcodes::TypeName(global.type));
+        encoded_import->set(
+            kImportGlobalType,
+            Smi::FromInt(WasmOpcodes::LocalTypeCodeFor(global.type)));
+        encoded_import->set(kImportIndex, Smi::FromInt(global.offset));
+        break;
+      }
+    }
     ret->set(static_cast<int>(i), *encoded_import);
   }
   return ret;
 }
 
-static MaybeHandle<JSFunction> ReportFFIError(
-    ErrorThrower* thrower, const char* error, uint32_t index,
-    Handle<String> module_name, MaybeHandle<String> function_name) {
-  Handle<String> function_name_handle;
-  if (function_name.ToHandle(&function_name_handle)) {
-    thrower->Error("Import #%d module=\"%.*s\" function=\"%.*s\" error: %s",
-                   index, module_name->length(), module_name->ToCString().get(),
-                   function_name_handle->length(),
-                   function_name_handle->ToCString().get(), error);
-  } else {
-    thrower->Error("Import #%d module=\"%.*s\" error: %s", index,
-                   module_name->length(), module_name->ToCString().get(),
-                   error);
-  }
-  thrower->Error("Import ");
-  return MaybeHandle<JSFunction>();
-}
-
-static MaybeHandle<JSReceiver> LookupFunction(
-    ErrorThrower* thrower, Factory* factory, Handle<JSReceiver> ffi,
-    uint32_t index, Handle<String> module_name,
-    MaybeHandle<String> function_name) {
-  if (ffi.is_null()) {
-    return ReportFFIError(thrower, "FFI is not an object", index, module_name,
-                          function_name);
-  }
-
-  // Look up the module first.
-  MaybeHandle<Object> result = Object::GetProperty(ffi, module_name);
-  if (result.is_null()) {
-    return ReportFFIError(thrower, "module not found", index, module_name,
-                          function_name);
-  }
-
-  Handle<Object> module = result.ToHandleChecked();
-
-  if (!module->IsJSReceiver()) {
-    return ReportFFIError(thrower, "module is not an object or function", index,
-                          module_name, function_name);
-  }
-
-  Handle<Object> function;
-  if (!function_name.is_null()) {
-    // Look up the function in the module.
-    MaybeHandle<Object> result =
-        Object::GetProperty(module, function_name.ToHandleChecked());
-    if (result.is_null()) {
-      return ReportFFIError(thrower, "function not found", index, module_name,
-                            function_name);
-    }
-    function = result.ToHandleChecked();
-  } else {
-    // No function specified. Use the "default export".
-    function = module;
-  }
-
-  if (!function->IsCallable()) {
-    return ReportFFIError(thrower, "not a callable", index, module_name,
-                          function_name);
-  }
-
-  return Handle<JSReceiver>::cast(function);
-}
-
-Handle<Code> CompileImportWrapper(Isolate* isolate,
-                                  const Handle<JSReceiver> ffi, int index,
-                                  Handle<FixedArray> import_data,
-                                  ErrorThrower* thrower) {
-  Handle<FixedArray> data =
-      import_data->GetValueChecked<FixedArray>(isolate, index);
-  Handle<String> module_name =
-      data->GetValueChecked<String>(isolate, kModuleName);
-  MaybeHandle<String> function_name =
-      data->GetValue<String>(isolate, kFunctionName);
-
-  // TODO(mtrofin): this is an uint32_t, actually. We should rationalize
-  // it when we rationalize signed/unsigned stuff.
-  int ret_count = Smi::cast(data->get(kOutputCount))->value();
-  CHECK_GE(ret_count, 0);
-  Handle<ByteArray> sig_data =
-      data->GetValueChecked<ByteArray>(isolate, kSignature);
-  int sig_data_size = sig_data->length();
-  int param_count = sig_data_size - ret_count;
-  CHECK(param_count >= 0);
-
-  MaybeHandle<JSReceiver> function = LookupFunction(
-      thrower, isolate->factory(), ffi, index, module_name, function_name);
-  if (function.is_null()) return Handle<Code>::null();
-  Handle<Code> code;
-  Handle<JSReceiver> target = function.ToHandleChecked();
-  bool isMatch = false;
-  Handle<Code> export_wrapper_code;
-  if (target->IsJSFunction()) {
-    Handle<JSFunction> func = Handle<JSFunction>::cast(target);
-    export_wrapper_code = handle(func->code());
-    if (export_wrapper_code->kind() == Code::JS_TO_WASM_FUNCTION) {
-      int exported_param_count =
-          Smi::cast(func->GetInternalField(kInternalArity))->value();
-      Handle<ByteArray> exportedSig = Handle<ByteArray>(
-          ByteArray::cast(func->GetInternalField(kInternalSignature)));
-      if (exported_param_count == param_count &&
-          exportedSig->length() == sig_data->length() &&
-          memcmp(exportedSig->data(), sig_data->data(),
-                 exportedSig->length()) == 0) {
-        isMatch = true;
-      }
-    }
-  }
-  if (isMatch) {
-    int wasm_count = 0;
-    int const mask = RelocInfo::ModeMask(RelocInfo::CODE_TARGET);
-    for (RelocIterator it(*export_wrapper_code, mask); !it.done(); it.next()) {
-      RelocInfo* rinfo = it.rinfo();
-      Address target_address = rinfo->target_address();
-      Code* target = Code::GetCodeFromTargetAddress(target_address);
-      if (target->kind() == Code::WASM_FUNCTION) {
-        ++wasm_count;
-        code = handle(target);
-      }
-    }
-    DCHECK(wasm_count == 1);
-    return code;
-  } else {
-    // Copy the signature to avoid a raw pointer into a heap object when
-    // GC can happen.
-    Zone zone(isolate->allocator());
-    MachineRepresentation* reps =
-        zone.NewArray<MachineRepresentation>(sig_data_size);
-    memcpy(reps, sig_data->data(),
-           sizeof(MachineRepresentation) * sig_data_size);
-    FunctionSig sig(ret_count, param_count, reps);
-
-    return compiler::CompileWasmToJSWrapper(isolate, target, &sig, index,
-                                            module_name, function_name);
-  }
-}
-
 void InitializeParallelCompilation(
     Isolate* isolate, const std::vector<WasmFunction>& functions,
     std::vector<compiler::WasmCompilationUnit*>& compilation_units,
     ModuleEnv& module_env, ErrorThrower* thrower) {
   for (uint32_t i = FLAG_skip_compiling_wasm_funcs; i < functions.size(); ++i) {
     const WasmFunction* func = &functions[i];
     compilation_units[i] =
         func->imported ? nullptr : new compiler::WasmCompilationUnit(
                                        thrower, isolate, &module_env, func, i);
   }
@@ skipping 439 matching lines @@
       max_mem_pages(0),
       mem_export(false),
       start_function_index(-1),
       origin(kWasmOrigin),
       globals_size(0),
       num_imported_functions(0),
       num_declared_functions(0),
       num_exported_functions(0),
       pending_tasks(new base::Semaphore(0)) {}
 
+void EncodeInit(const WasmModule* module, Factory* factory,
+                Handle<FixedArray> entry, int kind_index, int value_index,
+                const WasmInitExpr& expr) {
+  entry->set(kind_index, Smi::FromInt(0));
+
+  switch (expr.kind) {
+    case WasmInitExpr::kGlobalIndex: {
+      TRACE("  kind = 1, global index %u\n", expr.val.global_index);
+      entry->set(kind_index, Smi::FromInt(1));
+      uint32_t offset = module->globals[expr.val.global_index].offset;
+      entry->set(value_index, Smi::FromInt(offset));
+      break;
+    }
+    case WasmInitExpr::kI32Const:
+      TRACE("  kind = 0, i32 = %d\n", expr.val.i32_const);
+      entry->set(value_index, *factory->NewNumber(expr.val.i32_const));
+      break;
+    case WasmInitExpr::kI64Const:
+      // TODO(titzer): implement initializers for i64 globals.
+      UNREACHABLE();
+      break;
+    case WasmInitExpr::kF32Const:
+      TRACE("  kind = 0, f32 = %f\n", expr.val.f32_const);
+      entry->set(value_index, *factory->NewNumber(expr.val.f32_const));
+      break;
+    case WasmInitExpr::kF64Const:
+      TRACE("  kind = 0, f64 = %lf\n", expr.val.f64_const);
+      entry->set(value_index, *factory->NewNumber(expr.val.f64_const));
+      break;
+    default:
+      UNREACHABLE();
+  }
+}
+
 MaybeHandle<WasmCompiledModule> WasmModule::CompileFunctions(
     Isolate* isolate, ErrorThrower* thrower) const {
   Factory* factory = isolate->factory();
 
   MaybeHandle<WasmCompiledModule> nothing;
 
   WasmModuleInstance temp_instance(this);
   temp_instance.context = isolate->native_context();
   temp_instance.mem_size = GetMinModuleMemSize(this);
   temp_instance.mem_start = nullptr;
@@ skipping 24 matching lines @@
   module_env.origin = origin;
 
   // The {code_table} array contains import wrappers and functions (which
   // are both included in {functions.size()}, and export wrappers.
   int code_table_size =
       static_cast<int>(functions.size() + num_exported_functions);
   Handle<FixedArray> code_table =
       factory->NewFixedArray(static_cast<int>(code_table_size), TENURED);
 
   // Initialize the code table with placeholders.
-  for (uint32_t i = 0; i < functions.size(); i++) {
+  for (uint32_t i = 0; i < functions.size(); ++i) {
     Code::Kind kind = Code::WASM_FUNCTION;
     if (i < num_imported_functions) kind = Code::WASM_TO_JS_FUNCTION;
     Handle<Code> placeholder = CreatePlaceholder(factory, i, kind);
     code_table->set(static_cast<int>(i), *placeholder);
     temp_instance.function_code[i] = placeholder;
   }
 
   isolate->counters()->wasm_functions_per_module()->AddSample(
       static_cast<int>(functions.size()));
   if (!FLAG_trace_wasm_decoder && FLAG_wasm_num_compilation_tasks != 0) {
     // Avoid a race condition by collecting results into a second vector.
     std::vector<Handle<Code>> results;
     results.reserve(temp_instance.function_code.size());
-    for (size_t i = 0; i < temp_instance.function_code.size(); i++) {
+    for (size_t i = 0; i < temp_instance.function_code.size(); ++i) {
       results.push_back(temp_instance.function_code[i]);
     }
     CompileInParallel(isolate, this, results, thrower, &module_env);
 
-    for (size_t i = 0; i < results.size(); i++) {
+    for (size_t i = 0; i < results.size(); ++i) {
       temp_instance.function_code[i] = results[i];
     }
   } else {
     CompileSequentially(isolate, this, temp_instance.function_code, thrower,
                         &module_env);
   }
   if (thrower->error()) return nothing;
 
   // At this point, compilation has completed. Update the code table.
   for (size_t i = FLAG_skip_compiling_wasm_funcs;
@@ skipping 11 matching lines @@
       // TODO(mtrofin): do we need to flush the cache here?
       Assembler::FlushICache(isolate, code->instruction_start(),
                              code->instruction_size());
     }
   }
 
   // Create the compiled module object, and populate with compiled functions
   // and information needed at instantiation time. This object needs to be
   // serializable. Instantiation may occur off a deserialized version of this
   // object.
-  Handle<WasmCompiledModule> ret = WasmCompiledModule::New(
-      isolate, min_mem_pages, globals_size, mem_export, origin);
+  Handle<WasmCompiledModule> ret =
+      WasmCompiledModule::New(isolate, min_mem_pages, globals_size, origin);

[Mircea Trofin, 2016/10/05 16:21:09]

Weird, this isn't a change. Git cl format did this?

[titzer, 2016/10/05 18:29:39]

I removed a parameter that is no longer needed.

   ret->set_code_table(code_table);
   if (!indirect_table.is_null()) {
     ret->set_indirect_function_tables(indirect_table.ToHandleChecked());
   }
-  Handle<FixedArray> import_data = GetImportsData(factory, this);
-  ret->set_import_data(import_data);
 
-  // Compile exported function wrappers.
-  int export_size = static_cast<int>(num_exported_functions);
+  // Create and set import data.
+  ret->set_imports(EncodeImports(factory, this));
+
+  // Create and set export data.
+  int export_size = static_cast<int>(export_table.size());
   if (export_size > 0) {
     Handle<FixedArray> exports = factory->NewFixedArray(export_size, TENURED);
-    int index = -1;
+    int index = 0;
+    int func_index = 0;
 
     for (const WasmExport& exp : export_table) {
-      if (exp.kind != kExternalFunction)
-        continue;  // skip non-function exports.
-      index++;
-      Handle<FixedArray> export_data =
+      if (thrower->error()) return nothing;
+      Handle<FixedArray> encoded_export =
           factory->NewFixedArray(kWasmExportDataSize, TENURED);
-      FunctionSig* funcSig = functions[exp.index].sig;
-      Handle<ByteArray> exportedSig =
-          factory->NewByteArray(static_cast<int>(funcSig->parameter_count() +
-                                                 funcSig->return_count()),
-                                TENURED);
-      exportedSig->copy_in(0,
-                           reinterpret_cast<const byte*>(funcSig->raw_data()),
-                           exportedSig->length());
-      export_data->set(kExportedSignature, *exportedSig);
       WasmName str = GetName(exp.name_offset, exp.name_length);
       Handle<String> name = factory->InternalizeUtf8String(str);
-      Handle<Code> code = code_table->GetValueChecked<Code>(isolate, exp.index);
-      Handle<Code> export_code = compiler::CompileJSToWasmWrapper(
-          isolate, &module_env, code, exp.index);
-      if (thrower->error()) return nothing;
-      export_data->set(kExportName, *name);
-      export_data->set(kExportArity,
-                       Smi::FromInt(static_cast<int>(
-                           functions[exp.index].sig->parameter_count())));
-      export_data->set(kExportedFunctionIndex,
-                       Smi::FromInt(static_cast<int>(exp.index)));
-      exports->set(index, *export_data);
-      code_table->set(static_cast<int>(functions.size() + index), *export_code);
+      encoded_export->set(kExportKind, Smi::FromInt(exp.kind));
+      encoded_export->set(kExportName, *name);
+      encoded_export->set(kExportIndex,
+                          Smi::FromInt(static_cast<int>(exp.index)));
+      exports->set(index, *encoded_export);
+
+      switch (exp.kind) {
+        case kExternalFunction: {
+          // Copy the signature and arity.
+          FunctionSig* funcSig = functions[exp.index].sig;
+          Handle<ByteArray> exportedSig = factory->NewByteArray(
+              static_cast<int>(funcSig->parameter_count() +
+                               funcSig->return_count()),
+              TENURED);
+          exportedSig->copy_in(
+              0, reinterpret_cast<const byte*>(funcSig->raw_data()),
+              exportedSig->length());
+          encoded_export->set(kExportedSignature, *exportedSig);
+          encoded_export->set(
+              kExportArity,
+              Smi::FromInt(static_cast<int>(funcSig->parameter_count())));
+
+          // Compile a wrapper for an exported function.
+          Handle<Code> code =
+              code_table->GetValueChecked<Code>(isolate, exp.index);
+          Handle<Code> export_code = compiler::CompileJSToWasmWrapper(
+              isolate, &module_env, code, exp.index);
+          int code_table_index =
+              static_cast<int>(functions.size() + func_index);
+          code_table->set(code_table_index, *export_code);
+          encoded_export->set(kExportIndex, Smi::FromInt(code_table_index));
+          func_index++;
+        }
+        case kExternalTable:
+          // Nothing special about exported tables.
+          break;
+        case kExternalMemory:
+          // Nothing special about exported tables.
+          break;
+        case kExternalGlobal: {
+          // Encode the global type and the global offset.
+          const WasmGlobal& global = globals[exp.index];
+          encoded_export->set(
+              kExportGlobalType,
+              Smi::FromInt(WasmOpcodes::LocalTypeCodeFor(global.type)));
+          encoded_export->set(kExportIndex, Smi::FromInt(global.offset));
+          break;
+        }
+      }
+      index++;
     }
     ret->set_exports(exports);
   }
 
+  // Create and set init data.
+  int init_size = static_cast<int>(globals.size());
+  if (init_size > 0) {
+    Handle<FixedArray> inits = factory->NewFixedArray(init_size, TENURED);
+    int index = 0;
+    for (const WasmGlobal& global : globals) {
+      // Skip globals that have no initializer (e.g. imported ones).
+      if (global.init.kind == WasmInitExpr::kNone) continue;
+
+      Handle<FixedArray> encoded_init =
+          factory->NewFixedArray(kWasmGlobalInitDataSize, TENURED);
+      inits->set(index, *encoded_init);
+      TRACE("init[%d].type = %s\n", index, WasmOpcodes::TypeName(global.type));
+
+      encoded_init->set(
+          kGlobalInitType,
+          Smi::FromInt(WasmOpcodes::LocalTypeCodeFor(global.type)));
+      encoded_init->set(kGlobalInitIndex, Smi::FromInt(global.offset));
+      EncodeInit(this, factory, encoded_init, kGlobalInitKind, kGlobalInitValue,
+                 global.init);
+      index++;
+    }
+    inits->set_length(index);
+    ret->set_inits(inits);
+  }
+
   // Record data for startup function.
   if (start_function_index >= 0) {
     HandleScope scope(isolate);
     Handle<FixedArray> startup_data =
         factory->NewFixedArray(kWasmExportDataSize, TENURED);
     startup_data->set(kExportArity, Smi::FromInt(0));
-    startup_data->set(kExportedFunctionIndex,
-                      Smi::FromInt(start_function_index));
+    startup_data->set(kExportIndex, Smi::FromInt(start_function_index));
     ret->set_startup_function(startup_data);
   }
 
   // TODO(wasm): saving the module bytes for debugging is wasteful. We should
   // consider downloading this on-demand.
   {
     size_t module_bytes_len = module_end - module_start;
     DCHECK_LE(module_bytes_len, static_cast<size_t>(kMaxInt));
     Vector<const uint8_t> module_bytes_vec(module_start,
                                            static_cast<int>(module_bytes_len));
     Handle<String> module_bytes_string =
         factory->NewStringFromOneByte(module_bytes_vec, TENURED)
             .ToHandleChecked();
     ret->set_module_bytes(module_bytes_string);
   }
 
   Handle<ByteArray> function_name_table =
       BuildFunctionNamesTable(isolate, module_env.module);
   ret->set_function_names(function_name_table);
   if (data_segments.size() > 0) SaveDataSegmentInfo(factory, this, ret);
   DCHECK_EQ(ret->default_mem_size(), temp_instance.mem_size);
   return ret;
 }
 
+// A helper class to simplify instantiating a module from a compiled module.
+// It closes over the {Isolate}, the {ErrorThrower}, the {WasmCompiledModule},
+// etc.
+class WasmModuleInstantiateHelper {

[Mircea Trofin, 2016/10/05 16:21:08]

If not *Pipeline, how about WasmModuleInstanceBuilder?

I would love to avoid "Helper" or "Utility" names, they communicate very little
about the API.

[titzer, 2016/10/05 18:29:39]

WasmInstanceBuilder FTW

+ public:
+  Isolate* isolate_;

[Mircea Trofin, 2016/10/05 16:21:09]

since this is a class, could you make these private and add accessors? It would
also help with maintainability (I can more easily understand where things are
mutated by searching where set_blah_blah is called, rather than all uses of
blah_blah).

also, by the looks of it, a few things are read-only, e.g. isolate_, thrower_...
and a few things are built internally and only offered to the user to be read:
module_object_, memory_..

[titzer, 2016/10/05 18:29:39]

Since this is entirely contained in the CC file (and only a single method is
used outside the class), I don't see much value-add in public/private armor
here.

[Mircea Trofin, 2016/10/05 18:41:00]

Consistency with everywhere else in the codebase? Also, if you don't mean to
expose these properties out (appears not), there is benefit in hiding them and
not even exposing accessors, for encapsulation.

+  ErrorThrower* thrower_;
+  Handle<JSObject> module_object_;
+  Handle<JSReceiver> ffi_;
+  Handle<JSArrayBuffer> memory_;
+  Handle<WasmCompiledModule> compiled_module_;
+
+  WasmModuleInstantiateHelper(Isolate* isolate, ErrorThrower* thrower,
+                              Handle<JSObject> module_object,
+                              Handle<JSReceiver> ffi,
+                              Handle<JSArrayBuffer> memory)
+      : isolate_(isolate),
+        thrower_(thrower),
+        module_object_(module_object),
+        ffi_(ffi),
+        memory_(memory) {}
+
+  // Helper routine to print out errors with imports (FFI).
+  MaybeHandle<JSFunction> ReportFFIError(const char* error, uint32_t index,
+                                         Handle<String> module_name,
+                                         MaybeHandle<String> function_name) {
+    Handle<String> function_name_handle;
+    if (function_name.ToHandle(&function_name_handle)) {
+      thrower_->Error("Import #%d module=\"%.*s\" function=\"%.*s\" error: %s",
+                      index, module_name->length(),
+                      module_name->ToCString().get(),
+                      function_name_handle->length(),
+                      function_name_handle->ToCString().get(), error);
+    } else {
+      thrower_->Error("Import #%d module=\"%.*s\" error: %s", index,
+                      module_name->length(), module_name->ToCString().get(),
+                      error);
+    }
+    thrower_->Error("Import ");
+    return MaybeHandle<JSFunction>();
+  }
+
+  // Look up an import value in the {ffi_} object.
+  MaybeHandle<Object> LookupImport(uint32_t index, Handle<String> module_name,
+                                   MaybeHandle<String> import_name) {
+    if (ffi_.is_null()) {
+      return ReportFFIError("FFI is not an object", index, module_name,
+                            import_name);
+    }
+
+    // Look up the module first.
+    MaybeHandle<Object> result = Object::GetProperty(ffi_, module_name);
+    if (result.is_null()) {
+      return ReportFFIError("module not found", index, module_name,
+                            import_name);
+    }
+
+    Handle<Object> module = result.ToHandleChecked();
+
+    if (!import_name.is_null()) {
+      // Look up the value in the module.
+      if (!module->IsJSReceiver()) {
+        return ReportFFIError("module is not an object or function", index,
+                              module_name, import_name);
+      }
+
+      result = Object::GetProperty(module, import_name.ToHandleChecked());
+      if (result.is_null()) {
+        return ReportFFIError("import not found", index, module_name,
+                              import_name);
+      }
+    } else {
+      // No function specified. Use the "default export".
+      result = module;
+    }
+
+    return result;
+  }
+
+  // Load data segments into the memory.
+  void LoadDataSegments(Address mem_addr, size_t mem_size) {
+    CHECK(compiled_module_->has_data_segments() ==
+          compiled_module_->has_data_segments_info());
+
+    // If we have neither, we're done.
+    if (!compiled_module_->has_data_segments()) return;
+
+    Handle<ByteArray> data = compiled_module_->data_segments();
+    Handle<FixedArray> segments = compiled_module_->data_segments_info();
+
+    uint32_t last_extraction_pos = 0;
+    for (int i = 0; i < segments->length(); ++i) {
+      Handle<ByteArray> segment =
+          Handle<ByteArray>(ByteArray::cast(segments->get(i)));
+      uint32_t dest_addr =
+          static_cast<uint32_t>(segment->get_int(kDestAddrValue));
+      uint32_t source_size =
+          static_cast<uint32_t>(segment->get_int(kSourceSize));
+      CHECK_LT(dest_addr, mem_size);
+      CHECK_LE(source_size, mem_size);
+      CHECK_LE(dest_addr, mem_size - source_size);
+      byte* addr = mem_addr + dest_addr;
+      data->copy_out(last_extraction_pos, addr, source_size);
+      last_extraction_pos += source_size;
+    }
+  }
+
+  Handle<Code> CompileImportWrapper(int index, Handle<FixedArray> data,
+                                    Handle<JSReceiver> target,
+                                    Handle<String> module_name,
+                                    MaybeHandle<String> import_name) {
+    // TODO(mtrofin): this is an uint32_t, actually. We should rationalize
+    // it when we rationalize signed/unsigned stuff.
+    int ret_count = Smi::cast(data->get(kOutputCount))->value();
+    CHECK_GE(ret_count, 0);
+    Handle<ByteArray> sig_data =
+        data->GetValueChecked<ByteArray>(isolate_, kSignature);
+    int sig_data_size = sig_data->length();
+    int param_count = sig_data_size - ret_count;
+    CHECK(param_count >= 0);
+
+    Handle<Code> code;
+    bool isMatch = false;
+    Handle<Code> export_wrapper_code;
+    if (target->IsJSFunction()) {
+      Handle<JSFunction> func = Handle<JSFunction>::cast(target);
+      export_wrapper_code = handle(func->code());
+      if (export_wrapper_code->kind() == Code::JS_TO_WASM_FUNCTION) {
+        int exported_param_count =
+            Smi::cast(func->GetInternalField(kInternalArity))->value();
+        Handle<ByteArray> exportedSig = Handle<ByteArray>(
+            ByteArray::cast(func->GetInternalField(kInternalSignature)));
+        if (exported_param_count == param_count &&
+            exportedSig->length() == sig_data->length() &&
+            memcmp(exportedSig->data(), sig_data->data(),
+                   exportedSig->length()) == 0) {
+          isMatch = true;
+        }
+      }
+    }
+    if (isMatch) {
+      int wasm_count = 0;
+      int const mask = RelocInfo::ModeMask(RelocInfo::CODE_TARGET);
+      for (RelocIterator it(*export_wrapper_code, mask); !it.done();
+           it.next()) {
+        RelocInfo* rinfo = it.rinfo();
+        Address target_address = rinfo->target_address();
+        Code* target = Code::GetCodeFromTargetAddress(target_address);
+        if (target->kind() == Code::WASM_FUNCTION) {
+          ++wasm_count;
+          code = handle(target);
+        }
+      }
+      DCHECK(wasm_count == 1);
+      return code;
+    } else {
+      // Copy the signature to avoid a raw pointer into a heap object when
+      // GC can happen.
+      Zone zone(isolate_->allocator());
+      MachineRepresentation* reps =
+          zone.NewArray<MachineRepresentation>(sig_data_size);
+      memcpy(reps, sig_data->data(),
+             sizeof(MachineRepresentation) * sig_data_size);
+      FunctionSig sig(ret_count, param_count, reps);
+
+      return compiler::CompileWasmToJSWrapper(isolate_, target, &sig, index,
+                                              module_name, import_name);
+    }
+  }
+
+  void WriteGlobalValue(MaybeHandle<JSArrayBuffer> globals, uint32_t offset,
+                        Handle<Object> value, int type) {
+    double num;

[Mircea Trofin, 2016/10/05 16:21:09]

double num = 0.0

[titzer, 2016/10/05 18:29:39]

Done.

+    if (value->IsSmi()) {
+      num = Smi::cast(*value)->value();
+    } else if (value->IsHeapNumber()) {
+      num = HeapNumber::cast(*value)->value();
+    } else {
+      UNREACHABLE();
+    }
+    TRACE("init [globals+%u] = %lf, type = %d\n", offset, num, type);
+    byte* ptr = raw_buffer_ptr(globals, offset);
+    switch (type) {
+      case kLocalI32:
+        *reinterpret_cast<int32_t*>(ptr) = static_cast<int32_t>(num);
+        break;
+      case kLocalI64:
+        // TODO(titzer): initialization of imported i64 globals.
+        UNREACHABLE();
+        break;
+      case kLocalF32:
+        *reinterpret_cast<float*>(ptr) = static_cast<float>(num);
+        break;
+      case kLocalF64:
+        *reinterpret_cast<double*>(ptr) = num;
+        break;
+      default:
+        UNREACHABLE();
+    }
+  }
+
+  // Process the imports, including functions, tables, globals, and memory, in
+  // order, loading them from the {ffi_} object. Returns the number of imported
+  // functions.
+  int ProcessImports(MaybeHandle<JSArrayBuffer> globals,
+                     Handle<FixedArray> code_table) {
+    int num_imported_functions = 0;
+    if (!compiled_module_->has_imports()) return num_imported_functions;
+
+    Handle<FixedArray> imports = compiled_module_->imports();
+    for (int index = 0; index < imports->length(); index++) {

[Mircea Trofin, 2016/10/05 16:21:09]

++index - for consistency with the file

[titzer, 2016/10/05 18:29:39]

Done.

+      Handle<FixedArray> data =
+          imports->GetValueChecked<FixedArray>(isolate_, index);
+
+      Handle<String> module_name =
+          data->GetValueChecked<String>(isolate_, kModuleName);
+      MaybeHandle<String> function_name =
+          data->GetValue<String>(isolate_, kFunctionName);
+
+      MaybeHandle<Object> result =
+          LookupImport(index, module_name, function_name);
+      if (thrower_->error()) return 0;

[Mircea Trofin, 2016/10/05 16:21:09]

should it return -1, because error?

[titzer, 2016/10/05 18:29:39]

Done.

+
+      WasmExternalKind kind = static_cast<WasmExternalKind>(
+          Smi::cast(data->get(kImportKind))->value());
+      switch (kind) {
+        case kExternalFunction: {
+          // Function imports must be callable.
+          Handle<Object> function = result.ToHandleChecked();
+          if (!function->IsCallable()) {
+            ReportFFIError("function import requires a callable", index,
+                           module_name, function_name);
+            return 0;

[Mircea Trofin, 2016/10/05 16:21:09]

same here

[titzer, 2016/10/05 18:29:39]

Done.

+          }
+
+          Handle<Code> import_wrapper = CompileImportWrapper(
+              index, data, Handle<JSReceiver>::cast(function), module_name,
+              function_name);
+          int func_index = Smi::cast(data->get(kImportIndex))->value();
+          code_table->set(func_index, *import_wrapper);
+          RecordStats(isolate_, *import_wrapper);
+          num_imported_functions++;
+          break;
+        }
+        case kExternalTable:
+          // TODO(titzer): Table imports must be a WebAssembly.Table.
+          break;
+        case kExternalMemory:
+          // TODO(titzer): Memory imports must be a WebAssembly.Memory.
+          break;
+        case kExternalGlobal: {
+          // Global imports are converted to numbers and written into the
+          // {globals} array buffer.
+          Handle<Object> object = result.ToHandleChecked();
+          MaybeHandle<Object> number = Object::ToNumber(object);
+          if (number.is_null()) {
+            ReportFFIError("global import could not be converted to number",
+                           index, module_name, function_name);
+            return 0;

[Mircea Trofin, 2016/10/05 16:21:09]

same here

[titzer, 2016/10/05 18:29:39]

Done.

+          }
+          Handle<Object> val = number.ToHandleChecked();
+          int offset = Smi::cast(data->get(kImportIndex))->value();
+          int type = Smi::cast(data->get(kImportGlobalType))->value();
+          WriteGlobalValue(globals, offset, val, type);
+          break;
+        }
+        default:
+          UNREACHABLE();
+          break;
+      }
+    }
+    return num_imported_functions;
+  }
+
+  // Process initialization of globals.
+  void ProcessInits(MaybeHandle<JSArrayBuffer> globals) {
+    if (!compiled_module_->has_inits()) return;
+
+    Handle<FixedArray> inits = compiled_module_->inits();
+    for (int index = 0; index < inits->length(); index++) {

[Mircea Trofin, 2016/10/05 16:21:09]

++index, for consistency

[titzer, 2016/10/05 18:29:38]

Done.

+      Handle<FixedArray> data =
+          inits->GetValueChecked<FixedArray>(isolate_, index);
+
+      int offset = Smi::cast(data->get(kGlobalInitIndex))->value();
+      Handle<Object> val(data->get(kGlobalInitValue), isolate_);
+      int type = Smi::cast(data->get(kGlobalInitType))->value();
+      if (Smi::cast(data->get(kGlobalInitKind))->value() == 0) {
+        // Initialize with a constant.
+        WriteGlobalValue(globals, offset, val, type);
+      } else {
+        // Initialize with another global.
+        int old_offset = Smi::cast(*val)->value();
+        TRACE("init [globals+%u] = [globals+%d]\n", offset, old_offset);
+        int size = 4;

[Mircea Trofin, 2016/10/05 16:21:09]

what's "4"?

[titzer, 2016/10/05 18:29:38]

Done.

+        if (type == kLocalI64 || type == kLocalF64) size = 8;

[Mircea Trofin, 2016/10/05 16:21:09]

what's "8"? 

could we set size to one of the sizeof(int32_t) or sizeof(double)... or don't we
have some MachineTypes as an alternative?

[titzer, 2016/10/05 18:29:38]

Done.

+        memcpy(raw_buffer_ptr(globals, offset),
+               raw_buffer_ptr(globals, old_offset), size);
+      }
+    }
+  }
+
+  // Allocate memory for a module instance as a new JSArrayBuffer.
+  Handle<JSArrayBuffer> AllocateMemory(uint32_t min_mem_pages) {
+    if (min_mem_pages > WasmModule::kMaxMemPages) {
+      thrower_->Error("Out of memory: wasm memory too large");
+      return Handle<JSArrayBuffer>::null();
+    }
+    Handle<JSArrayBuffer> mem_buffer =
+        NewArrayBuffer(isolate_, min_mem_pages * WasmModule::kPageSize);
+
+    if (mem_buffer.is_null()) {
+      thrower_->Error("Out of memory: wasm memory");
+    }
+    return mem_buffer;
+  }
+
+  // Process the exports, creating wrappers for functions, tables, memories,
+  // and globals.
+  void ProcessExports(MaybeHandle<JSArrayBuffer> globals,
+                      Handle<FixedArray> code_table,
+                      Handle<JSObject> instance) {
+    if (!compiled_module_->has_exports()) return;
+
+    Handle<JSObject> exports_object = instance;
+    if (compiled_module_->origin() == kWasmOrigin) {
+      // Create the "exports" object.
+      Handle<JSFunction> object_function = Handle<JSFunction>(
+          isolate_->native_context()->object_function(), isolate_);
+      exports_object =
+          isolate_->factory()->NewJSObject(object_function, TENURED);
+      Handle<String> exports_name =
+          isolate_->factory()->InternalizeUtf8String("exports");
+      JSObject::AddProperty(instance, exports_name, exports_object, READ_ONLY);
+    }
+
+    PropertyDescriptor desc;
+    desc.set_writable(false);
+
+    Handle<FixedArray> exports = compiled_module_->exports();
+
+    for (int i = 0; i < exports->length(); ++i) {
+      Handle<FixedArray> export_data =
+          exports->GetValueChecked<FixedArray>(isolate_, i);
+      Handle<String> name =
+          export_data->GetValueChecked<String>(isolate_, kExportName);
+      WasmExternalKind kind = static_cast<WasmExternalKind>(
+          Smi::cast(export_data->get(kExportKind))->value());
+      switch (kind) {
+        case kExternalFunction: {
+          // Wrap and export the code as a JSFunction.
+          int code_table_index =
+              Smi::cast(export_data->get(kExportIndex))->value();
+          Handle<Code> export_code =
+              code_table->GetValueChecked<Code>(isolate_, code_table_index);
+          int arity = Smi::cast(export_data->get(kExportArity))->value();
+          MaybeHandle<ByteArray> signature =
+              export_data->GetValue<ByteArray>(isolate_, kExportedSignature);
+          desc.set_value(WrapExportCodeAsJSFunction(
+              isolate_, export_code, name, arity, signature, instance));
+          break;
+        }
+        case kExternalTable:
+          // TODO(titzer): create a WebAssembly.Table instance.
+          // TODO(titzer): should it have the same identity as an import?
+          break;
+        case kExternalMemory: {
+          // TODO(titzer): should memory have the same identity as an
+          // import?
+          Handle<JSArrayBuffer> buffer =
+              Handle<JSArrayBuffer>(JSArrayBuffer::cast(
+                  instance->GetInternalField(kWasmMemArrayBuffer)));
+          desc.set_value(
+              WasmJs::CreateWasmMemoryObject(isolate_, buffer, false, 0));
+          break;
+        }
+        case kExternalGlobal: {
+          // Export the value of the global variable as a number.
+          int offset = Smi::cast(export_data->get(kExportIndex))->value();
+          byte* ptr = raw_buffer_ptr(globals, offset);
+          double num = 0;
+          switch (Smi::cast(export_data->get(kExportGlobalType))->value()) {
+            case kLocalI32:
+              num = *reinterpret_cast<int32_t*>(ptr);
+              break;
+            case kLocalF32:
+              num = *reinterpret_cast<float*>(ptr);
+              break;
+            case kLocalF64:
+              num = *reinterpret_cast<double*>(ptr);
+              break;
+            default:
+              UNREACHABLE();
+          }
+          desc.set_value(isolate_->factory()->NewNumber(num));
+          break;
+        }
+        default:
+          UNREACHABLE();
+          break;
+      }
+
+      Maybe<bool> status = JSReceiver::DefineOwnProperty(
+          isolate_, exports_object, name, &desc, Object::THROW_ON_ERROR);
+      if (!status.IsJust()) {
+        thrower_->Error("export of %.*s failed.", name->length(),
+                        name->ToCString().get());
+        return;
+      }
+    }
+  }
+
+  // Instantiate a module, creating an instance.
+  MaybeHandle<JSObject> Instantiate() {
+    MaybeHandle<JSObject> nothing;
+    HistogramTimerScope wasm_instantiate_module_time_scope(
+        isolate_->counters()->wasm_instantiate_module_time());
+    Factory* factory = isolate_->factory();
+
+    //--------------------------------------------------------------------------
+    // Reuse the compiled module (if no owner), otherwise clone.
+    //--------------------------------------------------------------------------
+    Handle<FixedArray> code_table;
+    Handle<FixedArray> old_code_table;
+    Handle<JSObject> owner;
+    // If we don't clone, this will be null(). Otherwise, this will
+    // be a weak link to the original. If we lose the original to GC,
+    // this will be a cleared. We'll link the instances chain last.
+    MaybeHandle<WeakCell> link_to_original;
+
+    TRACE("Starting new module instantiation\n");
+    {
+      Handle<WasmCompiledModule> original(
+          WasmCompiledModule::cast(module_object_->GetInternalField(0)),
+          isolate_);
+      // Always make a new copy of the code_table, since the old_code_table
+      // may still have placeholders for imports.
+      old_code_table = original->code_table();
+      code_table = factory->CopyFixedArray(old_code_table);
+
+      if (original->has_weak_owning_instance()) {
+        WeakCell* tmp = original->ptr_to_weak_owning_instance();
+        DCHECK(!tmp->cleared());
+        // There is already an owner, clone everything.
+        owner = Handle<JSObject>(JSObject::cast(tmp->value()), isolate_);
+        // Insert the latest clone in front.
+        TRACE("Cloning from %d\n", original->instance_id());
+        compiled_module_ = WasmCompiledModule::Clone(isolate_, original);
+        // Replace the strong reference to point to the new instance here.
+        // This allows any of the other instances, including the original,
+        // to be collected.
+        module_object_->SetInternalField(0, *compiled_module_);
+        compiled_module_->set_weak_module_object(
+            original->weak_module_object());
+        link_to_original = factory->NewWeakCell(original);
+        // Don't link to original here. We remember the original
+        // as a weak link. If that link isn't clear by the time we finish
+        // instantiating this instance, then we link it at that time.
+        compiled_module_->reset_weak_next_instance();
+
+        // Clone the code for WASM functions and exports.
+        for (int i = 0; i < code_table->length(); ++i) {
+          Handle<Code> orig_code =
+              code_table->GetValueChecked<Code>(isolate_, i);
+          switch (orig_code->kind()) {
+            case Code::WASM_TO_JS_FUNCTION:
+              // Imports will be overwritten with newly compiled wrappers.
+              break;
+            case Code::JS_TO_WASM_FUNCTION:
+            case Code::WASM_FUNCTION: {
+              Handle<Code> code = factory->CopyCode(orig_code);
+              code_table->set(i, *code);
+              break;
+            }
+            default:
+              UNREACHABLE();
+          }
+        }
+        RecordStats(isolate_, code_table);
+      } else {
+        // There was no owner, so we can reuse the original.
+        compiled_module_ = original;
+        TRACE("Reusing existing instance %d\n",
+              compiled_module_->instance_id());
+      }
+      compiled_module_->set_code_table(code_table);
+    }
+
+    //--------------------------------------------------------------------------
+    // Allocate the instance object.
+    //--------------------------------------------------------------------------
+    Handle<Map> map = factory->NewMap(
+        JS_OBJECT_TYPE,
+        JSObject::kHeaderSize + kWasmModuleInternalFieldCount * kPointerSize);
+    Handle<JSObject> instance = factory->NewJSObjectFromMap(map, TENURED);
+    instance->SetInternalField(kWasmModuleCodeTable, *code_table);
+
+    //--------------------------------------------------------------------------
+    // Set up the memory for the new instance.
+    //--------------------------------------------------------------------------
+    MaybeHandle<JSArrayBuffer> old_memory;
+    // TODO(titzer): handle imported memory properly.
+
+    uint32_t min_mem_pages = compiled_module_->min_memory_pages();
+    isolate_->counters()->wasm_min_mem_pages_count()->AddSample(min_mem_pages);
+    // TODO(wasm): re-enable counter for max_mem_pages when we use that field.
+
+    if (memory_.is_null() && min_mem_pages > 0) {
+      memory_ = AllocateMemory(min_mem_pages);
+      if (memory_.is_null()) return nothing;  // failed to allocate memory
+    }
+
+    if (!memory_.is_null()) {
+      instance->SetInternalField(kWasmMemArrayBuffer, *memory_);
+      Address mem_start = static_cast<Address>(memory_->backing_store());
+      uint32_t mem_size =
+          static_cast<uint32_t>(memory_->byte_length()->Number());
+      LoadDataSegments(mem_start, mem_size);
+
+      uint32_t old_mem_size = compiled_module_->has_heap()
+                                  ? compiled_module_->mem_size()
+                                  : compiled_module_->default_mem_size();
+      Address old_mem_start =
+          compiled_module_->has_heap()
+              ? static_cast<Address>(compiled_module_->heap()->backing_store())
+              : nullptr;
+      RelocateInstanceCode(instance, old_mem_start, mem_start, old_mem_size,
+                           mem_size);
+      compiled_module_->set_heap(memory_);
+    }
+
+    //--------------------------------------------------------------------------
+    // Set up the globals for the new instance.
+    //--------------------------------------------------------------------------
+    MaybeHandle<JSArrayBuffer> old_globals;
+    MaybeHandle<JSArrayBuffer> globals;
+    uint32_t globals_size = compiled_module_->globals_size();
+    if (globals_size > 0) {
+      Handle<JSArrayBuffer> global_buffer =
+          NewArrayBuffer(isolate_, globals_size);
+      globals = global_buffer;
+      if (globals.is_null()) {
+        thrower_->Error("Out of memory: wasm globals");
+        return nothing;
+      }
+      Address old_address =
+          owner.is_null() ? nullptr : GetGlobalStartAddressFromCodeTemplate(
+                                          *factory->undefined_value(),
+                                          JSObject::cast(*owner));
+      RelocateGlobals(instance, old_address,
+                      static_cast<Address>(global_buffer->backing_store()));
+      instance->SetInternalField(kWasmGlobalsArrayBuffer, *global_buffer);
+    }
+
+    //--------------------------------------------------------------------------
+    // Process the imports for the module.
+    //--------------------------------------------------------------------------
+    int num_imported_functions = ProcessImports(globals, code_table);
+
+    //--------------------------------------------------------------------------
+    // Process the initialization for the module's globals.
+    //--------------------------------------------------------------------------
+    ProcessInits(globals);
+
+    //--------------------------------------------------------------------------
+    // Set up the debug support for the new instance.
+    //--------------------------------------------------------------------------
+    // TODO(wasm): avoid referencing this stuff from the instance, use it off
+    // the compiled module instead. See the following 3 assignments:
+    if (compiled_module_->has_module_bytes()) {
+      instance->SetInternalField(kWasmModuleBytesString,
+                                 compiled_module_->ptr_to_module_bytes());
+    }
+
+    if (compiled_module_->has_function_names()) {
+      instance->SetInternalField(kWasmFunctionNamesArray,
+                                 compiled_module_->ptr_to_function_names());
+    }
+
+    {
+      Handle<Object> handle = factory->NewNumber(num_imported_functions);
+      instance->SetInternalField(kWasmNumImportedFunctions, *handle);
+    }
+
+    //--------------------------------------------------------------------------
+    // Set up the runtime support for the new instance.
+    //--------------------------------------------------------------------------
+    Handle<WeakCell> weak_link = factory->NewWeakCell(instance);
+
+    for (int i = num_imported_functions + FLAG_skip_compiling_wasm_funcs;
+         i < code_table->length(); ++i) {
+      Handle<Code> code = code_table->GetValueChecked<Code>(isolate_, i);
+      if (code->kind() == Code::WASM_FUNCTION) {
+        Handle<FixedArray> deopt_data = factory->NewFixedArray(2, TENURED);
+        deopt_data->set(0, *weak_link);
+        deopt_data->set(1, Smi::FromInt(static_cast<int>(i)));
+        deopt_data->set_length(2);
+        code->set_deoptimization_data(*deopt_data);
+      }
+    }
+
+    //--------------------------------------------------------------------------
+    // Set up the indirect function tables for the new instance.
+    //--------------------------------------------------------------------------
+    {
+      std::vector<Handle<Code>> functions(
+          static_cast<size_t>(code_table->length()));
+      for (int i = 0; i < code_table->length(); ++i) {
+        functions[i] = code_table->GetValueChecked<Code>(isolate_, i);
+      }
+
+      if (compiled_module_->has_indirect_function_tables()) {
+        Handle<FixedArray> indirect_tables_template =
+            compiled_module_->indirect_function_tables();
+        Handle<FixedArray> to_replace =
+            owner.is_null() ? indirect_tables_template
+                            : handle(FixedArray::cast(owner->GetInternalField(
+                                  kWasmModuleFunctionTable)));
+        Handle<FixedArray> indirect_tables = SetupIndirectFunctionTable(
+            isolate_, code_table, indirect_tables_template, to_replace);
+        for (int i = 0; i < indirect_tables->length(); ++i) {
+          Handle<FixedArray> metadata =
+              indirect_tables->GetValueChecked<FixedArray>(isolate_, i);
+          uint32_t size = Smi::cast(metadata->get(kSize))->value();
+          Handle<FixedArray> table =
+              metadata->GetValueChecked<FixedArray>(isolate_, kTable);
+          PopulateFunctionTable(table, size, &functions);
+        }
+        instance->SetInternalField(kWasmModuleFunctionTable, *indirect_tables);
+      }
+    }
+
+    //--------------------------------------------------------------------------
+    // Set up the exports object for the new instance.
+    //--------------------------------------------------------------------------
+    ProcessExports(globals, code_table, instance);
+
+    if (num_imported_functions > 0 || !owner.is_null()) {
+      // If the code was cloned, or new imports were compiled, patch.
+      PatchDirectCalls(old_code_table, code_table, num_imported_functions);
+    }
+
+    FlushICache(isolate_, code_table);
+
+    //--------------------------------------------------------------------------
+    // Run the start function if one was specified.
+    //--------------------------------------------------------------------------
+    if (compiled_module_->has_startup_function()) {
+      Handle<FixedArray> startup_data = compiled_module_->startup_function();
+      HandleScope scope(isolate_);
+      int32_t start_index =
+          startup_data->GetValueChecked<Smi>(isolate_, kExportIndex)->value();
+      Handle<Code> startup_code =
+          code_table->GetValueChecked<Code>(isolate_, start_index);
+      int arity = Smi::cast(startup_data->get(kExportArity))->value();
+      MaybeHandle<ByteArray> startup_signature =
+          startup_data->GetValue<ByteArray>(isolate_, kExportedSignature);
+      Handle<JSFunction> startup_fct = WrapExportCodeAsJSFunction(
+          isolate_, startup_code, factory->InternalizeUtf8String("start"),
+          arity, startup_signature, instance);
+      RecordStats(isolate_, *startup_code);
+      // Call the JS function.
+      Handle<Object> undefined = factory->undefined_value();
+      MaybeHandle<Object> retval =
+          Execution::Call(isolate_, startup_fct, undefined, 0, nullptr);
+
+      if (retval.is_null()) {
+        thrower_->Error("WASM.instantiateModule(): start function failed");
+        return nothing;
+      }
+    }
+
+    DCHECK(wasm::IsWasmObject(*instance));
+
+    {
+      Handle<WeakCell> link_to_owner = factory->NewWeakCell(instance);
+
+      Handle<Object> global_handle =
+          isolate_->global_handles()->Create(*instance);
+      Handle<WeakCell> link_to_clone = factory->NewWeakCell(compiled_module_);
+      {
+        DisallowHeapAllocation no_gc;
+        compiled_module_->set_weak_owning_instance(link_to_owner);
+        Handle<WeakCell> next;
+        if (link_to_original.ToHandle(&next) && !next->cleared()) {
+          WasmCompiledModule* original =
+              WasmCompiledModule::cast(next->value());
+          DCHECK(original->has_weak_owning_instance());
+          DCHECK(!original->weak_owning_instance()->cleared());
+          compiled_module_->set_weak_next_instance(next);
+          original->set_weak_prev_instance(link_to_clone);
+        }
+
+        compiled_module_->set_weak_owning_instance(link_to_owner);
+        instance->SetInternalField(kWasmCompiledModule, *compiled_module_);
+        GlobalHandles::MakeWeak(global_handle.location(),
+                                global_handle.location(), &InstanceFinalizer,
+                                v8::WeakCallbackType::kFinalizer);
+      }
+    }
+    TRACE("Finishing instance %d\n", compiled_module_->instance_id());
+    TRACE_CHAIN(WasmCompiledModule::cast(module_object_->GetInternalField(0)));
+    return instance;
+  }
+};
+
 // Instantiates a WASM module, creating a WebAssembly.Instance from a
 // WebAssembly.Module.
 MaybeHandle<JSObject> WasmModule::Instantiate(Isolate* isolate,
                                               ErrorThrower* thrower,
                                               Handle<JSObject> module_object,
                                               Handle<JSReceiver> ffi,
                                               Handle<JSArrayBuffer> memory) {
-  MaybeHandle<JSObject> nothing;
-  HistogramTimerScope wasm_instantiate_module_time_scope(
-      isolate->counters()->wasm_instantiate_module_time());
-  Factory* factory = isolate->factory();
-
-  //--------------------------------------------------------------------------
-  // Reuse the compiled module (if no owner), otherwise clone.
-  //--------------------------------------------------------------------------
-  Handle<WasmCompiledModule> compiled_module;
-  Handle<FixedArray> code_table;
-  Handle<FixedArray> old_code_table;
-  Handle<JSObject> owner;
-  // If we don't clone, this will be null(). Otherwise, this will
-  // be a weak link to the original. If we lose the original to GC,
-  // this will be a cleared. We'll link the instances chain last.
-  MaybeHandle<WeakCell> link_to_original;
-
-  TRACE("Starting new module instantiation\n");
-  {
-    Handle<WasmCompiledModule> original(
-        WasmCompiledModule::cast(module_object->GetInternalField(0)), isolate);
-    // Always make a new copy of the code_table, since the old_code_table
-    // may still have placeholders for imports.
-    old_code_table = original->code_table();
-    code_table = factory->CopyFixedArray(old_code_table);
-
-    if (original->has_weak_owning_instance()) {
-      WeakCell* tmp = original->ptr_to_weak_owning_instance();
-      DCHECK(!tmp->cleared());
-      // There is already an owner, clone everything.
-      owner = Handle<JSObject>(JSObject::cast(tmp->value()), isolate);
-      // Insert the latest clone in front.
-      TRACE("Cloning from %d\n", original->instance_id());
-      compiled_module = WasmCompiledModule::Clone(isolate, original);
-      // Replace the strong reference to point to the new instance here.
-      // This allows any of the other instances, including the original,
-      // to be collected.
-      module_object->SetInternalField(0, *compiled_module);
-      compiled_module->set_weak_module_object(original->weak_module_object());
-      link_to_original = factory->NewWeakCell(original);
-      // Don't link to original here. We remember the original
-      // as a weak link. If that link isn't clear by the time we finish
-      // instantiating this instance, then we link it at that time.
-      compiled_module->reset_weak_next_instance();
-
-      // Clone the code for WASM functions and exports.
-      for (int i = 0; i < code_table->length(); ++i) {
-        Handle<Code> orig_code = code_table->GetValueChecked<Code>(isolate, i);
-        switch (orig_code->kind()) {
-          case Code::WASM_TO_JS_FUNCTION:
-            // Imports will be overwritten with newly compiled wrappers.
-            break;
-          case Code::JS_TO_WASM_FUNCTION:
-          case Code::WASM_FUNCTION: {
-            Handle<Code> code = factory->CopyCode(orig_code);
-            code_table->set(i, *code);
-            break;
-          }
-          default:
-            UNREACHABLE();
-        }
-      }
-      RecordStats(isolate, code_table);
-    } else {
-      // There was no owner, so we can reuse the original.
-      compiled_module = original;
-      TRACE("Reusing existing instance %d\n", compiled_module->instance_id());
-    }
-    compiled_module->set_code_table(code_table);
-  }
-
-  //--------------------------------------------------------------------------
-  // Allocate the instance object.
-  //--------------------------------------------------------------------------
-  Handle<Map> map = factory->NewMap(
-      JS_OBJECT_TYPE,
-      JSObject::kHeaderSize + kWasmModuleInternalFieldCount * kPointerSize);
-  Handle<JSObject> instance = factory->NewJSObjectFromMap(map, TENURED);
-  instance->SetInternalField(kWasmModuleCodeTable, *code_table);
-
-  //--------------------------------------------------------------------------
-  // Set up the memory for the new instance.
-  //--------------------------------------------------------------------------
-  MaybeHandle<JSArrayBuffer> old_memory;
-  // TODO(titzer): handle imported memory properly.
-
-  uint32_t min_mem_pages = compiled_module->min_memory_pages();
-  isolate->counters()->wasm_min_mem_pages_count()->AddSample(min_mem_pages);
-  // TODO(wasm): re-enable counter for max_mem_pages when we use that field.
-
-  if (memory.is_null() && min_mem_pages > 0) {
-    memory = AllocateMemory(thrower, isolate, min_mem_pages);
-    if (memory.is_null()) return nothing;  // failed to allocate memory
-  }
-
-  if (!memory.is_null()) {
-    instance->SetInternalField(kWasmMemArrayBuffer, *memory);
-    Address mem_start = static_cast<Address>(memory->backing_store());
-    uint32_t mem_size = static_cast<uint32_t>(memory->byte_length()->Number());
-    LoadDataSegments(compiled_module, mem_start, mem_size);
-
-    uint32_t old_mem_size = compiled_module->has_heap()
-                                ? compiled_module->mem_size()
-                                : compiled_module->default_mem_size();
-    Address old_mem_start =
-        compiled_module->has_heap()
-            ? static_cast<Address>(compiled_module->heap()->backing_store())
-            : nullptr;
-    RelocateInstanceCode(instance, old_mem_start, mem_start, old_mem_size,
-                         mem_size);
-    compiled_module->set_heap(memory);
-  }
-
-  //--------------------------------------------------------------------------
-  // Set up the globals for the new instance.
-  //--------------------------------------------------------------------------
-  MaybeHandle<JSArrayBuffer> old_globals;
-  MaybeHandle<JSArrayBuffer> globals;
-  uint32_t globals_size = compiled_module->globals_size();
-  if (globals_size > 0) {
-    Handle<JSArrayBuffer> global_buffer = NewArrayBuffer(isolate, globals_size);
-    globals = global_buffer;
-    if (globals.is_null()) {
-      thrower->Error("Out of memory: wasm globals");
-      return nothing;
-    }
-    Address old_address =
-        owner.is_null() ? nullptr : GetGlobalStartAddressFromCodeTemplate(
-                                        *isolate->factory()->undefined_value(),
-                                        JSObject::cast(*owner));
-    RelocateGlobals(instance, old_address,
-                    static_cast<Address>(global_buffer->backing_store()));
-    instance->SetInternalField(kWasmGlobalsArrayBuffer, *global_buffer);
-  }
-
-  //--------------------------------------------------------------------------
-  // Compile the import wrappers for the new instance.
-  //--------------------------------------------------------------------------
-  // TODO(titzer): handle imported globals and function tables.
-  int num_imported_functions = 0;
-  if (compiled_module->has_import_data()) {
-    Handle<FixedArray> import_data = compiled_module->import_data();
-    num_imported_functions = import_data->length();
-    for (int index = 0; index < num_imported_functions; index++) {
-      Handle<Code> import_wrapper =
-          CompileImportWrapper(isolate, ffi, index, import_data, thrower);
-      if (thrower->error()) return nothing;
-      code_table->set(index, *import_wrapper);
-      RecordStats(isolate, *import_wrapper);
-    }
-  }
-
-  //--------------------------------------------------------------------------
-  // Set up the debug support for the new instance.
-  //--------------------------------------------------------------------------
-  // TODO(wasm): avoid referencing this stuff from the instance, use it off
-  // the compiled module instead. See the following 3 assignments:
-  if (compiled_module->has_module_bytes()) {
-    instance->SetInternalField(kWasmModuleBytesString,
-                               compiled_module->ptr_to_module_bytes());
-  }
-
-  if (compiled_module->has_function_names()) {
-    instance->SetInternalField(kWasmFunctionNamesArray,
-                               compiled_module->ptr_to_function_names());
-  }
-
-  {
-    Handle<Object> handle = factory->NewNumber(num_imported_functions);
-    instance->SetInternalField(kWasmNumImportedFunctions, *handle);
-  }
-
-  //--------------------------------------------------------------------------
-  // Set up the runtime support for the new instance.
-  //--------------------------------------------------------------------------
-  Handle<WeakCell> weak_link = isolate->factory()->NewWeakCell(instance);
-
-  for (int i = num_imported_functions + FLAG_skip_compiling_wasm_funcs;
-       i < code_table->length(); ++i) {
-    Handle<Code> code = code_table->GetValueChecked<Code>(isolate, i);
-    if (code->kind() == Code::WASM_FUNCTION) {
-      Handle<FixedArray> deopt_data =
-          isolate->factory()->NewFixedArray(2, TENURED);
-      deopt_data->set(0, *weak_link);
-      deopt_data->set(1, Smi::FromInt(static_cast<int>(i)));
-      deopt_data->set_length(2);
-      code->set_deoptimization_data(*deopt_data);
-    }
-  }
-
-  //--------------------------------------------------------------------------
-  // Set up the indirect function tables for the new instance.
-  //--------------------------------------------------------------------------
-  {
-    std::vector<Handle<Code>> functions(
-        static_cast<size_t>(code_table->length()));
-    for (int i = 0; i < code_table->length(); ++i) {
-      functions[i] = code_table->GetValueChecked<Code>(isolate, i);
-    }
-
-    if (compiled_module->has_indirect_function_tables()) {
-      Handle<FixedArray> indirect_tables_template =
-          compiled_module->indirect_function_tables();
-      Handle<FixedArray> to_replace =
-          owner.is_null() ? indirect_tables_template
-                          : handle(FixedArray::cast(owner->GetInternalField(
-                                kWasmModuleFunctionTable)));
-      Handle<FixedArray> indirect_tables = SetupIndirectFunctionTable(
-          isolate, code_table, indirect_tables_template, to_replace);
-      for (int i = 0; i < indirect_tables->length(); ++i) {
-        Handle<FixedArray> metadata =
-            indirect_tables->GetValueChecked<FixedArray>(isolate, i);
-        uint32_t size = Smi::cast(metadata->get(kSize))->value();
-        Handle<FixedArray> table =
-            metadata->GetValueChecked<FixedArray>(isolate, kTable);
-        PopulateFunctionTable(table, size, &functions);
-      }
-      instance->SetInternalField(kWasmModuleFunctionTable, *indirect_tables);
-    }
-  }
-
-  //--------------------------------------------------------------------------
-  // Set up the exports object for the new instance.
-  //--------------------------------------------------------------------------
-  bool mem_export = compiled_module->export_memory();
-  ModuleOrigin origin = compiled_module->origin();
-
-  if (compiled_module->has_exports() || mem_export) {
-    PropertyDescriptor desc;
-    desc.set_writable(false);
-
-    Handle<JSObject> exports_object = instance;
-    if (origin == kWasmOrigin) {
-      // Create the "exports" object.
-      Handle<JSFunction> object_function = Handle<JSFunction>(
-          isolate->native_context()->object_function(), isolate);
-      exports_object = factory->NewJSObject(object_function, TENURED);
-      Handle<String> exports_name = factory->InternalizeUtf8String("exports");
-      JSObject::AddProperty(instance, exports_name, exports_object, READ_ONLY);
-    }
-    int first_export = -1;
-    // TODO(wasm): another iteration over the code objects.
-    for (int i = 0; i < code_table->length(); i++) {
-      Handle<Code> code = code_table->GetValueChecked<Code>(isolate, i);
-      if (code->kind() == Code::JS_TO_WASM_FUNCTION) {
-        first_export = i;
-        break;
-      }
-    }
-    if (compiled_module->has_exports()) {
-      Handle<FixedArray> exports = compiled_module->exports();
-      int export_size = exports->length();
-      for (int i = 0; i < export_size; ++i) {
-        Handle<FixedArray> export_data =
-            exports->GetValueChecked<FixedArray>(isolate, i);
-        Handle<String> name =
-            export_data->GetValueChecked<String>(isolate, kExportName);
-        int arity = Smi::cast(export_data->get(kExportArity))->value();
-        MaybeHandle<ByteArray> signature =
-            export_data->GetValue<ByteArray>(isolate, kExportedSignature);
-        Handle<Code> export_code =
-            code_table->GetValueChecked<Code>(isolate, first_export + i);
-        Handle<JSFunction> function = WrapExportCodeAsJSFunction(
-            isolate, export_code, name, arity, signature, instance);
-        desc.set_value(function);
-        Maybe<bool> status = JSReceiver::DefineOwnProperty(
-            isolate, exports_object, name, &desc, Object::THROW_ON_ERROR);
-        if (!status.IsJust()) {
-          thrower->Error("export of %.*s failed.", name->length(),
-                         name->ToCString().get());
-          return nothing;
-        }
-      }
-    }
-    if (mem_export) {
-      // Export the memory as a named property.
-      Handle<JSArrayBuffer> buffer = Handle<JSArrayBuffer>(
-          JSArrayBuffer::cast(instance->GetInternalField(kWasmMemArrayBuffer)));
-      Handle<Object> memory_object =
-          WasmJs::CreateWasmMemoryObject(isolate, buffer, false, 0);
-      // TODO(titzer): export the memory with the correct name.
-      Handle<String> name = factory->InternalizeUtf8String("memory");
-      JSObject::AddProperty(exports_object, name, memory_object, READ_ONLY);
-    }
-  }
-
-  if (num_imported_functions > 0 || !owner.is_null()) {
-    // If the code was cloned, or new imports were compiled, patch.
-    PatchDirectCalls(old_code_table, code_table, num_imported_functions);
-  }
-
-  FlushICache(isolate, code_table);
-
-  //--------------------------------------------------------------------------
-  // Run the start function if one was specified.
-  //--------------------------------------------------------------------------
-  if (compiled_module->has_startup_function()) {
-    Handle<FixedArray> startup_data = compiled_module->startup_function();
-    HandleScope scope(isolate);
-    int32_t start_index =
-        startup_data->GetValueChecked<Smi>(isolate, kExportedFunctionIndex)
-            ->value();
-    Handle<Code> startup_code =
-        code_table->GetValueChecked<Code>(isolate, start_index);
-    int arity = Smi::cast(startup_data->get(kExportArity))->value();
-    MaybeHandle<ByteArray> startup_signature =
-        startup_data->GetValue<ByteArray>(isolate, kExportedSignature);
-    Handle<JSFunction> startup_fct = WrapExportCodeAsJSFunction(
-        isolate, startup_code, factory->InternalizeUtf8String("start"), arity,
-        startup_signature, instance);
-    RecordStats(isolate, *startup_code);
-    // Call the JS function.
-    Handle<Object> undefined = isolate->factory()->undefined_value();
-    MaybeHandle<Object> retval =
-        Execution::Call(isolate, startup_fct, undefined, 0, nullptr);
-
-    if (retval.is_null()) {
-      thrower->Error("WASM.instantiateModule(): start function failed");
-      return nothing;
-    }
-  }
-
-  DCHECK(wasm::IsWasmObject(*instance));
-
-  {
-    Handle<WeakCell> link_to_owner = factory->NewWeakCell(instance);
-
-    Handle<Object> global_handle = isolate->global_handles()->Create(*instance);
-    Handle<WeakCell> link_to_clone = factory->NewWeakCell(compiled_module);
-    {
-      DisallowHeapAllocation no_gc;
-      compiled_module->set_weak_owning_instance(link_to_owner);
-      Handle<WeakCell> next;
-      if (link_to_original.ToHandle(&next) && !next->cleared()) {
-        WasmCompiledModule* original = WasmCompiledModule::cast(next->value());
-        DCHECK(original->has_weak_owning_instance());
-        DCHECK(!original->weak_owning_instance()->cleared());
-        compiled_module->set_weak_next_instance(next);
-        original->set_weak_prev_instance(link_to_clone);
-      }
-
-      compiled_module->set_weak_owning_instance(link_to_owner);
-      instance->SetInternalField(kWasmCompiledModule, *compiled_module);
-      GlobalHandles::MakeWeak(global_handle.location(),
-                              global_handle.location(), &InstanceFinalizer,
-                              v8::WeakCallbackType::kFinalizer);
-    }
-  }
-  TRACE("Finishing instance %d\n", compiled_module->instance_id());
-  TRACE_CHAIN(WasmCompiledModule::cast(module_object->GetInternalField(0)));
-  return instance;
+  WasmModuleInstantiateHelper helper(isolate, thrower, module_object, ffi,
+                                     memory);
+  return helper.Instantiate();
 }
 
-#if DEBUG
-uint32_t WasmCompiledModule::instance_id_counter_ = 0;
-#endif
-
 Handle<WasmCompiledModule> WasmCompiledModule::New(Isolate* isolate,
                                                    uint32_t min_memory_pages,
                                                    uint32_t globals_size,
-                                                   bool export_memory,
                                                    ModuleOrigin origin) {
   Handle<FixedArray> ret =
       isolate->factory()->NewFixedArray(PropertyIndices::Count, TENURED);
   // Globals size is expected to fit into an int without overflow. This is not
   // supported by the spec at the moment, however, we don't support array
   // buffer sizes over 1g, so, for now, we avoid alocating a HeapNumber for
   // the globals size. The CHECK guards this assumption.
   CHECK_GE(static_cast<int>(globals_size), 0);
   ret->set(kID_min_memory_pages,
            Smi::FromInt(static_cast<int>(min_memory_pages)));
   ret->set(kID_globals_size, Smi::FromInt(static_cast<int>(globals_size)));
-  ret->set(kID_export_memory, Smi::FromInt(static_cast<int>(export_memory)));
   ret->set(kID_origin, Smi::FromInt(static_cast<int>(origin)));
   WasmCompiledModule::cast(*ret)->Init();
   return handle(WasmCompiledModule::cast(*ret));
 }
 
 void WasmCompiledModule::Init() {
 #if DEBUG
-  set(kID_instance_id, Smi::FromInt(instance_id_counter_++));
+  static uint32_t instance_id_counter = 0;
+  set(kID_instance_id, Smi::FromInt(instance_id_counter++));
   TRACE("New compiled module id: %d\n", instance_id());
 #endif
 }
 
 void WasmCompiledModule::PrintInstancesChain() {
 #if DEBUG
   if (!FLAG_trace_wasm_instances) return;
   for (WasmCompiledModule* current = this; current != nullptr;) {
     PrintF("->%d", current->instance_id());
     if (current->ptr_to_weak_next_instance() == nullptr) break;
@@ skipping 83 matching lines @@
   if (!IsWasmObject(*object)) {
     return false;
   }
 
   // Get code table associated with the module js_object
   Object* obj = object->GetInternalField(kWasmModuleCodeTable);
   Handle<FixedArray> code_table(FixedArray::cast(obj));
 
   // Iterate through the code objects in the code table and update relocation
   // information
-  for (int i = 0; i < code_table->length(); i++) {
+  for (int i = 0; i < code_table->length(); ++i) {
     obj = code_table->get(i);
     Handle<Code> code(Code::cast(obj));
 
     int mode_mask = RelocInfo::ModeMask(RelocInfo::WASM_MEMORY_REFERENCE) |
                     RelocInfo::ModeMask(RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
     for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
       RelocInfo::Mode mode = it.rinfo()->rmode();
       if (RelocInfo::IsWasmMemoryReference(mode) ||
           RelocInfo::IsWasmMemorySizeReference(mode)) {
         it.rinfo()->update_wasm_memory_reference(old_start, new_start, old_size,
@@ skipping 14 matching lines @@
   for (uint32_t i = 0; i < table->size; ++i) {
     const WasmFunction* function = &module->functions[table->values[i]];
     values->set(i, Smi::FromInt(function->sig_index));
     values->set(i + table->max_size, Smi::FromInt(table->values[i]));
   }
   // Set the remaining elements to -1 (instead of "undefined"). These
   // elements are accessed directly as SMIs (without a check). On 64-bit
   // platforms, it is possible to have the top bits of "undefined" take
   // small integer values (or zero), which are more likely to be equal to
   // the signature index we check against.
-  for (uint32_t i = table->size; i < table->max_size; i++) {
+  for (uint32_t i = table->size; i < table->max_size; ++i) {
     values->set(i, Smi::FromInt(-1));
   }
   return values;
 }
 
 void PopulateFunctionTable(Handle<FixedArray> table, uint32_t table_size,
                            const std::vector<Handle<Code>>* code_table) {
   uint32_t max_size = table->length() / 2;
   for (uint32_t i = max_size; i < max_size + table_size; ++i) {
     int index = Smi::cast(table->get(static_cast<int>(i)))->value();
@@ skipping 179 matching lines @@
   WasmCompiledModule* compiled_module =
       WasmCompiledModule::cast(instance->GetInternalField(kWasmCompiledModule));
   CHECK(compiled_module->has_weak_module_object());
   CHECK(compiled_module->ptr_to_weak_module_object()->cleared());
 }
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8