Move GVNExpression DenseMapInfo to GVNExpression.h

[rriddle]

Summary

Make the DenseMapInfo for GVNExpression available outside of NewGVN.

[rriddle]

Going to define a custom DenseMapInfo for my use case for now.

include/llvm/Transforms/Scalar/GVNExpression.h

 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <iterator>
 #include <utility>
 
+struct HashedExpression;
 namespace llvm {
 
 namespace GVNExpression {
 
 enum ExpressionType {
   ET_Base,
   ET_Constant,
   ET_Variable,
if (PrintEType)
       OS << "ExpressionTypeUnknown, ";
     this->Expression::printInternal(OS, false);
     OS << " inst = " << *Inst;
   }
 };
 
 } // end namespace GVNExpression
 
+struct ExactEqualsExpression {
+  const GVNExpression::Expression &E;
+  explicit ExactEqualsExpression(const GVNExpression::Expression &E) : E(E) {}
+  hash_code getComputedHash() const { return E.getComputedHash(); }
+  bool operator==(const GVNExpression::Expression &Other) const {
+    return E.exactlyEquals(Other);
+  }
+};
+
+template <> struct DenseMapInfo<const GVNExpression::Expression *> {
+  static const GVNExpression::Expression *getEmptyKey() {
+    auto Val = static_cast<uintptr_t>(-1);
+    Val <<= PointerLikeTypeTraits<
+      const GVNExpression::Expression *>::NumLowBitsAvailable;
+    return reinterpret_cast<const GVNExpression::Expression *>(Val);
+  }
+  static const GVNExpression::Expression *getTombstoneKey() {
+    auto Val = static_cast<uintptr_t>(~1U);
+    Val <<= PointerLikeTypeTraits<
+      const GVNExpression::Expression *>::NumLowBitsAvailable;
+    return reinterpret_cast<const GVNExpression::Expression *>(Val);
+  }
+  static unsigned getHashValue(const GVNExpression::Expression *E) {
+    return E->getComputedHash();
+  }
+  static unsigned getHashValue(const ExactEqualsExpression &E) {
+    return E.getComputedHash();
+  }
+  static bool isEqual(const ExactEqualsExpression &LHS,
+                      const GVNExpression::Expression *RHS) {
+    if (RHS == getTombstoneKey() || RHS == getEmptyKey())
+      return false;
+    return LHS == *RHS;
+  }
+
+  static bool isEqual(const GVNExpression::Expression *LHS,
+                      const GVNExpression::Expression *RHS) {
+    if (LHS == RHS)
+      return true;
+    if (LHS == getTombstoneKey() || RHS == getTombstoneKey() ||
+      LHS == getEmptyKey() || RHS == getEmptyKey())
+      return false;
+    // Compare hashes before equality.  This is *not* what the hashtable does,
+    // since it is computing it modulo the number of buckets, whereas we are
+    // using the full hash keyspace.  Since the hashes are precomputed, this
+    // check is *much* faster than equality.
+    if (LHS->getComputedHash() != RHS->getComputedHash())
+      return false;
+    return *LHS == *RHS;
+  }
+};
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_GVNEXPRESSION_H

lib/Transforms/Scalar/NewGVN.cpp

private:
   // MemoryUses have real instructions representing them, so we only need to
   // track MemoryPhis here.
   MemoryMemberSet MemoryMembers;
   // Number of stores in this congruence class.
   // This is used so we can detect store equivalence changes properly.
   int StoreCount = 0;
 };
 
-namespace llvm {
-struct ExactEqualsExpression {
-  const Expression &E;
-  explicit ExactEqualsExpression(const Expression &E) : E(E) {}
-  hash_code getComputedHash() const { return E.getComputedHash(); }
-  bool operator==(const Expression &Other) const {
-    return E.exactlyEquals(Other);
-  }
-};
-
-template <> struct DenseMapInfo<const Expression *> {
-  static const Expression *getEmptyKey() {
-    auto Val = static_cast<uintptr_t>(-1);
-    Val <<= PointerLikeTypeTraits<const Expression *>::NumLowBitsAvailable;
-    return reinterpret_cast<const Expression *>(Val);
-  }
-  static const Expression *getTombstoneKey() {
-    auto Val = static_cast<uintptr_t>(~1U);
-    Val <<= PointerLikeTypeTraits<const Expression *>::NumLowBitsAvailable;
-    return reinterpret_cast<const Expression *>(Val);
-  }
-  static unsigned getHashValue(const Expression *E) {
-    return E->getComputedHash();
-  }
-  static unsigned getHashValue(const ExactEqualsExpression &E) {
-    return E.getComputedHash();
-  }
-  static bool isEqual(const ExactEqualsExpression &LHS, const Expression *RHS) {
-    if (RHS == getTombstoneKey() || RHS == getEmptyKey())
-      return false;
-    return LHS == *RHS;
-  }
-
-  static bool isEqual(const Expression *LHS, const Expression *RHS) {
-    if (LHS == RHS)
-      return true;
-    if (LHS == getTombstoneKey() || RHS == getTombstoneKey() ||
-        LHS == getEmptyKey() || RHS == getEmptyKey())
-      return false;
-    // Compare hashes before equality.  This is *not* what the hashtable does,
-    // since it is computing it modulo the number of buckets, whereas we are
-    // using the full hash keyspace.  Since the hashes are precomputed, this
-    // check is *much* faster than equality.
-    if (LHS->getComputedHash() != RHS->getComputedHash())
-      return false;
-    return *LHS == *RHS;
-  }
-};
-} // end namespace llvm
-
 namespace {
 class NewGVN {
   Function &F;
   DominatorTree *DT;
   const TargetLibraryInfo *TLI;
   AliasAnalysis *AA;
   MemorySSA *MSSA;
   MemorySSAWalker *MSSAWalker;