[wasm] Add support for multiple indirect function tables

src/compiler/wasm-compiler.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/compiler/wasm-compiler.h"
 
 #include <memory>
 
 #include "src/isolate-inl.h"
 
@@ skipping 260 matching lines @@
 };
 
 WasmGraphBuilder::WasmGraphBuilder(
     Zone* zone, JSGraph* jsgraph, wasm::FunctionSig* function_signature,
     compiler::SourcePositionTable* source_position_table)
     : zone_(zone),
       jsgraph_(jsgraph),
       module_(nullptr),
       mem_buffer_(nullptr),
       mem_size_(nullptr),
-      function_table_(nullptr),
+      function_tables_(zone),
       control_(nullptr),
       effect_(nullptr),
       cur_buffer_(def_buffer_),
       cur_bufsize_(kDefaultBufferSize),
       trap_(new (zone) WasmTrapHelper(this)),
       function_signature_(function_signature),
       source_position_table_(source_position_table) {
   DCHECK_NOT_NULL(jsgraph_);
 }
 
@@ skipping 1760 matching lines @@
 Node* WasmGraphBuilder::CallIndirect(uint32_t index, Node** args,
                                      wasm::WasmCodePosition position) {
   DCHECK_NOT_NULL(args[0]);
   DCHECK(module_ && module_->instance);
 
   MachineOperatorBuilder* machine = jsgraph()->machine();
 
   // Compute the code object by loading it from the function table.
   Node* key = args[0];
 
+  // Assume only one table for now.
+  DCHECK_LE(module_->instance->function_tables.size(), 1u);
   // Bounds check the index.
-  int table_size = static_cast<int>(module_->FunctionTableSize());
+  uint32_t table_size =
+      module_->IsValidTable(0) ? module_->GetTable(0)->max_size : 0;
   if (table_size > 0) {
     // Bounds check against the table size.
-    Node* size = Int32Constant(static_cast<int>(table_size));
+    Node* size = Uint32Constant(table_size);
     Node* in_bounds = graph()->NewNode(machine->Uint32LessThan(), key, size);
     trap_->AddTrapIfFalse(wasm::kTrapFuncInvalid, in_bounds, position);
   } else {
     // No function table. Generate a trap and return a constant.
     trap_->AddTrapIfFalse(wasm::kTrapFuncInvalid, Int32Constant(0), position);
     return trap_->GetTrapValue(module_->GetSignature(index));
   }
-  Node* table = FunctionTable();
+  Node* table = FunctionTable(0);
 
   // Load signature from the table and check.
   // The table is a FixedArray; signatures are encoded as SMIs.
   // [sig1, sig2, sig3, ...., code1, code2, code3 ...]
   ElementAccess access = AccessBuilder::ForFixedArrayElement();
   const int fixed_offset = access.header_size - access.tag();
   {
     Node* load_sig = graph()->NewNode(
         machine->Load(MachineType::AnyTagged()), table,
         graph()->NewNode(machine->Int32Add(),
                          graph()->NewNode(machine->Word32Shl(), key,
                                           Int32Constant(kPointerSizeLog2)),
                          Int32Constant(fixed_offset)),
         *effect_, *control_);
     Node* sig_match =
         graph()->NewNode(machine->Word32Equal(),
                          BuildChangeSmiToInt32(load_sig), Int32Constant(index));
     trap_->AddTrapIfFalse(wasm::kTrapFuncSigMismatch, sig_match, position);
   }
 
   // Load code object from the table.
-  int offset = fixed_offset + kPointerSize * table_size;
+  uint32_t offset = fixed_offset + kPointerSize * table_size;
   Node* load_code = graph()->NewNode(
       machine->Load(MachineType::AnyTagged()), table,
       graph()->NewNode(machine->Int32Add(),
                        graph()->NewNode(machine->Word32Shl(), key,
                                         Int32Constant(kPointerSizeLog2)),
-                       Int32Constant(offset)),
+                       Uint32Constant(offset)),
       *effect_, *control_);
 
   args[0] = load_code;
   wasm::FunctionSig* sig = module_->GetSignature(index);
   return BuildWasmCall(sig, args, position);
 }
 
 Node* WasmGraphBuilder::JITSingleFunction(Node* const base, Node* const length,
                                           Node* const index,
                                           const uint32_t sig_index,
@@ skipping 11 matching lines @@
     trap_->AddTrapIfTrue(wasm::kTrapFuncInvalid, length_negative, position);
 
     Node* in_bounds = graph()->NewNode(
         machine->Uint32LessThanOrEqual(),
         graph()->NewNode(machine->Int32Add(), base, length), MemSize(0));
     trap_->AddTrapIfFalse(wasm::kTrapMemOutOfBounds, in_bounds, position);
   }
 
   // Bounds check the index.
   {
-    int table_size = static_cast<int>(module_->FunctionTableSize());
+    // Assume only one table for now.
+    DCHECK_LE(module_->instance->function_tables.size(), 1u);
+    uint32_t table_size =
+        module_->IsValidTable(0) ? module_->GetTable(0)->max_size : 0;
     if (table_size > 0) {
       // Bounds check against the table size.
-      Node* size = Int32Constant(static_cast<int>(table_size));
+      Node* size = Uint32Constant(table_size);
       Node* in_bounds =
           graph()->NewNode(machine->Uint32LessThan(), index, size);
       trap_->AddTrapIfFalse(wasm::kTrapInvalidIndex, in_bounds, position);
     } else {
       // No function table. Generate a trap and return a constant.
       trap_->AddTrapIfFalse(wasm::kTrapFuncInvalid, Int32Constant(0), position);
       return trap_->GetTrapValue(module_->GetSignature(sig_index));
     }
   }
 
   const size_t runtime_input_params = 7;
   const size_t runtime_env_params = 5;
 
   Runtime::FunctionId f = Runtime::kJITSingleFunction;
   const Runtime::Function* fun = Runtime::FunctionForId(f);
   // CEntryStubConstant nodes have to be created and cached in the main
   // thread. At the moment this is only done for CEntryStubConstant(1).
   DCHECK_EQ(1, fun->result_size);
   const uint32_t return_count = static_cast<uint32_t>(sig->return_count());
   const uint32_t parameter_count =
       static_cast<uint32_t>(sig->parameter_count());
 
   const uint32_t inputs_size = runtime_input_params + runtime_env_params +
                                return_count + parameter_count;
   Node** inputs = Buffer(inputs_size);
   inputs[0] = jsgraph()->CEntryStubConstant(fun->result_size);
   inputs[1] = BuildChangeUint32ToSmi(base);
   inputs[2] = BuildChangeUint32ToSmi(length);
   inputs[3] = BuildChangeUint32ToSmi(index);
-  inputs[4] = FunctionTable();
+  inputs[4] = FunctionTable(0);
   inputs[5] = Uint32Constant(sig_index);
   inputs[6] = BuildChangeUint32ToSmi(Uint32Constant(return_count));
 
   // Pass in parameters and return types in to the runtime function
   // to allow it to regenerate signature
   for (uint32_t i = 0; i < return_count; ++i) {
     inputs[i + runtime_input_params] = BuildChangeUint32ToSmi(
         Uint32Constant(static_cast<int>(sig->GetReturn(i))));
   }
 
@@ skipping 621 matching lines @@
         size + offset, RelocInfo::WASM_MEMORY_SIZE_REFERENCE);
   }
 }
 
 Node* WasmGraphBuilder::DefaultS128Value() {
   Node* zero = jsgraph()->Int32Constant(0);
   return graph()->NewNode(jsgraph()->machine()->CreateInt32x4(), zero, zero,
                           zero, zero);
 }
 
-Node* WasmGraphBuilder::FunctionTable() {
+Node* WasmGraphBuilder::FunctionTable(uint32_t index) {
   DCHECK(module_ && module_->instance &&
-         !module_->instance->function_table.is_null());
-  if (!function_table_) {
-    function_table_ = HeapConstant(module_->instance->function_table);
+         index < module_->instance->function_tables.size());
+  if (!function_tables_.size()) {
+    for (size_t i = 0; i < module_->instance->function_tables.size(); ++i) {
+      DCHECK(!module_->instance->function_tables[i].is_null());
+      function_tables_.push_back(
+          HeapConstant(module_->instance->function_tables[i]));
+    }
   }
-  return function_table_;
+  return function_tables_[index];
 }
 
 Node* WasmGraphBuilder::ChangeToRuntimeCall(Node* node,
                                             Runtime::FunctionId function_id,
                                             Signature<Conversion>* signature) {
   SimplifiedOperatorBuilder simplified(jsgraph()->zone());
   const Runtime::Function* function = Runtime::FunctionForId(function_id);
   CallDescriptor* desc = Linkage::GetRuntimeCallDescriptor(
       jsgraph()->zone(), function_id, function->nargs, Operator::kNoProperties,
       CallDescriptor::kNoFlags);
@@ skipping 640 matching lines @@
                             function_->code_start_offset),
            compile_ms);
   }
 
   return code;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8