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, 116 insertions, 37 deletions

diff --git a/bfd/ecofflink.c b/bfd/ecofflink.c
index 306f028..7fd34cb 100644
--- a/bfd/ecofflink.c
+++ b/bfd/ecofflink.c
@@ -41,7 +41,7 @@ static boolean ecoff_write_symhdr PARAMS ((bfd *, struct ecoff_debug_info *,
 					   file_ptr where));
 
 /* Obstack allocation and deallocation routines.  */
-#define obstack_chunk_alloc bfd_xmalloc_by_size_t
+#define obstack_chunk_alloc malloc
 #define obstack_chunk_free free
 
 /* The minimum amount of data to allocate.  */
@@ -115,14 +115,22 @@ string_hash_newfunc (entry, table, string)
   if (ret == (struct string_hash_entry *) NULL)
     ret = ((struct string_hash_entry *)
 	   bfd_hash_allocate (table, sizeof (struct string_hash_entry)));
+  if (ret == (struct string_hash_entry *) NULL)
+    {
+      bfd_error = no_memory;
+      return NULL;
+    }
 
   /* Call the allocation method of the superclass.  */
   ret = ((struct string_hash_entry *)
 	 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
 
-  /* Initialize the local fields.  */
-  ret->val = -1;
-  ret->next = NULL;
+  if (ret)
+    {
+      /* Initialize the local fields.  */
+      ret->val = -1;
+      ret->next = NULL;
+    }
 
   return (struct bfd_hash_entry *) ret;
 }
@@ -197,12 +205,12 @@ struct accumulate
 
 /* Add a file entry to a shuffle list.  */
 
-static void add_file_shuffle PARAMS ((struct accumulate *,
+static boolean add_file_shuffle PARAMS ((struct accumulate *,
 				      struct shuffle **,
 				      struct shuffle **, bfd *, file_ptr,
 				      unsigned long));
 
-static void
+static boolean
 add_file_shuffle (ainfo, head, tail, input_bfd, offset, size)
      struct accumulate *ainfo;
      struct shuffle **head;
@@ -222,11 +230,16 @@ add_file_shuffle (ainfo, head, tail, input_bfd, offset, size)
       (*tail)->size += size;
       if ((*tail)->size > ainfo->largest_file_shuffle)
 	ainfo->largest_file_shuffle = (*tail)->size;
-      return;
+      return true;
     }
 
   n = (struct shuffle *) obstack_alloc (&ainfo->memory,
 					sizeof (struct shuffle));
+  if (!n)
+    {
+      bfd_error = no_memory;
+      return false;
+    }
   n->next = NULL;
   n->size = size;
   n->filep = true;
@@ -239,16 +252,17 @@ add_file_shuffle (ainfo, head, tail, input_bfd, offset, size)
   *tail = n;
   if (size > ainfo->largest_file_shuffle)
     ainfo->largest_file_shuffle = size;
+  return true;
 }
 
 /* Add a memory entry to a shuffle list.  */
 
-static void add_memory_shuffle PARAMS ((struct accumulate *,
-					struct shuffle **head,
-					struct shuffle **tail,
-					bfd_byte *data, unsigned long size));
+static boolean add_memory_shuffle PARAMS ((struct accumulate *,
+					   struct shuffle **head,
+					   struct shuffle **tail,
+					   bfd_byte *data, unsigned long size));
 
-static void
+static boolean
 add_memory_shuffle (ainfo, head, tail, data, size)
      struct accumulate *ainfo;
      struct shuffle **head;
@@ -260,6 +274,11 @@ add_memory_shuffle (ainfo, head, tail, data, size)
      
   n = (struct shuffle *) obstack_alloc (&ainfo->memory,
 					sizeof (struct shuffle));
+  if (!n)
+    {
+      bfd_error = no_memory;
+      return false;
+    }
   n->next = NULL;
   n->size = size;
   n->filep = false;
@@ -269,6 +288,7 @@ add_memory_shuffle (ainfo, head, tail, data, size)
   if (*tail != (struct shuffle *) NULL)
     (*tail)->next = n;
   *tail = n;
+  return true;
 }
 
 /* Initialize the FDR hash table.  This returns a handle which is then
@@ -284,7 +304,12 @@ bfd_ecoff_debug_init (output_bfd, output_debug, output_swap, info)
 {
   struct accumulate *ainfo;
 
-  ainfo = (struct accumulate *) bfd_xmalloc (sizeof (struct accumulate));
+  ainfo = (struct accumulate *) malloc (sizeof (struct accumulate));
+  if (!ainfo)
+    {
+      bfd_error = no_memory;
+      return NULL;
+    }
   if (! bfd_hash_table_init_n (&ainfo->fdr_hash.table, string_hash_newfunc,
 			       1021))
     return NULL;
@@ -319,7 +344,11 @@ bfd_ecoff_debug_init (output_bfd, output_debug, output_swap, info)
       output_debug->symbolic_header.issMax = 1;
     }
 
-  obstack_begin (&ainfo->memory, 4050);
+  if (!obstack_begin (&ainfo->memory, 4050))
+    {
+      bfd_error = no_memory;
+      return NULL;
+    }
 
   return (PTR) ainfo;
 }
@@ -447,7 +476,13 @@ bfd_ecoff_debug_accumulate (handle, output_bfd, output_debug, output_swap,
 
   sz = (input_symhdr->crfd + input_symhdr->ifdMax) * external_rfd_size;
   rfd_out = (bfd_byte *) obstack_alloc (&ainfo->memory, sz);
-  add_memory_shuffle (ainfo, &ainfo->rfd, &ainfo->rfd_end, rfd_out, sz);
+  if (!input_debug->ifdmap || !rfd_out)
+    {
+      bfd_error = no_memory;
+      return false;
+    }
+  if (!add_memory_shuffle (ainfo, &ainfo->rfd, &ainfo->rfd_end, rfd_out, sz))
+    return false;
 
   copied = 0;
 
@@ -537,7 +572,13 @@ bfd_ecoff_debug_accumulate (handle, output_bfd, output_debug, output_swap,
      information.  */
   sz = copied * external_fdr_size;
   fdr_out = (bfd_byte *) obstack_alloc (&ainfo->memory, sz);
-  add_memory_shuffle (ainfo, &ainfo->fdr, &ainfo->fdr_end, fdr_out, sz);
+  if (!fdr_out)
+    {
+      bfd_error = no_memory;
+      return false;
+    }
+  if (!add_memory_shuffle (ainfo, &ainfo->fdr, &ainfo->fdr_end, fdr_out, sz))
+    return false;
   for (fdr_ptr = fdr_start, i = 0;
        fdr_ptr < fdr_end;
        fdr_ptr += fdr_add, i++)
@@ -569,7 +610,13 @@ bfd_ecoff_debug_accumulate (handle, output_bfd, output_debug, output_swap,
       fgotfilename = false;
       sz = fdr.csym * external_sym_size;
       sym_out = (bfd_byte *) obstack_alloc (&ainfo->memory, sz);
-      add_memory_shuffle (ainfo, &ainfo->sym, &ainfo->sym_end, sym_out, sz);
+      if (!sym_out)
+	{
+	  bfd_error = no_memory;
+	  return false;
+	}
+      if (!add_memory_shuffle (ainfo, &ainfo->sym, &ainfo->sym_end, sym_out, sz))
+	return false;
       lraw_src = ((bfd_byte *) input_debug->external_sym
 		  + fdr.isymBase * input_swap->external_sym_size);
       lraw_end = lraw_src + fdr.csym * input_swap->external_sym_size;
@@ -658,10 +705,11 @@ bfd_ecoff_debug_accumulate (handle, output_bfd, output_debug, output_swap,
       /* Copy the information that does not need swapping.  */
       if (fdr.cbLine > 0)
 	{
-	  add_file_shuffle (ainfo, &ainfo->line, &ainfo->line_end,
+	  if (!add_file_shuffle (ainfo, &ainfo->line, &ainfo->line_end,
 			    input_bfd,
 			    input_symhdr->cbLineOffset + fdr.cbLineOffset,
-			    fdr.cbLine);
+			    fdr.cbLine))
+	    return false;
 	  fdr.ilineBase = output_symhdr->ilineMax;
 	  fdr.cbLineOffset = output_symhdr->cbLine;
 	  output_symhdr->ilineMax += fdr.cline;
@@ -669,11 +717,12 @@ bfd_ecoff_debug_accumulate (handle, output_bfd, output_debug, output_swap,
 	}
       if (fdr.caux > 0)
 	{
-	  add_file_shuffle (ainfo, &ainfo->aux, &ainfo->aux_end,
+	  if (!add_file_shuffle (ainfo, &ainfo->aux, &ainfo->aux_end,
 			    input_bfd,
 			    (input_symhdr->cbAuxOffset
 			     + fdr.iauxBase * sizeof (union aux_ext)),
-			    fdr.caux * sizeof (union aux_ext));
+			    fdr.caux * sizeof (union aux_ext)))
+	    return false;
 	  fdr.iauxBase = output_symhdr->iauxMax;
 	  output_symhdr->iauxMax += fdr.caux;
 	}
@@ -689,10 +738,11 @@ bfd_ecoff_debug_accumulate (handle, output_bfd, output_debug, output_swap,
 	}
       else if (fdr.cbSs > 0)
 	{
-	  add_file_shuffle (ainfo, &ainfo->ss, &ainfo->ss_end,
+	  if (!add_file_shuffle (ainfo, &ainfo->ss, &ainfo->ss_end,
 			    input_bfd,
 			    input_symhdr->cbSsOffset + fdr.issBase,
-			    fdr.cbSs);
+			    fdr.cbSs))
+	    return false;
 	  fdr.issBase = output_symhdr->issMax;
 	  output_symhdr->issMax += fdr.cbSs;
 	}
@@ -704,18 +754,24 @@ bfd_ecoff_debug_accumulate (handle, output_bfd, output_debug, output_swap,
 	     the information will suffice.  */
 	  BFD_ASSERT (external_pdr_size == input_swap->external_pdr_size);
 	  if (fdr.cpd > 0)
-	    add_file_shuffle (ainfo, &ainfo->pdr, &ainfo->pdr_end,
-			      input_bfd,
-			      (input_symhdr->cbPdOffset
-			       + fdr.ipdFirst * external_pdr_size),
-			      fdr.cpd * external_pdr_size);
+	    {
+	      if (!add_file_shuffle (ainfo, &ainfo->pdr, &ainfo->pdr_end,
+				     input_bfd,
+				     (input_symhdr->cbPdOffset
+				      + fdr.ipdFirst * external_pdr_size),
+				     fdr.cpd * external_pdr_size))
+		return false;
+	    }
 	  BFD_ASSERT (external_opt_size == input_swap->external_opt_size);
 	  if (fdr.copt > 0)
-	    add_file_shuffle (ainfo, &ainfo->opt, &ainfo->opt_end,
-			      input_bfd,
-			      (input_symhdr->cbOptOffset
-			       + fdr.ioptBase * external_opt_size),
-			      fdr.copt * external_opt_size);
+	    {
+	      if (!add_file_shuffle (ainfo, &ainfo->opt, &ainfo->opt_end,
+				     input_bfd,
+				     (input_symhdr->cbOptOffset
+				      + fdr.ioptBase * external_opt_size),
+				     fdr.copt * external_opt_size))
+		return false;
+	    }
 	}
       else
 	{
@@ -734,7 +790,13 @@ bfd_ecoff_debug_accumulate (handle, output_bfd, output_debug, output_swap,
 	  end = in + fdr.cpd * insz;
 	  sz = fdr.cpd * outsz;
 	  out = (bfd_byte *) obstack_alloc (&ainfo->memory, sz);
-	  add_memory_shuffle (ainfo, &ainfo->pdr, &ainfo->pdr_end, out, sz);
+	  if (!out)
+	    {
+	      bfd_error = no_memory;
+	      return false;
+	    }
+	  if (!add_memory_shuffle (ainfo, &ainfo->pdr, &ainfo->pdr_end, out, sz))
+	    return false;
 	  for (; in < end; in += insz, out += outsz)
 	    {
 	      PDR pdr;
@@ -751,7 +813,13 @@ bfd_ecoff_debug_accumulate (handle, output_bfd, output_debug, output_swap,
 	  end = in + fdr.copt * insz;
 	  sz = fdr.copt * outsz;
 	  out = (bfd_byte *) obstack_alloc (&ainfo->memory, sz);
-	  add_memory_shuffle (ainfo, &ainfo->opt, &ainfo->opt_end, out, sz);
+	  if (!out)
+	    {
+	      bfd_error = no_memory;
+	      return false;
+	    }
+	  if (!add_memory_shuffle (ainfo, &ainfo->opt, &ainfo->opt_end, out, sz))
+	    return false;
 	  for (; in < end; in += insz, out += outsz)
 	    {
 	      OPTR opt;
@@ -810,8 +878,9 @@ ecoff_add_string (ainfo, info, debug, fdr, string)
   len = strlen (string);
   if (info->relocateable)
     {
-      add_memory_shuffle (ainfo, &ainfo->ss, &ainfo->ss_end, (PTR) string,
-			  len + 1);
+      if (!add_memory_shuffle (ainfo, &ainfo->ss, &ainfo->ss_end, (PTR) string,
+			       len + 1))
+	return -1;
       ret = symhdr->issMax;
       symhdr->issMax += len + 1;
       fdr->cbSs += len + 1;
@@ -921,6 +990,11 @@ bfd_ecoff_debug_accumulate_other (handle, output_bfd, output_debug,
 
       external_sym = (PTR) obstack_alloc (&ainfo->memory,
 					  output_swap->external_sym_size);
+      if (!external_sym)
+	{
+	  bfd_error = no_memory;
+	  return false;
+	}
       (*swap_sym_out) (output_bfd, &internal_sym, external_sym);
       add_memory_shuffle (ainfo, &ainfo->sym, &ainfo->sym_end,
 			  external_sym, output_swap->external_sym_size);
@@ -936,6 +1010,11 @@ bfd_ecoff_debug_accumulate_other (handle, output_bfd, output_debug,
      it only applies to aux fields and there are none.  */
   external_fdr = (PTR) obstack_alloc (&ainfo->memory,
 				      output_swap->external_fdr_size);
+  if (!external_fdr)
+    {
+      bfd_error = no_memory;
+      return false;
+    }
   (*output_swap->swap_fdr_out) (output_bfd, &fdr, external_fdr);
   add_memory_shuffle (ainfo, &ainfo->fdr, &ainfo->fdr_end,
 		      external_fdr, output_swap->external_fdr_size);