[base] Remove PointersMatch, making a separate std::equals hashmap

src/base/hashmap.h

 // Copyright 2012 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.
 
 // The reason we write our own hash map instead of using unordered_map in STL,
 // is that STL containers use a mutex pool on debug build, which will lead to
 // deadlock when we are using async signal handler.
 
 #ifndef V8_BASE_HASHMAP_H_
 #define V8_BASE_HASHMAP_H_
@@ skipping 18 matching lines @@
  public:
   typedef TemplateHashMapEntry<Key, Value> Entry;
 
   // The default capacity.  This is used by the call sites which want
   // to pass in a non-default AllocationPolicy but want to use the
   // default value of capacity specified by the implementation.
   static const uint32_t kDefaultHashMapCapacity = 8;
 
   // initial_capacity is the size of the initial hash map;
   // it must be a power of 2 (and thus must not be 0).
-  TemplateHashMapImpl(MatchFun match = MatchFun(),
-                      uint32_t capacity = kDefaultHashMapCapacity,
+  TemplateHashMapImpl(uint32_t capacity = kDefaultHashMapCapacity,
+                      MatchFun match = MatchFun(),
                       AllocationPolicy allocator = AllocationPolicy());
 
   ~TemplateHashMapImpl();
 
   // If an entry with matching key is found, returns that entry.
   // Otherwise, nullptr is returned.
   Entry* Lookup(const Key& key, uint32_t hash) const;
 
   // If an entry with matching key is found, returns that entry.
   // If no matching entry is found, a new entry is inserted with
@@ skipping 28 matching lines @@
   //
   // If entries are inserted during iteration, the effect of
   // calling Next() is undefined.
   Entry* Start() const;
   Entry* Next(Entry* entry) const;
 
  private:
   Entry* map_;
   uint32_t capacity_;
   uint32_t occupancy_;
+  // TODO(leszeks): This takes up space even if it has no state, maybe replace
+  // with something that does the empty base optimisation e.g. std::tuple
   MatchFun match_;
 
   Entry* map_end() const { return map_ + capacity_; }
   Entry* Probe(const Key& key, uint32_t hash) const;
   Entry* FillEmptyEntry(Entry* entry, const Key& key, const Value& value,
                         uint32_t hash,
                         AllocationPolicy allocator = AllocationPolicy());
   void Initialize(uint32_t capacity, AllocationPolicy allocator);
   void Resize(AllocationPolicy allocator);
 };
 template <typename Key, typename Value, typename MatchFun,
           class AllocationPolicy>
 TemplateHashMapImpl<Key, Value, MatchFun, AllocationPolicy>::
-    TemplateHashMapImpl(MatchFun match, uint32_t initial_capacity,
+    TemplateHashMapImpl(uint32_t initial_capacity, MatchFun match,
                         AllocationPolicy allocator)
     : match_(match) {
   Initialize(initial_capacity, allocator);
 }
 
 template <typename Key, typename Value, typename MatchFun,
           class AllocationPolicy>
 TemplateHashMapImpl<Key, Value, MatchFun,
                     AllocationPolicy>::~TemplateHashMapImpl() {
   AllocationPolicy::Delete(map_);
@@ skipping 199 matching lines @@
                                  entry->hash, allocator);
       n--;
     }
   }
 
   // Delete old map.
   AllocationPolicy::Delete(map);
 }
 
 template <typename AllocationPolicy>
-class PointerTemplateHashMapImpl
+class CustomMatcherTemplateHashMapImpl
     : public TemplateHashMapImpl<void*, void*, bool (*)(void*, void*),
                                  AllocationPolicy> {
   typedef TemplateHashMapImpl<void*, void*, bool (*)(void*, void*),
                               AllocationPolicy>
       Base;
 
  public:
   typedef bool (*MatchFun)(void*, void*);
 
-  PointerTemplateHashMapImpl(MatchFun match = PointersMatch,
-                             uint32_t capacity = Base::kDefaultHashMapCapacity,
+  CustomMatcherTemplateHashMapImpl(
+      MatchFun match, uint32_t capacity = Base::kDefaultHashMapCapacity,
+      AllocationPolicy allocator = AllocationPolicy())
+      : Base(capacity, match, allocator) {}
+};
+
+typedef CustomMatcherTemplateHashMapImpl<DefaultAllocationPolicy>
+    CustomMatcherHashMap;
+
+template <typename AllocationPolicy>
+class PointerTemplateHashMapImpl
+    : public TemplateHashMapImpl<void*, void*, std::equal_to<void*>,
+                                 AllocationPolicy> {
+  typedef TemplateHashMapImpl<void*, void*, std::equal_to<void*>,
+                              AllocationPolicy>
+      Base;
+
+ public:
+  PointerTemplateHashMapImpl(uint32_t capacity = Base::kDefaultHashMapCapacity,
                              AllocationPolicy allocator = AllocationPolicy())
-      : Base(match, capacity, allocator) {}
-
-  static bool PointersMatch(void* key1, void* key2) { return key1 == key2; }
+      : Base(capacity, std::equal_to<void*>(), allocator) {}
 };
 
 typedef PointerTemplateHashMapImpl<DefaultAllocationPolicy> HashMap;
 
 // A hash map for pointer keys and values with an STL-like interface.
-template <class Key, class Value, class AllocationPolicy>
-class TemplateHashMap : private PointerTemplateHashMapImpl<AllocationPolicy> {
-  typedef PointerTemplateHashMapImpl<AllocationPolicy> Base;
+template <class Key, class Value, class MatchFun, class AllocationPolicy>
+class TemplateHashMap
+    : private TemplateHashMapImpl<void*, void*, MatchFun, AllocationPolicy> {
+  typedef TemplateHashMapImpl<void*, void*, MatchFun, AllocationPolicy> Base;
 
  public:
-  typedef bool (*MatchFun)(void*, void*);
-
   STATIC_ASSERT(sizeof(Key*) == sizeof(void*));    // NOLINT
   STATIC_ASSERT(sizeof(Value*) == sizeof(void*));  // NOLINT
   struct value_type {
     Key* first;
     Value* second;
   };
 
   class Iterator {
    public:
     Iterator& operator++() {
       entry_ = map_->Next(entry_);
       return *this;
     }
 
     value_type* operator->() { return reinterpret_cast<value_type*>(entry_); }
     bool operator!=(const Iterator& other) { return entry_ != other.entry_; }
 
    private:
     Iterator(const Base* map, typename Base::Entry* entry)
         : map_(map), entry_(entry) {}
 
     const Base* map_;
     typename Base::Entry* entry_;
 
     friend class TemplateHashMap;
   };
 
   TemplateHashMap(MatchFun match,
                   AllocationPolicy allocator = AllocationPolicy())
-      : Base(match, Base::kDefaultHashMapCapacity, allocator) {}
+      : Base(Base::kDefaultHashMapCapacity, match, allocator) {}
 
   Iterator begin() const { return Iterator(this, this->Start()); }
   Iterator end() const { return Iterator(this, nullptr); }
   Iterator find(Key* key, bool insert = false,
                 AllocationPolicy allocator = AllocationPolicy()) {
     if (insert) {
       return Iterator(this, this->LookupOrInsert(key, key->Hash(), allocator));
     }
     return Iterator(this, this->Lookup(key, key->Hash()));
   }
 };
 
 }  // namespace base
 }  // namespace v8
 
 #endif  // V8_BASE_HASHMAP_H_