daily update
[binutils.git] / libiberty / hashtab.c
bloba5671a0a768041bc12a4e62473ea12aa3afc7fc4
1 /* An expandable hash tables datatype.
2 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
4 Contributed by Vladimir Makarov (vmakarov@cygnus.com).
6 This file is part of the libiberty library.
7 Libiberty is free software; you can redistribute it and/or
8 modify it under the terms of the GNU Library General Public
9 License as published by the Free Software Foundation; either
10 version 2 of the License, or (at your option) any later version.
12 Libiberty is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Library General Public License for more details.
17 You should have received a copy of the GNU Library General Public
18 License along with libiberty; see the file COPYING.LIB. If
19 not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
20 Boston, MA 02110-1301, USA. */
22 /* This package implements basic hash table functionality. It is possible
23 to search for an entry, create an entry and destroy an entry.
25 Elements in the table are generic pointers.
27 The size of the table is not fixed; if the occupancy of the table
28 grows too high the hash table will be expanded.
30 The abstract data implementation is based on generalized Algorithm D
31 from Knuth's book "The art of computer programming". Hash table is
32 expanded by creation of new hash table and transferring elements from
33 the old table to the new table. */
35 #ifdef HAVE_CONFIG_H
36 #include "config.h"
37 #endif
39 #include <sys/types.h>
41 #ifdef HAVE_STDLIB_H
42 #include <stdlib.h>
43 #endif
44 #ifdef HAVE_STRING_H
45 #include <string.h>
46 #endif
47 #ifdef HAVE_MALLOC_H
48 #include <malloc.h>
49 #endif
50 #ifdef HAVE_LIMITS_H
51 #include <limits.h>
52 #endif
53 #ifdef HAVE_STDINT_H
54 #include <stdint.h>
55 #endif
57 #include <stdio.h>
59 #include "libiberty.h"
60 #include "ansidecl.h"
61 #include "hashtab.h"
63 #ifndef CHAR_BIT
64 #define CHAR_BIT 8
65 #endif
67 static unsigned int higher_prime_index (unsigned long);
68 static hashval_t htab_mod_1 (hashval_t, hashval_t, hashval_t, int);
69 static hashval_t htab_mod (hashval_t, htab_t);
70 static hashval_t htab_mod_m2 (hashval_t, htab_t);
71 static hashval_t hash_pointer (const void *);
72 static int eq_pointer (const void *, const void *);
73 static int htab_expand (htab_t);
74 static PTR *find_empty_slot_for_expand (htab_t, hashval_t);
76 /* At some point, we could make these be NULL, and modify the
77 hash-table routines to handle NULL specially; that would avoid
78 function-call overhead for the common case of hashing pointers. */
79 htab_hash htab_hash_pointer = hash_pointer;
80 htab_eq htab_eq_pointer = eq_pointer;
82 /* Table of primes and multiplicative inverses.
84 Note that these are not minimally reduced inverses. Unlike when generating
85 code to divide by a constant, we want to be able to use the same algorithm
86 all the time. All of these inverses (are implied to) have bit 32 set.
88 For the record, here's the function that computed the table; it's a
89 vastly simplified version of the function of the same name from gcc. */
91 #if 0
92 unsigned int
93 ceil_log2 (unsigned int x)
95 int i;
96 for (i = 31; i >= 0 ; --i)
97 if (x > (1u << i))
98 return i+1;
99 abort ();
102 unsigned int
103 choose_multiplier (unsigned int d, unsigned int *mlp, unsigned char *shiftp)
105 unsigned long long mhigh;
106 double nx;
107 int lgup, post_shift;
108 int pow, pow2;
109 int n = 32, precision = 32;
111 lgup = ceil_log2 (d);
112 pow = n + lgup;
113 pow2 = n + lgup - precision;
115 nx = ldexp (1.0, pow) + ldexp (1.0, pow2);
116 mhigh = nx / d;
118 *shiftp = lgup - 1;
119 *mlp = mhigh;
120 return mhigh >> 32;
122 #endif
124 struct prime_ent
126 hashval_t prime;
127 hashval_t inv;
128 hashval_t inv_m2; /* inverse of prime-2 */
129 hashval_t shift;
132 static struct prime_ent const prime_tab[] = {
133 { 7, 0x24924925, 0x9999999b, 2 },
134 { 13, 0x3b13b13c, 0x745d1747, 3 },
135 { 31, 0x08421085, 0x1a7b9612, 4 },
136 { 61, 0x0c9714fc, 0x15b1e5f8, 5 },
137 { 127, 0x02040811, 0x0624dd30, 6 },
138 { 251, 0x05197f7e, 0x073260a5, 7 },
139 { 509, 0x01824366, 0x02864fc8, 8 },
140 { 1021, 0x00c0906d, 0x014191f7, 9 },
141 { 2039, 0x0121456f, 0x0161e69e, 10 },
142 { 4093, 0x00300902, 0x00501908, 11 },
143 { 8191, 0x00080041, 0x00180241, 12 },
144 { 16381, 0x000c0091, 0x00140191, 13 },
145 { 32749, 0x002605a5, 0x002a06e6, 14 },
146 { 65521, 0x000f00e2, 0x00110122, 15 },
147 { 131071, 0x00008001, 0x00018003, 16 },
148 { 262139, 0x00014002, 0x0001c004, 17 },
149 { 524287, 0x00002001, 0x00006001, 18 },
150 { 1048573, 0x00003001, 0x00005001, 19 },
151 { 2097143, 0x00004801, 0x00005801, 20 },
152 { 4194301, 0x00000c01, 0x00001401, 21 },
153 { 8388593, 0x00001e01, 0x00002201, 22 },
154 { 16777213, 0x00000301, 0x00000501, 23 },
155 { 33554393, 0x00001381, 0x00001481, 24 },
156 { 67108859, 0x00000141, 0x000001c1, 25 },
157 { 134217689, 0x000004e1, 0x00000521, 26 },
158 { 268435399, 0x00000391, 0x000003b1, 27 },
159 { 536870909, 0x00000019, 0x00000029, 28 },
160 { 1073741789, 0x0000008d, 0x00000095, 29 },
161 { 2147483647, 0x00000003, 0x00000007, 30 },
162 /* Avoid "decimal constant so large it is unsigned" for 4294967291. */
163 { 0xfffffffb, 0x00000006, 0x00000008, 31 }
166 /* The following function returns an index into the above table of the
167 nearest prime number which is greater than N, and near a power of two. */
169 static unsigned int
170 higher_prime_index (unsigned long n)
172 unsigned int low = 0;
173 unsigned int high = sizeof(prime_tab) / sizeof(prime_tab[0]);
175 while (low != high)
177 unsigned int mid = low + (high - low) / 2;
178 if (n > prime_tab[mid].prime)
179 low = mid + 1;
180 else
181 high = mid;
184 /* If we've run out of primes, abort. */
185 if (n > prime_tab[low].prime)
187 fprintf (stderr, "Cannot find prime bigger than %lu\n", n);
188 abort ();
191 return low;
194 /* Returns a hash code for P. */
196 static hashval_t
197 hash_pointer (const PTR p)
199 return (hashval_t) ((long)p >> 3);
202 /* Returns non-zero if P1 and P2 are equal. */
204 static int
205 eq_pointer (const PTR p1, const PTR p2)
207 return p1 == p2;
211 /* The parens around the function names in the next two definitions
212 are essential in order to prevent macro expansions of the name.
213 The bodies, however, are expanded as expected, so they are not
214 recursive definitions. */
216 /* Return the current size of given hash table. */
218 #define htab_size(htab) ((htab)->size)
220 size_t
221 (htab_size) (htab_t htab)
223 return htab_size (htab);
226 /* Return the current number of elements in given hash table. */
228 #define htab_elements(htab) ((htab)->n_elements - (htab)->n_deleted)
230 size_t
231 (htab_elements) (htab_t htab)
233 return htab_elements (htab);
236 /* Return X % Y. */
238 static inline hashval_t
239 htab_mod_1 (hashval_t x, hashval_t y, hashval_t inv, int shift)
241 /* The multiplicative inverses computed above are for 32-bit types, and
242 requires that we be able to compute a highpart multiply. */
243 #ifdef UNSIGNED_64BIT_TYPE
244 __extension__ typedef UNSIGNED_64BIT_TYPE ull;
245 if (sizeof (hashval_t) * CHAR_BIT <= 32)
247 hashval_t t1, t2, t3, t4, q, r;
249 t1 = ((ull)x * inv) >> 32;
250 t2 = x - t1;
251 t3 = t2 >> 1;
252 t4 = t1 + t3;
253 q = t4 >> shift;
254 r = x - (q * y);
256 return r;
258 #endif
260 /* Otherwise just use the native division routines. */
261 return x % y;
264 /* Compute the primary hash for HASH given HTAB's current size. */
266 static inline hashval_t
267 htab_mod (hashval_t hash, htab_t htab)
269 const struct prime_ent *p = &prime_tab[htab->size_prime_index];
270 return htab_mod_1 (hash, p->prime, p->inv, p->shift);
273 /* Compute the secondary hash for HASH given HTAB's current size. */
275 static inline hashval_t
276 htab_mod_m2 (hashval_t hash, htab_t htab)
278 const struct prime_ent *p = &prime_tab[htab->size_prime_index];
279 return 1 + htab_mod_1 (hash, p->prime - 2, p->inv_m2, p->shift);
282 /* This function creates table with length slightly longer than given
283 source length. Created hash table is initiated as empty (all the
284 hash table entries are HTAB_EMPTY_ENTRY). The function returns the
285 created hash table, or NULL if memory allocation fails. */
287 htab_t
288 htab_create_alloc (size_t size, htab_hash hash_f, htab_eq eq_f,
289 htab_del del_f, htab_alloc alloc_f, htab_free free_f)
291 htab_t result;
292 unsigned int size_prime_index;
294 size_prime_index = higher_prime_index (size);
295 size = prime_tab[size_prime_index].prime;
297 result = (htab_t) (*alloc_f) (1, sizeof (struct htab));
298 if (result == NULL)
299 return NULL;
300 result->entries = (PTR *) (*alloc_f) (size, sizeof (PTR));
301 if (result->entries == NULL)
303 if (free_f != NULL)
304 (*free_f) (result);
305 return NULL;
307 result->size = size;
308 result->size_prime_index = size_prime_index;
309 result->hash_f = hash_f;
310 result->eq_f = eq_f;
311 result->del_f = del_f;
312 result->alloc_f = alloc_f;
313 result->free_f = free_f;
314 return result;
317 /* As above, but use the variants of alloc_f and free_f which accept
318 an extra argument. */
320 htab_t
321 htab_create_alloc_ex (size_t size, htab_hash hash_f, htab_eq eq_f,
322 htab_del del_f, void *alloc_arg,
323 htab_alloc_with_arg alloc_f,
324 htab_free_with_arg free_f)
326 htab_t result;
327 unsigned int size_prime_index;
329 size_prime_index = higher_prime_index (size);
330 size = prime_tab[size_prime_index].prime;
332 result = (htab_t) (*alloc_f) (alloc_arg, 1, sizeof (struct htab));
333 if (result == NULL)
334 return NULL;
335 result->entries = (PTR *) (*alloc_f) (alloc_arg, size, sizeof (PTR));
336 if (result->entries == NULL)
338 if (free_f != NULL)
339 (*free_f) (alloc_arg, result);
340 return NULL;
342 result->size = size;
343 result->size_prime_index = size_prime_index;
344 result->hash_f = hash_f;
345 result->eq_f = eq_f;
346 result->del_f = del_f;
347 result->alloc_arg = alloc_arg;
348 result->alloc_with_arg_f = alloc_f;
349 result->free_with_arg_f = free_f;
350 return result;
353 /* Update the function pointers and allocation parameter in the htab_t. */
355 void
356 htab_set_functions_ex (htab_t htab, htab_hash hash_f, htab_eq eq_f,
357 htab_del del_f, PTR alloc_arg,
358 htab_alloc_with_arg alloc_f, htab_free_with_arg free_f)
360 htab->hash_f = hash_f;
361 htab->eq_f = eq_f;
362 htab->del_f = del_f;
363 htab->alloc_arg = alloc_arg;
364 htab->alloc_with_arg_f = alloc_f;
365 htab->free_with_arg_f = free_f;
368 /* These functions exist solely for backward compatibility. */
370 #undef htab_create
371 htab_t
372 htab_create (size_t size, htab_hash hash_f, htab_eq eq_f, htab_del del_f)
374 return htab_create_alloc (size, hash_f, eq_f, del_f, xcalloc, free);
377 htab_t
378 htab_try_create (size_t size, htab_hash hash_f, htab_eq eq_f, htab_del del_f)
380 return htab_create_alloc (size, hash_f, eq_f, del_f, calloc, free);
383 /* This function frees all memory allocated for given hash table.
384 Naturally the hash table must already exist. */
386 void
387 htab_delete (htab_t htab)
389 size_t size = htab_size (htab);
390 PTR *entries = htab->entries;
391 int i;
393 if (htab->del_f)
394 for (i = size - 1; i >= 0; i--)
395 if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY)
396 (*htab->del_f) (entries[i]);
398 if (htab->free_f != NULL)
400 (*htab->free_f) (entries);
401 (*htab->free_f) (htab);
403 else if (htab->free_with_arg_f != NULL)
405 (*htab->free_with_arg_f) (htab->alloc_arg, entries);
406 (*htab->free_with_arg_f) (htab->alloc_arg, htab);
410 /* This function clears all entries in the given hash table. */
412 void
413 htab_empty (htab_t htab)
415 size_t size = htab_size (htab);
416 PTR *entries = htab->entries;
417 int i;
419 if (htab->del_f)
420 for (i = size - 1; i >= 0; i--)
421 if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY)
422 (*htab->del_f) (entries[i]);
424 memset (entries, 0, size * sizeof (PTR));
427 /* Similar to htab_find_slot, but without several unwanted side effects:
428 - Does not call htab->eq_f when it finds an existing entry.
429 - Does not change the count of elements/searches/collisions in the
430 hash table.
431 This function also assumes there are no deleted entries in the table.
432 HASH is the hash value for the element to be inserted. */
434 static PTR *
435 find_empty_slot_for_expand (htab_t htab, hashval_t hash)
437 hashval_t index = htab_mod (hash, htab);
438 size_t size = htab_size (htab);
439 PTR *slot = htab->entries + index;
440 hashval_t hash2;
442 if (*slot == HTAB_EMPTY_ENTRY)
443 return slot;
444 else if (*slot == HTAB_DELETED_ENTRY)
445 abort ();
447 hash2 = htab_mod_m2 (hash, htab);
448 for (;;)
450 index += hash2;
451 if (index >= size)
452 index -= size;
454 slot = htab->entries + index;
455 if (*slot == HTAB_EMPTY_ENTRY)
456 return slot;
457 else if (*slot == HTAB_DELETED_ENTRY)
458 abort ();
462 /* The following function changes size of memory allocated for the
463 entries and repeatedly inserts the table elements. The occupancy
464 of the table after the call will be about 50%. Naturally the hash
465 table must already exist. Remember also that the place of the
466 table entries is changed. If memory allocation failures are allowed,
467 this function will return zero, indicating that the table could not be
468 expanded. If all goes well, it will return a non-zero value. */
470 static int
471 htab_expand (htab_t htab)
473 PTR *oentries;
474 PTR *olimit;
475 PTR *p;
476 PTR *nentries;
477 size_t nsize, osize, elts;
478 unsigned int oindex, nindex;
480 oentries = htab->entries;
481 oindex = htab->size_prime_index;
482 osize = htab->size;
483 olimit = oentries + osize;
484 elts = htab_elements (htab);
486 /* Resize only when table after removal of unused elements is either
487 too full or too empty. */
488 if (elts * 2 > osize || (elts * 8 < osize && osize > 32))
490 nindex = higher_prime_index (elts * 2);
491 nsize = prime_tab[nindex].prime;
493 else
495 nindex = oindex;
496 nsize = osize;
499 if (htab->alloc_with_arg_f != NULL)
500 nentries = (PTR *) (*htab->alloc_with_arg_f) (htab->alloc_arg, nsize,
501 sizeof (PTR *));
502 else
503 nentries = (PTR *) (*htab->alloc_f) (nsize, sizeof (PTR *));
504 if (nentries == NULL)
505 return 0;
506 htab->entries = nentries;
507 htab->size = nsize;
508 htab->size_prime_index = nindex;
509 htab->n_elements -= htab->n_deleted;
510 htab->n_deleted = 0;
512 p = oentries;
515 PTR x = *p;
517 if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
519 PTR *q = find_empty_slot_for_expand (htab, (*htab->hash_f) (x));
521 *q = x;
524 p++;
526 while (p < olimit);
528 if (htab->free_f != NULL)
529 (*htab->free_f) (oentries);
530 else if (htab->free_with_arg_f != NULL)
531 (*htab->free_with_arg_f) (htab->alloc_arg, oentries);
532 return 1;
535 /* This function searches for a hash table entry equal to the given
536 element. It cannot be used to insert or delete an element. */
539 htab_find_with_hash (htab_t htab, const PTR element, hashval_t hash)
541 hashval_t index, hash2;
542 size_t size;
543 PTR entry;
545 htab->searches++;
546 size = htab_size (htab);
547 index = htab_mod (hash, htab);
549 entry = htab->entries[index];
550 if (entry == HTAB_EMPTY_ENTRY
551 || (entry != HTAB_DELETED_ENTRY && (*htab->eq_f) (entry, element)))
552 return entry;
554 hash2 = htab_mod_m2 (hash, htab);
555 for (;;)
557 htab->collisions++;
558 index += hash2;
559 if (index >= size)
560 index -= size;
562 entry = htab->entries[index];
563 if (entry == HTAB_EMPTY_ENTRY
564 || (entry != HTAB_DELETED_ENTRY && (*htab->eq_f) (entry, element)))
565 return entry;
569 /* Like htab_find_slot_with_hash, but compute the hash value from the
570 element. */
573 htab_find (htab_t htab, const PTR element)
575 return htab_find_with_hash (htab, element, (*htab->hash_f) (element));
578 /* This function searches for a hash table slot containing an entry
579 equal to the given element. To delete an entry, call this with
580 insert=NO_INSERT, then call htab_clear_slot on the slot returned
581 (possibly after doing some checks). To insert an entry, call this
582 with insert=INSERT, then write the value you want into the returned
583 slot. When inserting an entry, NULL may be returned if memory
584 allocation fails. */
586 PTR *
587 htab_find_slot_with_hash (htab_t htab, const PTR element,
588 hashval_t hash, enum insert_option insert)
590 PTR *first_deleted_slot;
591 hashval_t index, hash2;
592 size_t size;
593 PTR entry;
595 size = htab_size (htab);
596 if (insert == INSERT && size * 3 <= htab->n_elements * 4)
598 if (htab_expand (htab) == 0)
599 return NULL;
600 size = htab_size (htab);
603 index = htab_mod (hash, htab);
605 htab->searches++;
606 first_deleted_slot = NULL;
608 entry = htab->entries[index];
609 if (entry == HTAB_EMPTY_ENTRY)
610 goto empty_entry;
611 else if (entry == HTAB_DELETED_ENTRY)
612 first_deleted_slot = &htab->entries[index];
613 else if ((*htab->eq_f) (entry, element))
614 return &htab->entries[index];
616 hash2 = htab_mod_m2 (hash, htab);
617 for (;;)
619 htab->collisions++;
620 index += hash2;
621 if (index >= size)
622 index -= size;
624 entry = htab->entries[index];
625 if (entry == HTAB_EMPTY_ENTRY)
626 goto empty_entry;
627 else if (entry == HTAB_DELETED_ENTRY)
629 if (!first_deleted_slot)
630 first_deleted_slot = &htab->entries[index];
632 else if ((*htab->eq_f) (entry, element))
633 return &htab->entries[index];
636 empty_entry:
637 if (insert == NO_INSERT)
638 return NULL;
640 if (first_deleted_slot)
642 htab->n_deleted--;
643 *first_deleted_slot = HTAB_EMPTY_ENTRY;
644 return first_deleted_slot;
647 htab->n_elements++;
648 return &htab->entries[index];
651 /* Like htab_find_slot_with_hash, but compute the hash value from the
652 element. */
654 PTR *
655 htab_find_slot (htab_t htab, const PTR element, enum insert_option insert)
657 return htab_find_slot_with_hash (htab, element, (*htab->hash_f) (element),
658 insert);
661 /* This function deletes an element with the given value from hash
662 table (the hash is computed from the element). If there is no matching
663 element in the hash table, this function does nothing. */
665 void
666 htab_remove_elt (htab_t htab, PTR element)
668 htab_remove_elt_with_hash (htab, element, (*htab->hash_f) (element));
672 /* This function deletes an element with the given value from hash
673 table. If there is no matching element in the hash table, this
674 function does nothing. */
676 void
677 htab_remove_elt_with_hash (htab_t htab, PTR element, hashval_t hash)
679 PTR *slot;
681 slot = htab_find_slot_with_hash (htab, element, hash, NO_INSERT);
682 if (*slot == HTAB_EMPTY_ENTRY)
683 return;
685 if (htab->del_f)
686 (*htab->del_f) (*slot);
688 *slot = HTAB_DELETED_ENTRY;
689 htab->n_deleted++;
692 /* This function clears a specified slot in a hash table. It is
693 useful when you've already done the lookup and don't want to do it
694 again. */
696 void
697 htab_clear_slot (htab_t htab, PTR *slot)
699 if (slot < htab->entries || slot >= htab->entries + htab_size (htab)
700 || *slot == HTAB_EMPTY_ENTRY || *slot == HTAB_DELETED_ENTRY)
701 abort ();
703 if (htab->del_f)
704 (*htab->del_f) (*slot);
706 *slot = HTAB_DELETED_ENTRY;
707 htab->n_deleted++;
710 /* This function scans over the entire hash table calling
711 CALLBACK for each live entry. If CALLBACK returns false,
712 the iteration stops. INFO is passed as CALLBACK's second
713 argument. */
715 void
716 htab_traverse_noresize (htab_t htab, htab_trav callback, PTR info)
718 PTR *slot;
719 PTR *limit;
721 slot = htab->entries;
722 limit = slot + htab_size (htab);
726 PTR x = *slot;
728 if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
729 if (!(*callback) (slot, info))
730 break;
732 while (++slot < limit);
735 /* Like htab_traverse_noresize, but does resize the table when it is
736 too empty to improve effectivity of subsequent calls. */
738 void
739 htab_traverse (htab_t htab, htab_trav callback, PTR info)
741 if (htab_elements (htab) * 8 < htab_size (htab))
742 htab_expand (htab);
744 htab_traverse_noresize (htab, callback, info);
747 /* Return the fraction of fixed collisions during all work with given
748 hash table. */
750 double
751 htab_collisions (htab_t htab)
753 if (htab->searches == 0)
754 return 0.0;
756 return (double) htab->collisions / (double) htab->searches;
759 /* Hash P as a null-terminated string.
761 Copied from gcc/hashtable.c. Zack had the following to say with respect
762 to applicability, though note that unlike hashtable.c, this hash table
763 implementation re-hashes rather than chain buckets.
765 http://gcc.gnu.org/ml/gcc-patches/2001-08/msg01021.html
766 From: Zack Weinberg <zackw@panix.com>
767 Date: Fri, 17 Aug 2001 02:15:56 -0400
769 I got it by extracting all the identifiers from all the source code
770 I had lying around in mid-1999, and testing many recurrences of
771 the form "H_n = H_{n-1} * K + c_n * L + M" where K, L, M were either
772 prime numbers or the appropriate identity. This was the best one.
773 I don't remember exactly what constituted "best", except I was
774 looking at bucket-length distributions mostly.
776 So it should be very good at hashing identifiers, but might not be
777 as good at arbitrary strings.
779 I'll add that it thoroughly trounces the hash functions recommended
780 for this use at http://burtleburtle.net/bob/hash/index.html, both
781 on speed and bucket distribution. I haven't tried it against the
782 function they just started using for Perl's hashes. */
784 hashval_t
785 htab_hash_string (const PTR p)
787 const unsigned char *str = (const unsigned char *) p;
788 hashval_t r = 0;
789 unsigned char c;
791 while ((c = *str++) != 0)
792 r = r * 67 + c - 113;
794 return r;
797 /* DERIVED FROM:
798 --------------------------------------------------------------------
799 lookup2.c, by Bob Jenkins, December 1996, Public Domain.
800 hash(), hash2(), hash3, and mix() are externally useful functions.
801 Routines to test the hash are included if SELF_TEST is defined.
802 You can use this free for any purpose. It has no warranty.
803 --------------------------------------------------------------------
807 --------------------------------------------------------------------
808 mix -- mix 3 32-bit values reversibly.
809 For every delta with one or two bit set, and the deltas of all three
810 high bits or all three low bits, whether the original value of a,b,c
811 is almost all zero or is uniformly distributed,
812 * If mix() is run forward or backward, at least 32 bits in a,b,c
813 have at least 1/4 probability of changing.
814 * If mix() is run forward, every bit of c will change between 1/3 and
815 2/3 of the time. (Well, 22/100 and 78/100 for some 2-bit deltas.)
816 mix() was built out of 36 single-cycle latency instructions in a
817 structure that could supported 2x parallelism, like so:
818 a -= b;
819 a -= c; x = (c>>13);
820 b -= c; a ^= x;
821 b -= a; x = (a<<8);
822 c -= a; b ^= x;
823 c -= b; x = (b>>13);
825 Unfortunately, superscalar Pentiums and Sparcs can't take advantage
826 of that parallelism. They've also turned some of those single-cycle
827 latency instructions into multi-cycle latency instructions. Still,
828 this is the fastest good hash I could find. There were about 2^^68
829 to choose from. I only looked at a billion or so.
830 --------------------------------------------------------------------
832 /* same, but slower, works on systems that might have 8 byte hashval_t's */
833 #define mix(a,b,c) \
835 a -= b; a -= c; a ^= (c>>13); \
836 b -= c; b -= a; b ^= (a<< 8); \
837 c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
838 a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
839 b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
840 c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
841 a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
842 b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
843 c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
847 --------------------------------------------------------------------
848 hash() -- hash a variable-length key into a 32-bit value
849 k : the key (the unaligned variable-length array of bytes)
850 len : the length of the key, counting by bytes
851 level : can be any 4-byte value
852 Returns a 32-bit value. Every bit of the key affects every bit of
853 the return value. Every 1-bit and 2-bit delta achieves avalanche.
854 About 36+6len instructions.
856 The best hash table sizes are powers of 2. There is no need to do
857 mod a prime (mod is sooo slow!). If you need less than 32 bits,
858 use a bitmask. For example, if you need only 10 bits, do
859 h = (h & hashmask(10));
860 In which case, the hash table should have hashsize(10) elements.
862 If you are hashing n strings (ub1 **)k, do it like this:
863 for (i=0, h=0; i<n; ++i) h = hash( k[i], len[i], h);
865 By Bob Jenkins, 1996. bob_jenkins@burtleburtle.net. You may use this
866 code any way you wish, private, educational, or commercial. It's free.
868 See http://burtleburtle.net/bob/hash/evahash.html
869 Use for hash table lookup, or anything where one collision in 2^32 is
870 acceptable. Do NOT use for cryptographic purposes.
871 --------------------------------------------------------------------
874 hashval_t
875 iterative_hash (const PTR k_in /* the key */,
876 register size_t length /* the length of the key */,
877 register hashval_t initval /* the previous hash, or
878 an arbitrary value */)
880 register const unsigned char *k = (const unsigned char *)k_in;
881 register hashval_t a,b,c,len;
883 /* Set up the internal state */
884 len = length;
885 a = b = 0x9e3779b9; /* the golden ratio; an arbitrary value */
886 c = initval; /* the previous hash value */
888 /*---------------------------------------- handle most of the key */
889 #ifndef WORDS_BIGENDIAN
890 /* On a little-endian machine, if the data is 4-byte aligned we can hash
891 by word for better speed. This gives nondeterministic results on
892 big-endian machines. */
893 if (sizeof (hashval_t) == 4 && (((size_t)k)&3) == 0)
894 while (len >= 12) /* aligned */
896 a += *(hashval_t *)(k+0);
897 b += *(hashval_t *)(k+4);
898 c += *(hashval_t *)(k+8);
899 mix(a,b,c);
900 k += 12; len -= 12;
902 else /* unaligned */
903 #endif
904 while (len >= 12)
906 a += (k[0] +((hashval_t)k[1]<<8) +((hashval_t)k[2]<<16) +((hashval_t)k[3]<<24));
907 b += (k[4] +((hashval_t)k[5]<<8) +((hashval_t)k[6]<<16) +((hashval_t)k[7]<<24));
908 c += (k[8] +((hashval_t)k[9]<<8) +((hashval_t)k[10]<<16)+((hashval_t)k[11]<<24));
909 mix(a,b,c);
910 k += 12; len -= 12;
913 /*------------------------------------- handle the last 11 bytes */
914 c += length;
915 switch(len) /* all the case statements fall through */
917 case 11: c+=((hashval_t)k[10]<<24);
918 case 10: c+=((hashval_t)k[9]<<16);
919 case 9 : c+=((hashval_t)k[8]<<8);
920 /* the first byte of c is reserved for the length */
921 case 8 : b+=((hashval_t)k[7]<<24);
922 case 7 : b+=((hashval_t)k[6]<<16);
923 case 6 : b+=((hashval_t)k[5]<<8);
924 case 5 : b+=k[4];
925 case 4 : a+=((hashval_t)k[3]<<24);
926 case 3 : a+=((hashval_t)k[2]<<16);
927 case 2 : a+=((hashval_t)k[1]<<8);
928 case 1 : a+=k[0];
929 /* case 0: nothing left to add */
931 mix(a,b,c);
932 /*-------------------------------------------- report the result */
933 return c;