[wasm] Add support for multiple indirect function tables

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/macro-assembler.h"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
@@ skipping 136 matching lines @@
 // the compiled module is either obtained from the current v8 instance, or from
 // a snapshot produced by a compatible (==identical) v8 instance, we simply
 // fail at instantiation time, in the face of invalid data.
 enum CompiledWasmObjectFields {
   kFunctions,        // FixedArray of Code
   kImportData,       // maybe FixedArray of FixedArray respecting the
                      // WasmImportMetadata structure.
   kExports,          // maybe FixedArray of FixedArray of WasmExportMetadata
                      // structure
   kStartupFunction,  // maybe FixedArray of WasmExportMetadata structure
-  kIndirectFunctionTableSize,       // Smi. Size of indirect function table.
-  kIndirectFunctionTablePrototype,  // maybe FixedArray
-  kModuleBytes,                     // maybe String
-  kFunctionNameTable,               // maybe ByteArray
-  kMinRequiredMemory,               // Smi. an uint32_t
+  kTableOfIndirectFunctionTables,  // maybe FixedArray of FixedArray of
+                                   // WasmIndirectFunctionTableMetadata
+  kModuleBytes,                    // maybe String
+  kFunctionNameTable,              // maybe ByteArray
+  kMinRequiredMemory,              // Smi. an uint32_t
   // The following 2 are either together present or absent:
   kDataSegmentsInfo,  // maybe FixedArray of FixedArray respecting the
                       // WasmSegmentInfo structure
   kDataSegments,      // maybe ByteArray.
 
   kGlobalsSize,                 // Smi. an uint32_t
   kExportMem,                   // Smi. bool
   kOrigin,                      // Smi. ModuleOrigin
   kCompiledWasmObjectTableSize  // Sentinel value.
 };
@@ skipping 13 matching lines @@
   kExportedFunctionIndex,       // Smi, an uint32_t
   kWasmExportMetadataTableSize  // Sentinel value.
 };
 
 enum WasmSegmentInfo {
   kDestAddr,            // Smi. an uint32_t
   kSourceSize,          // Smi. an uint32_t
   kWasmSegmentInfoSize  // Sentinel value.
 };
 
+enum WasmIndirectFunctionTableMetadata {
+  kSize,   // Smi. an uint32_t
+  kTable,  // FixedArray of indirect function table
+  kWasmIndirectFunctionTableMetadataSize  // Sentinel value.
+};
+
 uint32_t GetMinModuleMemSize(const WasmModule* module) {
   return WasmModule::kPageSize * module->min_mem_pages;
 }
 
 void LoadDataSegments(Handle<FixedArray> compiled_module, Address mem_addr,
                       size_t mem_size) {
   MaybeHandle<ByteArray> maybe_data =
       compiled_module->GetValue<ByteArray>(kDataSegments);
   MaybeHandle<FixedArray> maybe_segments =
       compiled_module->GetValue<FixedArray>(kDataSegmentsInfo);
@@ skipping 45 matching lines @@
     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(kDataSegmentsInfo, *segments);
   compiled_module->set(kDataSegments, *data);
 }
 
-MaybeHandle<FixedArray> BuildFunctionTable(Isolate* isolate,
-                                           const WasmModule* module) {
-  // Compute the size of the indirect function table
-  uint32_t table_size = module->FunctionTableSize();
-  if (table_size == 0) {
-    return MaybeHandle<FixedArray>();
-  }
-
-  DCHECK_GE(table_size, module->function_table.size());
-
-  Handle<FixedArray> fixed = isolate->factory()->NewFixedArray(2 * table_size);
-  for (uint32_t i = 0; i < module->function_table.size(); ++i) {
-    const WasmFunction* function =
-        &module->functions[module->function_table[i]];
-    int fixed_array_index = static_cast<int>(i);
-    fixed->set(fixed_array_index, Smi::FromInt(function->sig_index));
-    fixed->set(fixed_array_index + table_size,
-               Smi::FromInt(module->function_table[fixed_array_index]));
-  }
-
-  // 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 = static_cast<uint32_t>(module->function_table.size());
-       i < table_size;
-       ++i) {
-    fixed->set(i, Smi::FromInt(-1));
-  }
-  return fixed;
-}
-
 void PatchFunctionTable(Handle<Code> code,
                         Handle<FixedArray> old_indirect_table,
                         Handle<FixedArray> new_indirect_table) {
   for (RelocIterator it(*code, 1 << RelocInfo::EMBEDDED_OBJECT); !it.done();
        it.next()) {
     if (it.rinfo()->target_object() == *old_indirect_table) {
       it.rinfo()->set_target_object(*new_indirect_table);
     }
   }
 }
@@ skipping 67 matching lines @@
     }
   }
 }
 
 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.
   static byte buffer[] = {0, 0, 0, 0, 0, 0, 0, 0};  // fake instructions.
-  static CodeDesc desc = {buffer, 8, 8, 0, 0, nullptr, 0, nullptr};
+  static CodeDesc desc = {
+      buffer, arraysize(buffer), arraysize(buffer), 0, 0, nullptr, 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);
   return code;
 }
 
 // TODO(mtrofin): remove when we stop relying on placeholders.
 void InitializePlaceholders(Factory* factory,
                             std::vector<Handle<Code>>* placeholders,
                             size_t size) {
@@ skipping 63 matching lines @@
 WasmModule::WasmModule(byte* module_start)
     : module_start(module_start),
       module_end(nullptr),
       min_mem_pages(0),
       max_mem_pages(0),
       mem_export(false),
       mem_external(false),
       start_function_index(-1),
       origin(kWasmOrigin),
       globals_size(0),
-      indirect_table_size(0),
       pending_tasks(new base::Semaphore(0)) {}
 
 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(),
@@ skipping 545 matching lines @@
   Factory* factory = isolate->factory();
 
   MaybeHandle<FixedArray> nothing;
 
   WasmModuleInstance temp_instance_for_compilation(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;
 
-  MaybeHandle<FixedArray> indirect_table = BuildFunctionTable(isolate, this);
-  if (!indirect_table.is_null()) {
-    temp_instance_for_compilation.function_table =
-        indirect_table.ToHandleChecked();
+  MaybeHandle<FixedArray> indirect_table =
+      function_tables.size()
+          ? factory->NewFixedArray(static_cast<int>(function_tables.size()))
+          : MaybeHandle<FixedArray>();
+  for (uint32_t i = 0; i < function_tables.size(); ++i) {
+    Handle<FixedArray> values = wasm::BuildFunctionTable(isolate, i, this);
+    temp_instance_for_compilation.function_tables[i] = values;
+
+    Handle<FixedArray> metadata = isolate->factory()->NewFixedArray(
+        kWasmIndirectFunctionTableMetadataSize);
+    metadata->set(kSize, Smi::FromInt(function_tables[i].size));
+    metadata->set(kTable, *values);
+    indirect_table.ToHandleChecked()->set(i, *metadata);
   }
 
   HistogramTimerScope wasm_compile_module_time_scope(
       isolate->counters()->wasm_compile_module_time());
 
   ModuleEnv module_env;
   module_env.module = this;
   module_env.instance = &temp_instance_for_compilation;
   module_env.origin = origin;
   InitializePlaceholders(factory, &module_env.placeholders, functions.size());
@@ skipping 26 matching lines @@
     compiled_functions->set(static_cast<int>(i), code);
   }
 
   // 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<FixedArray> ret =
       factory->NewFixedArray(kCompiledWasmObjectTableSize, TENURED);
   ret->set(kFunctions, *compiled_functions);
-  ret->set(kIndirectFunctionTableSize,
-           Smi::FromInt(static_cast<int>(function_table.size())));
   if (!indirect_table.is_null()) {
-    ret->set(kIndirectFunctionTablePrototype,
-             *indirect_table.ToHandleChecked());
+    ret->set(kTableOfIndirectFunctionTables, *indirect_table.ToHandleChecked());
   }
   Handle<FixedArray> import_data = GetImportsMetadata(factory, this);
   ret->set(kImportData, *import_data);
 
   // Compile export functions.
   int export_size = static_cast<int>(export_table.size());
   Handle<Code> startup_fct;
   if (export_size > 0) {
     Handle<FixedArray> exports = factory->NewFixedArray(export_size, TENURED);
     for (int i = 0; i < export_size; ++i) {
@@ skipping 81 matching lines @@
   CHECK(seen);
   Assembler::FlushICache(isolate, wrapper->instruction_start(),
                          wrapper->instruction_size());
 }
 
 Handle<FixedArray> CloneModuleForInstance(Isolate* isolate,
                                           Handle<FixedArray> original) {
   Factory* factory = isolate->factory();
   Handle<FixedArray> clone = factory->CopyFixedArray(original);
 
+  // Copy the outer table, each WasmIndirectFunctionTableMetadata table, and the
+  // inner kTable.
+  MaybeHandle<FixedArray> maybe_indirect_tables =
+      original->GetValue<FixedArray>(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>(i);
+      Handle<FixedArray> clone_metadata =
+          factory->CopyFixedArray(orig_metadata);
+      clone_indirect_tables->set(i, *clone_metadata);
+
+      Handle<FixedArray> orig_table =
+          clone_metadata->GetValueChecked<FixedArray>(kTable);
+      Handle<FixedArray> clone_table = factory->CopyFixedArray(orig_table);
+      clone_metadata->set(kTable, *clone_table);
+    }
+  }
+
+  // Clone each code, then if indirect tables are used, patch the cloned code to
+  // refer to the cloned kTable.
   Handle<FixedArray> orig_wasm_functions =
       original->GetValueChecked<FixedArray>(kFunctions);
   Handle<FixedArray> clone_wasm_functions =
       factory->CopyFixedArray(orig_wasm_functions);
   clone->set(kFunctions, *clone_wasm_functions);
-
-  MaybeHandle<FixedArray> maybe_indirect_table =
-      original->GetValue<FixedArray>(kIndirectFunctionTablePrototype);
-
-  Handle<FixedArray> indirect_table;
-  Handle<FixedArray> old_table;
-  if (maybe_indirect_table.ToHandle(&old_table)) {
-    indirect_table = factory->CopyFixedArray(old_table);
-    clone->set(kIndirectFunctionTablePrototype, *indirect_table);
-  }
-
-  for (int i = 0; i < orig_wasm_functions->length(); ++i) {
-    Handle<Code> orig_code = orig_wasm_functions->GetValueChecked<Code>(i);
+  for (int i = 0; i < clone_wasm_functions->length(); ++i) {
+    Handle<Code> orig_code = clone_wasm_functions->GetValueChecked<Code>(i);
     Handle<Code> cloned_code = factory->CopyCode(orig_code);
     clone_wasm_functions->set(i, *cloned_code);
-    if (!maybe_indirect_table.is_null()) {
-      PatchFunctionTable(cloned_code, old_table, indirect_table);
+
+    if (!clone_indirect_tables.is_null()) {
+      for (int j = 0; j < clone_indirect_tables->length(); ++j) {
+        Handle<FixedArray> orig_metadata =
+            indirect_tables->GetValueChecked<FixedArray>(j);
+        Handle<FixedArray> orig_table =
+            orig_metadata->GetValueChecked<FixedArray>(kTable);
+
+        Handle<FixedArray> clone_metadata =
+            clone_indirect_tables->GetValueChecked<FixedArray>(j);
+        Handle<FixedArray> clone_table =
+            clone_metadata->GetValueChecked<FixedArray>(kTable);
+
+        PatchFunctionTable(cloned_code, orig_table, clone_table);
+      }
     }
   }
 
   MaybeHandle<FixedArray> maybe_orig_exports =
       original->GetValue<FixedArray>(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) {
@@ skipping 51 matching lines @@
       isolate->counters()->wasm_instantiate_module_time());
   ErrorThrower thrower(isolate, "WasmModule::Instantiate()");
   Factory* factory = isolate->factory();
 
   compiled_module = CloneModuleForInstance(isolate, compiled_module);
 
   // These fields are compulsory.
   Handle<FixedArray> code_table =
       compiled_module->GetValueChecked<FixedArray>(kFunctions);
 
-  {
-    std::vector<Handle<Code>> functions(
-        static_cast<size_t>(code_table->length()));
-    for (int i = 0; i < code_table->length(); ++i) {
-      functions[static_cast<size_t>(i)] = code_table->GetValueChecked<Code>(i);
-    }
-    LinkModuleFunctions(isolate, functions);
+  std::vector<Handle<Code>> functions(
+      static_cast<size_t>(code_table->length()));
+  for (int i = 0; i < code_table->length(); ++i) {
+    functions[static_cast<size_t>(i)] = code_table->GetValueChecked<Code>(i);
   }
+  LinkModuleFunctions(isolate, functions);
 
   RecordStats(isolate, code_table);
 
   MaybeHandle<JSObject> nothing;
 
   Handle<Map> map = factory->NewMap(
       JS_OBJECT_TYPE,
       JSObject::kHeaderSize + kWasmModuleInternalFieldCount * kPointerSize);
   Handle<JSObject> js_object = factory->NewJSObjectFromMap(map, TENURED);
   js_object->SetInternalField(kWasmModuleCodeTable, *code_table);
 
   if (!(SetupInstanceHeap(isolate, compiled_module, js_object, memory,
                           &thrower) &&
         SetupGlobals(isolate, compiled_module, js_object, &thrower) &&
         SetupImports(isolate, compiled_module, js_object, &thrower, ffi) &&
         SetupExportsObject(compiled_module, isolate, js_object, &thrower))) {
     return nothing;
   }
 
   SetDebugSupport(factory, compiled_module, js_object);
 
   FlushAssemblyCache(isolate, code_table);
 
-  MaybeHandle<FixedArray> maybe_indirect_table =
-      compiled_module->GetValue<FixedArray>(kIndirectFunctionTablePrototype);
-  Handle<FixedArray> indirect_table;
-  if (maybe_indirect_table.ToHandle(&indirect_table)) {
-    int table_size =
-        Smi::cast(compiled_module->get(kIndirectFunctionTableSize))->value();
-    int half_point = indirect_table->length() / 2;
-    for (int i = half_point; i < half_point + table_size; ++i) {
-      int index = Smi::cast(indirect_table->get(i))->value();
-      DCHECK_GE(index, 0);
-      DCHECK_LT(index, code_table->length());
-      indirect_table->set(i, code_table->get(index));
+  MaybeHandle<FixedArray> maybe_indirect_tables =
+      compiled_module->GetValue<FixedArray>(kTableOfIndirectFunctionTables);
+  Handle<FixedArray> indirect_tables;
+  if (maybe_indirect_tables.ToHandle(&indirect_tables)) {
+    for (int i = 0; i < indirect_tables->length(); ++i) {
+      Handle<FixedArray> metadata =
+          indirect_tables->GetValueChecked<FixedArray>(i);
+      uint32_t size = Smi::cast(metadata->get(kSize))->value();
+      Handle<FixedArray> table = metadata->GetValueChecked<FixedArray>(kTable);
+      wasm::PopulateFunctionTable(table, size, &functions);
     }
-    js_object->SetInternalField(kWasmModuleFunctionTable, *indirect_table);
+    js_object->SetInternalField(kWasmModuleFunctionTable, *indirect_tables);
   }
 
   // Run the start function if one was specified.
   MaybeHandle<FixedArray> maybe_startup_fct =
       compiled_module->GetValue<FixedArray>(kStartupFunction);
   Handle<FixedArray> metadata;
   if (maybe_startup_fct.ToHandle(&metadata)) {
     HandleScope scope(isolate);
     Handle<Code> startup_code = metadata->GetValueChecked<Code>(kExportCode);
     int arity = Smi::cast(metadata->get(kExportArity))->value();
@@ skipping 134 matching lines @@
       if (RelocInfo::IsWasmMemoryReference(mode) ||
           RelocInfo::IsWasmMemorySizeReference(mode)) {
         it.rinfo()->update_wasm_memory_reference(old_start, new_start, old_size,
                                                  new_size);
       }
     }
   }
   return true;
 }
 
+Handle<FixedArray> BuildFunctionTable(Isolate* isolate, uint32_t index,
+                                      const WasmModule* module) {
+  const WasmIndirectFunctionTable* table = &module->function_tables[index];
+  DCHECK_EQ(table->size, table->values.size());
+  DCHECK_GE(table->max_size, table->size);
+  Handle<FixedArray> values =
+      isolate->factory()->NewFixedArray(2 * table->max_size);
+  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++) {
+    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();
+    DCHECK_GE(index, 0);
+    DCHECK_LT(static_cast<size_t>(index), code_table->size());
+    table->set(static_cast<int>(i), *(*code_table)[index]);
+  }
+}
+
 int GetNumberOfFunctions(JSObject* wasm) {
   Object* func_names_obj = wasm->GetInternalField(kWasmFunctionNamesArray);
   // TODO(clemensh): this looks inside an array constructed elsewhere. Refactor.
   return ByteArray::cast(func_names_obj)->get_int(0);
 }
 
 namespace testing {
 
 int32_t CompileAndRunWasmModule(Isolate* isolate, const byte* module_start,
                                 const byte* module_end, bool asm_js) {
@@ skipping 62 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