daily update

[deliverable/binutils-gdb.git] / bfd / hash.c

diff --git a/bfd/hash.c b/bfd/hash.c
index 8ea4375d5c70172be3d513351fdd4785c6c4ac78..14fc40301508728a4a72498e57b5b895d28bf152 100644 (file)
--- a/bfd/hash.c
+++ b/bfd/hash.c
@@ -1,27 +1,30 @@
 /* hash.c -- hash table routines for BFD
 /* hash.c -- hash table routines for BFD

-   Copyright (C) 1993, 94 Free Software Foundation, Inc.
+   Copyright 1993, 1994, 1995, 1997, 1999, 2001, 2002, 2003, 2004, 2005,
+   2006, 2007 Free Software Foundation, Inc.

    Written by Steve Chamberlain <sac@cygnus.com>
 
    Written by Steve Chamberlain <sac@cygnus.com>
 

-This file is part of BFD, the Binary File Descriptor library.
+   This file is part of BFD, the Binary File Descriptor library.

 
 

-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.

 
 

-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.

 
 

-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+   MA 02110-1301, USA.  */

 
 

-#include "bfd.h"

 #include "sysdep.h"
 #include "sysdep.h"

+#include "bfd.h"

 #include "libbfd.h"
 #include "libbfd.h"

-#include "obstack.h"
+#include "objalloc.h"
+#include "libiberty.h"

 
 /*
 SECTION
 
 /*
 SECTION


@@ -66,26 +69,30 @@ SUBSECTION
        <<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>> (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
        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
        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
        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
        been allocated for a hash table.  This will not free up the
        <<struct bfd_hash_table>> itself, which you must provide.
 
 
 @findex bfd_hash_table_free
        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.
 

+@findex bfd_hash_set_default_size
+       Use <<bfd_hash_set_default_size>> to set the default size of
+       hash table to use.
+

 INODE
 Looking Up or Entering a String, Traversing a Hash Table, Creating and Freeing a Hash Table, Hash Tables
 SUBSECTION
 INODE
 Looking Up or Entering a String, Traversing a Hash Table, Creating and Freeing a Hash Table, Hash Tables
 SUBSECTION


@@ -95,24 +102,24 @@ SUBSECTION
        The function <<bfd_hash_lookup>> is used both to look up a
        string in the hash table and to create a new entry.
 
        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>>.
 
        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.
 
        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
        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.
 
        deallocate or modify the string as long as the hash table
        exists.
 


@@ -132,7 +139,7 @@ SUBSECTION
        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
        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
        return immediately.
 
 INODE


@@ -224,20 +231,18 @@ SUBSUBSECTION
 EXAMPLE
 
 .struct bfd_hash_entry *
 EXAMPLE
 
 .struct bfd_hash_entry *

-.@var{function_name} (entry, table, string)
-.     struct bfd_hash_entry *entry;
-.     struct bfd_hash_table *table;
-.     const char *string;
+.@var{function_name} (struct bfd_hash_entry *entry,
+.                     struct bfd_hash_table *table,
+.                     const char *string)

 .{
 .  struct @var{entry_type} *ret = (@var{entry_type} *) entry;
 .
 . {* Allocate the structure if it has not already been allocated by a
 .    derived class.  *}
 .{
 .  struct @var{entry_type} *ret = (@var{entry_type} *) entry;
 .
 . {* Allocate the structure if it has not already been allocated by a
 .    derived class.  *}

-.  if (ret == (@var{entry_type} *) NULL)
+.  if (ret == NULL)

 .    {
 .    {

-.      ret = ((@var{entry_type} *)
-.            bfd_hash_allocate (table, sizeof (@var{entry_type})));
-.      if (ret == (@var{entry_type} *) NULL)
+.      ret = bfd_hash_allocate (table, sizeof (* ret));
+.      if (ret == NULL)

 .        return NULL;
 .    }
 .
 .        return NULL;
 .    }
 .


@@ -268,7 +273,7 @@ SUBSUBSECTION
        Write other derived routines
 
        You will want to write other routines for your new hash table,
        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
 
        You will want an initialization routine which calls the
        initialization routine of the hash table you are deriving from


@@ -293,81 +298,134 @@ SUBSUBSECTION
        <<aout_link_hash_traverse>> in aoutx.h.
 */
 
        <<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.  */
 /* The default number of entries to use when creating a hash table.  */

-#define DEFAULT_SIZE (4051)
+#define DEFAULT_SIZE 4051
+
+/* The following function returns a nearest prime number which is
+   greater than N, and near a power of two.  Copied from libiberty.
+   Returns zero for ridiculously large N to signify an error.  */
+
+static unsigned long
+higher_prime_number (unsigned long n)
+{
+  /* These are primes that are near, but slightly smaller than, a
+     power of two.  */
+  static const unsigned long primes[] = {
+    (unsigned long) 127,
+    (unsigned long) 2039,
+    (unsigned long) 32749,
+    (unsigned long) 65521,
+    (unsigned long) 131071,
+    (unsigned long) 262139,
+    (unsigned long) 524287,
+    (unsigned long) 1048573,
+    (unsigned long) 2097143,
+    (unsigned long) 4194301,
+    (unsigned long) 8388593,
+    (unsigned long) 16777213,
+    (unsigned long) 33554393,
+    (unsigned long) 67108859,
+    (unsigned long) 134217689,
+    (unsigned long) 268435399,
+    (unsigned long) 536870909,
+    (unsigned long) 1073741789,
+    (unsigned long) 2147483647,
+                                       /* 4294967291L */
+    ((unsigned long) 2147483647) + ((unsigned long) 2147483644),
+  };
+
+  const unsigned long *low = &primes[0];
+  const unsigned long *high = &primes[sizeof (primes) / sizeof (primes[0])];
+
+  while (low != high)
+    {
+      const unsigned long *mid = low + (high - low) / 2;
+      if (n >= *mid)
+       low = mid + 1;
+      else
+       high = mid;
+    }
+
+  if (n >= *low)
+    return 0;
+
+  return *low;
+}
+
+static size_t bfd_default_hash_table_size = DEFAULT_SIZE;

 
 /* Create a new hash table, given a number of entries.  */
 
 
 /* Create a new hash table, given a number of entries.  */
 

-boolean
-bfd_hash_table_init_n (table, newfunc, size)
-     struct bfd_hash_table *table;
-     struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
-                                               struct bfd_hash_table *,
-                                               const char *));
-     unsigned int size;
+bfd_boolean
+bfd_hash_table_init_n (struct bfd_hash_table *table,
+                      struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
+                                                         struct bfd_hash_table *,
+                                                         const char *),
+                      unsigned int entsize,
+                      unsigned int size)

 {
   unsigned int alloc;
 
   alloc = size * sizeof (struct bfd_hash_entry *);
 {
   unsigned int alloc;
 
   alloc = size * sizeof (struct bfd_hash_entry *);

-  if (!obstack_begin (&table->memory, alloc))
+
+  table->memory = (void *) objalloc_create ();
+  if (table->memory == NULL)

     {
       bfd_set_error (bfd_error_no_memory);
     {
       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)
+  table->table = objalloc_alloc ((struct objalloc *) table->memory, alloc);
+  if (table->table == NULL)

     {
       bfd_set_error (bfd_error_no_memory);
     {
       bfd_set_error (bfd_error_no_memory);

-      return false;
+      return FALSE;

     }
     }

-  memset ((PTR) table->table, 0, alloc);
+  memset ((void *) table->table, 0, alloc);

   table->size = size;
   table->size = size;

+  table->entsize = entsize;
+  table->count = 0;
+  table->frozen = 0;

   table->newfunc = newfunc;
   table->newfunc = newfunc;

-  return true;
+  return TRUE;

 }
 
 /* Create a new hash table with the default number of entries.  */
 
 }
 
 /* Create a new hash table with the default number of entries.  */
 

-boolean
-bfd_hash_table_init (table, newfunc)
-     struct bfd_hash_table *table;
-     struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
-                                               struct bfd_hash_table *,
-                                               const char *));
+bfd_boolean
+bfd_hash_table_init (struct bfd_hash_table *table,
+                    struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
+                                                       struct bfd_hash_table *,
+                                                       const char *),
+                    unsigned int entsize)

 {
 {

-  return bfd_hash_table_init_n (table, newfunc, DEFAULT_SIZE);
+  return bfd_hash_table_init_n (table, newfunc, entsize,
+                               bfd_default_hash_table_size);

 }
 
 /* Free a hash table.  */
 
 void
 }
 
 /* Free a hash table.  */
 
 void

-bfd_hash_table_free (table)
-     struct bfd_hash_table *table;
+bfd_hash_table_free (struct bfd_hash_table *table)

 {
 {

-  obstack_free (&table->memory, (PTR) NULL);
+  objalloc_free (table->memory);
+  table->memory = NULL;

 }
 
 /* Look up a string in a hash table.  */
 
 struct bfd_hash_entry *
 }
 
 /* Look up a string in a hash table.  */
 
 struct bfd_hash_entry *

-bfd_hash_lookup (table, string, create, copy)
-     struct bfd_hash_table *table;
-     const char *string;
-     boolean create;
-     boolean copy;
+bfd_hash_lookup (struct bfd_hash_table *table,
+                const char *string,
+                bfd_boolean create,
+                bfd_boolean copy)

 {
 {

-  register const unsigned char *s;
-  register unsigned long hash;
-  register unsigned int c;
+  const unsigned char *s;
+  unsigned long hash;
+  unsigned int c;

   struct bfd_hash_entry *hashp;
   unsigned int len;
   unsigned int index;
   struct bfd_hash_entry *hashp;
   unsigned int len;
   unsigned int index;

-  
+

   hash = 0;
   len = 0;
   s = (const unsigned char *) string;
   hash = 0;
   len = 0;
   s = (const unsigned char *) string;


@@ -375,14 +433,14 @@ bfd_hash_lookup (table, string, create, copy)
     {
       hash += c + (c << 17);
       hash ^= hash >> 2;
     {
       hash += c + (c << 17);
       hash ^= hash >> 2;

-      ++len;

     }
     }

+  len = (s - (const unsigned char *) string) - 1;

   hash += len + (len << 17);
   hash ^= hash >> 2;
 
   index = hash % table->size;
   for (hashp = table->table[index];
   hash += len + (len << 17);
   hash ^= hash >> 2;
 
   index = hash % table->size;
   for (hashp = table->table[index];

-       hashp != (struct bfd_hash_entry *) NULL;
+       hashp != NULL;

        hashp = hashp->next)
     {
       if (hashp->hash == hash
        hashp = hashp->next)
     {
       if (hashp->hash == hash


@@ -391,28 +449,86 @@ bfd_hash_lookup (table, string, create, copy)
     }
 
   if (! create)
     }
 
   if (! create)

-    return (struct bfd_hash_entry *) NULL;
+    return NULL;

 
 

-  hashp = (*table->newfunc) ((struct bfd_hash_entry *) NULL, table, string);
-  if (hashp == (struct bfd_hash_entry *) NULL)
-    return (struct bfd_hash_entry *) NULL;

   if (copy)
     {
       char *new;
 
   if (copy)
     {
       char *new;
 

-      new = (char *) obstack_alloc (&table->memory, len + 1);
+      new = objalloc_alloc ((struct objalloc *) table->memory, len + 1);

       if (!new)
        {
          bfd_set_error (bfd_error_no_memory);
       if (!new)
        {
          bfd_set_error (bfd_error_no_memory);

-         return (struct bfd_hash_entry *) NULL;
+         return NULL;

        }
        }

-      strcpy (new, string);
+      memcpy (new, string, len + 1);

       string = new;
     }
       string = new;
     }

+
+  return bfd_hash_insert (table, string, hash);
+}
+
+/* Insert an entry in a hash table.  */
+
+struct bfd_hash_entry *
+bfd_hash_insert (struct bfd_hash_table *table,
+                const char *string,
+                unsigned long hash)
+{
+  struct bfd_hash_entry *hashp;
+  unsigned int index;
+
+  hashp = (*table->newfunc) (NULL, table, string);
+  if (hashp == NULL)
+    return NULL;

   hashp->string = string;
   hashp->hash = hash;
   hashp->string = string;
   hashp->hash = hash;

+  index = hash % table->size;

   hashp->next = table->table[index];
   table->table[index] = hashp;
   hashp->next = table->table[index];
   table->table[index] = hashp;

+  table->count++;
+
+  if (!table->frozen && table->count > table->size * 3 / 4)
+    {
+      unsigned long newsize = higher_prime_number (table->size);
+      struct bfd_hash_entry **newtable;
+      unsigned int hi;
+      unsigned long alloc = newsize * sizeof (struct bfd_hash_entry *);
+
+      /* If we can't find a higher prime, or we can't possibly alloc
+        that much memory, don't try to grow the table.  */
+      if (newsize == 0 || alloc / sizeof (struct bfd_hash_entry *) != newsize)
+       {
+         table->frozen = 1;
+         return hashp;
+       }
+
+      newtable = ((struct bfd_hash_entry **)
+                 objalloc_alloc ((struct objalloc *) table->memory, alloc));
+      if (newtable == NULL)
+       {
+         table->frozen = 1;
+         return hashp;
+       }
+      memset ((PTR) newtable, 0, alloc);
+
+      for (hi = 0; hi < table->size; hi ++)
+       while (table->table[hi])
+         {
+           struct bfd_hash_entry *chain = table->table[hi];
+           struct bfd_hash_entry *chain_end = chain;
+
+           while (chain_end->next && chain_end->next->hash == chain->hash)
+             chain_end = chain_end->next;
+
+           table->table[hi] = chain_end->next;
+           index = chain->hash % newsize;
+           chain_end->next = newtable[index];
+           newtable[index] = chain;
+         }
+      table->table = newtable;
+      table->size = newsize;
+    }

 
   return hashp;
 }
 
   return hashp;
 }


@@ -420,17 +536,16 @@ bfd_hash_lookup (table, string, create, copy)
 /* Replace an entry in a hash table.  */
 
 void
 /* Replace an entry in a hash table.  */
 
 void

-bfd_hash_replace (table, old, nw)
-     struct bfd_hash_table *table;
-     struct bfd_hash_entry *old;
-     struct bfd_hash_entry *nw;
+bfd_hash_replace (struct bfd_hash_table *table,
+                 struct bfd_hash_entry *old,
+                 struct bfd_hash_entry *nw)

 {
   unsigned int index;
   struct bfd_hash_entry **pph;
 
   index = old->hash % table->size;
   for (pph = &table->table[index];
 {
   unsigned int index;
   struct bfd_hash_entry **pph;
 
   index = old->hash % table->size;
   for (pph = &table->table[index];

-       (*pph) != (struct bfd_hash_entry *) NULL;
+       (*pph) != NULL;

        pph = &(*pph)->next)
     {
       if (*pph == old)
        pph = &(*pph)->next)
     {
       if (*pph == old)


@@ -443,56 +558,70 @@ bfd_hash_replace (table, old, nw)
   abort ();
 }
 
   abort ();
 }
 

-/* Base method for creating a new hash table entry.  */
-
-/*ARGSUSED*/
-struct bfd_hash_entry *
-bfd_hash_newfunc (entry, table, string)
-     struct bfd_hash_entry *entry;
-     struct bfd_hash_table *table;
-     const char *string;
-{
-  if (entry == (struct bfd_hash_entry *) NULL)
-    entry = ((struct bfd_hash_entry *)
-            bfd_hash_allocate (table, sizeof (struct bfd_hash_entry)));
-  return entry;
-}
-

 /* Allocate space in a hash table.  */
 
 /* Allocate space in a hash table.  */
 

-PTR
-bfd_hash_allocate (table, size)
-     struct bfd_hash_table *table;
-     unsigned int size;
+void *
+bfd_hash_allocate (struct bfd_hash_table *table,
+                  unsigned int size)

 {
 {

-  PTR ret;
+  void * 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;
 }
 
   if (ret == NULL && size != 0)
     bfd_set_error (bfd_error_no_memory);
   return ret;
 }
 

+/* Base method for creating a new hash table entry.  */
+
+struct bfd_hash_entry *
+bfd_hash_newfunc (struct bfd_hash_entry *entry,
+                 struct bfd_hash_table *table,
+                 const char *string ATTRIBUTE_UNUSED)
+{
+  if (entry == NULL)
+    entry = bfd_hash_allocate (table, sizeof (* entry));
+  return entry;
+}
+

 /* Traverse a hash table.  */
 
 void
 /* Traverse a hash table.  */
 
 void

-bfd_hash_traverse (table, func, info)
-     struct bfd_hash_table *table;
-     boolean (*func) PARAMS ((struct bfd_hash_entry *, PTR));
-     PTR info;
+bfd_hash_traverse (struct bfd_hash_table *table,
+                  bfd_boolean (*func) (struct bfd_hash_entry *, void *),
+                  void * info)

 {
   unsigned int i;
 
 {
   unsigned int i;
 

+  table->frozen = 1;

   for (i = 0; i < table->size; i++)
     {
       struct bfd_hash_entry *p;
 
       for (p = table->table[i]; p != NULL; p = p->next)
   for (i = 0; i < table->size; i++)
     {
       struct bfd_hash_entry *p;
 
       for (p = table->table[i]; p != NULL; p = p->next)

-       {
-         if (! (*func) (p, info))
-           return;
-       }
+       if (! (*func) (p, info))
+         goto out;

     }
     }

+ out:
+  table->frozen = 0;
+}
+\f
+void
+bfd_hash_set_default_size (bfd_size_type hash_size)
+{
+  /* Extend this prime list if you want more granularity of hash table size.  */
+  static const bfd_size_type hash_size_primes[] =
+    {
+      251, 509, 1021, 2039, 4051, 8599, 16699, 32749
+    };
+  size_t index;
+
+  /* Work out best prime number near the hash_size.  */
+  for (index = 0; index < ARRAY_SIZE (hash_size_primes) - 1; ++index)
+    if (hash_size <= hash_size_primes[index])
+      break;
+
+  bfd_default_hash_table_size = hash_size_primes[index];

 }
 \f
 /* A few different object file formats (a.out, COFF, ELF) use a string
 }
 \f
 /* A few different object file formats (a.out, COFF, ELF) use a string


@@ -531,33 +660,28 @@ struct bfd_strtab_hash
   struct strtab_hash_entry *last;
   /* Whether to precede strings with a two byte length, as in the
      XCOFF .debug section.  */
   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
-  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
-

 /* Routine to create an entry in a strtab.  */
 
 static struct bfd_hash_entry *
 /* Routine to create an entry in a strtab.  */
 
 static struct bfd_hash_entry *

-strtab_hash_newfunc (entry, table, string)
-     struct bfd_hash_entry *entry;
-     struct bfd_hash_table *table;
-     const char *string;
+strtab_hash_newfunc (struct bfd_hash_entry *entry,
+                    struct bfd_hash_table *table,
+                    const char *string)

 {
   struct strtab_hash_entry *ret = (struct strtab_hash_entry *) entry;
 
   /* Allocate the structure if it has not already been allocated by a
      subclass.  */
 {
   struct strtab_hash_entry *ret = (struct strtab_hash_entry *) entry;
 
   /* Allocate the structure if it has not already been allocated by a
      subclass.  */

-  if (ret == (struct strtab_hash_entry *) NULL)
-    ret = ((struct strtab_hash_entry *)
-          bfd_hash_allocate (table, sizeof (struct strtab_hash_entry)));
-  if (ret == (struct strtab_hash_entry *) NULL)
+  if (ret == NULL)
+    ret = bfd_hash_allocate (table, sizeof (* ret));
+  if (ret == NULL)

     return NULL;
 
   /* Call the allocation method of the superclass.  */
     return NULL;
 
   /* Call the allocation method of the superclass.  */

-  ret = ((struct strtab_hash_entry *)
-        bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
+  ret = (struct strtab_hash_entry *)
+        bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);

 
   if (ret)
     {
 
   if (ret)
     {


@@ -578,18 +702,17 @@ strtab_hash_newfunc (entry, table, string)
 /* Create a new strtab.  */
 
 struct bfd_strtab_hash *
 /* Create a new strtab.  */
 
 struct bfd_strtab_hash *

-_bfd_stringtab_init ()
+_bfd_stringtab_init (void)

 {
   struct bfd_strtab_hash *table;
 {
   struct bfd_strtab_hash *table;

+  bfd_size_type amt = sizeof (* table);

 
 

-  table = (struct bfd_strtab_hash *) malloc (sizeof (struct bfd_strtab_hash));
+  table = bfd_malloc (amt);

   if (table == NULL)
   if (table == NULL)

-    {
-      bfd_set_error (bfd_error_no_memory);
-      return NULL;
-    }
+    return NULL;

 
 

-  if (! bfd_hash_table_init (&table->table, strtab_hash_newfunc))
+  if (!bfd_hash_table_init (&table->table, strtab_hash_newfunc,
+                           sizeof (struct strtab_hash_entry)))

     {
       free (table);
       return NULL;
     {
       free (table);
       return NULL;


@@ -598,7 +721,7 @@ _bfd_stringtab_init ()
   table->size = 0;
   table->first = NULL;
   table->last = NULL;
   table->size = 0;
   table->first = NULL;
   table->last = NULL;

-  table->xcoff = false;
+  table->xcoff = FALSE;

 
   return table;
 }
 
   return table;
 }


@@ -608,50 +731,46 @@ _bfd_stringtab_init ()
    string.  */
 
 struct bfd_strtab_hash *
    string.  */
 
 struct bfd_strtab_hash *

-_bfd_xcoff_stringtab_init ()
+_bfd_xcoff_stringtab_init (void)

 {
   struct bfd_strtab_hash *ret;
 
   ret = _bfd_stringtab_init ();
   if (ret != NULL)
 {
   struct bfd_strtab_hash *ret;
 
   ret = _bfd_stringtab_init ();
   if (ret != NULL)

-    ret->xcoff = true;
+    ret->xcoff = TRUE;

   return ret;
 }
 
 /* Free a strtab.  */
 
 void
   return ret;
 }
 
 /* Free a strtab.  */
 
 void

-_bfd_stringtab_free (table)
-     struct bfd_strtab_hash *table;
+_bfd_stringtab_free (struct bfd_strtab_hash *table)

 {
   bfd_hash_table_free (&table->table);
   free (table);
 }
 
 /* Get the index of a string in a strtab, adding it if it is not
 {
   bfd_hash_table_free (&table->table);
   free (table);
 }
 
 /* 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
    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_stringtab_add (struct bfd_strtab_hash *tab,
+                   const char *str,
+                   bfd_boolean hash,
+                   bfd_boolean copy)

 {
 {

-  register struct strtab_hash_entry *entry;
+  struct strtab_hash_entry *entry;

 
   if (hash)
     {
 
   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;
     }
   else
     {
       if (entry == NULL)
        return (bfd_size_type) -1;
     }
   else
     {

-      entry = ((struct strtab_hash_entry *)
-              bfd_hash_allocate (&tab->table,
-                                 sizeof (struct strtab_hash_entry)));
+      entry = bfd_hash_allocate (&tab->table, sizeof (* entry));

       if (entry == NULL)
        return (bfd_size_type) -1;
       if (! copy)
       if (entry == NULL)
        return (bfd_size_type) -1;
       if (! copy)


@@ -660,7 +779,7 @@ _bfd_stringtab_add (tab, str, hash, copy)
        {
          char *n;
 
        {
          char *n;
 

-         n = (char *) bfd_hash_allocate (&tab->table, strlen (str) + 1);
+         n = bfd_hash_allocate (&tab->table, strlen (str) + 1);

          if (n == NULL)
            return (bfd_size_type) -1;
          entry->root.string = n;
          if (n == NULL)
            return (bfd_size_type) -1;
          entry->root.string = n;


@@ -691,8 +810,7 @@ _bfd_stringtab_add (tab, str, hash, copy)
 /* Get the number of bytes in a strtab.  */
 
 bfd_size_type
 /* Get the number of bytes in a strtab.  */
 
 bfd_size_type

-_bfd_stringtab_size (tab)
-     struct bfd_strtab_hash *tab;
+_bfd_stringtab_size (struct bfd_strtab_hash *tab)

 {
   return tab->size;
 }
 {
   return tab->size;
 }


@@ -700,20 +818,18 @@ _bfd_stringtab_size (tab)
 /* Write out a strtab.  ABFD must already be at the right location in
    the file.  */
 
 /* Write out a strtab.  ABFD must already be at the right location in
    the file.  */
 

-boolean
-_bfd_stringtab_emit (abfd, tab)
-     register bfd *abfd;
-     struct bfd_strtab_hash *tab;
+bfd_boolean
+_bfd_stringtab_emit (bfd *abfd, struct bfd_strtab_hash *tab)

 {
 {

-  register boolean xcoff;
-  register struct strtab_hash_entry *entry;
+  bfd_boolean xcoff;
+  struct strtab_hash_entry *entry;

 
   xcoff = tab->xcoff;
 
   for (entry = tab->first; entry != NULL; entry = entry->next)
     {
 
   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;
 
       str = entry->root.string;
       len = strlen (str) + 1;


@@ -723,14 +839,14 @@ _bfd_stringtab_emit (abfd, tab)
          bfd_byte buf[2];
 
          /* The output length includes the null byte.  */
          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 ((void *) buf, (bfd_size_type) 2, abfd) != 2)
+           return FALSE;

        }
 
        }
 

-      if (bfd_write ((PTR) str, 1, len, abfd) != len)
-       return false;
+      if (bfd_bwrite ((void *) str, (bfd_size_type) len, abfd) != len)
+       return FALSE;

     }
 
     }
 

-  return true;
+  return TRUE;

 }
 }