1 /* hash.c -- hash table routines for BFD
2 Copyright 1993, 1994, 1995, 1997, 1999, 2001, 2002, 2003, 2004, 2005,
3 2006, 2007, 2009, 2010, 2011 Free Software Foundation, Inc.
4 Written by Steve Chamberlain <sac@cygnus.com>
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "libiberty.h"
34 BFD provides a simple set of hash table functions. Routines
35 are provided to initialize a hash table, to free a hash table,
36 to look up a string in a hash table and optionally create an
37 entry for it, and to traverse a hash table. There is
38 currently no routine to delete an string from a hash table.
40 The basic hash table does not permit any data to be stored
41 with a string. However, a hash table is designed to present a
42 base class from which other types of hash tables may be
43 derived. These derived types may store additional information
44 with the string. Hash tables were implemented in this way,
45 rather than simply providing a data pointer in a hash table
46 entry, because they were designed for use by the linker back
47 ends. The linker may create thousands of hash table entries,
48 and the overhead of allocating private data and storing and
49 following pointers becomes noticeable.
51 The basic hash table code is in <<hash.c>>.
54 @* Creating and Freeing a Hash Table::
55 @* Looking Up or Entering a String::
56 @* Traversing a Hash Table::
57 @* Deriving a New Hash Table Type::
61 Creating and Freeing a Hash Table, Looking Up or Entering a String, Hash Tables, Hash Tables
63 Creating and freeing a hash table
65 @findex bfd_hash_table_init
66 @findex bfd_hash_table_init_n
67 To create a hash table, create an instance of a <<struct
68 bfd_hash_table>> (defined in <<bfd.h>>) and call
69 <<bfd_hash_table_init>> (if you know approximately how many
70 entries you will need, the function <<bfd_hash_table_init_n>>,
71 which takes a @var{size} argument, may be used).
72 <<bfd_hash_table_init>> returns <<FALSE>> if some sort of
75 @findex bfd_hash_newfunc
76 The function <<bfd_hash_table_init>> take as an argument a
77 function to use to create new entries. For a basic hash
78 table, use the function <<bfd_hash_newfunc>>. @xref{Deriving
79 a New Hash Table Type}, for why you would want to use a
80 different value for this argument.
82 @findex bfd_hash_allocate
83 <<bfd_hash_table_init>> will create an objalloc which will be
84 used to allocate new entries. You may allocate memory on this
85 objalloc using <<bfd_hash_allocate>>.
87 @findex bfd_hash_table_free
88 Use <<bfd_hash_table_free>> to free up all the memory that has
89 been allocated for a hash table. This will not free up the
90 <<struct bfd_hash_table>> itself, which you must provide.
92 @findex bfd_hash_set_default_size
93 Use <<bfd_hash_set_default_size>> to set the default size of
97 Looking Up or Entering a String, Traversing a Hash Table, Creating and Freeing a Hash Table, Hash Tables
99 Looking up or entering a string
101 @findex bfd_hash_lookup
102 The function <<bfd_hash_lookup>> is used both to look up a
103 string in the hash table and to create a new entry.
105 If the @var{create} argument is <<FALSE>>, <<bfd_hash_lookup>>
106 will look up a string. If the string is found, it will
107 returns a pointer to a <<struct bfd_hash_entry>>. If the
108 string is not found in the table <<bfd_hash_lookup>> will
109 return <<NULL>>. You should not modify any of the fields in
110 the returns <<struct bfd_hash_entry>>.
112 If the @var{create} argument is <<TRUE>>, the string will be
113 entered into the hash table if it is not already there.
114 Either way a pointer to a <<struct bfd_hash_entry>> will be
115 returned, either to the existing structure or to a newly
116 created one. In this case, a <<NULL>> return means that an
119 If the @var{create} argument is <<TRUE>>, and a new entry is
120 created, the @var{copy} argument is used to decide whether to
121 copy the string onto the hash table objalloc or not. If
122 @var{copy} is passed as <<FALSE>>, you must be careful not to
123 deallocate or modify the string as long as the hash table
127 Traversing a Hash Table, Deriving a New Hash Table Type, Looking Up or Entering a String, Hash Tables
129 Traversing a hash table
131 @findex bfd_hash_traverse
132 The function <<bfd_hash_traverse>> may be used to traverse a
133 hash table, calling a function on each element. The traversal
134 is done in a random order.
136 <<bfd_hash_traverse>> takes as arguments a function and a
137 generic <<void *>> pointer. The function is called with a
138 hash table entry (a <<struct bfd_hash_entry *>>) and the
139 generic pointer passed to <<bfd_hash_traverse>>. The function
140 must return a <<boolean>> value, which indicates whether to
141 continue traversing the hash table. If the function returns
142 <<FALSE>>, <<bfd_hash_traverse>> will stop the traversal and
146 Deriving a New Hash Table Type, , Traversing a Hash Table, Hash Tables
148 Deriving a new hash table type
150 Many uses of hash tables want to store additional information
151 which each entry in the hash table. Some also find it
152 convenient to store additional information with the hash table
153 itself. This may be done using a derived hash table.
155 Since C is not an object oriented language, creating a derived
156 hash table requires sticking together some boilerplate
157 routines with a few differences specific to the type of hash
158 table you want to create.
160 An example of a derived hash table is the linker hash table.
161 The structures for this are defined in <<bfdlink.h>>. The
162 functions are in <<linker.c>>.
164 You may also derive a hash table from an already derived hash
165 table. For example, the a.out linker backend code uses a hash
166 table derived from the linker hash table.
169 @* Define the Derived Structures::
170 @* Write the Derived Creation Routine::
171 @* Write Other Derived Routines::
175 Define the Derived Structures, Write the Derived Creation Routine, Deriving a New Hash Table Type, Deriving a New Hash Table Type
177 Define the derived structures
179 You must define a structure for an entry in the hash table,
180 and a structure for the hash table itself.
182 The first field in the structure for an entry in the hash
183 table must be of the type used for an entry in the hash table
184 you are deriving from. If you are deriving from a basic hash
185 table this is <<struct bfd_hash_entry>>, which is defined in
186 <<bfd.h>>. The first field in the structure for the hash
187 table itself must be of the type of the hash table you are
188 deriving from itself. If you are deriving from a basic hash
189 table, this is <<struct bfd_hash_table>>.
191 For example, the linker hash table defines <<struct
192 bfd_link_hash_entry>> (in <<bfdlink.h>>). The first field,
193 <<root>>, is of type <<struct bfd_hash_entry>>. Similarly,
194 the first field in <<struct bfd_link_hash_table>>, <<table>>,
195 is of type <<struct bfd_hash_table>>.
198 Write the Derived Creation Routine, Write Other Derived Routines, Define the Derived Structures, Deriving a New Hash Table Type
200 Write the derived creation routine
202 You must write a routine which will create and initialize an
203 entry in the hash table. This routine is passed as the
204 function argument to <<bfd_hash_table_init>>.
206 In order to permit other hash tables to be derived from the
207 hash table you are creating, this routine must be written in a
210 The first argument to the creation routine is a pointer to a
211 hash table entry. This may be <<NULL>>, in which case the
212 routine should allocate the right amount of space. Otherwise
213 the space has already been allocated by a hash table type
214 derived from this one.
216 After allocating space, the creation routine must call the
217 creation routine of the hash table type it is derived from,
218 passing in a pointer to the space it just allocated. This
219 will initialize any fields used by the base hash table.
221 Finally the creation routine must initialize any local fields
222 for the new hash table type.
224 Here is a boilerplate example of a creation routine.
225 @var{function_name} is the name of the routine.
226 @var{entry_type} is the type of an entry in the hash table you
227 are creating. @var{base_newfunc} is the name of the creation
228 routine of the hash table type your hash table is derived
233 .struct bfd_hash_entry *
234 .@var{function_name} (struct bfd_hash_entry *entry,
235 . struct bfd_hash_table *table,
236 . const char *string)
238 . struct @var{entry_type} *ret = (@var{entry_type} *) entry;
240 . {* Allocate the structure if it has not already been allocated by a
244 . ret = bfd_hash_allocate (table, sizeof (* ret));
249 . {* Call the allocation method of the base class. *}
250 . ret = ((@var{entry_type} *)
251 . @var{base_newfunc} ((struct bfd_hash_entry *) ret, table, string));
253 . {* Initialize the local fields here. *}
255 . return (struct bfd_hash_entry *) ret;
259 The creation routine for the linker hash table, which is in
260 <<linker.c>>, looks just like this example.
261 @var{function_name} is <<_bfd_link_hash_newfunc>>.
262 @var{entry_type} is <<struct bfd_link_hash_entry>>.
263 @var{base_newfunc} is <<bfd_hash_newfunc>>, the creation
264 routine for a basic hash table.
266 <<_bfd_link_hash_newfunc>> also initializes the local fields
267 in a linker hash table entry: <<type>>, <<written>> and
271 Write Other Derived Routines, , Write the Derived Creation Routine, Deriving a New Hash Table Type
273 Write other derived routines
275 You will want to write other routines for your new hash table,
278 You will want an initialization routine which calls the
279 initialization routine of the hash table you are deriving from
280 and initializes any other local fields. For the linker hash
281 table, this is <<_bfd_link_hash_table_init>> in <<linker.c>>.
283 You will want a lookup routine which calls the lookup routine
284 of the hash table you are deriving from and casts the result.
285 The linker hash table uses <<bfd_link_hash_lookup>> in
286 <<linker.c>> (this actually takes an additional argument which
287 it uses to decide how to return the looked up value).
289 You may want a traversal routine. This should just call the
290 traversal routine of the hash table you are deriving from with
291 appropriate casts. The linker hash table uses
292 <<bfd_link_hash_traverse>> in <<linker.c>>.
294 These routines may simply be defined as macros. For example,
295 the a.out backend linker hash table, which is derived from the
296 linker hash table, uses macros for the lookup and traversal
297 routines. These are <<aout_link_hash_lookup>> and
298 <<aout_link_hash_traverse>> in aoutx.h.
301 /* The default number of entries to use when creating a hash table. */
302 #define DEFAULT_SIZE 4051
304 /* The following function returns a nearest prime number which is
305 greater than N, and near a power of two. Copied from libiberty.
306 Returns zero for ridiculously large N to signify an error. */
309 higher_prime_number (unsigned long n
)
311 /* These are primes that are near, but slightly smaller than, a
313 static const unsigned long primes
[] =
320 (unsigned long) 1021,
321 (unsigned long) 2039,
322 (unsigned long) 4093,
323 (unsigned long) 8191,
324 (unsigned long) 16381,
325 (unsigned long) 32749,
326 (unsigned long) 65521,
327 (unsigned long) 131071,
328 (unsigned long) 262139,
329 (unsigned long) 524287,
330 (unsigned long) 1048573,
331 (unsigned long) 2097143,
332 (unsigned long) 4194301,
333 (unsigned long) 8388593,
334 (unsigned long) 16777213,
335 (unsigned long) 33554393,
336 (unsigned long) 67108859,
337 (unsigned long) 134217689,
338 (unsigned long) 268435399,
339 (unsigned long) 536870909,
340 (unsigned long) 1073741789,
341 (unsigned long) 2147483647,
343 ((unsigned long) 2147483647) + ((unsigned long) 2147483644),
346 const unsigned long *low
= &primes
[0];
347 const unsigned long *high
= &primes
[sizeof (primes
) / sizeof (primes
[0])];
351 const unsigned long *mid
= low
+ (high
- low
) / 2;
364 static unsigned long bfd_default_hash_table_size
= DEFAULT_SIZE
;
366 /* Create a new hash table, given a number of entries. */
369 bfd_hash_table_init_n (struct bfd_hash_table
*table
,
370 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
371 struct bfd_hash_table
*,
373 unsigned int entsize
,
379 alloc
*= sizeof (struct bfd_hash_entry
*);
380 if (alloc
/ sizeof (struct bfd_hash_entry
*) != size
)
382 bfd_set_error (bfd_error_no_memory
);
386 table
->memory
= (void *) objalloc_create ();
387 if (table
->memory
== NULL
)
389 bfd_set_error (bfd_error_no_memory
);
392 table
->table
= (struct bfd_hash_entry
**)
393 objalloc_alloc ((struct objalloc
*) table
->memory
, alloc
);
394 if (table
->table
== NULL
)
396 bfd_set_error (bfd_error_no_memory
);
399 memset ((void *) table
->table
, 0, alloc
);
401 table
->entsize
= entsize
;
404 table
->newfunc
= newfunc
;
408 /* Create a new hash table with the default number of entries. */
411 bfd_hash_table_init (struct bfd_hash_table
*table
,
412 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
413 struct bfd_hash_table
*,
415 unsigned int entsize
)
417 return bfd_hash_table_init_n (table
, newfunc
, entsize
,
418 bfd_default_hash_table_size
);
421 /* Free a hash table. */
424 bfd_hash_table_free (struct bfd_hash_table
*table
)
426 objalloc_free ((struct objalloc
*) table
->memory
);
427 table
->memory
= NULL
;
430 static inline unsigned long
431 bfd_hash_hash (const char *string
, unsigned int *lenp
)
433 const unsigned char *s
;
440 s
= (const unsigned char *) string
;
441 while ((c
= *s
++) != '\0')
443 hash
+= c
+ (c
<< 17);
446 len
= (s
- (const unsigned char *) string
) - 1;
447 hash
+= len
+ (len
<< 17);
454 /* Look up a string in a hash table. */
456 struct bfd_hash_entry
*
457 bfd_hash_lookup (struct bfd_hash_table
*table
,
463 struct bfd_hash_entry
*hashp
;
467 hash
= bfd_hash_hash (string
, &len
);
468 _index
= hash
% table
->size
;
469 for (hashp
= table
->table
[_index
];
473 if (hashp
->hash
== hash
474 && strcmp (hashp
->string
, string
) == 0)
485 new_string
= (char *) objalloc_alloc ((struct objalloc
*) table
->memory
,
489 bfd_set_error (bfd_error_no_memory
);
492 memcpy (new_string
, string
, len
+ 1);
496 return bfd_hash_insert (table
, string
, hash
);
499 /* Insert an entry in a hash table. */
501 struct bfd_hash_entry
*
502 bfd_hash_insert (struct bfd_hash_table
*table
,
506 struct bfd_hash_entry
*hashp
;
509 hashp
= (*table
->newfunc
) (NULL
, table
, string
);
512 hashp
->string
= string
;
514 _index
= hash
% table
->size
;
515 hashp
->next
= table
->table
[_index
];
516 table
->table
[_index
] = hashp
;
519 if (!table
->frozen
&& table
->count
> table
->size
* 3 / 4)
521 unsigned long newsize
= higher_prime_number (table
->size
);
522 struct bfd_hash_entry
**newtable
;
524 unsigned long alloc
= newsize
* sizeof (struct bfd_hash_entry
*);
526 /* If we can't find a higher prime, or we can't possibly alloc
527 that much memory, don't try to grow the table. */
528 if (newsize
== 0 || alloc
/ sizeof (struct bfd_hash_entry
*) != newsize
)
534 newtable
= ((struct bfd_hash_entry
**)
535 objalloc_alloc ((struct objalloc
*) table
->memory
, alloc
));
536 if (newtable
== NULL
)
541 memset ((PTR
) newtable
, 0, alloc
);
543 for (hi
= 0; hi
< table
->size
; hi
++)
544 while (table
->table
[hi
])
546 struct bfd_hash_entry
*chain
= table
->table
[hi
];
547 struct bfd_hash_entry
*chain_end
= chain
;
549 while (chain_end
->next
&& chain_end
->next
->hash
== chain
->hash
)
550 chain_end
= chain_end
->next
;
552 table
->table
[hi
] = chain_end
->next
;
553 _index
= chain
->hash
% newsize
;
554 chain_end
->next
= newtable
[_index
];
555 newtable
[_index
] = chain
;
557 table
->table
= newtable
;
558 table
->size
= newsize
;
564 /* Rename an entry in a hash table. */
567 bfd_hash_rename (struct bfd_hash_table
*table
,
569 struct bfd_hash_entry
*ent
)
572 struct bfd_hash_entry
**pph
;
574 _index
= ent
->hash
% table
->size
;
575 for (pph
= &table
->table
[_index
]; *pph
!= NULL
; pph
= &(*pph
)->next
)
582 ent
->string
= string
;
583 ent
->hash
= bfd_hash_hash (string
, NULL
);
584 _index
= ent
->hash
% table
->size
;
585 ent
->next
= table
->table
[_index
];
586 table
->table
[_index
] = ent
;
589 /* Replace an entry in a hash table. */
592 bfd_hash_replace (struct bfd_hash_table
*table
,
593 struct bfd_hash_entry
*old
,
594 struct bfd_hash_entry
*nw
)
597 struct bfd_hash_entry
**pph
;
599 _index
= old
->hash
% table
->size
;
600 for (pph
= &table
->table
[_index
];
614 /* Allocate space in a hash table. */
617 bfd_hash_allocate (struct bfd_hash_table
*table
,
622 ret
= objalloc_alloc ((struct objalloc
*) table
->memory
, size
);
623 if (ret
== NULL
&& size
!= 0)
624 bfd_set_error (bfd_error_no_memory
);
628 /* Base method for creating a new hash table entry. */
630 struct bfd_hash_entry
*
631 bfd_hash_newfunc (struct bfd_hash_entry
*entry
,
632 struct bfd_hash_table
*table
,
633 const char *string ATTRIBUTE_UNUSED
)
636 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
641 /* Traverse a hash table. */
644 bfd_hash_traverse (struct bfd_hash_table
*table
,
645 bfd_boolean (*func
) (struct bfd_hash_entry
*, void *),
651 for (i
= 0; i
< table
->size
; i
++)
653 struct bfd_hash_entry
*p
;
655 for (p
= table
->table
[i
]; p
!= NULL
; p
= p
->next
)
656 if (! (*func
) (p
, info
))
664 bfd_hash_set_default_size (unsigned long hash_size
)
666 /* Extend this prime list if you want more granularity of hash table size. */
667 static const unsigned long hash_size_primes
[] =
669 31, 61, 127, 251, 509, 1021, 2039, 4091, 8191, 16381, 32749, 65537
673 /* Work out best prime number near the hash_size. */
674 for (_index
= 0; _index
< ARRAY_SIZE (hash_size_primes
) - 1; ++_index
)
675 if (hash_size
<= hash_size_primes
[_index
])
678 bfd_default_hash_table_size
= hash_size_primes
[_index
];
679 return bfd_default_hash_table_size
;
682 /* A few different object file formats (a.out, COFF, ELF) use a string
683 table. These functions support adding strings to a string table,
684 returning the byte offset, and writing out the table.
686 Possible improvements:
687 + look for strings matching trailing substrings of other strings
688 + better data structures? balanced trees?
689 + look at reducing memory use elsewhere -- maybe if we didn't have
690 to construct the entire symbol table at once, we could get by
691 with smaller amounts of VM? (What effect does that have on the
692 string table reductions?) */
694 /* An entry in the strtab hash table. */
696 struct strtab_hash_entry
698 struct bfd_hash_entry root
;
699 /* Index in string table. */
701 /* Next string in strtab. */
702 struct strtab_hash_entry
*next
;
705 /* The strtab hash table. */
707 struct bfd_strtab_hash
709 struct bfd_hash_table table
;
710 /* Size of strtab--also next available index. */
712 /* First string in strtab. */
713 struct strtab_hash_entry
*first
;
714 /* Last string in strtab. */
715 struct strtab_hash_entry
*last
;
716 /* Whether to precede strings with a two byte length, as in the
717 XCOFF .debug section. */
721 /* Routine to create an entry in a strtab. */
723 static struct bfd_hash_entry
*
724 strtab_hash_newfunc (struct bfd_hash_entry
*entry
,
725 struct bfd_hash_table
*table
,
728 struct strtab_hash_entry
*ret
= (struct strtab_hash_entry
*) entry
;
730 /* Allocate the structure if it has not already been allocated by a
733 ret
= (struct strtab_hash_entry
*) bfd_hash_allocate (table
,
738 /* Call the allocation method of the superclass. */
739 ret
= (struct strtab_hash_entry
*)
740 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
);
744 /* Initialize the local fields. */
745 ret
->index
= (bfd_size_type
) -1;
749 return (struct bfd_hash_entry
*) ret
;
752 /* Look up an entry in an strtab. */
754 #define strtab_hash_lookup(t, string, create, copy) \
755 ((struct strtab_hash_entry *) \
756 bfd_hash_lookup (&(t)->table, (string), (create), (copy)))
758 /* Create a new strtab. */
760 struct bfd_strtab_hash
*
761 _bfd_stringtab_init (void)
763 struct bfd_strtab_hash
*table
;
764 bfd_size_type amt
= sizeof (* table
);
766 table
= (struct bfd_strtab_hash
*) bfd_malloc (amt
);
770 if (!bfd_hash_table_init (&table
->table
, strtab_hash_newfunc
,
771 sizeof (struct strtab_hash_entry
)))
780 table
->xcoff
= FALSE
;
785 /* Create a new strtab in which the strings are output in the format
786 used in the XCOFF .debug section: a two byte length precedes each
789 struct bfd_strtab_hash
*
790 _bfd_xcoff_stringtab_init (void)
792 struct bfd_strtab_hash
*ret
;
794 ret
= _bfd_stringtab_init ();
803 _bfd_stringtab_free (struct bfd_strtab_hash
*table
)
805 bfd_hash_table_free (&table
->table
);
809 /* Get the index of a string in a strtab, adding it if it is not
810 already present. If HASH is FALSE, we don't really use the hash
811 table, and we don't eliminate duplicate strings. */
814 _bfd_stringtab_add (struct bfd_strtab_hash
*tab
,
819 struct strtab_hash_entry
*entry
;
823 entry
= strtab_hash_lookup (tab
, str
, TRUE
, copy
);
825 return (bfd_size_type
) -1;
829 entry
= (struct strtab_hash_entry
*) bfd_hash_allocate (&tab
->table
,
832 return (bfd_size_type
) -1;
834 entry
->root
.string
= str
;
839 n
= (char *) bfd_hash_allocate (&tab
->table
, strlen (str
) + 1);
841 return (bfd_size_type
) -1;
842 entry
->root
.string
= n
;
844 entry
->index
= (bfd_size_type
) -1;
848 if (entry
->index
== (bfd_size_type
) -1)
850 entry
->index
= tab
->size
;
851 tab
->size
+= strlen (str
) + 1;
857 if (tab
->first
== NULL
)
860 tab
->last
->next
= entry
;
867 /* Get the number of bytes in a strtab. */
870 _bfd_stringtab_size (struct bfd_strtab_hash
*tab
)
875 /* Write out a strtab. ABFD must already be at the right location in
879 _bfd_stringtab_emit (bfd
*abfd
, struct bfd_strtab_hash
*tab
)
882 struct strtab_hash_entry
*entry
;
886 for (entry
= tab
->first
; entry
!= NULL
; entry
= entry
->next
)
891 str
= entry
->root
.string
;
892 len
= strlen (str
) + 1;
898 /* The output length includes the null byte. */
899 bfd_put_16 (abfd
, (bfd_vma
) len
, buf
);
900 if (bfd_bwrite ((void *) buf
, (bfd_size_type
) 2, abfd
) != 2)
904 if (bfd_bwrite ((void *) str
, (bfd_size_type
) len
, abfd
) != len
)