[wasm] Support undefined indirect table entries, behind a flag.

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 130 matching lines @@
     function_code_[index] = code;
   }
 
   void Link(Handle<FixedArray> function_table,
             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);
+      int indirect_table_size;
+      if (FLAG_wasm_jit_prototype) {
+        indirect_table_size = 4 * table_size < kMinimumIndirectTableSize
+                                  ? kMinimumIndirectTableSize
+                                  : 4 * table_size;
+        DCHECK_EQ(function_table->length(), indirect_table_size);
+      } else {
+        indirect_table_size = 2 * table_size;
+        DCHECK_EQ(function_table->length(), indirect_table_size);
+      }
       for (int i = 0; i < table_size; i++) {
-        function_table->set(i + table_size, *function_code_[functions[i]]);
+        function_table->set(i + indirect_table_size / 2,
+                            *function_code_[functions[i]]);
       }
     }
   }
 
  private:
   static const int kPlaceholderMarker = 1000000000;
 
   Isolate* isolate_;
   std::vector<Handle<Code>> placeholder_code_;
   std::vector<Handle<Code>> function_code_;
@@ skipping 62 matching lines @@
     memcpy(addr, module->module_start + segment.source_offset,
            segment.source_size);
   }
 }
 
 Handle<FixedArray> BuildFunctionTable(Isolate* isolate, WasmModule* module) {
   if (module->function_table.size() == 0) {
     return Handle<FixedArray>::null();
   }
   int table_size = static_cast<int>(module->function_table.size());
-  Handle<FixedArray> fixed = isolate->factory()->NewFixedArray(2 * table_size);
+  int indirect_table_size;
+  if (FLAG_wasm_jit_prototype)
+    indirect_table_size = 4 * table_size < kMinimumIndirectTableSize
+                              ? kMinimumIndirectTableSize
+                              : 4 * table_size;
+  else
+    indirect_table_size = 2 * table_size;
+
+  Handle<FixedArray> fixed =
+      isolate->factory()->NewFixedArray(indirect_table_size);
   for (int i = 0; i < table_size; i++) {
     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) {
   if (size > (WasmModule::kMaxMemPages * WasmModule::kPageSize)) {
@@ skipping 429 matching lines @@
   }
   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);
+  instance.padded_entries =
+      static_cast<int>(instance.function_table->length() / 2) -
+      static_cast<int>(instance.module->function_table.size());
   WasmLinker linker(isolate, functions.size());
   ModuleEnv module_env;
   module_env.module = this;
   module_env.instance = &instance;
   module_env.linker = &linker;
   module_env.origin = origin;
 
   //-------------------------------------------------------------------------
   // Compile wrappers to imported functions.
   //-------------------------------------------------------------------------
@@ skipping 211 matching lines @@
   }
   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);
+  instance.padded_entries =
+      static_cast<int>(instance.function_table->length() / 2) -
+      static_cast<int>(module->function_table.size());
 
   // Create module environment.
   WasmLinker linker(isolate, module->functions.size());
   ModuleEnv module_env;
   module_env.module = module;
   module_env.instance = &instance;
   module_env.linker = &linker;
   module_env.origin = module->origin;
 
   // Compile all functions.
@@ skipping 55 matching lines @@
       wasm->GetInternalField(kWasmFunctionNamesArray), wasm->GetIsolate());
   if (func_names_arr_obj->IsUndefined())
     return func_names_arr_obj;  // Return undefined.
   return GetWasmFunctionNameFromTable(
       Handle<ByteArray>::cast(func_names_arr_obj), func_index);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8