[wasm] Misc fixes for async compilation

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/assembler-inl.h"
 #include "src/base/adapters.h"
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
@@ skipping 341 matching lines @@
     uint32_t start = module_env.module_env.module->num_imported_functions +
                      FLAG_skip_compiling_wasm_funcs;
     uint32_t num_funcs = static_cast<uint32_t>(functions.size());
     uint32_t funcs_to_compile = start > num_funcs ? 0 : num_funcs - start;
     compilation_units_.reserve(funcs_to_compile);
     for (uint32_t i = start; i < num_funcs; ++i) {
       const WasmFunction* func = &functions[i];
       compilation_units_.push_back(
           new compiler::WasmCompilationUnit(isolate_, &module_env, func));
     }
-    return num_funcs;
+    return funcs_to_compile;
   }
 
   void InitializeHandles() {
     for (auto unit : compilation_units_) {
       unit->InitializeHandles();
     }
   }
 
   uint32_t* StartCompilationTasks() {
     num_background_tasks_ =
@@ skipping 245 matching lines @@
         isolate_, module_wrapper, Handle<SeqOneByteString>::cast(module_bytes),
         script, asm_js_offset_table);
     if (lazy_compile) WasmSharedModuleData::PrepareForLazyCompilation(shared);
 
     // 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> compiled_module = WasmCompiledModule::New(
         isolate_, shared, code_table, function_tables, signature_tables);
-    if (function_table_count > 0) {
-      compiled_module->set_function_tables(function_tables);
-    }
 
     // If we created a wasm script, finish it now and make it public to the
     // debugger.
     if (asm_js_script.is_null()) {
       script->set_wasm_compiled_module(*compiled_module);
       isolate_->debug()->OnAfterCompile(script);
     }
 
     // Compile JS->WASM wrappers for exported functions.
     JSToWasmWrapperCache js_to_wasm_cache;
@@ skipping 2087 matching lines @@
   Handle<WasmModuleObject> module_object_;
   Handle<FixedArray> function_tables_;
   Handle<FixedArray> signature_tables_;
   Handle<WasmCompiledModule> compiled_module_;
   Handle<FixedArray> code_table_;
   std::unique_ptr<WasmInstance> temp_instance_ = nullptr;
   std::unique_ptr<uint32_t[]> task_ids_ = nullptr;
   size_t outstanding_units_ = 0;
   size_t num_background_tasks_ = 0;
 
+  void MoveHandlesToDeferred() {
+    DeferredHandleScope deferred(isolate_);
+    module_wrapper_ = handle(*module_wrapper_, isolate_);
+    function_tables_ = handle(*function_tables_, isolate_);
+    signature_tables_ = handle(*signature_tables_, isolate_);
+    code_table_ = handle(*code_table_, isolate_);
+    temp_instance_->ReopenHandles(isolate_);
+    helper_->InitializeHandles();
+    deferred_handles_.push_back(deferred.Detach());
+  }
+
   //==========================================================================
   // Step 1: (async) Decode the module.
   //==========================================================================
   bool DecodeModule() {
     {
       DisallowHandleAllocation no_handle;
       DisallowHeapAllocation no_allocation;
       // Decode the module bytes.
       TRACE_COMPILE("(1) Decoding module...\n");
       result_ = DecodeWasmModule(isolate_, wire_bytes_.start(),
@@ skipping 68 matching lines @@
 
     isolate_->counters()->wasm_functions_per_wasm_module()->AddSample(
         static_cast<int>(module_->functions.size()));
 
     helper_.reset(new CompilationHelper(isolate_, module_));
 
     DCHECK_LE(module_->num_imported_functions, module_->functions.size());
     size_t num_functions =
         module_->functions.size() - module_->num_imported_functions;
     if (num_functions == 0) {
-      DeferredHandleScope deferred(isolate_);
-      module_wrapper_ = handle(*module_wrapper_, isolate_);
-      deferred_handles_.push_back(deferred.Detach());
+      MoveHandlesToDeferred();

[ahaas, 2017/04/10 07:01:38]

The usual name that is used elsewhere in V8 is {ReopenHandles}, 

[Mircea Trofin, 2017/04/10 13:35:09]

Thanks - I assume you mean ReopenHandles as a suffix, like in ParseInfo's
ReopenHandlesInNewScope.

Done!

       // Degenerate case of an empty module.
       return DoSync(&AsyncCompileJob::FinishCompile);
     }
 
     // Start asynchronous compilation tasks.
     num_background_tasks_ =
         Max(static_cast<size_t>(1),
             Min(num_functions,
                 Min(static_cast<size_t>(FLAG_wasm_num_compilation_tasks),
                     V8::GetCurrentPlatform()
                         ->NumberOfAvailableBackgroundThreads())));
     module_bytes_env_ = std::unique_ptr<ModuleBytesEnv>(
         new ModuleBytesEnv(module_, temp_instance_.get(), wire_bytes_));
     outstanding_units_ = helper_->InitializeParallelCompilation(
         module_->functions, *module_bytes_env_);
 
     // Reopen all handles which should survive in the DeferredHandleScope.
-    DeferredHandleScope deferred(isolate_);
-    module_wrapper_ = handle(*module_wrapper_, isolate_);
-    function_tables_ = handle(*function_tables_, isolate_);
-    signature_tables_ = handle(*signature_tables_, isolate_);
-    code_table_ = handle(*code_table_, isolate_);
-    temp_instance_->ReopenHandles(isolate_);
-    helper_->InitializeHandles();
-    deferred_handles_.push_back(deferred.Detach());
-
+    MoveHandlesToDeferred();
     task_ids_ =
         std::unique_ptr<uint32_t[]>(new uint32_t[num_background_tasks_]);
     for (size_t i = 0; i < num_background_tasks_; ++i) {
       DoAsync(&AsyncCompileJob::ExecuteCompilationUnits, &(task_ids_.get())[i]);
     }
     return true;
   }
 
   //==========================================================================
   // Step 3 (async x K tasks): Execute compilation units.
@@ skipping 27 matching lines @@
     if (failed_) return true;  // already failed
 
     int func_index = -1;
     ErrorThrower thrower(isolate_, nullptr);
     Handle<Code> result = helper_->FinishCompilationUnit(&thrower, &func_index);
     if (thrower.error()) {
       RejectPromise(isolate_, context_, &thrower, module_promise_);
       failed_ = true;
     } else {
       DCHECK(func_index >= 0);
-      code_table_->set(func_index + module_->num_imported_functions, *(result));
+      code_table_->set(func_index, *(result));
     }
     if (failed_ || --outstanding_units_ == 0) {
       // All compilation units are done. We still need to wait for the
       // background tasks to shut down and only then is it safe to finish the
       // compile and delete this job. We can wait for that to happen also
       // in a background task.
       DoAsync(&AsyncCompileJob::WaitForBackgroundTasks);
     }
     return true;
   }
@@ skipping 428 matching lines @@
                                      callee_compiled->instruction_start());
     }
     DCHECK_EQ(non_compiled_functions.size(), idx);
   }
 
   Code* ret =
       Code::cast(compiled_module->code_table()->get(func_to_return_idx));
   DCHECK_EQ(Code::WASM_FUNCTION, ret->kind());
   return handle(ret, isolate);
 }