stdlib: use SipHash-1-3 for string hashing on non-ObjC platforms

Part of rdar://problem/24109692

Author: gribozavr

stdlib/public/SwiftShims/CMakeLists.txt

@@ -9,6 +9,7 @@ set(sources
   RefCount.h
   RuntimeShims.h
   RuntimeStubs.h
+  SwiftStdbool.h
   SwiftStddef.h
   SwiftStdint.h
   UnicodeShims.h

stdlib/public/SwiftShims/SwiftStdbool.h

@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_STDLIB_SHIMS_SWIFTSTDBOOL_H_
+#define SWIFT_STDLIB_SHIMS_SWIFTSTDBOOL_H_
+
+#ifdef __cplusplus
+typedef bool __swift_bool;
+#else
+typedef _Bool __swift_bool;
+#endif
+
+#endif
+

stdlib/public/SwiftShims/UnicodeShims.h

@@ -18,6 +18,7 @@
 #define SWIFT_STDLIB_SHIMS_UNICODESHIMS_H_
 
 #include "SwiftStdint.h"
+#include "SwiftStdbool.h"
 #include "Visibility.h"
 
 #if __has_feature(nullability)
@@ -83,13 +84,20 @@ _swift_stdlib_unicode_compare_utf8_utf8(const unsigned char *Left,
                                         __swift_int32_t RightLength);
 
 SWIFT_RUNTIME_STDLIB_INTERFACE
-__attribute__((__pure__)) __swift_intptr_t
-_swift_stdlib_unicode_hash(const __swift_uint16_t *Str, __swift_int32_t Length);
+void *_swift_stdlib_unicodeCollationIterator_create(
+    const __swift_uint16_t *Str,
+    __swift_uint32_t Length);
 
 SWIFT_RUNTIME_STDLIB_INTERFACE
-__attribute__((__pure__)) __swift_intptr_t
-_swift_stdlib_unicode_hash_ascii(const unsigned char *Str,
-                                 __swift_int32_t Length);
+__swift_int32_t _swift_stdlib_unicodeCollationIterator_next(
+    void *CollationIterator, __swift_bool *HitEnd);
+
+SWIFT_RUNTIME_STDLIB_INTERFACE
+void _swift_stdlib_unicodeCollationIterator_delete(
+    void *CollationIterator);
+
+SWIFT_RUNTIME_STDLIB_INTERFACE
+const __swift_int32_t *_swift_stdlib_unicode_getASCIICollationTable();
 
 SWIFT_RUNTIME_STDLIB_INTERFACE
 __swift_int32_t _swift_stdlib_unicode_strToUpper(

stdlib/public/SwiftShims/module.modulemap

@@ -9,6 +9,7 @@ module SwiftShims {
   header "RefCount.h"
   header "RuntimeShims.h"
   header "RuntimeStubs.h"
+  header "SwiftStdbool.h"
   header "SwiftStddef.h"
   header "SwiftStdint.h"
   header "UnicodeShims.h"

stdlib/public/core/StringHashable.swift

@@ -20,6 +20,50 @@ func _stdlib_NSStringHashValue(_ str: AnyObject, _ isASCII: Bool) -> Int
 func _stdlib_NSStringHashValuePointer(_ str: OpaquePointer, _ isASCII: Bool) -> Int
 #endif
 
+extension _Unicode {
+  internal static func hashASCII(
+    _ string: UnsafeBufferPointer<UInt8>
+  ) -> Int {
+    let collationTable = _swift_stdlib_unicode_getASCIICollationTable()
+    var hasher = _SipHash13Context(key: _Hashing.secretKey)
+    for c in string {
+      _precondition(c <= 127)
+      let element = collationTable[Int(c)]
+      // Ignore zero valued collation elements. They don't participate in the
+      // ordering relation.
+      if element != 0 {
+        hasher.append(element)
+      }
+    }
+    return hasher._finalizeAndReturnIntHash()
+  }
+
+  internal static func hashUTF16(
+    _ string: UnsafeBufferPointer<UInt16>
+  ) -> Int {
+    let collationIterator = _swift_stdlib_unicodeCollationIterator_create(
+      string.baseAddress!,
+      UInt32(string.count))
+    defer { _swift_stdlib_unicodeCollationIterator_delete(collationIterator) }
+
+    var hasher = _SipHash13Context(key: _Hashing.secretKey)
+    while true {
+      var hitEnd = false
+      let element =
+        _swift_stdlib_unicodeCollationIterator_next(collationIterator, &hitEnd)
+      if hitEnd {
+        break
+      }
+      // Ignore zero valued collation elements. They don't participate in the
+      // ordering relation.
+      if element != 0 {
+        hasher.append(element)
+      }
+    }
+    return hasher._finalizeAndReturnIntHash()
+  }
+}
+
 extension String : Hashable {
   /// The string's hash value.
   ///
@@ -49,10 +93,12 @@ extension String : Hashable {
     }
 #else
     if let asciiBuffer = self._core.asciiBuffer {
-      return _swift_stdlib_unicode_hash_ascii(
-        asciiBuffer.baseAddress!, Int32(asciiBuffer.count))
+      return _Unicode.hashASCII(UnsafeBufferPointer(
+        start: asciiBuffer.baseAddress!,
+        count: asciiBuffer.count))
     } else {
-      return _swift_stdlib_unicode_hash(_core.startUTF16, Int32(_core.count))
+      return _Unicode.hashUTF16(
+        UnsafeBufferPointer(start: _core.startUTF16, count: _core.count))
     }
 #endif
   }

stdlib/public/core/Unicode.swift

@@ -1176,3 +1176,7 @@ extension UTF16 {
     Builtin.unreachable()
   }
 }
+
+/// A namespace for Unicode utilities.
+internal enum _Unicode {}
+

stdlib/public/stubs/UnicodeNormalization.cpp

@@ -57,7 +57,6 @@ static const UCollator *GetRootCollator() {
 /// This class caches the collation element results for the ASCII subset of
 /// unicode.
 class ASCIICollation {
-  int32_t CollationTable[128];
 public:
   friend class swift::Lazy<ASCIICollation>;
 
@@ -66,6 +65,8 @@ class ASCIICollation {
     return &theTable.get();
   }
 
+  int32_t CollationTable[128];
+
   /// Maps an ASCII character to a collation element priority as would be
   /// returned by a call to ucol_next().
   int32_t map(unsigned char c) const {
@@ -189,91 +190,42 @@ swift::_swift_stdlib_unicode_compare_utf8_utf8(const unsigned char *LeftString,
   return Diff;
 }
 
-// These functions use murmurhash2 in its 32 and 64bit forms, which are
-// differentiated by the constants defined below. This seems like a good choice
-// for now because it operates efficiently in blocks rather than bytes, and 
-// the data returned from the collation iterator comes in 4byte chunks.
-#if __arm__ || __i386__
-#define HASH_SEED 0x88ddcc21
-#define HASH_M 0x5bd1e995
-#define HASH_R 24
-#else
-#define HASH_SEED 0x429b126688ddcc21
-#define HASH_M 0xc6a4a7935bd1e995
-#define HASH_R 47
-#endif
-
-static intptr_t hashChunk(const UCollator *Collator, intptr_t HashState,
-                          const uint16_t *Str, uint32_t Length,
-                          UErrorCode *ErrorCode) {
+void *swift::_swift_stdlib_unicodeCollationIterator_create(
+    const __swift_uint16_t *Str, __swift_uint32_t Length) {
+  UErrorCode ErrorCode = U_ZERO_ERROR;
 #if defined(__CYGWIN__) || defined(_MSC_VER)
   UCollationElements *CollationIterator = ucol_openElements(
-    Collator, reinterpret_cast<const UChar *>(Str), Length, ErrorCode);
+    GetRootCollator(), reinterpret_cast<const UChar *>(Str), Length,
+    &ErrorCode);
 #else
   UCollationElements *CollationIterator = ucol_openElements(
-    Collator, Str, Length, ErrorCode);
+    GetRootCollator(), Str, Length, &ErrorCode);
 #endif
-  while (U_SUCCESS(*ErrorCode)) {
-    intptr_t Elem = ucol_next(CollationIterator, ErrorCode);
-    // Ignore zero valued collation elements. They don't participate in the
-    // ordering relation.
-    if (Elem == 0)
-      continue;
-    if (Elem != UCOL_NULLORDER) {
-      Elem *= HASH_M;
-      Elem ^= Elem >> HASH_R;
-      Elem *= HASH_M;
-
-      HashState *= HASH_M;
-      HashState ^= Elem;
-    } else {
-      break;
-    }
+  if (U_FAILURE(ErrorCode)) {
+    swift::crash("_swift_stdlib_unicodeCollationIterator_create: ucol_openElements() failed.");
   }
-  ucol_closeElements(CollationIterator);
-  return HashState;
-}
-
-static intptr_t hashFinish(intptr_t HashState) {
-  HashState ^= HashState >> HASH_R;
-  HashState *= HASH_M;
-  HashState ^= HashState >> HASH_R;
-  return HashState;
+  return CollationIterator;
 }
 
-intptr_t
-swift::_swift_stdlib_unicode_hash(const uint16_t *Str, int32_t Length) {
+__swift_int32_t swift::_swift_stdlib_unicodeCollationIterator_next(
+    void *CollationIterator, bool *HitEnd) {
   UErrorCode ErrorCode = U_ZERO_ERROR;
-  intptr_t HashState = HASH_SEED;
-  HashState = hashChunk(GetRootCollator(), HashState, Str, Length, &ErrorCode);
-
+  auto Result = ucol_next(
+      static_cast<UCollationElements *>(CollationIterator), &ErrorCode);
   if (U_FAILURE(ErrorCode)) {
-    swift::crash("hashChunk: Unexpected error hashing unicode string.");
+    swift::crash("_swift_stdlib_unicodeCollationIterator_next: ucol_next() failed.");
   }
-  return hashFinish(HashState);
+  *HitEnd = (Result == UCOL_NULLORDER);
+  return Result;
 }
 
-intptr_t swift::_swift_stdlib_unicode_hash_ascii(const unsigned char *Str,
-                                                 int32_t Length) {
-  const ASCIICollation *Table = ASCIICollation::getTable();
-  intptr_t HashState = HASH_SEED;
-  int32_t Pos = 0;
-  while (Pos < Length) {
-    const unsigned char c = Str[Pos++];
-    assert((c & 0x80) == 0 && "This table only exists for the ASCII subset");
-    intptr_t Elem = Table->map(c);
-    // Ignore zero valued collation elements. They don't participate in the
-    // ordering relation.
-    if (Elem == 0)
-      continue;
-    Elem *= HASH_M;
-    Elem ^= Elem >> HASH_R;
-    Elem *= HASH_M;
+void swift::_swift_stdlib_unicodeCollationIterator_delete(
+    void *CollationIterator) {
+  ucol_closeElements(static_cast<UCollationElements *>(CollationIterator));
+}
 
-    HashState *= HASH_M;
-    HashState ^= Elem;
-  }
-  return hashFinish(HashState);
+const __swift_int32_t *swift::_swift_stdlib_unicode_getASCIICollationTable() {
+  return ASCIICollation::getTable()->CollationTable;
 }
 
 /// Convert the unicode string to uppercase. This function will return the