/* An expandable hash tables datatype.     Copyright (C) 1999-2026 Free Software Foundation, Inc.   Contributed by Vladimir Makarov (vmakarov@cygnus.com). This file is part of the libiberty library.Libiberty is free software; you can redistribute it and/ormodify it under the terms of the GNU Library General PublicLicense as published by the Free Software Foundation; eitherversion 2 of the License, or (at your option) any later version. Libiberty is distributed in the hope that it will be useful,but WITHOUT ANY WARRANTY; without even the implied warranty ofMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNULibrary General Public License for more details. You should have received a copy of the GNU Library General PublicLicense along with libiberty; see the file COPYING.LIB.  Ifnot, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,Boston, MA 02110-1301, USA.  */ /* This package implements basic hash table functionality.  It is possible   to search for an entry, create an entry and destroy an entry.    Elements in the table are generic pointers.    The size of the table is not fixed; if the occupancy of the table   grows too high the hash table will be expanded.    The abstract data implementation is based on generalized Algorithm D   from Knuth's book "The art of computer programming".  Hash table is   expanded by creation of new hash table and transferring elements from   the old table to the new table. */ #ifdef HAVE_CONFIG_H#include "config.h"#endif #include <sys/types.h> #ifdef HAVE_STDLIB_H#include <stdlib.h>#endif#ifdef HAVE_STRING_H#include <string.h>#endif#ifdef HAVE_MALLOC_H#include <malloc.h>#endif#ifdef HAVE_LIMITS_H#include <limits.h>#endif#ifdef HAVE_INTTYPES_H#include <inttypes.h>#endif#ifdef HAVE_STDINT_H#include <stdint.h>#endif #include <stdio.h> #include "libiberty.h"#include "ansidecl.h"#include "hashtab.h" #ifndef CHAR_BIT#define CHAR_BIT 8#endif static unsigned int higher_prime_index (unsigned long);static hashval_t htab_mod_1 (hashval_t, hashval_t, hashval_t, int);static hashval_t htab_mod (hashval_t, htab_t);static hashval_t htab_mod_m2 (hashval_t, htab_t);static hashval_t hash_pointer (const void *);static int eq_pointer (const void *, const void *);static int htab_expand (htab_t);static void **find_empty_slot_for_expand (htab_t, hashval_t); /* At some point, we could make these be NULL, and modify the   hash-table routines to handle NULL specially; that would avoid   function-call overhead for the common case of hashing pointers.  */htab_hash htab_hash_pointer = hash_pointer;htab_eq htab_eq_pointer = eq_pointer; /* Table of primes and multiplicative inverses.    Note that these are not minimally reduced inverses.  Unlike when generating   code to divide by a constant, we want to be able to use the same algorithm   all the time.  All of these inverses (are implied to) have bit 32 set.    For the record, here's the function that computed the table; it's a    vastly simplified version of the function of the same name from gcc.  */ #if 0unsigned intceil_log2 (unsigned int x){  int i;  for (i = 31; i >= 0 ; --i)    if (x > (1u << i))      return i+1;  abort ();} unsigned intchoose_multiplier (unsigned int d, unsigned int *mlp, unsigned char *shiftp){  unsigned long long mhigh;  double nx;  int lgup, post_shift;  int pow, pow2;  int n = 32, precision = 32;   lgup = ceil_log2 (d);  pow = n + lgup;  pow2 = n + lgup - precision;   nx = ldexp (1.0, pow) + ldexp (1.0, pow2);  mhigh = nx / d;   *shiftp = lgup - 1;  *mlp = mhigh;  return mhigh >> 32;}#endif struct prime_ent{  hashval_t prime;  hashval_t inv;  hashval_t inv_m2;	/* inverse of prime-2 */  hashval_t shift;}; static struct prime_ent const prime_tab[] = {  {          7, 0x24924925, 0x9999999b, 2 },  {         13, 0x3b13b13c, 0x745d1747, 3 },  {         31, 0x08421085, 0x1a7b9612, 4 },  {         61, 0x0c9714fc, 0x15b1e5f8, 5 },  {        127, 0x02040811, 0x0624dd30, 6 },  {        251, 0x05197f7e, 0x073260a5, 7 },  {        509, 0x01824366, 0x02864fc8, 8 },  {       1021, 0x00c0906d, 0x014191f7, 9 },  {       2039, 0x0121456f, 0x0161e69e, 10 },  {       4093, 0x00300902, 0x00501908, 11 },  {       8191, 0x00080041, 0x00180241, 12 },  {      16381, 0x000c0091, 0x00140191, 13 },  {      32749, 0x002605a5, 0x002a06e6, 14 },  {      65521, 0x000f00e2, 0x00110122, 15 },  {     131071, 0x00008001, 0x00018003, 16 },  {     262139, 0x00014002, 0x0001c004, 17 },  {     524287, 0x00002001, 0x00006001, 18 },  {    1048573, 0x00003001, 0x00005001, 19 },  {    2097143, 0x00004801, 0x00005801, 20 },  {    4194301, 0x00000c01, 0x00001401, 21 },  {    8388593, 0x00001e01, 0x00002201, 22 },  {   16777213, 0x00000301, 0x00000501, 23 },  {   33554393, 0x00001381, 0x00001481, 24 },  {   67108859, 0x00000141, 0x000001c1, 25 },  {  134217689, 0x000004e1, 0x00000521, 26 },  {  268435399, 0x00000391, 0x000003b1, 27 },  {  536870909, 0x00000019, 0x00000029, 28 },  { 1073741789, 0x0000008d, 0x00000095, 29 },  { 2147483647, 0x00000003, 0x00000007, 30 },  /* Avoid "decimal constant so large it is unsigned" for 4294967291.  */  { 0xfffffffb, 0x00000006, 0x00000008, 31 }}; /* The following function returns an index into the above table of the   nearest prime number which is greater than N, and near a power of two. */ static unsigned inthigher_prime_index (unsigned long n){  unsigned int low = 0;  unsigned int high = sizeof(prime_tab) / sizeof(prime_tab[0]);   while (low != high)    {      unsigned int mid = low + (high - low) / 2;      if (n > prime_tab[mid].prime)	low = mid + 1;      else	high = mid;    }   /* If we've run out of primes, abort.  */  if (n > prime_tab[low].prime)    {      fprintf (stderr, "Cannot find prime bigger than %lu\n", n);      abort ();    }   return low;} /* Returns non-zero if P1 and P2 are equal.  */ static inteq_pointer (const void *p1, const void *p2){  return p1 == p2;}  /* The parens around the function names in the next two definitions   are essential in order to prevent macro expansions of the name.   The bodies, however, are expanded as expected, so they are not   recursive definitions.  */ /* Return the current size of given hash table.  */ #define htab_size(htab)  ((htab)->size) size_t(htab_size) (htab_t htab){  return htab_size (htab);} /* Return the current number of elements in given hash table. */ #define htab_elements(htab)  ((htab)->n_elements - (htab)->n_deleted) size_t(htab_elements) (htab_t htab){  return htab_elements (htab);} /* Return X % Y.  */ static inline hashval_thtab_mod_1 (hashval_t x, hashval_t y, hashval_t inv, int shift){  /* The multiplicative inverses computed above are for 32-bit types, and     requires that we be able to compute a highpart multiply.  */#ifdef UNSIGNED_64BIT_TYPE  __extension__ typedef UNSIGNED_64BIT_TYPE ull;  if (sizeof (hashval_t) * CHAR_BIT <= 32)    {      hashval_t t1, t2, t3, t4, q, r;       t1 = ((ull)x * inv) >> 32;      t2 = x - t1;      t3 = t2 >> 1;      t4 = t1 + t3;      q  = t4 >> shift;      r  = x - (q * y);       return r;    }#endif   /* Otherwise just use the native division routines.  */  return x % y;} /* Compute the primary hash for HASH given HTAB's current size.  */ static inline hashval_thtab_mod (hashval_t hash, htab_t htab){  const struct prime_ent *p = &prime_tab[htab->size_prime_index];  return htab_mod_1 (hash, p->prime, p->inv, p->shift);} /* Compute the secondary hash for HASH given HTAB's current size.  */ static inline hashval_thtab_mod_m2 (hashval_t hash, htab_t htab){  const struct prime_ent *p = &prime_tab[htab->size_prime_index];  return 1 + htab_mod_1 (hash, p->prime - 2, p->inv_m2, p->shift);} /* This function creates table with length slightly longer than given   source length.  Created hash table is initiated as empty (all the   hash table entries are HTAB_EMPTY_ENTRY).  The function returns the   created hash table, or NULL if memory allocation fails.  */ htab_thtab_create_alloc (size_t size, htab_hash hash_f, htab_eq eq_f,                   htab_del del_f, htab_alloc alloc_f, htab_free free_f){  return htab_create_typed_alloc (size, hash_f, eq_f, del_f, alloc_f, alloc_f,				  free_f);} /* As above, but uses the variants of ALLOC_F and FREE_F which accept   an extra argument.  */ htab_thtab_create_alloc_ex (size_t size, htab_hash hash_f, htab_eq eq_f,		      htab_del del_f, void *alloc_arg,		      htab_alloc_with_arg alloc_f,		      htab_free_with_arg free_f){  htab_t result;  unsigned int size_prime_index;   size_prime_index = higher_prime_index (size);  size = prime_tab[size_prime_index].prime;   result = (htab_t) (*alloc_f) (alloc_arg, 1, sizeof (struct htab));  if (result == NULL)    return NULL;  result->entries = (void **) (*alloc_f) (alloc_arg, size, sizeof (void *));  if (result->entries == NULL)    {      if (free_f != NULL)	(*free_f) (alloc_arg, result);      return NULL;    }  result->size = size;  result->size_prime_index = size_prime_index;  result->hash_f = hash_f;  result->eq_f = eq_f;  result->del_f = del_f;  result->alloc_arg = alloc_arg;  result->alloc_with_arg_f = alloc_f;  result->free_with_arg_f = free_f;  return result;} /* @deftypefn Supplemental htab_t htab_create_typed_alloc (size_t @var{size}, @htab_hash @var{hash_f}, htab_eq @var{eq_f}, htab_del @var{del_f}, @htab_alloc @var{alloc_tab_f}, htab_alloc @var{alloc_f}, @htab_free @var{free_f}) This function creates a hash table that uses two different allocators@var{alloc_tab_f} and @var{alloc_f} to use for allocating the table itselfand its entries respectively.  This is useful when variables of differenttypes need to be allocated with different allocators. The created hash table is slightly larger than @var{size} and it isinitially empty (all the hash table entries are @code{HTAB_EMPTY_ENTRY}).The function returns the created hash table, or @code{NULL} if memoryallocation fails. @end deftypefn */ htab_thtab_create_typed_alloc (size_t size, htab_hash hash_f, htab_eq eq_f,			 htab_del del_f, htab_alloc alloc_tab_f,			 htab_alloc alloc_f, htab_free free_f){  htab_t result;  unsigned int size_prime_index;   size_prime_index = higher_prime_index (size);  size = prime_tab[size_prime_index].prime;   result = (htab_t) (*alloc_tab_f) (1, sizeof (struct htab));  if (result == NULL)    return NULL;  result->entries = (void **) (*alloc_f) (size, sizeof (void *));  if (result->entries == NULL)    {      if (free_f != NULL)	(*free_f) (result);      return NULL;    }  result->size = size;  result->size_prime_index = size_prime_index;  result->hash_f = hash_f;  result->eq_f = eq_f;  result->del_f = del_f;  result->alloc_f = alloc_f;  result->free_f = free_f;  return result;}  /* Update the function pointers and allocation parameter in the htab_t.  */ voidhtab_set_functions_ex (htab_t htab, htab_hash hash_f, htab_eq eq_f,                       htab_del del_f, void *alloc_arg,                       htab_alloc_with_arg alloc_f, htab_free_with_arg free_f){  htab->hash_f = hash_f;  htab->eq_f = eq_f;  htab->del_f = del_f;  htab->alloc_arg = alloc_arg;  htab->alloc_with_arg_f = alloc_f;  htab->free_with_arg_f = free_f;} /* These functions exist solely for backward compatibility.  */ #undef htab_createhtab_thtab_create (size_t size, htab_hash hash_f, htab_eq eq_f, htab_del del_f){  return htab_create_alloc (size, hash_f, eq_f, del_f, xcalloc, free);} htab_thtab_try_create (size_t size, htab_hash hash_f, htab_eq eq_f, htab_del del_f){  return htab_create_alloc (size, hash_f, eq_f, del_f, calloc, free);} /* This function frees all memory allocated for given hash table.   Naturally the hash table must already exist. */ voidhtab_delete (htab_t htab){  size_t size = htab_size (htab);  void **entries = htab->entries;  int i;   if (htab->del_f)    for (i = size - 1; i >= 0; i--)      if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY)	(*htab->del_f) (entries[i]);   if (htab->free_f != NULL)    {      (*htab->free_f) (entries);      (*htab->free_f) (htab);    }  else if (htab->free_with_arg_f != NULL)    {      (*htab->free_with_arg_f) (htab->alloc_arg, entries);      (*htab->free_with_arg_f) (htab->alloc_arg, htab);    }} /* This function clears all entries in the given hash table.  */ voidhtab_empty (htab_t htab){  size_t size = htab_size (htab);  void **entries = htab->entries;  int i;   if (htab->del_f)    for (i = size - 1; i >= 0; i--)      if (entries[i] != HTAB_EMPTY_ENTRY && entries[i] != HTAB_DELETED_ENTRY)	(*htab->del_f) (entries[i]);   /* Instead of clearing megabyte, downsize the table.  */  if (size > 1024*1024 / sizeof (void *))    {      int nindex = higher_prime_index (1024 / sizeof (void *));      int nsize = prime_tab[nindex].prime;       if (htab->free_f != NULL)	(*htab->free_f) (htab->entries);      else if (htab->free_with_arg_f != NULL)	(*htab->free_with_arg_f) (htab->alloc_arg, htab->entries);      if (htab->alloc_with_arg_f != NULL)	htab->entries = (void **) (*htab->alloc_with_arg_f) (htab->alloc_arg, nsize,							     sizeof (void *));      else	htab->entries = (void **) (*htab->alloc_f) (nsize, sizeof (void *));     htab->size = nsize;     htab->size_prime_index = nindex;    }  else    memset (entries, 0, size * sizeof (void *));  htab->n_deleted = 0;  htab->n_elements = 0;} /* Similar to htab_find_slot, but without several unwanted side effects:    - Does not call htab->eq_f when it finds an existing entry.    - Does not change the count of elements/searches/collisions in the      hash table.   This function also assumes there are no deleted entries in the table.   HASH is the hash value for the element to be inserted.  */ static void **find_empty_slot_for_expand (htab_t htab, hashval_t hash){  hashval_t index = htab_mod (hash, htab);  size_t size = htab_size (htab);  void **slot = htab->entries + index;  hashval_t hash2;   if (*slot == HTAB_EMPTY_ENTRY)    return slot;  else if (*slot == HTAB_DELETED_ENTRY)    abort ();   hash2 = htab_mod_m2 (hash, htab);  for (;;)    {      index += hash2;      if (index >= size)	index -= size;       slot = htab->entries + index;

Lines 1–500 of 1001. Load more