[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 122 matching lines @@
     function_code()[index] = code;
   }
 
   void Link(Handle<FixedArray> function_table,
             const 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

[bradn, 2016/06/16 08:00:20]

I'd thought we'd talked about adding a field to one of the sections?

+                                  ? 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:
   std::vector<Handle<Code>>& function_code() { return *function_code_; }
 
   void CreatePlaceholder(uint32_t index) {
     DCHECK(index < function_code().size());
     DCHECK(function_code()[index].is_null());
@@ skipping 69 matching lines @@
            segment.source_size);
   }
 }
 
 Handle<FixedArray> BuildFunctionTable(Isolate* isolate,
                                       const 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

[bradn, 2016/06/16 08:00:20]

Definitely don't want to repeat this calculation all over.

+                              ? 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++) {
     const 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) {
@@ skipping 482 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, &instance.function_code);
   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 174 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, &instance.function_code);
   ModuleEnv module_env;
   module_env.module = module;
   module_env.instance = &instance;
   module_env.linker = &linker;
   module_env.origin = module->origin;
 
   if (module->export_table.size() == 0) {
@@ skipping 57 matching lines @@
          object->GetInternalField(kWasmModuleCodeTable)->IsFixedArray() &&
          object->GetInternalField(kWasmMemArrayBuffer)->IsJSArrayBuffer() &&
          (object->GetInternalField(kWasmFunctionNamesArray)->IsByteArray() ||
           object->GetInternalField(kWasmFunctionNamesArray)
               ->IsUndefined(object->GetIsolate()));
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8