Hash Tables
===========

BFD provides a simple set of hash table functions.  Routines are provided to initialize a hash table, to free a hash table, to look up a string in a hash table and optionally create an entry for it, and to traverse a hash table.  There is currently no routine to delete an string from a hash table.

The basic hash table does not permit any data to be stored with a string.  However, a hash table is designed to present a base class from which other types of hash tables may be derived.  These derived types may store additional information with the string.  Hash tables were implemented in this way, rather than simply providing a data pointer in a hash table entry, because they were designed for use by the linker back ends.  The linker may create thousands of hash table entries, and the overhead of allocating private data and storing and following pointers becomes noticeable.

The basic hash table code is in hash.c.

Creating and freeing a hash table
---------------------------------

To create a hash table, create an instance of a struct bfd_hash_table (defined in bfd.h) and call bfd_hash_table_init (if you know approximately how many entries you will need, the function bfd_hash_table_init_n, which takes a SIZE argument, may be used). bfd_hash_table_init returns FALSE if some sort of error occurs.

The function bfd_hash_table_init take as an argument a function to use to create new entries.  For a basic hash table, use the function bfd_hash_newfunc.  See Deriving a New Hash Table Type, for why you would want to use a different value for this argument.

bfd_hash_table_init will create an objalloc which will be used to allocate new entries.  You may allocate memory on this objalloc using bfd_hash_allocate.

Use bfd_hash_table_free to free up all the memory that has been allocated for a hash table.  This will not free up the struct bfd_hash_table itself, which you must provide.

Looking up or entering a string
-------------------------------

The function bfd_hash_lookup is used both to look up a string in the hash table and to create a new entry.

If the CREATE argument is FALSE, bfd_hash_lookup will look up a string.  If the string is found, it will returns a pointer to a struct bfd_hash_entry.  If the string is not found in the table bfd_hash_lookup will return NULL.  You should not modify any of the fields in the returns struct bfd_hash_entry.

If the CREATE argument is TRUE, the string will be entered into the hash table if it is not already there. Either way a pointer to a struct bfd_hash_entry will be returned, either to the existing structure or to a newly created one.  In this case, a NULL return means that an error occurred.

If the CREATE argument is TRUE, and a new entry is created, the COPY argument is used to decide whether to copy the string onto the hash table objalloc or not.  If COPY is passed as FALSE, you must be careful not to deallocate or modify the string as long as the hash table exists.

Traversing a hash table
-----------------------

The function bfd_hash_traverse may be used to traverse a hash table, calling a function on each element.  The traversal is done in a random order.

bfd_hash_traverse takes as arguments a function and a generic void * pointer.  The function is called with a hash table entry (a struct bfd_hash_entry *) and the generic pointer passed to bfd_hash_traverse.  The function must return a boolean value, which indicates whether to continue traversing the hash table.  If the function returns FALSE, bfd_hash_traverse will stop the traversal and return immediately.

Deriving a new hash table type
------------------------------

Many uses of hash tables want to store additional information which each entry in the hash table.  Some also find it convenient to store additional information with the hash table itself.  This may be done using a derived hash table.

Since C is not an object oriented language, creating a derived hash table requires sticking together some boilerplate routines with a few differences specific to the type of hash table you want to create.

An example of a derived hash table is the linker hash table. The structures for this are defined in bfdlink.h.  The functions are in linker.c.

You may also derive a hash table from an already derived hash table.  For example, the a.out linker backend code uses a hash table derived from the linker hash table.

Define the derived structures
.............................

You must define a structure for an entry in the hash table, and a structure for the hash table itself.

The first field in the structure for an entry in the hash table must be of the type used for an entry in the hash table you are deriving from.  If you are deriving from a basic hash table this is struct bfd_hash_entry, which is defined in bfd.h.  The first field in the structure for the hash table itself must be of the type of the hash table you are deriving from itself.  If you are deriving from a basic hash table, this is struct bfd_hash_table.

For example, the linker hash table defines struct bfd_link_hash_entry (in bfdlink.h).  The first field, root, is of type struct bfd_hash_entry.  Similarly, the first field in struct bfd_link_hash_table, table, is of type struct bfd_hash_table.

Write the derived creation routine
..................................

You must write a routine which will create and initialize an entry in the hash table.  This routine is passed as the function argument to bfd_hash_table_init.

In order to permit other hash tables to be derived from the hash table you are creating, this routine must be written in a standard way.

The first argument to the creation routine is a pointer to a hash table entry.  This may be NULL, in which case the routine should allocate the right amount of space.  Otherwise the space has already been allocated by a hash table type derived from this one.

After allocating space, the creation routine must call the creation routine of the hash table type it is derived from, passing in a pointer to the space it just allocated.  This will initialize any fields used by the base hash table.

Finally the creation routine must initialize any local fields for the new hash table type.

Here is a boilerplate example of a creation routine. FUNCTION_NAME is the name of the routine. ENTRY_TYPE is the type of an entry in the hash table you are creating.  BASE_NEWFUNC is the name of the creation routine of the hash table type your hash table is derived from.

     struct bfd_hash_entry *
     FUNCTION_NAME (entry, table, string)
          struct bfd_hash_entry *entry;
          struct bfd_hash_table *table;
          const char *string;
     {
       struct ENTRY_TYPE *ret = (ENTRY_TYPE *) entry;

      /* Allocate the structure if it has not already been allocated by a
         derived class.  */
       if (ret == (ENTRY_TYPE *) NULL)
         {
           ret = ((ENTRY_TYPE *)
                  bfd_hash_allocate (table, sizeof (ENTRY_TYPE)));
           if (ret == (ENTRY_TYPE *) NULL)
             return NULL;
         }

      /* Call the allocation method of the base class.  */
       ret = ((ENTRY_TYPE *)
             BASE_NEWFUNC ((struct bfd_hash_entry *) ret, table, string));

      /* Initialize the local fields here.  */

       return (struct bfd_hash_entry *) ret;
     }

Description

The creation routine for the linker hash table, which is in linker.c, looks just like this example. FUNCTION_NAME is _bfd_link_hash_newfunc. ENTRY_TYPE is struct bfd_link_hash_entry. BASE_NEWFUNC is bfd_hash_newfunc, the creation routine for a basic hash table.

_bfd_link_hash_newfunc also initializes the local fields in a linker hash table entry: type, written and next.

Write other derived routines
............................

You will want to write other routines for your new hash table, as well.

You will want an initialization routine which calls the initialization routine of the hash table you are deriving from and initializes any other local fields.  For the linker hash table, this is _bfd_link_hash_table_init in linker.c.

You will want a lookup routine which calls the lookup routine of the hash table you are deriving from and casts the result. The linker hash table uses bfd_link_hash_lookup in linker.c (this actually takes an additional argument which it uses to decide how to return the looked up value).

You may want a traversal routine.  This should just call the traversal routine of the hash table you are deriving from with appropriate casts.  The linker hash table uses bfd_link_hash_traverse in linker.c.

These routines may simply be defined as macros.  For example, the a.out backend linker hash table, which is derived from the linker hash table, uses macros for the lookup and traversal routines.  These are aout_link_hash_lookup and aout_link_hash_traverse in aoutx.h.