Implement Tuple Hashable Conformance

Azoy · Azoy · commit 4ff28f2b4091 · 2020-10-22T18:28:02.000-04:00
diff --git a/include/swift/Runtime/BuiltinProtocolConformances.h b/include/swift/Runtime/BuiltinProtocolConformances.h
@@ -112,6 +112,45 @@ bool _swift_tupleComparable_greaterThan(OpaqueValue *tuple1, OpaqueValue *tuple2
                                         SWIFT_CONTEXT Metadata *swiftSelf,
                                         Metadata *Self, void *witnessTable);
 
+//===----------------------------------------------------------------------===//
+// Tuple Hashable Conformance
+//===----------------------------------------------------------------------===//
+
+// public protocol Hashable {}
+#define SWIFT_HASHABLE_MANGLING SH
+
+#define HASHABLE_DESCRIPTOR PROTOCOL_DESCRIPTOR_SYM(SWIFT_HASHABLE_MANGLING)
+
+#define HASHABLE_DESCRIPTOR_SYMBOL SYMBOL("$sSHMp")
+
+// Swift._hashValue<A where A: Swift.Hashable>(for: A) -> Swift.Int
+#define SWIFT_HASHVALUE_FUNC $ss10_hashValue3forSix_tSHRzlF
+// Swift.Hasher.combine<A where A: Swift.Hashable>(A) -> ()
+#define SWIFT_HASHER_COMBINE_FUNC $ss6HasherV7combineyyxSHRzlF
+
+#define HASHABLE_BASE_CONFORMANCE_DESCRIPTOR SYMBOL("$sSHSQTb")
+#define HASHABLE_HASHVALUE_METHOD_DESCRIPTOR SYMBOL("$sSH9hashValueSivgTq")
+#define HASHABLE_HASH_METHOD_DESCRIPTOR SYMBOL("$sSH4hash4intoys6HasherVz_tFTq")
+#define HASHABLE_RAWHASHVALUE_METHOD_DESCRIPTOR \
+          SYMBOL("$sSH13_rawHashValue4seedS2i_tFTq")
+
+#define TUPLE_HASHABLE_CONF SYMBOL("_swift_tupleHashable_conf")
+#define TUPLE_HASHABLE_HASHVALUE SYMBOL("_swift_tupleHashable_hashValue")
+#define TUPLE_HASHABLE_HASH SYMBOL("_swift_tupleHashable_hash")
+
+/// The protocol witness for Swift.Hashable.hashValue.getter: Swift.Int in
+/// conformance (A...): Swift.Hashable in Swift.
+SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+intptr_t _swift_tupleHashable_hashValue(SWIFT_CONTEXT OpaqueValue *tuple,
+                                        Metadata *Self, void *witnessTable);
+
+/// The protocol witness for Swift.Hashable.hash(into:) in conformance
+/// (A...): Swift.Hashable in Swift.
+SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+void _swift_tupleHashable_hash(OpaqueValue *hasher,
+                               SWIFT_CONTEXT OpaqueValue *tuple,
+                               Metadata *Self, void *witnessTable);
+
 } // end namespace swift
 
 #endif
diff --git a/lib/AST/Module.cpp b/lib/AST/Module.cpp
@@ -1014,12 +1014,13 @@ LookupConformanceInModuleRequest::evaluate(
     return ProtocolConformanceRef(protocol);
 
   // Tuples have builtin conformances implemented within the runtime.
-  // These conformances so far consist of Equatable and Comparable.
+  // These conformances so far consist of Equatable, Comparable, and Hashable.
   if (auto tuple = type->getAs<TupleType>()) {
     auto equatable = ctx.getProtocol(KnownProtocolKind::Equatable);
     auto comparable = ctx.getProtocol(KnownProtocolKind::Comparable);
+    auto hashable = ctx.getProtocol(KnownProtocolKind::Hashable);
 
-    if (protocol != equatable && protocol != comparable)
+    if (protocol != equatable && protocol != comparable && protocol != hashable)
       return ProtocolConformanceRef::forInvalid();
 
     SmallVector<ProtocolConformanceRef, 4> elementConformances;
diff --git a/lib/IRGen/IRGenMangler.cpp b/lib/IRGen/IRGenMangler.cpp
@@ -157,6 +157,7 @@ std::string IRGenMangler::mangleProtocolConformanceDescriptor(
     if (conformance->getType()->is<TupleType>()) {
       auto equatable = ctx.getProtocol(KnownProtocolKind::Equatable);
       auto comparable = ctx.getProtocol(KnownProtocolKind::Comparable);
+      auto hashable = ctx.getProtocol(KnownProtocolKind::Hashable);
 
       if (conformance->getProtocol() == equatable) {
         return "_swift_tupleEquatable_conf";
@@ -166,6 +167,10 @@ std::string IRGenMangler::mangleProtocolConformanceDescriptor(
         return "_swift_tupleComparable_conf";
       }
 
+      if (conformance->getProtocol() == hashable) {
+        return "_swift_tupleHashable_conf";
+      }
+
       llvm_unreachable("mangling conformance descriptor for unknown tuple \
                         protocol");
     }
diff --git a/stdlib/public/runtime/BuiltinProtocolConformances.cpp b/stdlib/public/runtime/BuiltinProtocolConformances.cpp
@@ -608,3 +608,203 @@ bool swift::_swift_tupleComparable_greaterThan(OpaqueValue *tuple1,
   // each other.
   return false;
 }
+
+//===----------------------------------------------------------------------===//
+// Tuple Hashable Conformance
+//===----------------------------------------------------------------------===//
+
+#if defined(__ELF__)
+// Create a GOT equivalent for the Hashable reference.
+__asm(
+  "  .type got." HASHABLE_DESCRIPTOR_SYMBOL ", @object\n"
+  "  .section .data.rel.ro\n"
+  "  .p2align 3\n"
+  "got." HASHABLE_DESCRIPTOR_SYMBOL ":\n"
+  "  .quad (" HASHABLE_DESCRIPTOR_SYMBOL ")\n"
+  "  .size got." HASHABLE_DESCRIPTOR_SYMBOL ", 8\n"
+);
+
+// Create a GOT equivalent for the Hashable base conformance to Equatable.
+__asm(
+  "  .type got." HASHABLE_BASE_CONFORMANCE_DESCRIPTOR ", @object\n"
+  "  .p2align 3\n"
+  "got." HASHABLE_BASE_CONFORMANCE_DESCRIPTOR ":\n"
+  "  .quad (" HASHABLE_BASE_CONFORMANCE_DESCRIPTOR ")\n"
+  "  .size got." HASHABLE_BASE_CONFORMANCE_DESCRIPTOR ", 8\n"
+);
+
+// Create a GOT equivalent for the Hashable.hashValue method descriptor.
+__asm(
+  "  .type got." HASHABLE_HASHVALUE_METHOD_DESCRIPTOR ", @object\n"
+  "  .p2align 3\n"
+  "got." HASHABLE_HASHVALUE_METHOD_DESCRIPTOR ":\n"
+  "  .quad (" HASHABLE_HASHVALUE_METHOD_DESCRIPTOR ")\n"
+  "  .size got." HASHABLE_HASHVALUE_METHOD_DESCRIPTOR ", 8\n"
+);
+
+// Create a GOT equivalent for the Hashable.hash(into:) method descriptor.
+__asm(
+  "  .type got." HASHABLE_HASH_METHOD_DESCRIPTOR ", @object\n"
+  "  .p2align 3\n"
+  "got." HASHABLE_HASH_METHOD_DESCRIPTOR ":\n"
+  "  .quad (" HASHABLE_HASH_METHOD_DESCRIPTOR ")\n"
+  "  .size got." HASHABLE_HASH_METHOD_DESCRIPTOR ", 8\n"
+);
+
+// Create a GOT equivalent for the Hashable._rawHashValue method descriptor.
+__asm(
+  "  .type got." HASHABLE_RAWHASHVALUE_METHOD_DESCRIPTOR ", @object\n"
+  "  .p2align 3\n"
+  "got." HASHABLE_RAWHASHVALUE_METHOD_DESCRIPTOR ":\n"
+  "  .quad (" HASHABLE_RAWHASHVALUE_METHOD_DESCRIPTOR ")\n"
+  "  .size got." HASHABLE_RAWHASHVALUE_METHOD_DESCRIPTOR ", 8\n"
+);
+#endif
+
+// Define the conformance descriptor for tuple Hashable. We do this in
+// assembly to work around relative reference issues.
+__asm(
+  #if defined(__ELF__)
+  "  .type __swift_tupleHashable_private, @object\n"
+  "  .local __swift_tupleHashable_private\n"
+  "  .comm __swift_tupleHashable_private, 128, 16\n"
+  "  .protected " TUPLE_HASHABLE_CONF "\n"
+  "  .type " TUPLE_HASHABLE_CONF ", @object\n"
+  "  .section .rodata\n"
+  #elif defined(__MACH__)
+  "  .zerofill __DATA, __bss, __swift_tupleHashable_private, 128, 4\n"
+  "  .section __TEXT, __const\n"
+  #endif
+  "  .globl " TUPLE_HASHABLE_CONF "\n"
+  "  .p2align 2\n"
+  TUPLE_HASHABLE_CONF ":\n"
+  #if defined(__ELF__)
+  // This is an indirectable relative reference to the GOT equivalent for the
+  // Hashable protocol descriptor, hence why we add 1 to indicate indirect.
+  "  .long (got." HASHABLE_DESCRIPTOR_SYMBOL " - \
+              (" TUPLE_HASHABLE_CONF ")) + 1\n"
+  #elif defined(__MACH__)
+  "  .long " HASHABLE_DESCRIPTOR_SYMBOL "@GOTPCREL + 5\n"
+  #endif
+  // 769 is the MetadataKind::Tuple
+  "  .long 769\n"
+  // This indicates that we have no witness table pattern. We use a generic
+  // witness table for builtin conformances.
+  "  .long 0\n"
+  // 196640 are the ConformanceFlags with the type reference bit set to
+  // MetadataKind, the has resilient witness bit, and the generic witness table
+  // bit.
+  "  .long 196640\n"
+  // This 4 is the ResilientWitnessesHeader indicating we have 4 resilient
+  // witnesses.
+  "  .long 4\n"
+  #if defined(__ELF__)
+  // This is an indirectable relative reference to the GOT equivalent for the
+  // Hashable base conformance for Equatable, hence why we add 1 to indicate
+  // indirect.
+  "  .long ((got." HASHABLE_BASE_CONFORMANCE_DESCRIPTOR " - \
+              (" TUPLE_HASHABLE_CONF ")) - 20) + 1\n"
+  #elif defined(__MACH__)
+  "  .long " HASHABLE_BASE_CONFORMANCE_DESCRIPTOR "@GOTPCREL + 5\n"
+  #endif
+  // This is a direct relative reference to the associated conformance for
+  // Equatable defined above in assembly. NOTE: We intentionally use the
+  // Comparable implementation for this because the implementation is the same
+  // for both Hashable and Comparable. Both want to grab the Equatable table
+  // from its elements whose witness table is located in the same place for both
+  // protocols. NOTE: This is minus 23 because the associated conformance
+  // structure is 1 aligned.
+  "  .long ((\"" TUPLE_COMPARABLE_ASSOCIATEDCONFORMANCE "\") - \
+            (" TUPLE_HASHABLE_CONF ")) - 23\n"
+  #if defined(__ELF__)
+  // This is an indirectable relative reference to the GOT equivalent for the
+  // Hashable.hashValue method descriptor, hence why we add 1 to indicate
+  // indirect.
+  "  .long ((got." HASHABLE_HASHVALUE_METHOD_DESCRIPTOR " - \
+              (" TUPLE_HASHABLE_CONF ")) - 28) + 1\n"
+  #elif defined(__MACH__)
+  "  .long " HASHABLE_HASHVALUE_METHOD_DESCRIPTOR "@GOTPCREL + 5\n"
+  #endif
+  // This is a direct relative reference to the hashValue witness defined below.
+  "  .long ((" TUPLE_HASHABLE_HASHVALUE ") - (" TUPLE_HASHABLE_CONF ")) - 32\n"
+  #if defined(__ELF__)
+  // This is an indirectable relative reference to the GOT equivalent for the
+  // Hashable.hash(into:) method descriptor, hence why we add 1 to indicate
+  // indirect.
+  "  .long ((got." HASHABLE_HASH_METHOD_DESCRIPTOR " - \
+              (" TUPLE_HASHABLE_CONF ")) - 36) + 1\n"
+  #elif defined(__MACH__)
+  "  .long " HASHABLE_HASH_METHOD_DESCRIPTOR "@GOTPCREL + 5\n"
+  #endif
+  // This is a direct relative reference to the hash(into:) witness defined below.
+  "  .long ((" TUPLE_HASHABLE_HASH ") - (" TUPLE_HASHABLE_CONF ")) - 40\n"
+  #if defined(__ELF__)
+  // This is an indirectable relative reference to the GOT equivalent for the
+  // Hashable._rawHashValue method descriptor, hence why we add 1 to indicate
+  // indirect.
+  "  .long ((got." HASHABLE_RAWHASHVALUE_METHOD_DESCRIPTOR " - \
+              (" TUPLE_HASHABLE_CONF ")) - 44) + 1\n"
+  #elif defined(__MACH__)
+  "  .long " HASHABLE_RAWHASHVALUE_METHOD_DESCRIPTOR "@GOTPCREL + 5\n"
+  #endif
+  // This 0 indicates that we are requesting the default implementation for the
+  // _rawHashValue getter.
+  "  .long 0\n"
+  // The witness table size in words.
+  "  .short 0\n"
+  // The witness table private size in words & requires instantiation.
+  "  .short 1\n"
+  // The witness table instantiator function.
+  "  .long 0\n"
+  // This is a direct relative reference to the private data for the
+  // conformance.
+  "  .long (__swift_tupleHashable_private - (" TUPLE_HASHABLE_CONF ")) - 60\n"
+  #if defined(__ELF__)
+  "  .size " TUPLE_HASHABLE_CONF ", 64\n"
+  #endif
+);
+
+// These are all function values that we reinterpret later.
+extern void *SWIFT_HASHVALUE_FUNC;
+extern void *SWIFT_HASHER_COMBINE_FUNC;
+
+using HashValueFn = SWIFT_CC(swift) intptr_t(OpaqueValue *value, Metadata *Self,
+                                             void *witnessTable);
+using HasherCombineFn = SWIFT_CC(swift) void(OpaqueValue *value,
+                                             const Metadata *Self,
+                                             const WitnessTable *witnessTable,
+                                             SWIFT_CONTEXT OpaqueValue *hasher);
+
+SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+intptr_t _swift_tupleHashable_hashValue(SWIFT_CONTEXT OpaqueValue *tuple,
+                                        Metadata *Self, void *witnessTable) {
+  auto _hashValue = reinterpret_cast<HashValueFn *>(&SWIFT_HASHVALUE_FUNC);
+  return _hashValue(tuple, Self, witnessTable);
+}
+
+SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+void _swift_tupleHashable_hash(OpaqueValue *hasher,
+                               SWIFT_CONTEXT OpaqueValue *tuple,
+                               Metadata *Self, void *witnessTable) {
+  auto tupleTy = cast<TupleTypeMetadata>(Self);
+  auto table = reinterpret_cast<void**>(witnessTable);
+
+  // Loop through all elements and hash them into the Hasher.
+  for (size_t i = 0; i != tupleTy->NumElements; i += 1) {
+    auto elt = tupleTy->getElement(i);
+
+    // Get the element conformance from the private data in the witness table.
+    auto conformance = reinterpret_cast<const WitnessTable *>(table[-1 - i]);
+
+    // Get the element value from the tuple.
+    auto value = reinterpret_cast<OpaqueValue *>(
+                  reinterpret_cast<char *>(tuple) + elt.Offset);
+
+    auto hasherCombine = 
+        reinterpret_cast<HasherCombineFn *>(&SWIFT_HASHER_COMBINE_FUNC);
+
+    // Call the combine function on the hasher for this element value and we're
+    // done!
+    hasherCombine(value, elt.Type, conformance, hasher);
+  }
+}
diff --git a/stdlib/public/runtime/ProtocolConformance.cpp b/stdlib/public/runtime/ProtocolConformance.cpp
@@ -378,16 +378,18 @@ searchInConformanceCache(const Metadata *type,
 
 extern const ProtocolDescriptor EQUATABLE_DESCRIPTOR;
 extern const ProtocolDescriptor COMPARABLE_DESCRIPTOR;
+extern const ProtocolDescriptor HASHABLE_DESCRIPTOR;
 
 static bool tupleConformsToProtocol(const Metadata *type,
                                     const ProtocolDescriptor *protocol) {
   auto tuple = cast<TupleTypeMetadata>(type);
 
-  // At the moment, tuples can only conform to Equatable and Comparable, so
-  // reject all other protocols.
+  // At the moment, tuples can only conform to Equatable, Comparable and
+  // Hashable, so reject all other protocols.
   auto equatable = &EQUATABLE_DESCRIPTOR;
   auto comparable = &COMPARABLE_DESCRIPTOR;
-  if (protocol != equatable && protocol != comparable)
+  auto hashable = &HASHABLE_DESCRIPTOR;
+  if (protocol != equatable && protocol != comparable && protocol != hashable)
     return false;
 
   for (size_t i = 0; i != tuple->NumElements; i += 1) {
@@ -401,6 +403,7 @@ static bool tupleConformsToProtocol(const Metadata *type,
 
 extern const ProtocolConformanceDescriptor _swift_tupleEquatable_conf;
 extern const ProtocolConformanceDescriptor _swift_tupleComparable_conf;
+extern const ProtocolConformanceDescriptor _swift_tupleHashable_conf;
 
 static const ProtocolConformanceDescriptor *getTupleConformanceDescriptor(
                                            const ProtocolDescriptor *protocol) {
@@ -412,6 +415,10 @@ static const ProtocolConformanceDescriptor *getTupleConformanceDescriptor(
     return &_swift_tupleComparable_conf;
   }
 
+  if (protocol == &HASHABLE_DESCRIPTOR) {
+    return &_swift_tupleHashable_conf;
+  }
+
   return nullptr;
 }
 
diff --git a/test/IRGen/builtin_conformances.swift b/test/IRGen/builtin_conformances.swift
@@ -2,6 +2,7 @@
 
 // CHECK-LABEL: @_swift_tupleEquatable_conf = external global %swift.protocol_conformance_descriptor
 // CHECK-LABEL: @_swift_tupleComparable_conf = external global %swift.protocol_conformance_descriptor
+// CHECK-LABEL: @_swift_tupleHashable_conf = external global %swift.protocol_conformance_descriptor
 
 struct Wrapper<T> {
   let value: T
@@ -60,3 +61,28 @@ public func testTupleComparable() {
   // CHECK: {{%.*}} = call swiftcc i1 {{.*}}({{%.*}}.1* noalias nocapture undef, {{%.*}}.1* noalias nocapture undef, %swift.type* getelementptr inbounds (%swift.full_type, %swift.full_type* @"$sytN", i32 0, i32 1), i8** [[TEST_TUPLE_COMPARABLE_WT1]])
   let _ = Wrapper(value: ()) < Wrapper(value: ())
 }
+
+//===----------------------------------------------------------------------===//
+// Tuple Hashable conformance
+//===----------------------------------------------------------------------===//
+
+extension Wrapper: Hashable where T: Hashable {}
+
+public func hashValue<T: Hashable>(for instance: T) -> Int {
+  instance.hashValue
+}
+
+public func useHashable<T: Hashable>(_ thing: T) -> Int {
+  // CHECK: [[USE_HASHABLE_WT:%.*]] = call i8** @swift_getWitnessTable(%swift.protocol_conformance_descriptor* @_swift_tupleHashable_conf, %swift.type* {{%.*}}, i8*** {{%.*}})
+  // CHECK-NEXT: {{%.*}} = call swiftcc i64 {{.*}}(%swift.opaque* noalias nocapture {{%.*}}, %swift.type* {{%.*}}, i8** [[USE_HASHABLE_WT]])
+  hashValue(for: (thing, thing))
+}
+
+public func testTupleHashable() {
+  // CHECK: [[TEST_TUPLE_HASHABLE_WT1:%.*]] = call i8** @swift_getWitnessTable(%swift.protocol_conformance_descriptor* @_swift_tupleHashable_conf, %swift.type* getelementptr inbounds (%swift.full_type, %swift.full_type* @"$sytN", i32 0, i32 1), i8*** undef)
+  // CHECK: {{%.*}} = call swiftcc i64 {{.*}}(%swift.opaque* noalias nocapture undef, %swift.type* getelementptr inbounds (%swift.full_type, %swift.full_type* @"$sytN", i32 0, i32 1), i8** [[TEST_TUPLE_HASHABLE_WT1]])
+  let _ = hashValue(for: ())
+
+  // CHECK: {{%.*}} = call swiftcc i64 {{.*}}(%swift.type* {{%.*}}, i8** [[TEST_TUPLE_HASHABLE_WT1]], {{%.*}} noalias nocapture swiftself undef)
+  let _ = Wrapper(value: ()).hashValue
+}
diff --git a/test/Interpreter/builtin_conformances.swift b/test/Interpreter/builtin_conformances.swift
diff --git a/test/expr/unary/keypath/keypath.swift b/test/expr/unary/keypath/keypath.swift
