Merge ^vendor/binutils/dist@214082 into contrib/binutils.

1 files changed, 131 insertions, 129 deletions

diff --git a/contrib/binutils/bfd/hash.c b/contrib/binutils/bfd/hash.c
index 58fa532..ce9ba5c6 100644
--- a/contrib/binutils/bfd/hash.c
+++ b/contrib/binutils/bfd/hash.c
@@ -1,28 +1,29 @@
 /* hash.c -- hash table routines for BFD
-   Copyright 1993, 1994, 1995, 1997, 1999, 2001, 2002, 2003
-   Free Software Foundation, Inc.
+   Copyright 1993, 1994, 1995, 1997, 1999, 2001, 2002, 2003, 2004, 2005,
+   2006 Free Software Foundation, Inc.
    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 2 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 "libbfd.h"
 #include "objalloc.h"
+#include "libiberty.h"
 
 /*
 SECTION
@@ -87,6 +88,10 @@ SUBSECTION
 	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
@@ -225,20 +230,18 @@ SUBSUBSECTION
 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.  *}
-.  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;
 .    }
 .
@@ -295,37 +298,38 @@ SUBSUBSECTION
 */
 
 /* The default number of entries to use when creating a hash table.  */
-#define DEFAULT_SIZE (4051)
+#define DEFAULT_SIZE 4051
+static size_t bfd_default_hash_table_size = DEFAULT_SIZE;
 
 /* Create a new hash table, given a number of entries.  */
 
 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 *,
-						struct bfd_hash_table *,
-						const char *));
-     unsigned int size;
+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 *);
 
-  table->memory = (PTR) objalloc_create ();
+  table->memory = (void *) objalloc_create ();
   if (table->memory == NULL)
     {
       bfd_set_error (bfd_error_no_memory);
       return FALSE;
     }
-  table->table = ((struct bfd_hash_entry **)
-		  objalloc_alloc ((struct objalloc *) table->memory, alloc));
+  table->table = objalloc_alloc ((struct objalloc *) table->memory, alloc);
   if (table->table == NULL)
     {
       bfd_set_error (bfd_error_no_memory);
       return FALSE;
     }
-  memset ((PTR) table->table, 0, alloc);
+  memset ((void *) table->table, 0, alloc);
   table->size = size;
+  table->entsize = entsize;
   table->newfunc = newfunc;
   return TRUE;
 }
@@ -333,37 +337,36 @@ bfd_hash_table_init_n (table, newfunc, size)
 /* Create a new hash table with the default number of entries.  */
 
 bfd_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_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
-bfd_hash_table_free (table)
-     struct bfd_hash_table *table;
+bfd_hash_table_free (struct bfd_hash_table *table)
 {
-  objalloc_free ((struct objalloc *) table->memory);
+  objalloc_free (table->memory);
   table->memory = NULL;
 }
 
 /* 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;
-     bfd_boolean create;
-     bfd_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;
@@ -382,7 +385,7 @@ bfd_hash_lookup (table, string, create, copy)
 
   index = hash % table->size;
   for (hashp = table->table[index];
-       hashp != (struct bfd_hash_entry *) NULL;
+       hashp != NULL;
        hashp = hashp->next)
     {
       if (hashp->hash == hash
@@ -391,21 +394,20 @@ bfd_hash_lookup (table, string, create, copy)
     }
 
   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;
+  hashp = (*table->newfunc) (NULL, table, string);
+  if (hashp == NULL)
+    return NULL;
   if (copy)
     {
       char *new;
 
-      new = (char *) objalloc_alloc ((struct objalloc *) table->memory,
-				     len + 1);
+      new = objalloc_alloc ((struct objalloc *) table->memory, len + 1);
       if (!new)
 	{
 	  bfd_set_error (bfd_error_no_memory);
-	  return (struct bfd_hash_entry *) NULL;
+	  return NULL;
 	}
       memcpy (new, string, len + 1);
       string = new;
@@ -421,17 +423,16 @@ bfd_hash_lookup (table, string, create, copy)
 /* 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];
-       (*pph) != (struct bfd_hash_entry *) NULL;
+       (*pph) != NULL;
        pph = &(*pph)->next)
     {
       if (*pph == old)
@@ -444,28 +445,13 @@ bfd_hash_replace (table, old, nw)
   abort ();
 }
 
-/* Base method for creating a new hash table entry.  */
-
-struct bfd_hash_entry *
-bfd_hash_newfunc (entry, table, string)
-     struct bfd_hash_entry *entry;
-     struct bfd_hash_table *table;
-     const char *string ATTRIBUTE_UNUSED;
-{
-  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.  */
 
-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 = objalloc_alloc ((struct objalloc *) table->memory, size);
   if (ret == NULL && size != 0)
@@ -473,13 +459,24 @@ bfd_hash_allocate (table, size)
   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
-bfd_hash_traverse (table, func, info)
-     struct bfd_hash_table *table;
-     bfd_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;
 
@@ -488,13 +485,29 @@ bfd_hash_traverse (table, func, info)
       struct bfd_hash_entry *p;
 
       for (p = table->table[i]; p != NULL; p = p->next)
-	{
-	  if (! (*func) (p, info))
-	    return;
-	}
+	if (! (*func) (p, info))
+	  return;
     }
 }
 
+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];
+}
+
 /* A few different object file formats (a.out, COFF, ELF) use a string
    table.  These functions support adding strings to a string table,
    returning the byte offset, and writing out the table.
@@ -534,30 +547,25 @@ struct bfd_strtab_hash
   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 *
-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.  */
-  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.  */
-  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)
     {
@@ -578,16 +586,17 @@ strtab_hash_newfunc (entry, table, string)
 /* Create a new strtab.  */
 
 struct bfd_strtab_hash *
-_bfd_stringtab_init ()
+_bfd_stringtab_init (void)
 {
   struct bfd_strtab_hash *table;
-  bfd_size_type amt = sizeof (struct bfd_strtab_hash);
+  bfd_size_type amt = sizeof (* table);
 
-  table = (struct bfd_strtab_hash *) bfd_malloc (amt);
+  table = bfd_malloc (amt);
   if (table == 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;
@@ -606,7 +615,7 @@ _bfd_stringtab_init ()
    string.  */
 
 struct bfd_strtab_hash *
-_bfd_xcoff_stringtab_init ()
+_bfd_xcoff_stringtab_init (void)
 {
   struct bfd_strtab_hash *ret;
 
@@ -619,8 +628,7 @@ _bfd_xcoff_stringtab_init ()
 /* 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);
@@ -631,13 +639,12 @@ _bfd_stringtab_free (table)
    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;
-     bfd_boolean hash;
-     bfd_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)
     {
@@ -647,9 +654,7 @@ _bfd_stringtab_add (tab, str, hash, copy)
     }
   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)
@@ -658,7 +663,7 @@ _bfd_stringtab_add (tab, str, hash, copy)
 	{
 	  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;
@@ -689,8 +694,7 @@ _bfd_stringtab_add (tab, str, hash, copy)
 /* 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;
 }
@@ -699,12 +703,10 @@ _bfd_stringtab_size (tab)
    the file.  */
 
 bfd_boolean
-_bfd_stringtab_emit (abfd, tab)
-     register bfd *abfd;
-     struct bfd_strtab_hash *tab;
+_bfd_stringtab_emit (bfd *abfd, struct bfd_strtab_hash *tab)
 {
-  register bfd_boolean xcoff;
-  register struct strtab_hash_entry *entry;
+  bfd_boolean xcoff;
+  struct strtab_hash_entry *entry;
 
   xcoff = tab->xcoff;
 
@@ -722,11 +724,11 @@ _bfd_stringtab_emit (abfd, tab)
 
 	  /* The output length includes the null byte.  */
 	  bfd_put_16 (abfd, (bfd_vma) len, buf);
-	  if (bfd_bwrite ((PTR) buf, (bfd_size_type) 2, abfd) != 2)
+	  if (bfd_bwrite ((void *) buf, (bfd_size_type) 2, abfd) != 2)
 	    return FALSE;
 	}
 
-      if (bfd_bwrite ((PTR) str, (bfd_size_type) len, abfd) != len)
+      if (bfd_bwrite ((void *) str, (bfd_size_type) len, abfd) != len)
 	return FALSE;
     }