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

src/wasm/wasm-module.h

 // 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.
 
 #ifndef V8_WASM_MODULE_H_
 #define V8_WASM_MODULE_H_
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/handles.h"
 #include "src/parsing/preparse-data.h"
 
+#include "src/wasm/signature-map.h"
 #include "src/wasm/wasm-opcodes.h"
-#include "src/wasm/wasm-result.h"
 
 namespace v8 {
 namespace internal {
 
 namespace compiler {
 class CallDescriptor;
 class WasmCompilationUnit;
 }
 
 namespace wasm {
+class ErrorThrower;
+
 const size_t kMaxModuleSize = 1024 * 1024 * 1024;
 const size_t kMaxFunctionSize = 128 * 1024;
 const size_t kMaxStringSize = 256;
 const uint32_t kWasmMagic = 0x6d736100;
 const uint32_t kWasmVersion = 0x0c;
 
 const uint8_t kWasmFunctionTypeForm = 0x40;
 const uint8_t kWasmAnyFunctionTypeForm = 0x20;
 
 enum WasmSectionCode {
@@ skipping 91 matching lines @@
   uint32_t source_size;    // end offset in the module bytes.
 };
 
 // Static representation of a wasm indirect call table.
 struct WasmIndirectFunctionTable {
   uint32_t size;                // initial table size.
   uint32_t max_size;            // maximum table size.
   std::vector<int32_t> values;  // function table, -1 indicating invalid.
   bool imported;                // true if imported.
   bool exported;                // true if exported.
+  SignatureMap map;             // canonicalizing map for sig indexes.
 };
 
 // Static representation of how to initialize a table.
 struct WasmTableInit {
   uint32_t table_index;
   WasmInitExpr offset;
   std::vector<uint32_t> entries;
 };
 
 // Static representation of a WASM import.
@@ skipping 185 matching lines @@
   const WasmFunction* function_;
   const WasmModule* module_;
   WasmFunctionName(const WasmFunction* function, const ModuleEnv* menv)
       : function_(function), module_(menv ? menv->module : nullptr) {}
 };
 
 std::ostream& operator<<(std::ostream& os, const WasmModule& module);
 std::ostream& operator<<(std::ostream& os, const WasmFunction& function);
 std::ostream& operator<<(std::ostream& os, const WasmFunctionName& name);
 
-typedef Result<const WasmModule*> ModuleResult;
-typedef Result<WasmFunction*> FunctionResult;
-typedef std::vector<std::pair<int, int>> FunctionOffsets;
-typedef Result<FunctionOffsets> FunctionOffsetsResult;
-
 class WasmCompiledModule : public FixedArray {
  public:
   static WasmCompiledModule* cast(Object* fixed_array) {
     SLOW_DCHECK(IsWasmCompiledModule(fixed_array));
     return reinterpret_cast<WasmCompiledModule*>(fixed_array);
   }
 
 #define WCM_OBJECT_OR_WEAK(TYPE, NAME, ID)                           \
   Handle<TYPE> NAME() const { return handle(ptr_to_##NAME()); }      \
                                                                      \
@@ skipping 191 matching lines @@
                             int instance_count);
 void ValidateModuleState(Isolate* isolate, Handle<JSObject> module_obj);
 void ValidateOrphanedInstance(Isolate* isolate, Handle<JSObject> instance);
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_MODULE_H_