/* hash.c -- hash table routines for BFD
- Copyright (C) 1993, 94 Free Software Foundation, Inc.
+ Copyright 1993, 1994, 1995, 1997, 1999, 2001, 2002
+ Free Software Foundation, Inc.
Written by Steve Chamberlain <sac@cygnus.com>
This file is part of BFD, the Binary File Descriptor library.
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
-#include "obstack.h"
+#include "objalloc.h"
/*
SECTION
<<bfd_hash_table_init>> (if you know approximately how many
entries you will need, the function <<bfd_hash_table_init_n>>,
which takes a @var{size} argument, may be used).
- <<bfd_hash_table_init>> returns <<false>> if some sort of
+ <<bfd_hash_table_init>> returns <<FALSE>> if some sort of
error occurs.
@findex bfd_hash_newfunc
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>>. @xref{Deriving
- a New Hash Table Type} for why you would want to use a
+ a New Hash Table Type}, for why you would want to use a
different value for this argument.
@findex bfd_hash_allocate
- <<bfd_hash_table_init>> will create an obstack which will be
+ <<bfd_hash_table_init>> will create an objalloc which will be
used to allocate new entries. You may allocate memory on this
- obstack using <<bfd_hash_allocate>>.
+ objalloc using <<bfd_hash_allocate>>.
@findex bfd_hash_table_free
Use <<bfd_hash_table_free>> to free up all the memory that has
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 @var{create} argument is <<false>>, <<bfd_hash_lookup>>
+ If the @var{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 @var{create} argument is <<true>>, the string will be
+ If the @var{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 @var{create} argument is <<true>>, and a new entry is
+ If the @var{create} argument is <<TRUE>>, and a new entry is
created, the @var{copy} argument is used to decide whether to
- copy the string onto the hash table obstack or not. If
- @var{copy} is passed as <<false>>, you must be careful not to
+ copy the string onto the hash table objalloc or not. If
+ @var{copy} is passed as <<FALSE>>, you must be careful not to
deallocate or modify the string as long as the hash table
exists.
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
+ <<FALSE>>, <<bfd_hash_traverse>> will stop the traversal and
return immediately.
INODE
Write other derived routines
You will want to write other routines for your new hash table,
- as well.
+ as well.
You will want an initialization routine which calls the
initialization routine of the hash table you are deriving from
<<aout_link_hash_traverse>> in aoutx.h.
*/
-/* Obstack allocation and deallocation routines. */
-#define obstack_chunk_alloc malloc
-#define obstack_chunk_free free
-
/* The default number of entries to use when creating a hash table. */
#define DEFAULT_SIZE (4051)
/* Create a new hash table, given a number of entries. */
-boolean
+bfd_boolean
bfd_hash_table_init_n (table, newfunc, size)
struct bfd_hash_table *table;
struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
unsigned int alloc;
alloc = size * sizeof (struct bfd_hash_entry *);
- if (!obstack_begin (&table->memory, alloc))
+
+ table->memory = (PTR) objalloc_create ();
+ if (table->memory == NULL)
{
bfd_set_error (bfd_error_no_memory);
- return false;
+ return FALSE;
}
table->table = ((struct bfd_hash_entry **)
- obstack_alloc (&table->memory, alloc));
- if (!table->table)
+ objalloc_alloc ((struct objalloc *) table->memory, alloc));
+ if (table->table == NULL)
{
bfd_set_error (bfd_error_no_memory);
- return false;
+ return FALSE;
}
memset ((PTR) table->table, 0, alloc);
table->size = size;
table->newfunc = newfunc;
- return true;
+ return TRUE;
}
/* Create a new hash table with the default number of entries. */
-boolean
+bfd_boolean
bfd_hash_table_init (table, newfunc)
struct bfd_hash_table *table;
struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
bfd_hash_table_free (table)
struct bfd_hash_table *table;
{
- obstack_free (&table->memory, (PTR) NULL);
+ objalloc_free ((struct objalloc *) table->memory);
+ table->memory = NULL;
}
/* Look up a string in a hash table. */
bfd_hash_lookup (table, string, create, copy)
struct bfd_hash_table *table;
const char *string;
- boolean create;
- boolean copy;
+ bfd_boolean create;
+ bfd_boolean copy;
{
register const unsigned char *s;
register unsigned long hash;
struct bfd_hash_entry *hashp;
unsigned int len;
unsigned int index;
-
+
hash = 0;
len = 0;
s = (const unsigned char *) string;
{
hash += c + (c << 17);
hash ^= hash >> 2;
- ++len;
}
+ len = (s - (const unsigned char *) string) - 1;
hash += len + (len << 17);
hash ^= hash >> 2;
{
char *new;
- new = (char *) obstack_alloc (&table->memory, len + 1);
+ new = (char *) objalloc_alloc ((struct objalloc *) table->memory,
+ len + 1);
if (!new)
{
bfd_set_error (bfd_error_no_memory);
return (struct bfd_hash_entry *) NULL;
}
- strcpy (new, string);
+ memcpy (new, string, len + 1);
string = new;
}
hashp->string = string;
bfd_hash_newfunc (entry, table, string)
struct bfd_hash_entry *entry;
struct bfd_hash_table *table;
- const char *string;
+ const char *string ATTRIBUTE_UNUSED;
{
if (entry == (struct bfd_hash_entry *) NULL)
entry = ((struct bfd_hash_entry *)
{
PTR ret;
- ret = obstack_alloc (&table->memory, size);
+ ret = objalloc_alloc ((struct objalloc *) table->memory, size);
if (ret == NULL && size != 0)
bfd_set_error (bfd_error_no_memory);
return ret;
void
bfd_hash_traverse (table, func, info)
struct bfd_hash_table *table;
- boolean (*func) PARAMS ((struct bfd_hash_entry *, PTR));
+ bfd_boolean (*func) PARAMS ((struct bfd_hash_entry *, PTR));
PTR info;
{
unsigned int i;
struct strtab_hash_entry *last;
/* Whether to precede strings with a two byte length, as in the
XCOFF .debug section. */
- boolean xcoff;
+ bfd_boolean xcoff;
};
static struct bfd_hash_entry *strtab_hash_newfunc
_bfd_stringtab_init ()
{
struct bfd_strtab_hash *table;
+ bfd_size_type amt = sizeof (struct bfd_strtab_hash);
- table = (struct bfd_strtab_hash *) malloc (sizeof (struct bfd_strtab_hash));
+ table = (struct bfd_strtab_hash *) bfd_malloc (amt);
if (table == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return NULL;
- }
+ return NULL;
if (! bfd_hash_table_init (&table->table, strtab_hash_newfunc))
{
table->size = 0;
table->first = NULL;
table->last = NULL;
- table->xcoff = false;
+ table->xcoff = FALSE;
return table;
}
ret = _bfd_stringtab_init ();
if (ret != NULL)
- ret->xcoff = true;
+ ret->xcoff = TRUE;
return ret;
}
}
/* Get the index of a string in a strtab, adding it if it is not
- already present. If HASH is false, we don't really use the hash
+ already present. If HASH is FALSE, we don't really use the hash
table, and we don't eliminate duplicate strings. */
bfd_size_type
_bfd_stringtab_add (tab, str, hash, copy)
struct bfd_strtab_hash *tab;
const char *str;
- boolean hash;
- boolean copy;
+ bfd_boolean hash;
+ bfd_boolean copy;
{
register struct strtab_hash_entry *entry;
if (hash)
{
- entry = strtab_hash_lookup (tab, str, true, copy);
+ entry = strtab_hash_lookup (tab, str, TRUE, copy);
if (entry == NULL)
return (bfd_size_type) -1;
}
/* Write out a strtab. ABFD must already be at the right location in
the file. */
-boolean
+bfd_boolean
_bfd_stringtab_emit (abfd, tab)
register bfd *abfd;
struct bfd_strtab_hash *tab;
{
- register boolean xcoff;
+ register bfd_boolean xcoff;
register struct strtab_hash_entry *entry;
xcoff = tab->xcoff;
for (entry = tab->first; entry != NULL; entry = entry->next)
{
- register const char *str;
- register size_t len;
+ const char *str;
+ size_t len;
str = entry->root.string;
len = strlen (str) + 1;
bfd_byte buf[2];
/* The output length includes the null byte. */
- bfd_put_16 (abfd, len, buf);
- if (bfd_write ((PTR) buf, 1, 2, abfd) != 2)
- return false;
+ bfd_put_16 (abfd, (bfd_vma) len, buf);
+ if (bfd_bwrite ((PTR) buf, (bfd_size_type) 2, abfd) != 2)
+ return FALSE;
}
- if (bfd_write ((PTR) str, 1, len, abfd) != len)
- return false;
+ if (bfd_bwrite ((PTR) str, (bfd_size_type) len, abfd) != len)
+ return FALSE;
}
- return true;
+ return TRUE;
}