* opncls.c (bfd_alloc_by_size_t): Set bfd_error_no_memory if

	obstack_alloc fails.
	(bfd_alloc_finish): Set bfd_error_no_memory if obstack_finish
	fails.
	* libbfd.c (bfd_zmalloc): Set bfd_error_no_memory if malloc fails.
	* Many files: don't set bfd_error_no_memory if one of the above
	routines fails.

1 files changed, 282 insertions, 7 deletions

diff --git a/bfd/hash.c b/bfd/hash.c
index 987c259..8ea4375 100644
--- a/bfd/hash.c
+++ b/bfd/hash.c
@@ -16,7 +16,7 @@ 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "bfd.h"
 #include "sysdep.h"
@@ -234,8 +234,12 @@ EXAMPLE
 . {* Allocate the structure if it has not already been allocated by a
 .    derived class.  *}
 .  if (ret == (@var{entry_type} *) NULL)
-.    ret = ((@var{entry_type} *)
-.	   bfd_hash_allocate (table, sizeof (@var{entry_type})));
+.    {
+.      ret = ((@var{entry_type} *)
+.	      bfd_hash_allocate (table, sizeof (@var{entry_type})));
+.      if (ret == (@var{entry_type} *) NULL)
+.        return NULL;
+.    }
 .
 . {* Call the allocation method of the base class.  *}
 .  ret = ((@var{entry_type} *)
@@ -311,14 +315,14 @@ bfd_hash_table_init_n (table, newfunc, size)
   alloc = size * sizeof (struct bfd_hash_entry *);
   if (!obstack_begin (&table->memory, alloc))
     {
-      bfd_error = no_memory;
+      bfd_set_error (bfd_error_no_memory);
       return false;
     }
   table->table = ((struct bfd_hash_entry **)
 		  obstack_alloc (&table->memory, alloc));
   if (!table->table)
     {
-      bfd_error = no_memory;
+      bfd_set_error (bfd_error_no_memory);
       return false;
     }
   memset ((PTR) table->table, 0, alloc);
@@ -399,7 +403,7 @@ bfd_hash_lookup (table, string, create, copy)
       new = (char *) obstack_alloc (&table->memory, len + 1);
       if (!new)
 	{
-	  bfd_error = no_memory;
+	  bfd_set_error (bfd_error_no_memory);
 	  return (struct bfd_hash_entry *) NULL;
 	}
       strcpy (new, string);
@@ -413,6 +417,32 @@ bfd_hash_lookup (table, string, create, copy)
   return hashp;
 }
 
+/* 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;
+{
+  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 = &(*pph)->next)
+    {
+      if (*pph == old)
+	{
+	  *pph = nw;
+	  return;
+	}
+    }
+
+  abort ();
+}
+
 /* Base method for creating a new hash table entry.  */
 
 /*ARGSUSED*/
@@ -435,7 +465,12 @@ bfd_hash_allocate (table, size)
      struct bfd_hash_table *table;
      unsigned int size;
 {
-  return obstack_alloc (&table->memory, size);
+  PTR ret;
+
+  ret = obstack_alloc (&table->memory, size);
+  if (ret == NULL && size != 0)
+    bfd_set_error (bfd_error_no_memory);
+  return ret;
 }
 
 /* Traverse a hash table.  */
@@ -459,3 +494,243 @@ bfd_hash_traverse (table, func, info)
 	}
     }
 }
+
+/* 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.
+
+   Possible improvements:
+   + look for strings matching trailing substrings of other strings
+   + better data structures?  balanced trees?
+   + look at reducing memory use elsewhere -- maybe if we didn't have
+     to construct the entire symbol table at once, we could get by
+     with smaller amounts of VM?  (What effect does that have on the
+     string table reductions?)  */
+
+/* An entry in the strtab hash table.  */
+
+struct strtab_hash_entry
+{
+  struct bfd_hash_entry root;
+  /* Index in string table.  */
+  bfd_size_type index;
+  /* Next string in strtab.  */
+  struct strtab_hash_entry *next;
+};
+
+/* The strtab hash table.  */
+
+struct bfd_strtab_hash
+{
+  struct bfd_hash_table table;
+  /* Size of strtab--also next available index.  */
+  bfd_size_type size;
+  /* First string in strtab.  */
+  struct strtab_hash_entry *first;
+  /* Last string in strtab.  */
+  struct strtab_hash_entry *last;
+  /* Whether to precede strings with a two byte length, as in the
+     XCOFF .debug section.  */
+  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;
+{
+  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)
+    return NULL;
+
+  /* Call the allocation method of the superclass.  */
+  ret = ((struct strtab_hash_entry *)
+	 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
+
+  if (ret)
+    {
+      /* Initialize the local fields.  */
+      ret->index = (bfd_size_type) -1;
+      ret->next = NULL;
+    }
+
+  return (struct bfd_hash_entry *) ret;
+}
+
+/* Look up an entry in an strtab.  */
+
+#define strtab_hash_lookup(t, string, create, copy) \
+  ((struct strtab_hash_entry *) \
+   bfd_hash_lookup (&(t)->table, (string), (create), (copy)))
+
+/* Create a new strtab.  */
+
+struct bfd_strtab_hash *
+_bfd_stringtab_init ()
+{
+  struct bfd_strtab_hash *table;
+
+  table = (struct bfd_strtab_hash *) malloc (sizeof (struct bfd_strtab_hash));
+  if (table == NULL)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return NULL;
+    }
+
+  if (! bfd_hash_table_init (&table->table, strtab_hash_newfunc))
+    {
+      free (table);
+      return NULL;
+    }
+
+  table->size = 0;
+  table->first = NULL;
+  table->last = NULL;
+  table->xcoff = false;
+
+  return table;
+}
+
+/* Create a new strtab in which the strings are output in the format
+   used in the XCOFF .debug section: a two byte length precedes each
+   string.  */
+
+struct bfd_strtab_hash *
+_bfd_xcoff_stringtab_init ()
+{
+  struct bfd_strtab_hash *ret;
+
+  ret = _bfd_stringtab_init ();
+  if (ret != NULL)
+    ret->xcoff = true;
+  return ret;
+}
+
+/* Free a strtab.  */
+
+void
+_bfd_stringtab_free (table)
+     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
+   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;
+{
+  register struct strtab_hash_entry *entry;
+
+  if (hash)
+    {
+      entry = strtab_hash_lookup (tab, str, true, copy);
+      if (entry == NULL)
+	return (bfd_size_type) -1;
+    }
+  else
+    {
+      entry = ((struct strtab_hash_entry *)
+	       bfd_hash_allocate (&tab->table,
+				  sizeof (struct strtab_hash_entry)));
+      if (entry == NULL)
+	return (bfd_size_type) -1;
+      if (! copy)
+	entry->root.string = str;
+      else
+	{
+	  char *n;
+
+	  n = (char *) bfd_hash_allocate (&tab->table, strlen (str) + 1);
+	  if (n == NULL)
+	    return (bfd_size_type) -1;
+	  entry->root.string = n;
+	}
+      entry->index = (bfd_size_type) -1;
+      entry->next = NULL;
+    }
+
+  if (entry->index == (bfd_size_type) -1)
+    {
+      entry->index = tab->size;
+      tab->size += strlen (str) + 1;
+      if (tab->xcoff)
+	{
+	  entry->index += 2;
+	  tab->size += 2;
+	}
+      if (tab->first == NULL)
+	tab->first = entry;
+      else
+	tab->last->next = entry;
+      tab->last = entry;
+    }
+
+  return entry->index;
+}
+
+/* Get the number of bytes in a strtab.  */
+
+bfd_size_type
+_bfd_stringtab_size (tab)
+     struct bfd_strtab_hash *tab;
+{
+  return tab->size;
+}
+
+/* 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;
+{
+  register 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;
+
+      str = entry->root.string;
+      len = strlen (str) + 1;
+
+      if (xcoff)
+	{
+	  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;
+	}
+
+      if (bfd_write ((PTR) str, 1, len, abfd) != len)
+	return false;
+    }
+
+  return true;
+}