[wasm] Clone indirect function table when instantiating.

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 1204 matching lines @@
       seen = true;
       it.rinfo()->set_target_address(new_target->instruction_start(),
                                      UPDATE_WRITE_BARRIER, SKIP_ICACHE_FLUSH);
     }
   }
   CHECK(seen);
   Assembler::FlushICache(isolate, wrapper->instruction_start(),
                          wrapper->instruction_size());
 }
 
+Handle<FixedArray> SetupIndirectFunctionTable(
+    Isolate* isolate, Handle<FixedArray> wasm_functions,
+    Handle<FixedArray> indirect_table_template) {
+  Factory* factory = isolate->factory();
+  Handle<FixedArray> cloned_indirect_tables =
+      factory->CopyFixedArray(indirect_table_template);
+  for (int i = 0; i < cloned_indirect_tables->length(); ++i) {
+    Handle<FixedArray> orig_metadata =
+        cloned_indirect_tables->GetValueChecked<FixedArray>(isolate, i);
+    Handle<FixedArray> cloned_metadata = factory->CopyFixedArray(orig_metadata);
+    cloned_indirect_tables->set(i, *cloned_metadata);
+
+    Handle<FixedArray> orig_table =
+        cloned_metadata->GetValueChecked<FixedArray>(isolate, kTable);
+    Handle<FixedArray> cloned_table = factory->CopyFixedArray(orig_table);
+    cloned_metadata->set(kTable, *cloned_table);
+    // Patch the cloned code to refer to the cloned kTable.
+    for (int i = 0; i < wasm_functions->length(); ++i) {
+      Handle<Code> wasm_function =
+          wasm_functions->GetValueChecked<Code>(isolate, i);
+      PatchFunctionTable(wasm_function, orig_table, cloned_table);
+    }
+  }
+  return cloned_indirect_tables;
+}
+
 Handle<FixedArray> CloneModuleForInstance(Isolate* isolate,
                                           Handle<FixedArray> original) {
   Factory* factory = isolate->factory();
   Handle<FixedArray> clone = factory->CopyFixedArray(original);
 
   // Clone each wasm code object.
   Handle<FixedArray> orig_wasm_functions =
       original->GetValueChecked<FixedArray>(isolate, kFunctions);
   Handle<FixedArray> clone_wasm_functions =
       factory->CopyFixedArray(orig_wasm_functions);
   clone->set(kFunctions, *clone_wasm_functions);
   for (int i = 0; i < clone_wasm_functions->length(); ++i) {
     Handle<Code> orig_code =
         clone_wasm_functions->GetValueChecked<Code>(isolate, i);
     Handle<Code> cloned_code = factory->CopyCode(orig_code);
     clone_wasm_functions->set(i, *cloned_code);
   }
 
-  // Copy the outer table, each WasmIndirectFunctionTableMetadata table, and the
-  // inner kTable.
-  MaybeHandle<FixedArray> maybe_indirect_tables =
-      original->GetValue<FixedArray>(isolate, kTableOfIndirectFunctionTables);
-  Handle<FixedArray> indirect_tables, clone_indirect_tables;
-  if (maybe_indirect_tables.ToHandle(&indirect_tables)) {
-    clone_indirect_tables = factory->CopyFixedArray(indirect_tables);
-    clone->set(kTableOfIndirectFunctionTables, *clone_indirect_tables);
-    for (int i = 0; i < clone_indirect_tables->length(); ++i) {
-      Handle<FixedArray> orig_metadata =
-          clone_indirect_tables->GetValueChecked<FixedArray>(isolate, i);
-      Handle<FixedArray> clone_metadata =
-          factory->CopyFixedArray(orig_metadata);
-      clone_indirect_tables->set(i, *clone_metadata);
-
-      Handle<FixedArray> orig_table =
-          clone_metadata->GetValueChecked<FixedArray>(isolate, kTable);
-      Handle<FixedArray> clone_table = factory->CopyFixedArray(orig_table);
-      clone_metadata->set(kTable, *clone_table);
-      // Patch the cloned code to refer to the cloned kTable.
-      for (int i = 0; i < clone_wasm_functions->length(); ++i) {
-        Handle<Code> cloned_code =
-            clone_wasm_functions->GetValueChecked<Code>(isolate, i);
-        PatchFunctionTable(cloned_code, orig_table, clone_table);
-      }
-    }
-  }
-
   MaybeHandle<FixedArray> maybe_orig_exports =
       original->GetValue<FixedArray>(isolate, kExports);
   Handle<FixedArray> orig_exports;
   if (maybe_orig_exports.ToHandle(&orig_exports)) {
     Handle<FixedArray> cloned_exports = factory->CopyFixedArray(orig_exports);
     clone->set(kExports, *cloned_exports);
     for (int i = 0; i < orig_exports->length(); ++i) {
       Handle<FixedArray> export_metadata =
           orig_exports->GetValueChecked<FixedArray>(isolate, i);
       Handle<FixedArray> clone_metadata =
@@ skipping 81 matching lines @@
     return nothing;
   }
 
   SetDebugSupport(factory, compiled_module, js_object);
 
   FlushAssemblyCache(isolate, code_table);
 
   MaybeHandle<FixedArray> maybe_indirect_tables =
       compiled_module->GetValue<FixedArray>(isolate,
                                             kTableOfIndirectFunctionTables);
-  Handle<FixedArray> indirect_tables;
-  if (maybe_indirect_tables.ToHandle(&indirect_tables)) {
+  Handle<FixedArray> indirect_tables_template;
+  if (maybe_indirect_tables.ToHandle(&indirect_tables_template)) {
+    Handle<FixedArray> indirect_tables = SetupIndirectFunctionTable(
+        isolate, code_table, indirect_tables_template);
     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);
       wasm::PopulateFunctionTable(table, size, &functions);
     }
     js_object->SetInternalField(kWasmModuleFunctionTable, *indirect_tables);
   }
@@ skipping 279 matching lines @@
     return static_cast<int32_t>(HeapNumber::cast(*result)->value());
   }
   thrower->Error("WASM.compileRun() failed: Return value should be number");
   return -1;
 }
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8