[wasm] Canonicalize function signature indices for matching in indirect calls.

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 2041 matching lines @@
 
 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, TENURED);
   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));
+    int32_t index = table->map.Find(function->sig);
+    DCHECK_GE(index, 0);
+    values->set(i, Smi::FromInt(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));
   }
@@ skipping 203 matching lines @@
   WasmCompiledModule* compiled_module =
       WasmCompiledModule::cast(instance->GetInternalField(kWasmCompiledModule));
   CHECK(compiled_module->has_weak_module_object());
   CHECK(compiled_module->ptr_to_weak_module_object()->cleared());
 }
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8