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

src/wasm/signature-map.h

Index: src/wasm/signature-map.h
diff --git a/src/wasm/signature-map.h b/src/wasm/signature-map.h
new file mode 100644
index 0000000000000000000000000000000000000000..7c9b6f5e8b2bddd57b91417ac84e2eff1357f978
--- /dev/null
+++ b/src/wasm/signature-map.h
@@ -0,0 +1,40 @@
+// Copyright 2016 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_SIGNATURE_MAP_H_
+#define V8_WASM_SIGNATURE_MAP_H_
+
+#include <map>
+
+#include "src/signature.h"
+#include "src/wasm/wasm-opcodes.h"
+
+namespace v8 {
+namespace internal {
+namespace wasm {
+
+// A signature map canonicalizes signatures into a range of indices so that
+// two different {FunctionSig} instances with the same contents map to the
+// same index.
+class SignatureMap {
+ public:
+  // Gets the index for a signature, assigning a new index if necessary.
+  uint32_t Get(FunctionSig* sig);
+
+  // Gets the index for a signature, returning {-1} if not found.
+  int32_t Find(FunctionSig* sig) const;
+
+ private:
+  struct CompareFunctionSigs {
+    bool operator()(FunctionSig* a, FunctionSig* b) const;
+  };
+  uint32_t next_;
+  std::map<FunctionSig*, uint32_t, CompareFunctionSigs> map_;

[Clemens Hammacher, 2016/10/10 17:35:02]

Depending on the size of the map, an std::unordered_map can be much faster.
Defining Hash and Equals should not be much harder than defining Compare.

[titzer, 2016/10/10 17:45:21]

I've added a TODO here (since it was much easier to copy the previous
well-tested implementation from wasm-module-builder.cc).

+};
+
+}  // namespace wasm
+}  // namespace internal
+}  // namespace v8
+
+#endif  // V8_WASM_SIGNATURE_MAP_H_