1 /* An expandable hash tables datatype.
2 Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3 Contributed by Vladimir Makarov (vmakarov@cygnus.com).
5 This file is part of the libiberty library.
6 Libiberty is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Library General Public
8 License as published by the Free Software Foundation; either
9 version 2 of the License, or (at your option) any later version.
11 Libiberty is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Library General Public License for more details.
16 You should have received a copy of the GNU Library General Public
17 License along with libiberty; see the file COPYING.LIB. If
18 not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* This package implements basic hash table functionality. It is possible
22 to search for an entry, create an entry and destroy an entry.
24 Elements in the table are generic pointers.
26 The size of the table is not fixed; if the occupancy of the table
27 grows too high the hash table will be expanded.
29 The abstract data implementation is based on generalized Algorithm D
30 from Knuth's book "The art of computer programming". Hash table is
31 expanded by creation of new hash table and transferring elements from
32 the old table to the new table. */
38 #include <sys/types.h>
50 #include "libiberty.h"
53 /* This macro defines reserved value for empty table entry. */
55 #define EMPTY_ENTRY ((PTR) 0)
57 /* This macro defines reserved value for table entry which contained
60 #define DELETED_ENTRY ((PTR) 1)
62 static unsigned long higher_prime_number PARAMS ((unsigned long));
63 static hashval_t hash_pointer PARAMS ((const void *));
64 static int eq_pointer PARAMS ((const void *, const void *));
65 static int htab_expand PARAMS ((htab_t));
66 static PTR *find_empty_slot_for_expand PARAMS ((htab_t, hashval_t));
68 /* At some point, we could make these be NULL, and modify the
69 hash-table routines to handle NULL specially; that would avoid
70 function-call overhead for the common case of hashing pointers. */
71 htab_hash htab_hash_pointer = hash_pointer;
72 htab_eq htab_eq_pointer = eq_pointer;
74 /* The following function returns a nearest prime number which is
75 greater than N, and near a power of two. */
78 higher_prime_number (n)
81 /* These are primes that are near, but slightly smaller than, a
83 static const unsigned long primes[] = {
95 (unsigned long) 16381,
96 (unsigned long) 32749,
97 (unsigned long) 65521,
98 (unsigned long) 131071,
99 (unsigned long) 262139,
100 (unsigned long) 524287,
101 (unsigned long) 1048573,
102 (unsigned long) 2097143,
103 (unsigned long) 4194301,
104 (unsigned long) 8388593,
105 (unsigned long) 16777213,
106 (unsigned long) 33554393,
107 (unsigned long) 67108859,
108 (unsigned long) 134217689,
109 (unsigned long) 268435399,
110 (unsigned long) 536870909,
111 (unsigned long) 1073741789,
112 (unsigned long) 2147483647,
114 ((unsigned long) 2147483647) + ((unsigned long) 2147483644),
117 const unsigned long *low = &primes[0];
118 const unsigned long *high = &primes[sizeof(primes) / sizeof(primes[0])];
122 const unsigned long *mid = low + (high - low) / 2;
129 /* If we've run out of primes, abort. */
132 fprintf (stderr, "Cannot find prime bigger than %lu\n", n);
139 /* Returns a hash code for P. */
145 return (hashval_t) ((long)p >> 3);
148 /* Returns non-zero if P1 and P2 are equal. */
158 /* This function creates table with length slightly longer than given
159 source length. Created hash table is initiated as empty (all the
160 hash table entries are EMPTY_ENTRY). The function returns the
161 created hash table, or NULL if memory allocation fails. */
164 htab_create_alloc (size, hash_f, eq_f, del_f, alloc_f, free_f)
174 size = higher_prime_number (size);
175 result = (htab_t) (*alloc_f) (1, sizeof (struct htab));
178 result->entries = (PTR *) (*alloc_f) (size, sizeof (PTR));
179 if (result->entries == NULL)
186 result->hash_f = hash_f;
188 result->del_f = del_f;
189 result->alloc_f = alloc_f;
190 result->free_f = free_f;
194 /* These functions exist solely for backward compatibility. */
198 htab_create (size, hash_f, eq_f, del_f)
204 return htab_create_alloc (size, hash_f, eq_f, del_f, xcalloc, free);
208 htab_try_create (size, hash_f, eq_f, del_f)
214 return htab_create_alloc (size, hash_f, eq_f, del_f, calloc, free);
217 /* This function frees all memory allocated for given hash table.
218 Naturally the hash table must already exist. */
227 for (i = htab->size - 1; i >= 0; i--)
228 if (htab->entries[i] != EMPTY_ENTRY
229 && htab->entries[i] != DELETED_ENTRY)
230 (*htab->del_f) (htab->entries[i]);
232 if (htab->free_f != NULL)
234 (*htab->free_f) (htab->entries);
235 (*htab->free_f) (htab);
239 /* This function clears all entries in the given hash table. */
248 for (i = htab->size - 1; i >= 0; i--)
249 if (htab->entries[i] != EMPTY_ENTRY
250 && htab->entries[i] != DELETED_ENTRY)
251 (*htab->del_f) (htab->entries[i]);
253 memset (htab->entries, 0, htab->size * sizeof (PTR));
256 /* Similar to htab_find_slot, but without several unwanted side effects:
257 - Does not call htab->eq_f when it finds an existing entry.
258 - Does not change the count of elements/searches/collisions in the
260 This function also assumes there are no deleted entries in the table.
261 HASH is the hash value for the element to be inserted. */
264 find_empty_slot_for_expand (htab, hash)
268 size_t size = htab->size;
269 unsigned int index = hash % size;
270 PTR *slot = htab->entries + index;
273 if (*slot == EMPTY_ENTRY)
275 else if (*slot == DELETED_ENTRY)
278 hash2 = 1 + hash % (size - 2);
285 slot = htab->entries + index;
286 if (*slot == EMPTY_ENTRY)
288 else if (*slot == DELETED_ENTRY)
293 /* The following function changes size of memory allocated for the
294 entries and repeatedly inserts the table elements. The occupancy
295 of the table after the call will be about 50%. Naturally the hash
296 table must already exist. Remember also that the place of the
297 table entries is changed. If memory allocation failures are allowed,
298 this function will return zero, indicating that the table could not be
299 expanded. If all goes well, it will return a non-zero value. */
311 oentries = htab->entries;
312 olimit = oentries + htab->size;
314 nsize = higher_prime_number (htab->size * 2);
316 nentries = (PTR *) (*htab->alloc_f) (nsize, sizeof (PTR));
317 if (nentries == NULL)
319 htab->entries = nentries;
322 htab->n_elements -= htab->n_deleted;
330 if (x != EMPTY_ENTRY && x != DELETED_ENTRY)
332 PTR *q = find_empty_slot_for_expand (htab, (*htab->hash_f) (x));
341 if (htab->free_f != NULL)
342 (*htab->free_f) (oentries);
346 /* This function searches for a hash table entry equal to the given
347 element. It cannot be used to insert or delete an element. */
350 htab_find_with_hash (htab, element, hash)
364 entry = htab->entries[index];
365 if (entry == EMPTY_ENTRY
366 || (entry != DELETED_ENTRY && (*htab->eq_f) (entry, element)))
369 hash2 = 1 + hash % (size - 2);
378 entry = htab->entries[index];
379 if (entry == EMPTY_ENTRY
380 || (entry != DELETED_ENTRY && (*htab->eq_f) (entry, element)))
385 /* Like htab_find_slot_with_hash, but compute the hash value from the
389 htab_find (htab, element)
393 return htab_find_with_hash (htab, element, (*htab->hash_f) (element));
396 /* This function searches for a hash table slot containing an entry
397 equal to the given element. To delete an entry, call this with
398 INSERT = 0, then call htab_clear_slot on the slot returned (possibly
399 after doing some checks). To insert an entry, call this with
400 INSERT = 1, then write the value you want into the returned slot.
401 When inserting an entry, NULL may be returned if memory allocation
405 htab_find_slot_with_hash (htab, element, hash, insert)
409 enum insert_option insert;
411 PTR *first_deleted_slot;
417 if (insert == INSERT && htab->size * 3 <= htab->n_elements * 4
418 && htab_expand (htab) == 0)
425 first_deleted_slot = NULL;
427 entry = htab->entries[index];
428 if (entry == EMPTY_ENTRY)
430 else if (entry == DELETED_ENTRY)
431 first_deleted_slot = &htab->entries[index];
432 else if ((*htab->eq_f) (entry, element))
433 return &htab->entries[index];
435 hash2 = 1 + hash % (size - 2);
443 entry = htab->entries[index];
444 if (entry == EMPTY_ENTRY)
446 else if (entry == DELETED_ENTRY)
448 if (!first_deleted_slot)
449 first_deleted_slot = &htab->entries[index];
451 else if ((*htab->eq_f) (entry, element))
452 return &htab->entries[index];
456 if (insert == NO_INSERT)
461 if (first_deleted_slot)
463 *first_deleted_slot = EMPTY_ENTRY;
464 return first_deleted_slot;
467 return &htab->entries[index];
470 /* Like htab_find_slot_with_hash, but compute the hash value from the
474 htab_find_slot (htab, element, insert)
477 enum insert_option insert;
479 return htab_find_slot_with_hash (htab, element, (*htab->hash_f) (element),
483 /* This function deletes an element with the given value from hash
484 table. If there is no matching element in the hash table, this
485 function does nothing. */
488 htab_remove_elt (htab, element)
494 slot = htab_find_slot (htab, element, NO_INSERT);
495 if (*slot == EMPTY_ENTRY)
499 (*htab->del_f) (*slot);
501 *slot = DELETED_ENTRY;
505 /* This function clears a specified slot in a hash table. It is
506 useful when you've already done the lookup and don't want to do it
510 htab_clear_slot (htab, slot)
514 if (slot < htab->entries || slot >= htab->entries + htab->size
515 || *slot == EMPTY_ENTRY || *slot == DELETED_ENTRY)
519 (*htab->del_f) (*slot);
521 *slot = DELETED_ENTRY;
525 /* This function scans over the entire hash table calling
526 CALLBACK for each live entry. If CALLBACK returns false,
527 the iteration stops. INFO is passed as CALLBACK's second
531 htab_traverse (htab, callback, info)
536 PTR *slot = htab->entries;
537 PTR *limit = slot + htab->size;
543 if (x != EMPTY_ENTRY && x != DELETED_ENTRY)
544 if (!(*callback) (slot, info))
547 while (++slot < limit);
550 /* Return the current size of given hash table. */
559 /* Return the current number of elements in given hash table. */
565 return htab->n_elements - htab->n_deleted;
568 /* Return the fraction of fixed collisions during all work with given
572 htab_collisions (htab)
575 if (htab->searches == 0)
578 return (double) htab->collisions / (double) htab->searches;
581 /* Hash P as a null-terminated string.
583 Copied from gcc/hashtable.c. Zack had the following to say with respect
584 to applicability, though note that unlike hashtable.c, this hash table
585 implementation re-hashes rather than chain buckets.
587 http://gcc.gnu.org/ml/gcc-patches/2001-08/msg01021.html
588 From: Zack Weinberg <zackw@panix.com>
589 Date: Fri, 17 Aug 2001 02:15:56 -0400
591 I got it by extracting all the identifiers from all the source code
592 I had lying around in mid-1999, and testing many recurrences of
593 the form "H_n = H_{n-1} * K + c_n * L + M" where K, L, M were either
594 prime numbers or the appropriate identity. This was the best one.
595 I don't remember exactly what constituted "best", except I was
596 looking at bucket-length distributions mostly.
598 So it should be very good at hashing identifiers, but might not be
599 as good at arbitrary strings.
601 I'll add that it thoroughly trounces the hash functions recommended
602 for this use at http://burtleburtle.net/bob/hash/index.html, both
603 on speed and bucket distribution. I haven't tried it against the
604 function they just started using for Perl's hashes. */
610 const unsigned char *str = (const unsigned char *) p;
614 while ((c = *str++) != 0)
615 r = r * 67 + c - 113;