1diff --git a/base/third_party/cityhash/city.cc b/base/third_party/cityhash/city.cc 2index 41cd5ee16993..22e3b4981ff5 100644 3--- a/base/third_party/cityhash/city.cc 4+++ b/base/third_party/cityhash/city.cc 5@@ -27,25 +27,13 @@ 6 // possible hash functions, by using SIMD instructions, or by 7 // compromising on hash quality. 8 9-#include "config.h" 10-#include <city.h> 11+#include "city.h" 12 13 #include <algorithm> 14 #include <string.h> // for memcpy and memset 15 16-using namespace std; 17- 18-static uint64 UNALIGNED_LOAD64(const char *p) { 19- uint64 result; 20- memcpy(&result, p, sizeof(result)); 21- return result; 22-} 23- 24-static uint32 UNALIGNED_LOAD32(const char *p) { 25- uint32 result; 26- memcpy(&result, p, sizeof(result)); 27- return result; 28-} 29+using std::make_pair; 30+using std::pair; 31 32 #ifdef _MSC_VER 33 34@@ -89,10 +77,19 @@ static uint32 UNALIGNED_LOAD32(const char *p) { 35 36 #else 37 38-#include <byteswap.h> 39+// XXX(cavalcanti): building 'native_client' fails with this header. 40+//#include <byteswap.h> 41+ 42+// Falling back to compiler builtins instead. 43+#define bswap_32(x) __builtin_bswap32(x) 44+#define bswap_64(x) __builtin_bswap64(x) 45 46 #endif 47 48+namespace base { 49+namespace internal { 50+namespace cityhash_v111 { 51+ 52 #ifdef WORDS_BIGENDIAN 53 #define uint32_in_expected_order(x) (bswap_32(x)) 54 #define uint64_in_expected_order(x) (bswap_64(x)) 55@@ -109,6 +106,18 @@ static uint32 UNALIGNED_LOAD32(const char *p) { 56 #endif 57 #endif 58 59+static uint64 UNALIGNED_LOAD64(const char *p) { 60+ uint64 result; 61+ memcpy(&result, p, sizeof(result)); 62+ return result; 63+} 64+ 65+static uint32 UNALIGNED_LOAD32(const char *p) { 66+ uint32 result; 67+ memcpy(&result, p, sizeof(result)); 68+ return result; 69+} 70+ 71 static uint64 Fetch64(const char *p) { 72 return uint64_in_expected_order(UNALIGNED_LOAD64(p)); 73 } 74@@ -217,11 +226,11 @@ uint32 CityHash32(const char *s, size_t len) { 75 f = f * 5 + 0xe6546b64; 76 size_t iters = (len - 1) / 20; 77 do { 78- uint32 a0 = Rotate32(Fetch32(s) * c1, 17) * c2; 79- uint32 a1 = Fetch32(s + 4); 80- uint32 a2 = Rotate32(Fetch32(s + 8) * c1, 17) * c2; 81- uint32 a3 = Rotate32(Fetch32(s + 12) * c1, 17) * c2; 82- uint32 a4 = Fetch32(s + 16); 83+ a0 = Rotate32(Fetch32(s) * c1, 17) * c2; 84+ a1 = Fetch32(s + 4); 85+ a2 = Rotate32(Fetch32(s + 8) * c1, 17) * c2; 86+ a3 = Rotate32(Fetch32(s + 12) * c1, 17) * c2; 87+ a4 = Fetch32(s + 16); 88 h ^= a0; 89 h = Rotate32(h, 18); 90 h = h * 5 + 0xe6546b64; 91@@ -512,135 +521,7 @@ uint128 CityHash128(const char *s, size_t len) { 92 CityHash128WithSeed(s, len, uint128(k0, k1)); 93 } 94 95-#ifdef __SSE4_2__ 96-#include <citycrc.h> 97-#include <nmmintrin.h> 98- 99-// Requires len >= 240. 100-static void CityHashCrc256Long(const char *s, size_t len, 101- uint32 seed, uint64 *result) { 102- uint64 a = Fetch64(s + 56) + k0; 103- uint64 b = Fetch64(s + 96) + k0; 104- uint64 c = result[0] = HashLen16(b, len); 105- uint64 d = result[1] = Fetch64(s + 120) * k0 + len; 106- uint64 e = Fetch64(s + 184) + seed; 107- uint64 f = 0; 108- uint64 g = 0; 109- uint64 h = c + d; 110- uint64 x = seed; 111- uint64 y = 0; 112- uint64 z = 0; 113- 114- // 240 bytes of input per iter. 115- size_t iters = len / 240; 116- len -= iters * 240; 117- do { 118-#undef CHUNK 119-#define CHUNK(r) \ 120- PERMUTE3(x, z, y); \ 121- b += Fetch64(s); \ 122- c += Fetch64(s + 8); \ 123- d += Fetch64(s + 16); \ 124- e += Fetch64(s + 24); \ 125- f += Fetch64(s + 32); \ 126- a += b; \ 127- h += f; \ 128- b += c; \ 129- f += d; \ 130- g += e; \ 131- e += z; \ 132- g += x; \ 133- z = _mm_crc32_u64(z, b + g); \ 134- y = _mm_crc32_u64(y, e + h); \ 135- x = _mm_crc32_u64(x, f + a); \ 136- e = Rotate(e, r); \ 137- c += e; \ 138- s += 40 139- 140- CHUNK(0); PERMUTE3(a, h, c); 141- CHUNK(33); PERMUTE3(a, h, f); 142- CHUNK(0); PERMUTE3(b, h, f); 143- CHUNK(42); PERMUTE3(b, h, d); 144- CHUNK(0); PERMUTE3(b, h, e); 145- CHUNK(33); PERMUTE3(a, h, e); 146- } while (--iters > 0); 147- 148- while (len >= 40) { 149- CHUNK(29); 150- e ^= Rotate(a, 20); 151- h += Rotate(b, 30); 152- g ^= Rotate(c, 40); 153- f += Rotate(d, 34); 154- PERMUTE3(c, h, g); 155- len -= 40; 156- } 157- if (len > 0) { 158- s = s + len - 40; 159- CHUNK(33); 160- e ^= Rotate(a, 43); 161- h += Rotate(b, 42); 162- g ^= Rotate(c, 41); 163- f += Rotate(d, 40); 164- } 165- result[0] ^= h; 166- result[1] ^= g; 167- g += h; 168- a = HashLen16(a, g + z); 169- x += y << 32; 170- b += x; 171- c = HashLen16(c, z) + h; 172- d = HashLen16(d, e + result[0]); 173- g += e; 174- h += HashLen16(x, f); 175- e = HashLen16(a, d) + g; 176- z = HashLen16(b, c) + a; 177- y = HashLen16(g, h) + c; 178- result[0] = e + z + y + x; 179- a = ShiftMix((a + y) * k0) * k0 + b; 180- result[1] += a + result[0]; 181- a = ShiftMix(a * k0) * k0 + c; 182- result[2] = a + result[1]; 183- a = ShiftMix((a + e) * k0) * k0; 184- result[3] = a + result[2]; 185-} 186- 187-// Requires len < 240. 188-static void CityHashCrc256Short(const char *s, size_t len, uint64 *result) { 189- char buf[240]; 190- memcpy(buf, s, len); 191- memset(buf + len, 0, 240 - len); 192- CityHashCrc256Long(buf, 240, ~static_cast<uint32>(len), result); 193-} 194+} // namespace cityhash_v111 195+} // namespace internal 196+} // namespace base 197 198-void CityHashCrc256(const char *s, size_t len, uint64 *result) { 199- if (LIKELY(len >= 240)) { 200- CityHashCrc256Long(s, len, 0, result); 201- } else { 202- CityHashCrc256Short(s, len, result); 203- } 204-} 205- 206-uint128 CityHashCrc128WithSeed(const char *s, size_t len, uint128 seed) { 207- if (len <= 900) { 208- return CityHash128WithSeed(s, len, seed); 209- } else { 210- uint64 result[4]; 211- CityHashCrc256(s, len, result); 212- uint64 u = Uint128High64(seed) + result[0]; 213- uint64 v = Uint128Low64(seed) + result[1]; 214- return uint128(HashLen16(u, v + result[2]), 215- HashLen16(Rotate(v, 32), u * k0 + result[3])); 216- } 217-} 218- 219-uint128 CityHashCrc128(const char *s, size_t len) { 220- if (len <= 900) { 221- return CityHash128(s, len); 222- } else { 223- uint64 result[4]; 224- CityHashCrc256(s, len, result); 225- return uint128(result[2], result[3]); 226- } 227-} 228- 229-#endif 230diff --git a/base/third_party/cityhash/city.h b/base/third_party/cityhash/city.h 231index 94499ce419c7..e4672f6d44da 100644 232--- a/base/third_party/cityhash/city.h 233+++ b/base/third_party/cityhash/city.h 234@@ -59,13 +59,20 @@ 235 // of a+b is easily derived from the hashes of a and b. This property 236 // doesn't hold for any hash functions in this file. 237 238-#ifndef CITY_HASH_H_ 239-#define CITY_HASH_H_ 240+#ifndef BASE_THIRD_PARTY_CITYHASH_CITY_H_ 241+#define BASE_THIRD_PARTY_CITYHASH_CITY_H_ 242 243 #include <stdlib.h> // for size_t. 244 #include <stdint.h> 245 #include <utility> 246 247+// XXX(cavalcantii): Declaring it inside of the 'base' namespace allows to 248+// handle linker symbol clash error with deprecated CityHash from 249+// third_party/smhasher in a few unit tests. 250+namespace base { 251+namespace internal { 252+namespace cityhash_v111 { 253+ 254 typedef uint8_t uint8; 255 typedef uint32_t uint32; 256 typedef uint64_t uint64; 257@@ -109,4 +116,8 @@ inline uint64 Hash128to64(const uint128& x) { 258 return b; 259 } 260 261+} // namespace cityhash_v111 262+} // namespace internal 263+} // namespace base 264+ 265 #endif // CITY_HASH_H_ 266