[IRGen] Add hashable conformance to [Stack]Addr.

Provide template instantiations of llvm::DenseMapInfo at
swift::irgen::Address and swift::irgen::StackAddress.

Author: nate-chandler

lib/IRGen/Address.h

@@ -18,12 +18,13 @@
 #define SWIFT_IRGEN_ADDRESS_H
 
 #include "IRGen.h"
-#include "llvm/IR/Value.h"
+#include "llvm/ADT/ilist.h"
 #include "llvm/IR/Argument.h"
+#include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instruction.h"
-#include "llvm/ADT/ilist.h"
-#include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Type.h"
+#include "llvm/IR/Value.h"
 
 namespace swift {
 namespace irgen {
@@ -39,6 +40,9 @@ class Address {
 
   Address(llvm::Value *addr, llvm::Type *elementType, Alignment align)
       : Addr(addr), ElementType(elementType), Align(align) {
+    if (addr == llvm::DenseMapInfo<llvm::Value *>::getEmptyKey() ||
+        llvm::DenseMapInfo<llvm::Value *>::getTombstoneKey())
+      return;
     assert(llvm::cast<llvm::PointerType>(addr->getType())
                ->isOpaqueOrPointeeTypeMatches(elementType) &&
            "Incorrect pointer element type");
@@ -63,6 +67,12 @@ class Address {
   }
 
   llvm::Type *getElementType() const { return ElementType; }
+
+  bool operator==(Address RHS) const {
+    return Addr == RHS.Addr && ElementType == RHS.ElementType &&
+           Align == RHS.Align;
+  }
+  bool operator!=(Address RHS) const { return !(*this == RHS); }
 };
 
 /// An address in memory together with the (possibly null) heap
@@ -139,9 +149,64 @@ class StackAddress {
   llvm::Value *getExtraInfo() const { return ExtraInfo; }
 
   bool isValid() const { return Addr.isValid(); }
+
+  bool operator==(StackAddress RHS) const {
+    return Addr == RHS.Addr && ExtraInfo == RHS.ExtraInfo;
+  }
+  bool operator!=(StackAddress RHS) const { return !(*this == RHS); }
 };
 
 } // end namespace irgen
 } // end namespace swift
 
+namespace llvm {
+template <>
+struct DenseMapInfo<swift::irgen::Address> {
+  static swift::irgen::Address getEmptyKey() {
+    return swift::irgen::Address(DenseMapInfo<llvm::Value *>::getEmptyKey(),
+                                 DenseMapInfo<llvm::Type *>::getEmptyKey(),
+                                 swift::irgen::Alignment(8));
+  }
+  static swift::irgen::Address getTombstoneKey() {
+    return swift::irgen::Address(DenseMapInfo<llvm::Value *>::getTombstoneKey(),
+                                 DenseMapInfo<llvm::Type *>::getTombstoneKey(),
+                                 swift::irgen::Alignment(8));
+  }
+  static unsigned getHashValue(swift::irgen::Address address) {
+    return detail::combineHashValue(
+        DenseMapInfo<llvm::Value *>::getHashValue(address.getAddress()),
+        detail::combineHashValue(
+            DenseMapInfo<llvm::Type *>::getHashValue(address.getElementType()),
+            DenseMapInfo<swift::irgen::Alignment::int_type>::getHashValue(
+                address.getAlignment().getValue())));
+  }
+  static bool isEqual(swift::irgen::Address LHS, swift::irgen::Address RHS) {
+    return LHS == RHS;
+  }
+};
+template <>
+struct DenseMapInfo<swift::irgen::StackAddress> {
+  static swift::irgen::StackAddress getEmptyKey() {
+    return swift::irgen::StackAddress(
+        DenseMapInfo<swift::irgen::Address>::getEmptyKey(),
+        DenseMapInfo<llvm::Value *>::getEmptyKey());
+  }
+  static swift::irgen::StackAddress getTombstoneKey() {
+    return swift::irgen::StackAddress(
+        DenseMapInfo<swift::irgen::Address>::getTombstoneKey(),
+        DenseMapInfo<llvm::Value *>::getTombstoneKey());
+  }
+  static unsigned getHashValue(swift::irgen::StackAddress address) {
+    return detail::combineHashValue(
+        DenseMapInfo<swift::irgen::Address>::getHashValue(address.getAddress()),
+        DenseMapInfo<swift::irgen::Alignment::int_type>::getHashValue(
+            address.getAlignment().getValue()));
+  }
+  static bool isEqual(swift::irgen::StackAddress LHS,
+                      swift::irgen::StackAddress RHS) {
+    return LHS == RHS;
+  }
+};
+} // end namespace llvm
+
 #endif