[wasm] Separate compilation from instantiation

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/base/atomic-utils.h"
 #include "src/macro-assembler.h"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
 #include "src/v8.h"
 
@@ skipping 97 matching lines @@
   } else {
     os << "?";
   }
   return os;
 }
 
 // A helper class for compiling multiple wasm functions that offers
 // placeholder code objects for calling functions that are not yet compiled.
 class WasmLinker {
  public:
-  WasmLinker(Isolate* isolate, std::vector<Handle<Code>>* functions)
-      : isolate_(isolate),
-        placeholder_code_(functions->size()),
-        function_code_(functions) {
+  WasmLinker(Isolate* isolate, uint32_t function_count)
+      : isolate_(isolate), placeholder_code_(function_count) {}
+
+  void InitializePlaceholders() {
     for (uint32_t i = 0; i < placeholder_code_.size(); ++i) {
-      CreatePlaceholder(i);
+      placeholder_code_[i] =
+          CreatePlaceholder(isolate_->factory(), i, Code::WASM_FUNCTION);
     }
   }
-
-  Handle<Code> GetPlaceholderCode(uint32_t index) const {
+  // Lazy, not thread safe
+  Handle<Code> GetPlaceholderCode(uint32_t index) {
+    if (placeholder_code_[index].is_null()) {
+      placeholder_code_[index] =
+          CreatePlaceholder(isolate_->factory(), index, Code::WASM_FUNCTION);
+    }
     return placeholder_code_[index];
   }
 
-  void Finish(uint32_t index, Handle<Code> code) {
-    DCHECK(index < function_code().size());
-    function_code()[index] = code;
-  }
-
-  void Link(Handle<FixedArray> function_table,
-            const std::vector<uint16_t>& functions) {
-    for (size_t i = 0; i < function_code().size(); i++) {
-      LinkFunction(function_code()[i]);
-    }
-    if (!function_table.is_null()) {
-      int table_size = static_cast<int>(functions.size());
-      DCHECK_EQ(function_table->length(), table_size * 2);
-      for (int i = 0; i < table_size; i++) {
-        function_table->set(i + table_size, *function_code()[functions[i]]);
+  static void LinkModuleFunctions(Isolate* isolate,
+                                  std::vector<Handle<Code>>& functions) {
+    for (size_t i = 0; i < functions.size(); i++) {
+      Handle<Code> code = functions[i];
+      bool modified = LinkFunction(code, functions, Code::WASM_FUNCTION);
+      if (modified) {
+        Assembler::FlushICache(isolate, code->instruction_start(),
+                               code->instruction_size());
       }
     }
   }
 
- private:
-  std::vector<Handle<Code>>& function_code() { return *function_code_; }
+  static void LinkImports(Isolate* isolate,
+                          std::vector<Handle<Code>>& functions,
+                          const std::vector<Handle<Code>>& imports) {
+    for (uint32_t i = 0; i < functions.size(); ++i) {
+      Handle<Code> code = functions[i];
+      bool modified =
+          WasmLinker::LinkFunction(code, imports, Code::WASM_TO_JS_FUNCTION);
+      if (modified) {
+        Assembler::FlushICache(isolate, code->instruction_start(),
+                               code->instruction_size());
+      }
+    }
+  }
 
-  void CreatePlaceholder(uint32_t index) {
-    DCHECK(index < function_code().size());
-    DCHECK(function_code()[index].is_null());
+  static Handle<Code> CreatePlaceholder(Factory* factory, uint32_t index,
+                                        Code::Kind kind) {
     // Create a placeholder code object and encode the corresponding index in
     // the {constant_pool_offset} field of the code object.
     // TODO(titzer): placeholder code objects are somewhat dangerous.
-    byte buffer[] = {0, 0, 0, 0, 0, 0, 0, 0};  // fake instructions.
-    CodeDesc desc = {buffer, 8, 8, 0, 0, nullptr};
-    Handle<Code> code = isolate_->factory()->NewCode(
-        desc, Code::KindField::encode(Code::WASM_FUNCTION),
-        Handle<Object>::null());
+    static byte buffer[] = {0, 0, 0, 0, 0, 0, 0, 0};  // fake instructions.
+    static CodeDesc desc = {buffer, 8, 8, 0, 0, nullptr};
+    Handle<Code> code = factory->NewCode(desc, Code::KindField::encode(kind),
+                                         Handle<Object>::null());
     code->set_constant_pool_offset(static_cast<int>(index) +
                                    kPlaceholderMarker);
-    placeholder_code_[index] = code;
-    function_code()[index] = code;
+    return code;
   }
 
+ private:
   Isolate* isolate_;
   std::vector<Handle<Code>> placeholder_code_;
-  std::vector<Handle<Code>>* function_code_;
 
-  void LinkFunction(Handle<Code> code) {
+  static bool LinkFunction(Handle<Code> unlinked,
+                           const std::vector<Handle<Code>>& to_link,

[titzer, 2016/06/16 23:12:14]

What does to_link mean? Is it the finished code objects?

[Mircea Trofin, 2016/06/16 23:43:11]

It's functions referenced from unlinked. When we link the wasm functions among
themselves, the unlinked 
and to_link sets are the same. When we link wasm to js functions, the to_link
set is the imports

[titzer, 2016/06/17 00:23:42]

how about code_targets as a name?

[Mircea Trofin, 2016/06/17 00:39:30]

That's a good name, I'll rename. Thanks!

+                           Code::Kind kind) {
     bool modified = false;
     int mode_mask = RelocInfo::kCodeTargetMask;
     AllowDeferredHandleDereference embedding_raw_address;
-    for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
+    for (RelocIterator it(*unlinked, mode_mask); !it.done(); it.next()) {
       RelocInfo::Mode mode = it.rinfo()->rmode();
       if (RelocInfo::IsCodeTarget(mode)) {
         Code* target =
             Code::GetCodeFromTargetAddress(it.rinfo()->target_address());
-        if (target->kind() == Code::WASM_FUNCTION &&
+        if (target->kind() == kind &&
             target->constant_pool_offset() >= kPlaceholderMarker) {
           // Patch direct calls to placeholder code objects.
           uint32_t index = target->constant_pool_offset() - kPlaceholderMarker;
-          CHECK(index < function_code().size());
-          Handle<Code> new_target = function_code()[index];
+          CHECK(index < to_link.size());
+          Handle<Code> new_target = to_link[index];
           if (target != *new_target) {
-            CHECK_EQ(*placeholder_code_[index], target);
             it.rinfo()->set_target_address(new_target->instruction_start(),
                                            SKIP_WRITE_BARRIER,
                                            SKIP_ICACHE_FLUSH);
             modified = true;
           }
         }
       }
     }
-    if (modified) {
-      Assembler::FlushICache(isolate_, code->instruction_start(),
-                             code->instruction_size());
-    }
+    return modified;
   }
 };
 
 namespace {
 // Internal constants for the layout of the module object.
 const int kWasmModuleInternalFieldCount = 5;
 const int kWasmModuleFunctionTable = 0;
 const int kWasmModuleCodeTable = 1;
 const int kWasmMemArrayBuffer = 2;
 const int kWasmGlobalsArrayBuffer = 3;
 const int kWasmFunctionNamesArray = 4;
 
+uint32_t GetMinModuleMemSize(const WasmModule* module) {
+  return WasmModule::kPageSize * module->min_mem_pages;
+}
+
 void LoadDataSegments(const WasmModule* module, byte* mem_addr,
                       size_t mem_size) {
   for (const WasmDataSegment& segment : module->data_segments) {
     if (!segment.init) continue;
     if (!segment.source_size) continue;
     CHECK_LT(segment.dest_addr, mem_size);
     CHECK_LE(segment.source_size, mem_size);
     CHECK_LE(segment.dest_addr + segment.source_size, mem_size);
     byte* addr = mem_addr + segment.dest_addr;
     memcpy(addr, module->module_start + segment.source_offset,
@@ skipping 11 matching lines @@
   for (int i = 0; i < table_size; i++) {
     const WasmFunction* function =
         &module->functions[module->function_table[i]];
     fixed->set(i, Smi::FromInt(function->sig_index));
   }
   return fixed;
 }
 
 Handle<JSArrayBuffer> NewArrayBuffer(Isolate* isolate, size_t size,
                                      byte** backing_store) {
+  *backing_store = nullptr;
   if (size > (WasmModule::kMaxMemPages * WasmModule::kPageSize)) {
     // TODO(titzer): lift restriction on maximum memory allocated here.
-    *backing_store = nullptr;
     return Handle<JSArrayBuffer>::null();
   }
-  void* memory =
-      isolate->array_buffer_allocator()->Allocate(static_cast<int>(size));
-  if (!memory) {
-    *backing_store = nullptr;
+  void* memory = isolate->array_buffer_allocator()->Allocate(size);
+  if (memory == nullptr) {
     return Handle<JSArrayBuffer>::null();
   }
 
   *backing_store = reinterpret_cast<byte*>(memory);
 
 #if DEBUG
   // Double check the API allocator actually zero-initialized the memory.
   byte* bytes = reinterpret_cast<byte*>(*backing_store);
   for (size_t i = 0; i < size; i++) {
     DCHECK_EQ(0, bytes[i]);
   }
 #endif
 
   Handle<JSArrayBuffer> buffer = isolate->factory()->NewJSArrayBuffer();
   JSArrayBuffer::Setup(buffer, isolate, false, memory, static_cast<int>(size));
   buffer->set_is_neuterable(false);
   return buffer;
 }
 
+void RelocateInstanceCode(WasmModuleInstance* instance) {
+  for (uint32_t i = 0; i < instance->function_code.size(); ++i) {
+    Handle<Code> function = instance->function_code[i];
+    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(
+          nullptr, instance->mem_start, GetMinModuleMemSize(instance->module),
+          static_cast<uint32_t>(instance->mem_size));
+    }
+  }
+}
+
 // Set the memory for a module instance to be the {memory} array buffer.
 void SetMemory(WasmModuleInstance* instance, Handle<JSArrayBuffer> memory) {
   memory->set_is_neuterable(false);
   instance->mem_start = reinterpret_cast<byte*>(memory->backing_store());
   instance->mem_size = memory->byte_length()->Number();
   instance->mem_buffer = memory;
+  RelocateInstanceCode(instance);
 }
 
 // Allocate memory for a module instance as a new JSArrayBuffer.
 bool AllocateMemory(ErrorThrower* thrower, Isolate* isolate,
                     WasmModuleInstance* instance) {
   DCHECK(instance->module);
   DCHECK(instance->mem_buffer.is_null());
 
   if (instance->module->min_mem_pages > WasmModule::kMaxMemPages) {
     thrower->Error("Out of memory: wasm memory too large");
     return false;
   }
-  instance->mem_size = WasmModule::kPageSize * instance->module->min_mem_pages;
+  instance->mem_size = GetMinModuleMemSize(instance->module);
   instance->mem_buffer =
       NewArrayBuffer(isolate, instance->mem_size, &instance->mem_start);
-  if (!instance->mem_start) {
+  if (instance->mem_start == nullptr) {
     thrower->Error("Out of memory: wasm memory");
     instance->mem_size = 0;
     return false;
   }
+  RelocateInstanceCode(instance);
   return true;
 }
 
 bool AllocateGlobals(ErrorThrower* thrower, Isolate* isolate,
                      WasmModuleInstance* instance) {
   uint32_t globals_size = instance->module->globals_size;
   if (globals_size > 0) {
     instance->globals_buffer =
         NewArrayBuffer(isolate, globals_size, &instance->globals_start);
     if (!instance->globals_start) {
       // Not enough space for backing store of globals.
       thrower->Error("Out of memory: wasm globals");
       return false;
     }
+
+    for (uint32_t i = 0; i < instance->function_code.size(); ++i) {
+      Handle<Code> function = instance->function_code[i];
+      AllowDeferredHandleDereference embedding_raw_address;
+      int mask = 1 << RelocInfo::WASM_GLOBAL_REFERENCE;
+      for (RelocIterator it(*function, mask); !it.done(); it.next()) {
+        it.rinfo()->update_wasm_global_reference(nullptr,
+                                                 instance->globals_start);
+      }
+    }
   }
   return true;
 }
 }  // namespace
 
 WasmModule::WasmModule()
     : module_start(nullptr),
       module_end(nullptr),
       min_mem_pages(0),
       max_mem_pages(0),
@@ skipping 145 matching lines @@
       PrintF("Total generated wasm code: %zu bytes\n", code_size);
       PrintF("Total generated wasm reloc: %zu bytes\n", reloc_size);
     }
   }
 };
 
 bool CompileWrappersToImportedFunctions(
     Isolate* isolate, const WasmModule* module, const Handle<JSReceiver> ffi,
     WasmModuleInstance* instance, ErrorThrower* thrower, Factory* factory,
     ModuleEnv* module_env, CodeStats& code_stats) {
-  uint32_t index = 0;
   if (module->import_table.size() > 0) {
     instance->import_code.reserve(module->import_table.size());
-    for (const WasmImport& import : module->import_table) {
+    for (uint32_t index = 0; index < module->import_table.size(); ++index) {
+      const WasmImport& import = module->import_table[index];
       WasmName module_name = module->GetNameOrNull(import.module_name_offset,
                                                    import.module_name_length);
       WasmName function_name = module->GetNameOrNull(
           import.function_name_offset, import.function_name_length);
       MaybeHandle<JSFunction> function = LookupFunction(
           *thrower, factory, ffi, index, module_name, function_name);
       if (function.is_null()) return false;
 
       Handle<Code> code = compiler::CompileWasmToJSWrapper(
           isolate, module_env, function.ToHandleChecked(), import.sig,
           module_name, function_name);
-      instance->import_code.push_back(code);
+      instance->import_code[index] = code;
       code_stats.Record(*code);
-      index++;
     }
   }
   return true;
 }
 
 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++) {
     compilation_units[i] = new compiler::WasmCompilationUnit(
         &thrower, isolate, &module_env, &functions[i], i);
   }
+  module_env.linker->InitializePlaceholders();
 }
 
 uint32_t* StartCompilationTasks(
     Isolate* isolate,
     std::vector<compiler::WasmCompilationUnit*>& compilation_units,
     std::queue<compiler::WasmCompilationUnit*>& executed_units,
     const base::SmartPointer<base::Semaphore>& pending_tasks,
     base::Mutex& result_mutex, base::AtomicNumber<size_t>& next_unit) {
   const size_t num_tasks =
       Min(static_cast<size_t>(FLAG_wasm_num_compilation_tasks),
@@ skipping 126 matching lines @@
         thrower, isolate, module_env, &func);
     if (code.is_null()) {
       thrower->Error("Compilation of #%d:%.*s failed.", i, str.length(),
                      str.start());
       break;
     }
       // Install the code into the linker table.
     functions[i] = code;
   }
 }
+
+void PopulateFunctionTable(WasmModuleInstance* instance) {
+  if (!instance->function_table.is_null()) {
+    int table_size = static_cast<int>(instance->module->function_table.size());
+    DCHECK_EQ(instance->function_table->length(), table_size * 2);
+    for (int i = 0; i < table_size; i++) {
+      instance->function_table->set(
+          i + table_size,
+          *instance->function_code[instance->module->function_table[i]]);
+    }
+  }
+}
 }  // namespace
 
 void SetDeoptimizationData(Factory* factory, Handle<JSObject> js_object,
                            std::vector<Handle<Code>>& functions) {
   for (size_t i = FLAG_skip_compiling_wasm_funcs; i < functions.size(); ++i) {
     Handle<Code> code = functions[i];
     DCHECK(code->deoptimization_data() == nullptr ||
            code->deoptimization_data()->length() == 0);
     Handle<FixedArray> deopt_data = factory->NewFixedArray(2, TENURED);
     if (!js_object.is_null()) {
       deopt_data->set(0, *js_object);
     }
     deopt_data->set(1, Smi::FromInt(static_cast<int>(i)));
     deopt_data->set_length(2);
     code->set_deoptimization_data(*deopt_data);
   }
 }
 
+Handle<FixedArray> WasmModule::Compile(Isolate* isolate) const {
+  Factory* factory = isolate->factory();
+  ErrorThrower thrower(isolate, "WasmModule::Compile()");
+  CodeStats code_stats;
+
+  WasmModuleInstance temp_instance_for_compilation(this);
+  temp_instance_for_compilation.function_table =
+      BuildFunctionTable(isolate, this);
+  temp_instance_for_compilation.context = isolate->native_context();
+  temp_instance_for_compilation.mem_size = GetMinModuleMemSize(this);
+  temp_instance_for_compilation.mem_start = nullptr;
+  temp_instance_for_compilation.globals_start = nullptr;
+
+  WasmLinker linker(isolate,
+                    static_cast<uint32_t>(
+                        temp_instance_for_compilation.function_code.size()));
+  ModuleEnv module_env;
+  module_env.module = this;
+  module_env.linker = &linker;
+  module_env.instance = &temp_instance_for_compilation;
+  module_env.origin = origin;
+
+  Handle<FixedArray> ret =
+      factory->NewFixedArray(static_cast<int>(functions.size()), TENURED);
+
+  temp_instance_for_compilation.import_code.resize(import_table.size());
+  for (uint32_t i = 0; i < import_table.size(); ++i) {
+    temp_instance_for_compilation.import_code[i] =
+        WasmLinker::CreatePlaceholder(factory, i, Code::WASM_TO_JS_FUNCTION);
+  }
+  isolate->counters()->wasm_functions_per_module()->AddSample(
+      static_cast<int>(functions.size()));
+  if (FLAG_wasm_num_compilation_tasks != 0) {
+    CompileInParallel(isolate, this,
+                      temp_instance_for_compilation.function_code, &thrower,
+                      &module_env);
+  } else {
+    CompileSequentially(isolate, this,
+                        temp_instance_for_compilation.function_code, &thrower,
+                        &module_env);
+  }
+  if (thrower.error()) {
+    return Handle<FixedArray>::null();
+  }
+
+  WasmLinker::LinkModuleFunctions(isolate,

[titzer, 2016/06/16 23:12:14]

Why not make this an instance method, since there is an instance available here?

Also, why do we need to run the linker? Doesn't the compiled code already
contain direct calls to the placeholder code?

[Mircea Trofin, 2016/06/16 23:43:11]

There doesn't seem to be anything the wasm linker instance would bring in, in
fact,
that change I have that removes placeholders and uses indices completely gets
rid of
linker as an object.
To link the module functions within themselves. 

[titzer, 2016/06/17 00:23:42]

That sounds good, but until then can we simply move those static methods out?
Since we already have many top-level helpers in the anonymous namespace.
Ah, right. Ok.

[Mircea Trofin, 2016/06/17 00:39:30]

You mean move the statics out as stand-alone functions? Happy to - that's
actually
in-line with what the aforementioned subsequent change would do, anyway.

+                                  temp_instance_for_compilation.function_code);
+
+  // At this point, compilation has completed. Update the code table
+  // and record sizes.
+  for (size_t i = FLAG_skip_compiling_wasm_funcs;
+       i < temp_instance_for_compilation.function_code.size(); ++i) {
+    Code* code = *temp_instance_for_compilation.function_code[i];
+    ret->set(static_cast<int>(i), code);
+    code_stats.Record(code);
+  }
+
+  PopulateFunctionTable(&temp_instance_for_compilation);
+
+  return ret;
+}
+
 // 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<JSReceiver> ffi,
     Handle<JSArrayBuffer> memory) const {
   HistogramTimerScope wasm_instantiate_module_time_scope(
       isolate->counters()->wasm_instantiate_module_time());
   ErrorThrower thrower(isolate, "WasmModule::Instantiate()");
   Factory* factory = isolate->factory();
 
   // If FLAG_print_wasm_code_size is set, this aggregates the sum of all code
   // objects created for this module.
   // TODO(titzer): switch this to TRACE_EVENT
   CodeStats code_stats;
 
   //-------------------------------------------------------------------------
   // Allocate the instance and its JS counterpart.
   //-------------------------------------------------------------------------
   Handle<Map> map = factory->NewMap(
       JS_OBJECT_TYPE,
       JSObject::kHeaderSize + kWasmModuleInternalFieldCount * kPointerSize);
   WasmModuleInstance instance(this);
   instance.context = isolate->native_context();
   instance.js_object = factory->NewJSObjectFromMap(map, TENURED);
-  Handle<FixedArray> code_table =
-      factory->NewFixedArray(static_cast<int>(functions.size()), TENURED);
+
+  Handle<FixedArray> code_table = Compile(isolate);
+  if (code_table.is_null()) return Handle<JSObject>::null();
+
   instance.js_object->SetInternalField(kWasmModuleCodeTable, *code_table);
 
+  for (uint32_t i = 0; i < functions.size(); ++i) {
+    Handle<Code> code = Handle<Code>(Code::cast(code_table->get(i)));
+    instance.function_code[i] = code;
+  }
+
   //-------------------------------------------------------------------------
   // Allocate and initialize the linear memory.
   //-------------------------------------------------------------------------
   isolate->counters()->wasm_min_mem_pages_count()->AddSample(
       instance.module->min_mem_pages);
   isolate->counters()->wasm_max_mem_pages_count()->AddSample(
       instance.module->max_mem_pages);
   if (memory.is_null()) {
     if (!AllocateMemory(&thrower, isolate, &instance)) {
       return MaybeHandle<JSObject>();
@@ skipping 12 matching lines @@
     return MaybeHandle<JSObject>();
   }
   if (!instance.globals_buffer.is_null()) {
     instance.js_object->SetInternalField(kWasmGlobalsArrayBuffer,
                                          *instance.globals_buffer);
   }
 
   HistogramTimerScope wasm_compile_module_time_scope(
       isolate->counters()->wasm_compile_module_time());
 
-  instance.function_table = BuildFunctionTable(isolate, this);
-  WasmLinker linker(isolate, &instance.function_code);
   ModuleEnv module_env;
   module_env.module = this;
   module_env.instance = &instance;
-  module_env.linker = &linker;
   module_env.origin = origin;
 
   //-------------------------------------------------------------------------
   // Compile wrappers to imported functions.
   //-------------------------------------------------------------------------
   if (!CompileWrappersToImportedFunctions(isolate, this, ffi, &instance,
                                           &thrower, factory, &module_env,
                                           code_stats)) {
     return MaybeHandle<JSObject>();
   }
-  //-------------------------------------------------------------------------
-  // Compile all functions in the module.
-  //-------------------------------------------------------------------------
   {
-    isolate->counters()->wasm_functions_per_module()->AddSample(
-        static_cast<int>(functions.size()));
-    if (FLAG_wasm_num_compilation_tasks != 0) {
-      CompileInParallel(isolate, this, instance.function_code, &thrower,
-                        &module_env);
-    } else {
-      // 5) The main thread finishes the compilation.
-      CompileSequentially(isolate, this, instance.function_code, &thrower,
-                          &module_env);
-    }
-    if (thrower.error()) {
-      return Handle<JSObject>::null();
-    }
-
-    // At this point, compilation has completed. Update the code table
-    // and record sizes.
-    for (size_t i = FLAG_skip_compiling_wasm_funcs;
-         i < instance.function_code.size(); ++i) {
-      Code* code = *instance.function_code[i];
-      code_table->set(static_cast<int>(i), code);
-      code_stats.Record(code);
-    }
-
-    // Patch all direct call sites.
-    linker.Link(instance.function_table, this->function_table);
     instance.js_object->SetInternalField(kWasmModuleFunctionTable,
                                          Smi::FromInt(0));
+    WasmLinker::LinkImports(isolate, instance.function_code,
+                            instance.import_code);
 
     SetDeoptimizationData(factory, instance.js_object, instance.function_code);
 
     //-------------------------------------------------------------------------
     // Create and populate the exports object.
     //-------------------------------------------------------------------------
     if (export_table.size() > 0 || mem_export) {
       Handle<JSObject> exports_object;
       if (origin == kWasmOrigin) {
         // Create the "exports" object.
@@ skipping 113 matching lines @@
   }
 
   int32_t retval = CompileAndRunWasmModule(isolate, result.val);
   delete result.val;
   return retval;
 }
 
 int32_t CompileAndRunWasmModule(Isolate* isolate, const WasmModule* module) {
   ErrorThrower thrower(isolate, "CompileAndRunWasmModule");
   WasmModuleInstance instance(module);
+  Handle<FixedArray> code_table = module->Compile(isolate);
+
+  if (code_table.is_null()) return -1;
+
+  for (uint32_t i = 0; i < module->functions.size(); ++i) {
+    Handle<Code> code = Handle<Code>(Code::cast(code_table->get(i)));
+    instance.function_code[i] = code;
+  }
 
   // Allocate and initialize the linear memory.
   if (!AllocateMemory(&thrower, isolate, &instance)) {
     return -1;
   }
   LoadDataSegments(module, instance.mem_start, instance.mem_size);
 
   // Allocate the globals area if necessary.
   if (!AllocateGlobals(&thrower, isolate, &instance)) {
     return -1;
   }
 
-  // Build the function table.
-  instance.function_table = BuildFunctionTable(isolate, module);
-
   // Create module environment.
-  WasmLinker linker(isolate, &instance.function_code);
+  WasmLinker linker(isolate,
+                    static_cast<uint32_t>(instance.function_code.size()));
   ModuleEnv module_env;
   module_env.module = module;
   module_env.instance = &instance;
   module_env.linker = &linker;
   module_env.origin = module->origin;
 
   if (module->export_table.size() == 0) {
     thrower.Error("WASM.compileRun() failed: no exported functions");
     return -2;
   }
 
   // Compile all functions.
   for (const WasmFunction& func : module->functions) {
     // Compile the function and install it in the linker.
     Handle<Code> code = compiler::WasmCompilationUnit::CompileWasmFunction(
         &thrower, isolate, &module_env, &func);
-    if (!code.is_null()) linker.Finish(func.func_index, code);
+    if (!code.is_null()) instance.function_code[func.func_index] = code;
     if (thrower.error()) return -1;
   }
 
-  linker.Link(instance.function_table, instance.module->function_table);
+  WasmLinker::LinkModuleFunctions(isolate, instance.function_code);
 
   // Wrap the main code so it can be called as a JS function.
   uint32_t main_index = module->export_table.back().func_index;
   Handle<Code> main_code = instance.function_code[main_index];
   Handle<String> name = isolate->factory()->NewStringFromStaticChars("main");
   Handle<JSObject> module_object = Handle<JSObject>(0, isolate);
   Handle<JSFunction> jsfunc = compiler::CompileJSToWasmWrapper(
       isolate, &module_env, name, main_code, module_object, main_index);
 
   // Call the JS function.
@@ skipping 49 matching lines @@
   // TODO(clemensh): Check wasm byte header once we store a copy of the bytes.
   return object->GetInternalFieldCount() == kWasmModuleInternalFieldCount &&
          object->GetInternalField(kWasmModuleCodeTable)->IsFixedArray() &&
          object->GetInternalField(kWasmMemArrayBuffer)->IsJSArrayBuffer() &&
          object->GetInternalField(kWasmFunctionNamesArray)->IsByteArray();
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8