Make all callers of malloc or realloc (including via obstacks)

	check the result for NULL.  Most set bfd_error to no_memory and
	return in that case; a few are harder to fix, and are marked
	with "FIXME <return type>".

	* elf32-hppa.c (hppa_elf_build_arg_reloc_stub
	hppa_elf_build_long_branch_stub):  Check bfd_make_empty_symbol return.
	* linker.c (_bfd_generic_link_output_symbols
	_bfd_generic_link_write_global_symbol): Ditto
	* section.c (bfd_make_section_anyway): Ditto.

	* tekhex.c (find_chunk tekhex_mkobject): Check bfd_alloc.
	(first_phase): Ditto.  FIXME void
	(tekhex_make_empty_symbol): Check bfd_zalloc.

	* sunos.c (sunos_read_dynamic_info): Check bfd_zalloc.
	(MY(read_dynamic_symbols) MY(read_dynamic_relocs)): Check bfd_alloc.

	* stringhash.c (_bfd_stringtab_hash_newfunc): Check bfd_hash_allocate.

	* srec.c: Indent.
	(fillup_symbols): Check bfd_alloc.  FIXME void
	(srec_mkobject srec_get_section_contents
	srec_set_section_contents): Check bfd_alloc.
	(srec_make_empty_symbol): Check bfd_zalloc.

	* som.c (hppa_som_gen_reloc_type): Check bfd_alloc_by_size_t.
	(make_unique_section): Check bfd_alloc.
	(som_new_section_hook): Check bfd_zalloc.
	(bfd_som_attach_aux_hdr): Ditto.  FIXME void

	* rs6000-core.c (rs6000coff_core_p): Check bfd_zalloc.

	* osf-core.c (osf_core_make_empty_symbol): Check bfd_zalloc.
	(osf_core_core_file_p): Check bfd_alloc.

	* oasys.c (oasys_slurp_symbol_table oasys_archive_p
	oasys_mkobject oasys_object_p oasys_new_section_hook
	oasys_set_section_contents): Check bfd_alloc.
	(oasys_slurp_section_data): Check bfd_zalloc and bfd_alloc.
	(oasys_make_empty_symbol): Check bfd_zalloc.

	* nlmcode.h (nlm_make_empty_symbol): Check bfd_zalloc.
	(nlm_slurp_symbol_table): Check bfd_zalloc and bfd_alloc.

	* nlm32-sparc.c (nlm_sparc_read_import): Check bfd_alloc.

	* nlm32-i386.c (nlm_i386_read_import): Check bfd_alloc.

	* nlm32-alpha.c (nlm_alpha_read_import): Check bfd_alloc.

	* linker.c (_bfd_link_hash_newfunc
	(generic_link_hash_newfunc
	(archive_hash_newfunc
	(_bfd_generic_link_add_one_symbol): Check bfd_hash_allocate.
	(_bfd_generic_final_link
	(_bfd_generic_link_output_symbols
	(default_indirect_link_order): Check bfd_alloc.
	(bfd_new_link_order): Check bfd_alloc_by_size_t.

	* irix-core.c (irix_core_make_empty_symbol): Check bfd_zalloc.

	* ieee.c: Indent.
	(read_id get_symbol get_section_entry ieee_archive_p ieee_object_p
	ieee_slurp_section_data ieee_new_section_hook): Check bfd_alloc.
	(do_one): Check bfd_alloc.  Return a boolean.
	(ieee_slurp_section_data): Check it.
	(init_for_output): Check bfd_alloc.  Return a boolean.
	(ieee_set_section_contents): Check it.
	(do_with_relocs):  Check bfd_alloc.  Return a boolean.
	(ieee_bfd_debug_info_accumulate): Ditto.  FIXME void.
	(ieee_mkobject): Check bfd_zalloc.
	(ieee_make_empty_symbol): Check bfd_zmalloc.

	* hpux-core.c (hpux_core_make_empty_symbol): Check
	bfd_zalloc.

	* hppabsd-core.c (hppabsd_core_make_empty_symbol): Check
	bfd_zalloc.
	(hppabsd_core_core_file_p): Check bfd_zalloc.

	* hp300hpux.c (MY(slurp_symbol_table)): Check bfd_alloc.

	* elfcode.h (elf_new_section_hook): Check bfd_alloc.
	(bfd_section_from_phdr): Ditto.
	(write_relocs): Ditto.  FIXME void
	(elf_map_symbols assign_section_numbers map_program_segments):
	Ditto.  Return a boolean.
	(swap_out_syms): Ditto.  Check elf_map_symbols.
	(elf_slurp_symbol_table): Check bfd_zalloc.
	(elf_slurp_reloca_table): Check bfd_alloc.
	(elf_slurp_reloc_table): Ditto.
	(elf_compute_section_file_positions): Check assign_section_numbers.
	(assign_file_positions_except_relocs): Return a boolean.
	Check map_program_segments.
	(elf_compute_section_file_positions): Check it.

	* elf32-mips.c (mips_elf_final_link): Check bfd_alloc.

	* elf32-hppa.c (hppa_elf_stub_branch_reloc): Check bfd_zmalloc and
	realloc.
	(hppa_elf_stub_reloc): Ditto.
	(hppa_elf_build_arg_reloc_stub): Check bfd_zalloc.
	(hppa_elf_build_long_branch_stub): Ditto.
	(elf32_hppa_backend_symbol_table_processing): Ditto.

	* ecoff.c (ecoff_set_symbol_info): Check bfd_alloc.  Return a boolean.
	(ecoff_slurp_symbol_table): Check it.
	(ecoff_slurp_armap): Check bfd_alloc.
	(ecoff_write_armap): Check bfd_zalloc.
	(ecoff_link_hash_newfunc): Check bfd_hash_allocate and
	_bfd_link_hash_newfunc.
	(ecoff_link_add_externals): Check bfd_alloc.

	* ctor.c (bfd_constructor_entry): Check bfd_alloc.

	* coffgen.c (coff_real_object_p): Check bfd_alloc.
	(coff_renumber_symbols): Check bfd_alloc_by_size_t.  Return a boolean.
	(coff_write_symbol): Check bfd_alloc.  FIXME int
	(coff_write_linenumbers): Check bfd_alloc.  Return a boolean.
	(coff_section_symbol): Check bfd_alloc_by_size_t.
	(coff_get_normalized_symtab): Check bfd_alloc.
	(coff_bfd_make_debug_symbol): Check bfd_zalloc.
	* libcoff-in.h: Change decls of coff_renumber_symbols,
	coff_write_linenumbers.
	* libcoff.h: Rebuilt.
	* coffcode.h (coff_write_object_contents): Check
	coff_renumber_symbols, coff_write_linenumbers.

	* coffcode.h: Indent.
	(coff_add_missing_symbols): Check bfd_alloc_by_size_t.  Return a
	boolean.
	(coff_write_object_contents): Check it.

	* coff-alpha.c (alpha_relocate_section): Check bfd_alloc.
	* coff-mips.c (mips_relocate_section): Ditto.

	* archive.c (bfd_slurp_bsd_armap_f2): Check bfd_alloc value.
	(do_slurp_bsd_armap): Ditto.
	(compute_and_write_armap): Check bfd_realloc value.

	* aoutx.h (translate_from_native_sym_flags): Check bfd_alloc
	return value.  Return boolean value.
	(NAME(aout,make_empty_symbol)): Check bfd_zalloc return value.
	(NAME(aout,slurp_symbol_table)): Check bf_alloc and bfd_zalloc
	return value.
	(add_to_stringtab): Ditto.  FIXME void
	(aout_link_hash_newfunc): Check bfd_hash_allocate return value.
	(aout_link_add_symbols): Check bfd_alloc value.
	(translate_symbol_table): Check translate_from_native_sym_flags.
	* hp300hpux.c (MY(slurp_symbol_table)): Ditto.
	* aoutx.h (aout_link_hash_newfunc): Check _bfd_link_hash_newfunc.

	* opncls.c (bfd_zalloc bfd_realloc): Check result of bfd_alloc.

	* opncls.c (obstack_chunk_alloc): Define as malloc, not
	bfd_xmalloc_by_size_t.
	(_bfd_new_bfd): Check obstack_begin for 0 return.

	* ieee.c (obstack_chunk_alloc): Define as malloc, not
	bfd_xmalloc_by_size_t.
	(ieee_archive_p): Check obstack_begin for 0 return and
	obstack_finish for NULL return.

	* hash.c (obstack_chunk_alloc): Define as malloc, not
	bfd_xmalloc_by_size_t.
	(bfd_hash_table_init_n): Check obstack_begin for 0 return and
	obstack_finish for NULL return.
	(bfd_hash_lookup): Check obstack_alloc for NULL return.

	* ecofflink.c (obstack_chunk_alloc): Define as malloc, not
	bfd_xmalloc_by_size_t.
	bfd_ecoff_debug_accumulate
	bfd_ecoff_debug_accumulate_other): Check obstack_alloc.
	(add_file_shuffle add_memory_shuffle): Check obstack_alloc for
	NULL return.  Return boolean, not void.
	(bfd_ecoff_debug_init): Check obstack_begin for 0 return.
	(bfd_ecoff_debug_accumulate): Check add_file_shuffle
	and add_memory_shuffle return.
	(string_hash_newfunc): Check bfd_hash_allocate and bfd_hash_newfunc.
	(bfd_ecoff_debug_accumulate): Check bfd_alloc.
	(ecoff_add_string): Check add_memory_shuffle return.

	* libbfd-in.h (xmalloc, bfd_xmalloc, bfd_xmalloc_by_size_t):
	Remove decls.
	* libbfd.h: Rebuilt.

1 files changed, 143 insertions, 32 deletions

diff --git a/bfd/coffgen.c b/bfd/coffgen.c
index c9a570f..d3a3582 100644
--- a/bfd/coffgen.c
+++ b/bfd/coffgen.c
@@ -1,5 +1,5 @@
 /* Support for the generic parts of COFF, for BFD.
-   Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
+   Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
    Written by Cygnus Support.
 
 This file is part of BFD, the Binary File Descriptor library.
@@ -132,6 +132,11 @@ DEFUN(coff_real_object_p,(abfd, nscns, internal_f, internal_a),
   scnhsz = bfd_coff_scnhsz (abfd);
   readsize = nscns * scnhsz;
   external_sections = (char *)bfd_alloc(abfd, readsize);
+  if (!external_sections)
+    {
+      bfd_error = no_memory;
+      goto fail;
+    }
 
   if (bfd_read((PTR)external_sections, 1, readsize, abfd) != readsize) {
     goto fail;
@@ -420,7 +425,7 @@ struct internal_syment *syment)
  do that here too.
 
 */
-void
+boolean
 DEFUN(coff_renumber_symbols,(bfd_ptr),
       bfd *bfd_ptr)
 {
@@ -444,6 +449,11 @@ DEFUN(coff_renumber_symbols,(bfd_ptr),
     newsyms = (asymbol **) bfd_alloc_by_size_t (bfd_ptr,
 						sizeof (asymbol *)
 						* (symbol_count + 1));
+    if (!newsyms)
+      {
+	bfd_error = no_memory;
+	return false;
+      }
     bfd_ptr->outsymbols = newsyms;
     for (i = 0; i < symbol_count; i++)
       if (symbol_ptr_ptr[i]->section != &bfd_und_section)
@@ -485,6 +495,7 @@ DEFUN(coff_renumber_symbols,(bfd_ptr),
 	}
       }
   obj_conv_table_size (bfd_ptr) = native_index;
+  return true;
 }
 
 /*
@@ -493,42 +504,59 @@ DEFUN(coff_renumber_symbols,(bfd_ptr),
 
 */
 void
-DEFUN(coff_mangle_symbols,(bfd_ptr),
-      bfd *bfd_ptr)
+coff_mangle_symbols (bfd_ptr)
+     bfd *bfd_ptr;
 {
-  unsigned int symbol_count = bfd_get_symcount(bfd_ptr);
+  unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
   asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
   unsigned int symbol_index;
 
   for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
-      {
-	coff_symbol_type *coff_symbol_ptr =
-	  coff_symbol_from(bfd_ptr, symbol_ptr_ptr[symbol_index]);
+    {
+      coff_symbol_type *coff_symbol_ptr =
+	coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
 
-	if (coff_symbol_ptr && coff_symbol_ptr->native) {
+      if (coff_symbol_ptr && coff_symbol_ptr->native)
+	{
 	  int i;
 	  combined_entry_type *s = coff_symbol_ptr->native;
 
-	  for (i = 0; i < s->u.syment.n_numaux ; i++) {
-	    combined_entry_type *a = s + i + 1;
-	    if (a->fix_tag) {
-	      a->u.auxent.x_sym.x_tagndx.l =
-		a->u.auxent.x_sym.x_tagndx.p->offset;
-	      a->fix_tag = 0;
+	  if (s->fix_value)
+	    {
+	      /* FIXME: We should use a union here.  */
+	      s->u.syment.n_value =
+		((combined_entry_type *) s->u.syment.n_value)->offset;
+	      s->fix_value = 0;
 	    }
-	    if (a->fix_end) {
-	      a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
-		a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
-	      a->fix_end = 0;
-	      
+	  for (i = 0; i < s->u.syment.n_numaux ; i++)
+	    {
+	      combined_entry_type *a = s + i + 1;
+	      if (a->fix_tag)
+		{
+		  a->u.auxent.x_sym.x_tagndx.l =
+		    a->u.auxent.x_sym.x_tagndx.p->offset;
+		  a->fix_tag = 0;
+		}
+	      if (a->fix_end)
+		{
+		  a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
+		    a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
+		  a->fix_end = 0;
+		}
+	      if (a->fix_scnlen)
+		{
+		  a->u.auxent.x_csect.x_scnlen.l =
+		    a->u.auxent.x_csect.x_scnlen.p->offset;
+		  a->fix_scnlen = 0;
+		}
 	    }
-
-	  }
 	}
-      }
+    }
 }
 
-static int string_size;
+static bfd_size_type string_size;
+static bfd_size_type debug_string_size;
+static asection *debug_string_section;
 
 static void
 DEFUN(coff_fix_symbol_name,(abfd, symbol, native),
@@ -569,17 +597,50 @@ DEFUN(coff_fix_symbol_name,(abfd, symbol, native),
     }
   }
   else
-      {				/* NOT A C_FILE SYMBOL */
-	if (name_length <= SYMNMLEN) {
+    {				/* NOT A C_FILE SYMBOL */
+      if (name_length <= SYMNMLEN)
+	{
 	  /* This name will fit into the symbol neatly */
 	  strncpy(native->u.syment._n._n_name, symbol->name, SYMNMLEN);
 	}
-	else {
+      else if (! bfd_coff_symname_in_debug (abfd, &native->u.syment))
+	{
 	  native->u.syment._n._n_n._n_offset =  string_size + 4;
 	  native->u.syment._n._n_n._n_zeroes = 0;
 	  string_size += name_length + 1;
 	}
-      }
+      else
+	{
+	  long filepos;
+	  bfd_byte buf[2];
+
+	  /* This name should be written into the .debug section.  For
+	     some reason each name is preceded by a two byte length
+	     and also followed by a null byte.  FIXME: We assume that
+	     the .debug section has already been created, and that it
+	     is large enough.  */
+	  if (debug_string_section == (asection *) NULL)
+	    debug_string_section = bfd_get_section_by_name (abfd, ".debug");
+	  filepos = bfd_tell (abfd);
+	  bfd_put_16 (abfd, name_length + 1, buf);
+	  if (! bfd_set_section_contents (abfd,
+					  debug_string_section,
+					  (PTR) buf,
+					  (file_ptr) debug_string_size,
+					  (bfd_size_type) 2)
+	      || ! bfd_set_section_contents (abfd,
+					     debug_string_section,
+					     (PTR) symbol->name,
+					     (file_ptr) debug_string_size + 2,
+					     (bfd_size_type) name_length + 1))
+	    abort ();
+	  if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
+	    abort ();
+	  native->u.syment._n._n_n._n_offset = debug_string_size + 2;
+	  native->u.syment._n._n_n._n_zeroes = 0;
+	  debug_string_size += name_length + 3;
+	}
+    }
 }
 
 #define	set_index(symbol, idx)	((symbol)->udata =(PTR) (idx))
@@ -625,6 +686,11 @@ unsigned int written)
 
   symesz = bfd_coff_symesz (abfd);
   buf = bfd_alloc (abfd, symesz);
+  if (!buf)
+    {
+      bfd_error = no_memory;
+      abort();			/* FIXME */
+    }
   bfd_coff_swap_sym_out(abfd, &native->u.syment, buf);
   bfd_write(buf, 1, symesz, abfd);
   bfd_release (abfd, buf);
@@ -636,6 +702,11 @@ unsigned int written)
 
       auxesz = bfd_coff_auxesz (abfd);
       buf = bfd_alloc (abfd, auxesz);
+      if (!buf)
+	{
+	  bfd_error = no_memory;
+	  abort();		/* FIXME */
+	}
       for (j = 0; j < native->u.syment.n_numaux;  j++)
 	{
 	  bfd_coff_swap_aux_out(abfd,
@@ -785,7 +856,7 @@ DEFUN(coff_write_symbols,(abfd),
   asymbol       **p;
 
   string_size = 0;
-
+  debug_string_size = 0;
 
   /* Seek to the right place */
   bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET);
@@ -833,9 +904,10 @@ DEFUN(coff_write_symbols,(abfd),
 		     (c_symbol->native->u.syment.n_sclass == C_FILE)) ?
 	     FILNMLEN : SYMNMLEN;
 
-	   if (name_length > maxlen) {
+	   if (name_length > maxlen
+	       && ! bfd_coff_symname_in_debug (abfd,
+					       &c_symbol->native->u.syment))
 	     bfd_write((PTR) (q->name), 1, name_length + 1, abfd);
-	   }
 	 }
    }
   else {
@@ -848,9 +920,15 @@ DEFUN(coff_write_symbols,(abfd),
     bfd_h_put_32 (abfd, size, buffer);
     bfd_write((PTR) buffer, 1, sizeof (buffer), abfd);
   }
+
+  BFD_ASSERT (debug_string_size == 0
+	      || (debug_string_section != (asection *) NULL
+		  && (BFD_ALIGN (debug_string_size,
+				 1 << debug_string_section->alignment_power)
+		      == bfd_section_size (abfd, debug_string_section))));
 }
 
-void
+boolean
 DEFUN(coff_write_linenumbers,(abfd),
       bfd            *abfd)
 {
@@ -860,6 +938,11 @@ DEFUN(coff_write_linenumbers,(abfd),
 
   linesz = bfd_coff_linesz (abfd);
   buff = bfd_alloc (abfd, linesz);
+  if (!buff)
+    {
+      bfd_error = no_memory;
+      return;
+    }
   for (s = abfd->sections; s != (asection *) NULL; s = s->next) {
     if (s->lineno_count) {
       asymbol       **q = abfd->outsymbols;
@@ -893,6 +976,7 @@ DEFUN(coff_write_linenumbers,(abfd),
     }
   }
   bfd_release (abfd, buff);
+  return true;
 }
 
 /*ARGSUSED*/
@@ -925,6 +1009,11 @@ coff_section_symbol (abfd, name)
       };
       struct foo *f;
       f = (struct foo *) bfd_alloc_by_size_t (abfd, sizeof (*f));
+      if (!f)
+	{
+	  bfd_error = no_error;
+	  return NULL;
+	}
       memset ((char *) f, 0, sizeof (*f));
       coff_symbol_from (abfd, sym)->native = csym = f->e;
     }
@@ -1106,11 +1195,21 @@ bfd            *abfd)
     }
 
   internal = (combined_entry_type *)bfd_alloc(abfd, size);
+  if (!internal)
+    {
+      bfd_error = no_memory;
+      return NULL;
+    }
   internal_end = internal + bfd_get_symcount(abfd);
 
   symesz = bfd_coff_symesz (abfd);
   raw_size =      bfd_get_symcount(abfd) * symesz;
   raw = bfd_alloc(abfd,raw_size);
+  if (!raw)
+    {
+      bfd_error = no_memory;
+      return NULL;
+    }
 
   if (bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET) == -1
       || bfd_read(raw, raw_size, 1, abfd) != raw_size) {
@@ -1131,8 +1230,10 @@ bfd            *abfd)
 
       unsigned int i;
       bfd_coff_swap_sym_in(abfd, (PTR)raw_src, (PTR)&internal_ptr->u.syment);
+      internal_ptr->fix_value = 0;
       internal_ptr->fix_tag = 0;
       internal_ptr->fix_end = 0;
+      internal_ptr->fix_scnlen = 0;
       symbol_ptr = internal_ptr;
 
       for (i = 0;
@@ -1142,8 +1243,10 @@ bfd            *abfd)
 	internal_ptr++;
 	raw_src += symesz;
       
+	internal_ptr->fix_value = 0;
 	internal_ptr->fix_tag = 0;
 	internal_ptr->fix_end = 0;
+	internal_ptr->fix_scnlen = 0;
 	bfd_coff_swap_aux_in(abfd, (PTR) raw_src,
 			     symbol_ptr->u.syment.n_type,
 			     symbol_ptr->u.syment.n_sclass,
@@ -1212,6 +1315,8 @@ bfd            *abfd)
 	    internal_ptr->u.syment._n._n_n._n_offset =  (long int) newstring;
 	    internal_ptr->u.syment._n._n_n._n_zeroes = 0;
 	  }
+	else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
+	  internal_ptr->u.syment._n._n_n._n_offset = (long int) "";
 	else if (!bfd_coff_symname_in_debug(abfd, &internal_ptr->u.syment)) {
 	    /* Long name already.  Point symbol at the string in the table.  */
 	    if (string_table == NULL) {
@@ -1259,6 +1364,7 @@ DEFUN (coff_make_empty_symbol, (abfd),
     bfd_error = no_memory;
     return (NULL);
   }				/* on error */
+  memset (new, 0, sizeof *new);
   new->symbol.section = 0;
   new->native = 0;
   new->lineno = (alent *) NULL;
@@ -1282,6 +1388,11 @@ coff_bfd_make_debug_symbol (abfd, ptr, sz)
   }				/* on error */
   /* @@ This shouldn't be using a constant multiplier.  */
   new->native = (combined_entry_type *) bfd_zalloc (abfd, sizeof (combined_entry_type) * 10);
+  if (!new->native)
+    {
+      bfd_error = no_memory;
+      return (NULL);
+    }				/* on error */
   new->symbol.section = &bfd_debug_section;
   new->lineno = (alent *) NULL;
   new->done_lineno = false;