From 9783e04a6438e7d81c48d202b2c1bfab315a91f8 Mon Sep 17 00:00:00 2001 From: David MacKenzie Date: Sat, 12 Feb 1994 00:45:54 +0000 Subject: 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 ". * 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. --- bfd/coffgen.c | 175 +++++++++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 143 insertions(+), 32 deletions(-) (limited to 'bfd/coffgen.c') 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; -- cgit v1.1