Refactor hashing (#3023)

* Unifies internal hashing helpers to naturally integrate with std::hash
* Removes the previous custom implementation
* Computed hashes are now always size_t
* Introduces a hash_combine helper
* Fixes an overwritten partial hash in Relooper.cpp

1 files changed, 8 insertions, 8 deletions

diff --git a/src/passes/CodeFolding.cpp b/src/passes/CodeFolding.cpp
index 04819a04d..ee54c50a6 100644
--- a/src/passes/CodeFolding.cpp
+++ b/src/passes/CodeFolding.cpp
@@ -606,25 +606,25 @@ private:
     if (next.size() >= 2) {
       // now we want to find a mergeable item - any item that is equal among a
       // subset
-      std::map<Expression*, HashType> hashes; // expression => hash value
+      std::map<Expression*, size_t> hashes; // expression => hash value
       // hash value => expressions with that hash
-      std::map<HashType, std::vector<Expression*>> hashed;
+      std::map<size_t, std::vector<Expression*>> hashed;
       for (auto& tail : next) {
         auto* item = getItem(tail, num);
         auto hash = hashes[item] = ExpressionAnalyzer::hash(item);
         hashed[hash].push_back(item);
       }
       // look at each hash value exactly once. we do this in a deterministic
-      // order.
-      std::set<HashType> seen;
+      // order by iterating over a vector retaining insertion order.
+      std::set<size_t> seen;
       for (auto& tail : next) {
         auto* item = getItem(tail, num);
-        auto hash = hashes[item];
-        if (seen.count(hash)) {
+        auto digest = hashes[item];
+        if (seen.count(digest)) {
           continue;
         }
-        seen.insert(hash);
-        auto& items = hashed[hash];
+        seen.insert(digest);
+        auto& items = hashed[digest];
         if (items.size() == 1) {
           continue;
         }