X-Git-Url: https://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Fhash%2Fhash.c;h=9b3f58b2b20a649785b7f053c4c7828413610148;hp=cb4465405e2eff8022a014e0690583e6d16d9ac0;hb=c4c5fed020ba44b9930119672a36a1cb33aff090;hpb=7449ae0ff0ef5c96b7a76010986e00ebb28b2a65

diff --git a/ccan/hash/hash.c b/ccan/hash/hash.c
index cb446540..9b3f58b2 100644
--- a/ccan/hash/hash.c
+++ b/ccan/hash/hash.c
@@ -543,13 +543,13 @@ static uint32_t hashbig( const void *key, size_t length, uint32_t *val2)
  * element.  This delivers least-surprise: hash such as "int arr[] = {
  * 1, 2 }; hash_stable(arr, 2, 0);" will be the same on big and little
  * endian machines, even though a bytewise hash wouldn't be. */
-uint64_t hash64_stable_64(const void *key, size_t n, uint32_t base)
+uint64_t hash64_stable_64(const void *key, size_t n, uint64_t base)
 {
 	const uint64_t *k = key;
 	uint32_t a,b,c;
 
 	/* Set up the internal state */
-	a = b = c = 0xdeadbeef + ((uint32_t)n*8) + base;
+	a = b = c = 0xdeadbeef + ((uint32_t)n*8) + (base >> 32) + base;
 
 	while (n > 3) {
 		a += (uint32_t)k[0];
@@ -582,13 +582,13 @@ uint64_t hash64_stable_64(const void *key, size_t n, uint32_t base)
 	return ((uint64_t)b << 32) | c;
 }
 
-uint64_t hash64_stable_32(const void *key, size_t n, uint32_t base)
+uint64_t hash64_stable_32(const void *key, size_t n, uint64_t base)
 {
 	const uint32_t *k = key;
 	uint32_t a,b,c;
 
 	/* Set up the internal state */
-	a = b = c = 0xdeadbeef + ((uint32_t)n*4) + base;
+	a = b = c = 0xdeadbeef + ((uint32_t)n*4) + (base >> 32) + base;
 
 	while (n > 3) {
 		a += k[0];
@@ -612,13 +612,13 @@ uint64_t hash64_stable_32(const void *key, size_t n, uint32_t base)
 	return ((uint64_t)b << 32) | c;
 }
 
-uint64_t hash64_stable_16(const void *key, size_t n, uint32_t base)
+uint64_t hash64_stable_16(const void *key, size_t n, uint64_t base)
 {
 	const uint16_t *k = key;
 	uint32_t a,b,c;
 
 	/* Set up the internal state */
-	a = b = c = 0xdeadbeef + ((uint32_t)n*2) + base;
+	a = b = c = 0xdeadbeef + ((uint32_t)n*2) + (base >> 32) + base;
 
 	while (n > 6) {
 		a += (uint32_t)k[0] + ((uint32_t)k[1] << 16);
@@ -648,12 +648,13 @@ uint64_t hash64_stable_16(const void *key, size_t n, uint32_t base)
 	final(a,b,c);
 	return ((uint64_t)b << 32) | c;
 }
-	
-uint64_t hash64_stable_8(const void *key, size_t n, uint32_t base)
+
+uint64_t hash64_stable_8(const void *key, size_t n, uint64_t base)
 {
-	uint32_t lower = hashlittle(key, n, &base);
+	uint32_t b32 = base + (base >> 32);
+	uint32_t lower = hashlittle(key, n, &b32);
 
-	return ((uint64_t)base << 32) | lower;	
+	return ((uint64_t)b32 << 32) | lower;	
 }
 
 uint32_t hash_any(const void *key, size_t length, uint32_t base)
@@ -686,16 +687,17 @@ uint32_t hash_stable_8(const void *key, size_t n, uint32_t base)
 
 /* Jenkins' lookup8 is a 64 bit hash, but he says it's obsolete.  Use
  * the plain one and recombine into 64 bits. */
-uint64_t hash64_any(const void *key, size_t length, uint32_t base)
+uint64_t hash64_any(const void *key, size_t length, uint64_t base)
 {
+	uint32_t b32 = base + (base >> 32);
 	uint32_t lower;
 
 	if (HASH_BIG_ENDIAN)
-		lower = hashbig(key, length, &base);
+		lower = hashbig(key, length, &b32);
 	else
-		lower = hashlittle(key, length, &base);
+		lower = hashlittle(key, length, &b32);
 
-	return ((uint64_t)base << 32) | lower;
+	return ((uint64_t)b32 << 32) | lower;
 }
 
 #ifdef SELF_TEST