Revert "Revert "[wasm] Consolidate function table representation.""

This reverts commit 862d605c.

Reason for revert: fixed compile issue

Original change's description:
> Revert "[wasm] Consolidate function table representation."
> 
> This reverts commit 4a45f35f.
> 
> Reason for revert: https://build.chromium.org/p/client.v8/builders/V8%20Linux64%20-%20debug%20builder/builds/25471 
> 
> Original change's description:
> > [wasm] Consolidate function table representation.
> > 
> > This CL avoids the need to reference the function tables (and signatures)
> > as either fixed arrays or vectors, preferring vectors.
> > 
> > The only place we need fixed arrays is on the compiled module, to support
> > serialization. When we move off the GC heap, we'll also move away
> > from fixed arrays in that last case.
> > 
> > The CL aids with getting wasm of the GC heap, by reducing the places 
> > and representations we'll need to change  when changing the way we 
> > reference fixed tables.
> > 
> > Bug: 
> > Change-Id: Id4e43905a3df39062bf2839fa72dd5d9a0fe87da
> > Reviewed-on: https://chromium-review.googlesource.com/588334
> > Commit-Queue: Mircea Trofin <mtrofin@chromium.org>
> > Reviewed-by: Brad Nelson <bradnelson@chromium.org>
> > Cr-Commit-Position: refs/heads/master@{#46917}
> 
> TBR=bradnelson@chromium.org,titzer@chromium.org,mtrofin@chromium.org,ahaas@chromium.org
> 
> Change-Id: Ie7d04f7ec74d6d0b3783df1c78c91c100ab784f4
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> Reviewed-on: https://chromium-review.googlesource.com/588627
> Reviewed-by: Mircea Trofin <mtrofin@chromium.org>
> Commit-Queue: Mircea Trofin <mtrofin@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#46918}

TBR=bradnelson@chromium.org,titzer@chromium.org,mtrofin@chromium.org,ahaas@chromium.org

Change-Id: Ic0ba8097c13f2b1afd263b6243360e8ab95ae474
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/588667
Commit-Queue: Mircea Trofin <mtrofin@chromium.org>
Reviewed-by: Mircea Trofin <mtrofin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#46919}

src/wasm/module-compiler.cc

@@ -337,23 +337,17 @@ MaybeHandle<WasmModuleObject> ModuleCompiler::CompileToModuleObject(
 
   // Initialize the indirect tables with placeholders.
   int function_table_count = static_cast<int>(module_->function_tables.size());
-  Handle<FixedArray> function_tables =
-      factory->NewFixedArray(function_table_count, TENURED);
-  Handle<FixedArray> signature_tables =
-      factory->NewFixedArray(function_table_count, TENURED);
   for (int i = 0; i < function_table_count; ++i) {
     temp_instance.function_tables[i] = factory->NewFixedArray(1, TENURED);
     temp_instance.signature_tables[i] = factory->NewFixedArray(1, TENURED);
-    function_tables->set(i, *temp_instance.function_tables[i]);
-    signature_tables->set(i, *temp_instance.signature_tables[i]);
   }
 
   TimedHistogramScope wasm_compile_module_time_scope(
       module_->is_wasm() ? counters()->wasm_compile_wasm_module_time()
                          : counters()->wasm_compile_asm_module_time());
-  return CompileToModuleObjectInternal(
-      thrower, wire_bytes, asm_js_script, asm_js_offset_table_bytes, factory,
-      &temp_instance, &function_tables, &signature_tables);
+  return CompileToModuleObjectInternal(thrower, wire_bytes, asm_js_script,
+                                       asm_js_offset_table_bytes, factory,
+                                       &temp_instance);
 }
 
 namespace {
@@ -562,8 +556,7 @@ void ResolvePromise(Isolate* isolate, Handle<Context> context,
 MaybeHandle<WasmModuleObject> ModuleCompiler::CompileToModuleObjectInternal(
     ErrorThrower* thrower, const ModuleWireBytes& wire_bytes,
     Handle<Script> asm_js_script, Vector<const byte> asm_js_offset_table_bytes,
-    Factory* factory, WasmInstance* temp_instance,
-    Handle<FixedArray>* function_tables, Handle<FixedArray>* signature_tables) {
+    Factory* factory, WasmInstance* temp_instance) {
   ModuleBytesEnv module_env(module_.get(), temp_instance, wire_bytes);
 
   // The {code_table} array contains import wrappers and functions (which
@@ -668,7 +661,8 @@ MaybeHandle<WasmModuleObject> ModuleCompiler::CompileToModuleObjectInternal(
   // 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);
+      isolate_, shared, code_table, *module_env.module_env.function_tables,
+      *module_env.module_env.signature_tables);
 
   // If we created a wasm script, finish it now and make it public to the
   // debugger.
@@ -1912,8 +1906,6 @@ AsyncCompileJob::~AsyncCompileJob() {
 
 void AsyncCompileJob::ReopenHandlesInDeferredScope() {
   DeferredHandleScope deferred(isolate_);
-  function_tables_ = handle(*function_tables_, isolate_);
-  signature_tables_ = handle(*signature_tables_, isolate_);
   code_table_ = handle(*code_table_, isolate_);
   temp_instance_->ReopenHandles(isolate_);
   compiler_->ReopenHandlesInDeferredScope();
@@ -2079,18 +2071,11 @@ class AsyncCompileJob::PrepareAndStartCompile : public CompileStep {
     // Initialize the indirect tables with placeholders.
     int function_table_count =
         static_cast<int>(module_->function_tables.size());
-    job_->function_tables_ =
-        factory->NewFixedArray(function_table_count, TENURED);
-    job_->signature_tables_ =
-        factory->NewFixedArray(function_table_count, TENURED);
     for (int i = 0; i < function_table_count; ++i) {
       job_->temp_instance_->function_tables[i] =
           factory->NewFixedArray(1, TENURED);
       job_->temp_instance_->signature_tables[i] =
           factory->NewFixedArray(1, TENURED);
-      job_->function_tables_->set(i, *job_->temp_instance_->function_tables[i]);
-      job_->signature_tables_->set(i,
-                                   *job_->temp_instance_->signature_tables[i]);
     }
 
     // The {code_table} array contains import wrappers and functions (which
@@ -2302,9 +2287,10 @@ class AsyncCompileJob::FinishCompile : public CompileStep {
     // and information needed at instantiation time. This object needs to be
     // serializable. Instantiation may occur off a deserialized version of
     // this object.
-    job_->compiled_module_ = WasmCompiledModule::New(
-        job_->isolate_, shared, job_->code_table_, job_->function_tables_,
-        job_->signature_tables_);
+    job_->compiled_module_ =
+        WasmCompiledModule::New(job_->isolate_, shared, job_->code_table_,
+                                job_->temp_instance_->function_tables,
+                                job_->temp_instance_->signature_tables);
 
     // Finish the wasm script now and make it public to the debugger.
     script->set_wasm_compiled_module(*job_->compiled_module_);

src/wasm/module-compiler.h

@@ -163,8 +163,7 @@ class ModuleCompiler {
       ErrorThrower* thrower, const ModuleWireBytes& wire_bytes,
       Handle<Script> asm_js_script,
       Vector<const byte> asm_js_offset_table_bytes, Factory* factory,
-      WasmInstance* temp_instance, Handle<FixedArray>* function_tables,
-      Handle<FixedArray>* signature_tables);
+      WasmInstance* temp_instance);
 
   Isolate* isolate_;
   std::unique_ptr<WasmModule> module_;
@@ -348,8 +347,6 @@ class AsyncCompileJob {
 
   std::vector<DeferredHandles*> deferred_handles_;
   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;

src/wasm/wasm-objects.cc

@@ -793,8 +793,8 @@ void WasmSharedModuleData::PrepareForLazyCompilation(
 Handle<WasmCompiledModule> WasmCompiledModule::New(
     Isolate* isolate, Handle<WasmSharedModuleData> shared,
     Handle<FixedArray> code_table,
-    MaybeHandle<FixedArray> maybe_empty_function_tables,
-    MaybeHandle<FixedArray> maybe_signature_tables) {
+    const std::vector<Handle<FixedArray>>& function_tables,
+    const std::vector<Handle<FixedArray>>& signature_tables) {
   Handle<FixedArray> ret =
       isolate->factory()->NewFixedArray(PropertyIndices::Count, TENURED);
   // WasmCompiledModule::cast would fail since fields are not set yet.
@@ -804,15 +804,22 @@ Handle<WasmCompiledModule> WasmCompiledModule::New(
   compiled_module->set_shared(shared);
   compiled_module->set_native_context(isolate->native_context());
   compiled_module->set_code_table(code_table);
-  int function_table_count =
-      static_cast<int>(shared->module()->function_tables.size());
+  size_t function_table_count = shared->module()->function_tables.size();
   if (function_table_count > 0) {
-    compiled_module->set_signature_tables(
-        maybe_signature_tables.ToHandleChecked());
-    compiled_module->set_empty_function_tables(
-        maybe_empty_function_tables.ToHandleChecked());
-    compiled_module->set_function_tables(
-        maybe_empty_function_tables.ToHandleChecked());
+    DCHECK_EQ(function_tables.size(), signature_tables.size());
+    DCHECK_EQ(function_tables.size(), function_table_count);
+    int count_as_int = static_cast<int>(function_table_count);
+    Handle<FixedArray> sig_tables =
+        isolate->factory()->NewFixedArray(count_as_int, TENURED);
+    Handle<FixedArray> func_tables =
+        isolate->factory()->NewFixedArray(count_as_int, TENURED);
+    for (int i = 0; i < count_as_int; ++i) {
+      sig_tables->set(i, *(signature_tables[static_cast<size_t>(i)]));
+      func_tables->set(i, *(function_tables[static_cast<size_t>(i)]));
+    }
+    compiled_module->set_signature_tables(sig_tables);
+    compiled_module->set_empty_function_tables(func_tables);
+    compiled_module->set_function_tables(func_tables);
   }
   // TODO(mtrofin): we copy these because the order of finalization isn't
   // reliable, and we need these at Reset (which is called at

src/wasm/wasm-objects.h

@@ -424,8 +424,8 @@ class WasmCompiledModule : public FixedArray {
   static Handle<WasmCompiledModule> New(
       Isolate* isolate, Handle<WasmSharedModuleData> shared,
       Handle<FixedArray> code_table,
-      MaybeHandle<FixedArray> maybe_empty_function_tables,
-      MaybeHandle<FixedArray> maybe_signature_tables);
+      const std::vector<Handle<FixedArray>>& function_tables,
+      const std::vector<Handle<FixedArray>>& signature_tables);
 
   static Handle<WasmCompiledModule> Clone(Isolate* isolate,
                                           Handle<WasmCompiledModule> module);

test/cctest/wasm/wasm-run-utils.h

@@ -343,9 +343,9 @@ class TestingModule : public ModuleEnv {
                                   script, Handle<ByteArray>::null());
     Handle<FixedArray> code_table = isolate_->factory()->NewFixedArray(0);
 
+    std::vector<Handle<FixedArray>> empty;
     Handle<WasmCompiledModule> compiled_module = WasmCompiledModule::New(
-        isolate_, shared_module_data, code_table, MaybeHandle<FixedArray>(),
-        MaybeHandle<FixedArray>());
+        isolate_, shared_module_data, code_table, empty, empty);
     Handle<FixedArray> weak_exported = isolate_->factory()->NewFixedArray(0);
     compiled_module->set_weak_exported_functions(weak_exported);
     DCHECK(WasmCompiledModule::IsWasmCompiledModule(*compiled_module));