From d0a3b33eb62f31954526689042b8d2e6744518b5 Mon Sep 17 00:00:00 2001 From: Paul Moore Date: Mon, 21 Oct 2013 16:00:15 -0400 Subject: hash: cleanup the Jenkins hash source to better match our code Style improvements as well as a wrapper function to select the "best" hash for a given situation. Some unused functions were also removed. Signed-off-by: Paul Moore --- src/hash.c | 805 ++++++++++++++++++------------------------------------------- 1 file changed, 240 insertions(+), 565 deletions(-) diff --git a/src/hash.c b/src/hash.c index 5b55679..cb52b3b 100644 --- a/src/hash.c +++ b/src/hash.c @@ -1,116 +1,95 @@ +/** + * Seccomp Library hash code + * + * Release under the Public Domain + * Author: Bob Jenkins + */ + /* -------------------------------------------------------------------------------- -lookup3.c, by Bob Jenkins, May 2006, Public Domain. - -These are functions for producing 32-bit hashes for hash table lookup. -hashword(), hashlittle(), hashlittle2(), hashbig(), mix(), and final() -are externally useful functions. Routines to test the hash are included -if SELF_TEST is defined. You can use this free for any purpose. It's in -the public domain. It has no warranty. - -You probably want to use hashlittle(). hashlittle() and hashbig() -hash byte arrays. hashlittle() is is faster than hashbig() on -little-endian machines. Intel and AMD are little-endian machines. -On second thought, you probably want hashlittle2(), which is identical to -hashlittle() except it returns two 32-bit hashes for the price of one. -You could implement hashbig2() if you wanted but I haven't bothered here. - -If you want to find a hash of, say, exactly 7 integers, do - a = i1; b = i2; c = i3; - mix(a,b,c); - a += i4; b += i5; c += i6; - mix(a,b,c); - a += i7; - final(a,b,c); -then use c as the hash value. If you have a variable length array of -4-byte integers to hash, use hashword(). If you have a byte array (like -a character string), use hashlittle(). If you have several byte arrays, or -a mix of things, see the comments above hashlittle(). - -Why is this so big? I read 12 bytes at a time into 3 4-byte integers, -then mix those integers. This is fast (you can do a lot more thorough -mixing with 12*3 instructions on 3 integers than you can with 3 instructions -on 1 byte), but shoehorning those bytes into integers efficiently is messy. -------------------------------------------------------------------------------- -*/ - -#include /* defines uint32_t etc */ -#include /* attempt to define endianness */ -#ifdef linux -# include /* attempt to define endianness */ -#endif + * lookup3.c, by Bob Jenkins, May 2006, Public Domain. + * + * These are functions for producing 32-bit hashes for hash table lookup. + * jhash_word(), jhash_le(), jhash_be(), mix(), and final() are externally useful + * functions. Routines to test the hash are included if SELF_TEST is defined. + * You can use this free for any purpose. It's in the public domain. It has + * no warranty. + * + * You probably want to use jhash_le(). jhash_le() and jhash_be() hash byte + * arrays. jhash_le() is is faster than jhash_be() on little-endian machines. + * Intel and AMD are little-endian machines. + * + * If you want to find a hash of, say, exactly 7 integers, do + * a = i1; b = i2; c = i3; + * mix(a,b,c); + * a += i4; b += i5; c += i6; + * mix(a,b,c); + * a += i7; + * final(a,b,c); + * + * then use c as the hash value. If you have a variable length array of + * 4-byte integers to hash, use jhash_word(). If you have a byte array (like + * a character string), use jhash_le(). If you have several byte arrays, or + * a mix of things, see the comments above jhash_le(). + * + * Why is this so big? I read 12 bytes at a time into 3 4-byte integers, then + * mix those integers. This is fast (you can do a lot more thorough mixing + * with 12*3 instructions on 3 integers than you can with 3 instructions on 1 + * byte), but shoehorning those bytes into integers efficiently is messy. + */ + +#include +#include "arch.h" #include "hash.h" -#define hashlittle jhash -/* - * My best guess at if you are big-endian or little-endian. This may - * need adjustment. - */ -#if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && \ - __BYTE_ORDER == __LITTLE_ENDIAN) || \ - (defined(i386) || defined(__i386__) || defined(__i486__) || \ - defined(__i586__) || defined(__i686__) || defined(vax) || defined(MIPSEL)) -# define HASH_LITTLE_ENDIAN 1 -# define HASH_BIG_ENDIAN 0 -#elif (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && \ - __BYTE_ORDER == __BIG_ENDIAN) || \ - (defined(sparc) || defined(POWERPC) || defined(mc68000) || defined(sel)) -# define HASH_LITTLE_ENDIAN 0 -# define HASH_BIG_ENDIAN 1 -#else -# define HASH_LITTLE_ENDIAN 0 -# define HASH_BIG_ENDIAN 0 -#endif - -#define hashsize(n) ((uint32_t)1<<(n)) -#define hashmask(n) (hashsize(n)-1) -#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k)))) +#define hashsize(n) ((uint32_t)1<<(n)) +#define hashmask(n) (hashsize(n)-1) +#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k)))) -/* -------------------------------------------------------------------------------- -mix -- mix 3 32-bit values reversibly. - -This is reversible, so any information in (a,b,c) before mix() is -still in (a,b,c) after mix(). - -If four pairs of (a,b,c) inputs are run through mix(), or through -mix() in reverse, there are at least 32 bits of the output that -are sometimes the same for one pair and different for another pair. -This was tested for: -* pairs that differed by one bit, by two bits, in any combination - of top bits of (a,b,c), or in any combination of bottom bits of - (a,b,c). -* "differ" is defined as +, -, ^, or ~^. For + and -, I transformed - the output delta to a Gray code (a^(a>>1)) so a string of 1's (as - is commonly produced by subtraction) look like a single 1-bit - difference. -* the base values were pseudorandom, all zero but one bit set, or - all zero plus a counter that starts at zero. - -Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that -satisfy this are - 4 6 8 16 19 4 - 9 15 3 18 27 15 - 14 9 3 7 17 3 -Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing -for "differ" defined as + with a one-bit base and a two-bit delta. I -used http://burtleburtle.net/bob/hash/avalanche.html to choose -the operations, constants, and arrangements of the variables. - -This does not achieve avalanche. There are input bits of (a,b,c) -that fail to affect some output bits of (a,b,c), especially of a. The -most thoroughly mixed value is c, but it doesn't really even achieve -avalanche in c. - -This allows some parallelism. Read-after-writes are good at doubling -the number of bits affected, so the goal of mixing pulls in the opposite -direction as the goal of parallelism. I did what I could. Rotates -seem to cost as much as shifts on every machine I could lay my hands -on, and rotates are much kinder to the top and bottom bits, so I used -rotates. -------------------------------------------------------------------------------- -*/ +/** + * Mix 3 32-bit values reversibly + * @param a 32-bit value + * @param b 32-bit value + * @param c 32-bit value + * + * This is reversible, so any information in (a,b,c) before mix() is still + * in (a,b,c) after mix(). + * + * If four pairs of (a,b,c) inputs are run through mix(), or through mix() in + * reverse, there are at least 32 bits of the output that are sometimes the + * same for one pair and different for another pair. + * + * This was tested for: + * - pairs that differed by one bit, by two bits, in any combination of top + * bits of (a,b,c), or in any combination of bottom bits of (a,b,c). + * - "differ" is defined as +, -, ^, or ~^. For + and -, I transformed the + * output delta to a Gray code (a^(a>>1)) so a string of 1's (as is commonly + * produced by subtraction) look like a single 1-bit difference. + * - the base values were pseudorandom, all zero but one bit set, or all zero + * plus a counter that starts at zero. + * + * Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that + * satisfy this are + * 4 6 8 16 19 4 + * 9 15 3 18 27 15 + * 14 9 3 7 17 3 + * + * Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing for "differ" + * defined as + with a one-bit base and a two-bit delta. I used + * http://burtleburtle.net/bob/hash/avalanche.html to choose the operations, + * constants, and arrangements of the variables. + * + * This does not achieve avalanche. There are input bits of (a,b,c) that fail + * to affect some output bits of (a,b,c), especially of a. The most thoroughly + * mixed value is c, but it doesn't really even achieve avalanche in c. + * + * This allows some parallelism. Read-after-writes are good at doubling the + * number of bits affected, so the goal of mixing pulls in the opposite + * direction as the goal of parallelism. I did what I could. Rotates seem to + * cost as much as shifts on every machine I could lay my hands on, and rotates + * are much kinder to the top and bottom bits, so I used rotates. + * + */ #define mix(a,b,c) \ { \ a -= c; a ^= rot(c, 4); c += b; \ @@ -121,31 +100,31 @@ rotates. c -= b; c ^= rot(b, 4); b += a; \ } -/* -------------------------------------------------------------------------------- -final -- final mixing of 3 32-bit values (a,b,c) into c - -Pairs of (a,b,c) values differing in only a few bits will usually -produce values of c that look totally different. This was tested for -* pairs that differed by one bit, by two bits, in any combination - of top bits of (a,b,c), or in any combination of bottom bits of - (a,b,c). -* "differ" is defined as +, -, ^, or ~^. For + and -, I transformed - the output delta to a Gray code (a^(a>>1)) so a string of 1's (as - is commonly produced by subtraction) look like a single 1-bit - difference. -* the base values were pseudorandom, all zero but one bit set, or - all zero plus a counter that starts at zero. - -These constants passed: - 14 11 25 16 4 14 24 - 12 14 25 16 4 14 24 -and these came close: - 4 8 15 26 3 22 24 - 10 8 15 26 3 22 24 - 11 8 15 26 3 22 24 -------------------------------------------------------------------------------- -*/ +/** + * Final mixing of 3 32-bit values (a,b,c) into c + * @param a 32-bit value + * @param b 32-bit value + * @param c 32-bit value + * + * Pairs of (a,b,c) values differing in only a few bits will usually produce + * values of c that look totally different. This was tested for: + * - pairs that differed by one bit, by two bits, in any combination of top + * bits of (a,b,c), or in any combination of bottom bits of (a,b,c). + * - "differ" is defined as +, -, ^, or ~^. For + and -, I transformed the + * output delta to a Gray code (a^(a>>1)) so a string of 1's (as is commonly + * produced by subtraction) look like a single 1-bit difference. + * - the base values were pseudorandom, all zero but one bit set, or all zero + * plus a counter that starts at zero. + * + * These constants passed: + * 14 11 25 16 4 14 24 + * 12 14 25 16 4 14 24 + * and these came close: + * 4 8 15 26 3 22 24 + * 10 8 15 26 3 22 24 + * 11 8 15 26 3 22 24 + * + */ #define final(a,b,c) \ { \ c ^= b; c -= rot(b,14); \ @@ -157,30 +136,31 @@ and these came close: c ^= b; c -= rot(b,24); \ } -/* --------------------------------------------------------------------- - This works on all machines. To be useful, it requires - -- that the key be an array of uint32_t's, and - -- that the length be the number of uint32_t's in the key - - The function hashword() is identical to hashlittle() on little-endian - machines, and identical to hashbig() on big-endian machines, - except that the length has to be measured in uint32_ts rather than in - bytes. hashlittle() is more complicated than hashword() only because - hashlittle() has to dance around fitting the key bytes into registers. --------------------------------------------------------------------- -*/ -uint32_t hashword( - const uint32_t *k, /* the key, an array of uint32_t values */ - size_t length, /* the length of the key, in uint32_ts */ - uint32_t initval) /* the previous hash, or an arbitrary value */ +/** + * Hash an array of 32-bit values + * @param k the key, an array of uint32_t values + * @param length the number of array elements + * @param initval the previous hash, or an arbitrary value + * + * This works on all machines. To be useful, it requires: + * - that the key be an array of uint32_t's, and + * - that the length be the number of uint32_t's in the key + * + * The function jhash_word() is identical to jhash_le() on little-endian + * machines, and identical to jhash_be() on big-endian machines, except that + * the length has to be measured in uint32_ts rather than in bytes. jhash_le() + * is more complicated than jhash_word() only because jhash_le() has to dance + * around fitting the key bytes into registers. + * + */ +static uint32_t jhash_word(const uint32_t *k, size_t length, uint32_t initval) { uint32_t a, b, c; - /* Set up the internal state */ + /* set up the internal state */ a = b = c = 0xdeadbeef + (((uint32_t)length) << 2) + initval; - /*-------------------------------------------- handle most of the key */ + /* handle most of the key */ while (length > 3) { a += k[0]; b += k[1]; @@ -190,8 +170,8 @@ uint32_t hashword( k += 3; } - /*-------------------------------------- handle the last 3 uint32_t's */ - switch(length) { /* all the case statements fall through */ + /* handle the last 3 uint32_t's */ + switch(length) { case 3 : c += k[2]; case 2 : @@ -199,103 +179,51 @@ uint32_t hashword( case 1 : a += k[0]; final(a, b, c); - case 0: /* case 0: nothing left to add */ + case 0: + /* nothing left to add */ break; } - /*------------------------------------------------- report the result */ + return c; } -/* --------------------------------------------------------------------- -hashword2() -- same as hashword(), but take two seeds and return two -32-bit values. pc and pb must both be nonnull, and *pc and *pb must -both be initialized with seeds. If you pass in (*pb)==0, the output -(*pc) will be the same as the return value from hashword(). --------------------------------------------------------------------- -*/ -void hashword2 ( - const uint32_t *k, /* the key, an array of uint32_t values */ - size_t length, /* the length of the key, in uint32_ts */ - uint32_t *pc, /* IN: seed OUT: primary hash value */ - uint32_t *pb) /* IN: more seed OUT: secondary hash value */ +/** + * Hash a variable-length key into a 32-bit value + * @param k the key (the unaligned variable-length array of bytes) + * @param length the length of the key, counting by bytes + * @param initval can be any 4-byte value + * + * Returns a 32-bit value. Every bit of the key affects every bit of the + * return value. Two keys differing by one or two bits will have totally + * different hash values. + * + * The best hash table sizes are powers of 2. There is no need to do mod a + * prime (mod is sooo slow!). If you need less than 32 bits, use a bitmask. + * For example, if you need only 10 bits, do: + * h = (h & hashmask(10)); + * In which case, the hash table should have hashsize(10) elements. + * + * If you are hashing n strings (uint8_t **)k, do it like this: + * for (i=0, h=0; i 3) { - a += k[0]; - b += k[1]; - c += k[2]; - mix(a, b, c); - length -= 3; - k += 3; - } - - /*-------------------------------------- handle the last 3 uint32_t's */ - switch(length) { /* all the case statements fall through */ - case 3 : - c += k[2]; - case 2 : - b += k[1]; - case 1 : - a += k[0]; - final(a, b, c); - case 0: /* case 0: nothing left to add */ - break; - } - /*------------------------------------------------- report the result */ - *pc = c; - *pb = b; -} - -/* -------------------------------------------------------------------------------- -hashlittle() -- hash a variable-length key into a 32-bit value - k : the key (the unaligned variable-length array of bytes) - length : the length of the key, counting by bytes - initval : can be any 4-byte value -Returns a 32-bit value. Every bit of the key affects every bit of -the return value. Two keys differing by one or two bits will have -totally different hash values. - -The best hash table sizes are powers of 2. There is no need to do -mod a prime (mod is sooo slow!). If you need less than 32 bits, -use a bitmask. For example, if you need only 10 bits, do - h = (h & hashmask(10)); -In which case, the hash table should have hashsize(10) elements. - -If you are hashing n strings (uint8_t **)k, do it like this: - for (i=0, h=0; iendian == ARCH_ENDIAN_LITTLE) && + ((u.i & 0x3) == 0)) { + /* read 32-bit chunks */ + const uint32_t *k = (const uint32_t *)key; - /* all but last block: aligned reads and affect 32-bits - * of (a,b,c) */ while (length > 12) { a += k[0]; b += k[1]; @@ -305,17 +233,14 @@ uint32_t hashlittle( const void *key, size_t length, uint32_t initval) k += 3; } - /*------------------ handle the last (probably partial) block */ - /* - * "k[2]&0xffffff" actually reads beyond the end of the string, + /* "k[2]&0xffffff" actually reads beyond the end of the string, * but then masks off the part it's not allowed to read. * Because the string is aligned, the masked-off tail is in the * same word as the rest of the string. Every machine with * memory protection I've seen does it on word boundaries, so * is OK with this. But VALGRIND will still catch it and * complain. The masking trick does make the hash noticably - * faster for short strings (like English words). - */ + * faster for short strings (like English words). */ #ifndef VALGRIND switch(length) { @@ -368,7 +293,8 @@ uint32_t hashlittle( const void *key, size_t length, uint32_t initval) a += k[0] & 0xff; break; case 0 : - return c; /* zero length strings require no mixing */ + /* zero length strings require no mixing */ + return c; } #else /* make valgrind happy */ @@ -381,28 +307,28 @@ uint32_t hashlittle( const void *key, size_t length, uint32_t initval) a += k[0]; break; case 11: - c += ((uint32_t)k8[10]) << 16; /* fall through */ + c += ((uint32_t)k8[10]) << 16; case 10: - c += ((uint32_t)k8[9]) << 8; /* fall through */ + c += ((uint32_t)k8[9]) << 8; case 9 : - c += k8[8]; /* fall through */ + c += k8[8]; case 8 : b += k[1]; a += k[0]; break; case 7 : - b += ((uint32_t)k8[6]) << 16; /* fall through */ + b += ((uint32_t)k8[6]) << 16; case 6 : - b += ((uint32_t)k8[5]) << 8; /* fall through */ + b += ((uint32_t)k8[5]) << 8; case 5 : - b += k8[4]; /* fall through */ + b += k8[4]; case 4 : a += k[0]; break; case 3 : - a += ((uint32_t)k8[2]) << 16; /* fall through */ + a += ((uint32_t)k8[2]) << 16; case 2 : - a += ((uint32_t)k8[1]) << 8; /* fall through */ + a += ((uint32_t)k8[1]) << 8; case 1 : a += k8[0]; break; @@ -412,11 +338,12 @@ uint32_t hashlittle( const void *key, size_t length, uint32_t initval) #endif /* !valgrind */ - } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) { - const uint16_t *k = (const uint16_t *)key; /* read 16b chunks */ + } else if ((arch_def_native->endian == ARCH_ENDIAN_LITTLE) && + ((u.i & 0x1) == 0)) { + /* read 16-bit chunks */ + const uint16_t *k = (const uint16_t *)key; const uint8_t *k8; - /*---- all but last block: aligned reads and different mixing */ while (length > 12) { a += k[0] + (((uint32_t)k[1]) << 16); b += k[2] + (((uint32_t)k[3]) << 16); @@ -426,7 +353,6 @@ uint32_t hashlittle( const void *key, size_t length, uint32_t initval) k += 6; } - /*------------------ handle the last (probably partial) block */ k8 = (const uint8_t *)k; switch(length) { case 12: @@ -435,31 +361,31 @@ uint32_t hashlittle( const void *key, size_t length, uint32_t initval) a += k[0] + (((uint32_t)k[1]) << 16); break; case 11: - c += ((uint32_t)k8[10]) << 16; /* fall through */ + c += ((uint32_t)k8[10]) << 16; case 10: c += k[4]; b += k[2] + (((uint32_t)k[3]) << 16); a += k[0] + (((uint32_t)k[1]) << 16); break; case 9 : - c += k8[8]; /* fall through */ + c += k8[8]; case 8 : b += k[2] + (((uint32_t)k[3]) << 16); a += k[0] + (((uint32_t)k[1]) << 16); break; case 7 : - b += ((uint32_t)k8[6]) << 16; /* fall through */ + b += ((uint32_t)k8[6]) << 16; case 6 : b += k[2]; a += k[0] + (((uint32_t)k[1]) << 16); break; case 5 : - b += k8[4]; /* fall through */ + b += k8[4]; case 4 : a += k[0] + (((uint32_t)k[1]) << 16); break; case 3 : - a += ((uint32_t)k8[2]) << 16; /* fall through */ + a += ((uint32_t)k8[2]) << 16; case 2 : a += k[0]; break; @@ -467,13 +393,14 @@ uint32_t hashlittle( const void *key, size_t length, uint32_t initval) a += k8[0]; break; case 0 : - return c; /* zero length requires no mixing */ + /* zero length requires no mixing */ + return c; } - } else { /* need to read the key one byte at a time */ + } else { + /* need to read the key one byte at a time */ const uint8_t *k = (const uint8_t *)key; - /*---- all but the last block: affect some 32 bits of (a,b,c) */ while (length > 12) { a += k[0]; a += ((uint32_t)k[1]) << 8; @@ -492,8 +419,7 @@ uint32_t hashlittle( const void *key, size_t length, uint32_t initval) k += 12; } - /*--------------------- last block: affect all 32 bits of (c) */ - switch(length) { /* all the case statements fall through */ + switch(length) { case 12: c += ((uint32_t)k[11]) << 24; case 11: @@ -528,286 +454,18 @@ uint32_t hashlittle( const void *key, size_t length, uint32_t initval) return c; } -/* - * hashlittle2: return 2 32-bit hash values +/** + * Hash a variable-length key into a 32-bit value + * @param k the key (the unaligned variable-length array of bytes) + * @param length the length of the key, counting by bytes + * @param initval can be any 4-byte value + * + * This is the same as jhash_word() on big-endian machines. It is different + * from jhash_le() on all machines. jhash_be() takes advantage of big-endian + * byte ordering. * - * This is identical to hashlittle(), except it returns two 32-bit hash - * values instead of just one. This is good enough for hash table - * lookup with 2^^64 buckets, or if you want a second hash if you're not - * happy with the first, or if you want a probably-unique 64-bit ID for - * the key. *pc is better mixed than *pb, so use *pc first. If you want - * a 64-bit value do something like "*pc + (((uint64_t)*pb)<<32)". - */ -void hashlittle2( - const void *key, /* the key to hash */ - size_t length, /* length of the key */ - uint32_t *pc, /* IN: primary initval, OUT: primary hash */ - uint32_t *pb) /* IN: secondary initval, OUT: secondary hash */ -{ - uint32_t a, b, c; /* internal state */ - union { - const void *ptr; - size_t i; - } u; /* needed for Mac Powerbook G4 */ - - /* Set up the internal state */ - a = b = c = 0xdeadbeef + ((uint32_t)length) + *pc; - c += *pb; - - u.ptr = key; - if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) { - const uint32_t *k = (const uint32_t *)key; /* read 32b chunks */ - - /* all but last block: aligned reads and affect 32 bits - * of (a,b,c) */ - while (length > 12) { - a += k[0]; - b += k[1]; - c += k[2]; - mix(a, b, c); - length -= 12; - k += 3; - } - - /*------------------ handle the last (probably partial) block */ - /* - * "k[2]&0xffffff" actually reads beyond the end of the string, - * but then masks off the part it's not allowed to read. - * Because the string is aligned, the masked-off tail is in the - * same word as the rest of the string. Every machine with - * memory protection I've seen does it on word boundaries, so - * is OK with this. But VALGRIND will still catch it and - * complain. The masking trick does make the hash noticably - * faster for short strings (like English words). - */ -#ifndef VALGRIND - - switch(length) { - case 12: - c += k[2]; - b += k[1]; - a += k[0]; - break; - case 11: - c += k[2] & 0xffffff; - b += k[1]; - a += k[0]; - break; - case 10: - c += k[2] & 0xffff; - b += k[1]; - a += k[0]; - break; - case 9 : - c += k[2] & 0xff; - b += k[1]; - a += k[0]; - break; - case 8 : - b += k[1]; - a += k[0]; - break; - case 7 : - b += k[1] & 0xffffff; - a += k[0]; - break; - case 6 : - b += k[1] & 0xffff; - a += k[0]; - break; - case 5 : - b += k[1] & 0xff; - a += k[0]; - break; - case 4 : - a += k[0]; - break; - case 3 : - a += k[0] & 0xffffff; - break; - case 2 : - a += k[0] & 0xffff; - break; - case 1 : - a += k[0] & 0xff; - break; - case 0 : - *pc = c; - *pb = b; - return; /* zero length strings require no mixing */ - } - -#else /* make valgrind happy */ - - k8 = (const uint8_t *)k; - switch(length) { - case 12: - c += k[2]; - b += k[1]; - a += k[0]; - break; - case 11: - c += ((uint32_t)k8[10]) << 16; /* fall through */ - case 10: - c += ((uint32_t)k8[9]) << 8; /* fall through */ - case 9 : - c += k8[8]; /* fall through */ - case 8 : - b += k[1]; - a += k[0]; - break; - case 7 : - b += ((uint32_t)k8[6]) << 16; /* fall through */ - case 6 : - b += ((uint32_t)k8[5]) << 8; /* fall through */ - case 5 : - b += k8[4]; /* fall through */ - case 4 : - a += k[0]; - break; - case 3 : - a += ((uint32_t)k8[2]) << 16; /* fall through */ - case 2 : - a += ((uint32_t)k8[1]) << 8; /* fall through */ - case 1 : - a += k8[0]; - break; - case 0 : - *pc = c; - *pb = b; - return; /* zero length strings require no mixing */ - } - -#endif /* !valgrind */ - - } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) { - const uint16_t *k = (const uint16_t *)key; /* read 16b chunks */ - const uint8_t *k8; - - /*---- all but last block: aligned reads and different mixing */ - while (length > 12) { - a += k[0] + (((uint32_t)k[1]) << 16); - b += k[2] + (((uint32_t)k[3]) << 16); - c += k[4] + (((uint32_t)k[5]) << 16); - mix(a, b, c); - length -= 12; - k += 6; - } - - /*------------------ handle the last (probably partial) block */ - k8 = (const uint8_t *)k; - switch(length) { - case 12: - c += k[4] + (((uint32_t)k[5]) << 16); - b += k[2] + (((uint32_t)k[3]) << 16); - a += k[0] + (((uint32_t)k[1]) << 16); - break; - case 11: - c += ((uint32_t)k8[10]) << 16; /* fall through */ - case 10: - c += k[4]; - b += k[2] + (((uint32_t)k[3]) << 16); - a += k[0] + (((uint32_t)k[1]) << 16); - break; - case 9 : - c += k8[8]; /* fall through */ - case 8 : - b += k[2] + (((uint32_t)k[3]) << 16); - a += k[0] + (((uint32_t)k[1]) << 16); - break; - case 7 : - b += ((uint32_t)k8[6]) << 16; /* fall through */ - case 6 : - b += k[2]; - a += k[0] + (((uint32_t)k[1]) << 16); - break; - case 5 : - b += k8[4]; /* fall through */ - case 4 : - a += k[0] + (((uint32_t)k[1]) << 16); - break; - case 3 : - a += ((uint32_t)k8[2]) << 16; /* fall through */ - case 2 : - a += k[0]; - break; - case 1 : - a += k8[0]; - break; - case 0 : - *pc = c; - *pb = b; - return; /* zero length strings require no mixing */ - } - - } else { /* need to read the key one byte at a time */ - const uint8_t *k = (const uint8_t *)key; - - /*---- all but the last block: affect some 32 bits of (a,b,c) */ - while (length > 12) { - a += k[0]; - a += ((uint32_t)k[1]) << 8; - a += ((uint32_t)k[2]) << 16; - a += ((uint32_t)k[3]) << 24; - b += k[4]; - b += ((uint32_t)k[5]) << 8; - b += ((uint32_t)k[6]) << 16; - b += ((uint32_t)k[7]) << 24; - c += k[8]; - c += ((uint32_t)k[9]) << 8; - c += ((uint32_t)k[10]) << 16; - c += ((uint32_t)k[11]) << 24; - mix(a, b, c); - length -= 12; - k += 12; - } - - /*--------------------- last block: affect all 32 bits of (c) */ - switch(length) { /* all the case statements fall through */ - case 12: - c += ((uint32_t)k[11]) << 24; - case 11: - c += ((uint32_t)k[10]) << 16; - case 10: - c += ((uint32_t)k[9]) << 8; - case 9 : - c += k[8]; - case 8 : - b += ((uint32_t)k[7]) << 24; - case 7 : - b += ((uint32_t)k[6]) << 16; - case 6 : - b += ((uint32_t)k[5]) << 8; - case 5 : - b += k[4]; - case 4 : - a += ((uint32_t)k[3]) << 24; - case 3 : - a += ((uint32_t)k[2]) << 16; - case 2 : - a += ((uint32_t)k[1]) << 8; - case 1 : - a += k[0]; - break; - case 0 : - *pc = c; - *pb = b; - return; /* zero length strings require no mixing */ - } - } - - final(a, b, c); - *pc = c; - *pb = b; -} - -/* - * hashbig(): - * This is the same as hashword() on big-endian machines. It is different - * from hashlittle() on all machines. hashbig() takes advantage of - * big-endian byte ordering. */ -uint32_t hashbig( const void *key, size_t length, uint32_t initval) +static uint32_t jhash_be( const void *key, size_t length, uint32_t initval) { uint32_t a, b, c; union { @@ -815,15 +473,15 @@ uint32_t hashbig( const void *key, size_t length, uint32_t initval) size_t i; } u; /* to cast key to (size_t) happily */ - /* Set up the internal state */ + /* set up the internal state */ a = b = c = 0xdeadbeef + ((uint32_t)length) + initval; u.ptr = key; - if (HASH_BIG_ENDIAN && ((u.i & 0x3) == 0)) { - const uint32_t *k = (const uint32_t *)key; /* read 32b chunks */ + if ((arch_def_native->endian == ARCH_ENDIAN_BIG) && + ((u.i & 0x3) == 0)) { + /* read 32-bit chunks */ + const uint32_t *k = (const uint32_t *)key; - /* all but last block: aligned reads and affect 32 bits - * of (a,b,c) */ while (length > 12) { a += k[0]; b += k[1]; @@ -833,17 +491,14 @@ uint32_t hashbig( const void *key, size_t length, uint32_t initval) k += 3; } - /*------------------ handle the last (probably partial) block */ - /* - * "k[2]<<8" actually reads beyond the end of the string, but + /* "k[2]<<8" actually reads beyond the end of the string, but * then shifts out the part it's not allowed to read. Because * the string is aligned, the illegal read is in the same word * as the rest of the string. Every machine with memory * protection I've seen does it on word boundaries, so is OK * with this. But VALGRIND will still catch it and complain. * The masking trick does make the hash noticably faster for - * short strings (like English words). - */ + * short strings (like English words). */ #ifndef VALGRIND switch(length) { @@ -896,41 +551,42 @@ uint32_t hashbig( const void *key, size_t length, uint32_t initval) a += k[0] & 0xff000000; break; case 0 : - return c; /* zero length strings require no mixing */ + /* zero length strings require no mixing */ + return c; } #else /* make valgrind happy */ k8 = (const uint8_t *)k; - switch(length) { /* all the case statements fall through */ + switch(length) { case 12: c += k[2]; b += k[1]; a += k[0]; break; case 11: - c += ((uint32_t)k8[10]) << 8; /* fall through */ + c += ((uint32_t)k8[10]) << 8; case 10: - c += ((uint32_t)k8[9]) << 16; /* fall through */ + c += ((uint32_t)k8[9]) << 16; case 9 : - c += ((uint32_t)k8[8]) << 24; /* fall through */ + c += ((uint32_t)k8[8]) << 24; case 8 : b += k[1]; a += k[0]; break; case 7 : - b += ((uint32_t)k8[6]) << 8; /* fall through */ + b += ((uint32_t)k8[6]) << 8; case 6 : - b += ((uint32_t)k8[5]) << 16; /* fall through */ + b += ((uint32_t)k8[5]) << 16; case 5 : - b += ((uint32_t)k8[4]) << 24; /* fall through */ + b += ((uint32_t)k8[4]) << 24; case 4 : a += k[0]; break; case 3 : - a += ((uint32_t)k8[2]) << 8; /* fall through */ + a += ((uint32_t)k8[2]) << 8; case 2 : - a += ((uint32_t)k8[1]) << 16; /* fall through */ + a += ((uint32_t)k8[1]) << 16; case 1 : a += ((uint32_t)k8[0]) << 24; break; @@ -940,10 +596,10 @@ uint32_t hashbig( const void *key, size_t length, uint32_t initval) #endif /* !VALGRIND */ - } else { /* need to read the key one byte at a time */ + } else { + /* need to read the key one byte at a time */ const uint8_t *k = (const uint8_t *)key; - /*---- all but the last block: affect some 32 bits of (a,b,c) */ while (length > 12) { a += ((uint32_t)k[0]) << 24; a += ((uint32_t)k[1]) << 16; @@ -962,8 +618,7 @@ uint32_t hashbig( const void *key, size_t length, uint32_t initval) k += 12; } - /*--------------------- last block: affect all 32 bits of (c) */ - switch(length) { /* all the case statements fall through */ + switch(length) { case 12: c += k[11]; case 11: @@ -997,3 +652,23 @@ uint32_t hashbig( const void *key, size_t length, uint32_t initval) final(a, b, c); return c; } + +/** + * Hash a variable-length key into a 32-bit value + * @param k the key (the unaligned variable-length array of bytes) + * @param length the length of the key, counting by bytes + * @param initval can be any 4-byte value + * + * A small wrapper function that selects the proper hash function based on the + * native machine's byte-ordering. + * + */ +uint32_t jhash(const void *key, size_t length, uint32_t initval) +{ + if (length % sizeof(uint32_t) == 0) + return jhash_word(key, (length / sizeof(uint32_t)), initval); + else if (arch_def_native->endian == ARCH_ENDIAN_BIG) + return jhash_be(key, length, initval); + else + return jhash_le(key, length, initval); +} -- cgit v1.2.1