X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=bfd%2Fcoffgen.c;h=7d48ea9cf61e17e516f0c189641444f2b4329d0a;hb=68ffbac672c0d7f2566e715f878e65ed9b44795f;hp=b6fa5ca0552d6fdade90a50c49bde810b5355911;hpb=082b7297014d9ccc3990c3c6be689dd18946d826;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/coffgen.c b/bfd/coffgen.c index b6fa5ca055..7d48ea9cf6 100644 --- a/bfd/coffgen.c +++ b/bfd/coffgen.c @@ -1,24 +1,25 @@ /* Support for the generic parts of COFF, for BFD. Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, - 2000, 2001, 2002, 2003, 2004 + 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. Written by Cygnus Support. -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 3 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. */ /* Most of this hacked by Steve Chamberlain, sac@cygnus.com. Split out of coffcode.h by Ian Taylor, ian@cygnus.com. */ @@ -37,48 +38,19 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ Those functions may not use any COFF specific information, such as coff_data (abfd). */ -#include "bfd.h" #include "sysdep.h" +#include "bfd.h" #include "libbfd.h" #include "coff/internal.h" #include "libcoff.h" -static void coff_fix_symbol_name - PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_size_type *, - asection **, bfd_size_type *)); -static bfd_boolean coff_write_symbol - PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_vma *, - bfd_size_type *, asection **, bfd_size_type *)); -static bfd_boolean coff_write_alien_symbol - PARAMS ((bfd *, asymbol *, bfd_vma *, bfd_size_type *, - asection **, bfd_size_type *)); -static bfd_boolean coff_write_native_symbol - PARAMS ((bfd *, coff_symbol_type *, bfd_vma *, bfd_size_type *, - asection **, bfd_size_type *)); -static void coff_pointerize_aux - PARAMS ((bfd *, combined_entry_type *, combined_entry_type *, - unsigned int, combined_entry_type *)); -static bfd_boolean make_a_section_from_file - PARAMS ((bfd *, struct internal_scnhdr *, unsigned int)); -static const bfd_target *coff_real_object_p - PARAMS ((bfd *, unsigned, struct internal_filehdr *, - struct internal_aouthdr *)); -static void fixup_symbol_value - PARAMS ((bfd *, coff_symbol_type *, struct internal_syment *)); -static char *build_debug_section - PARAMS ((bfd *)); -static char *copy_name - PARAMS ((bfd *, char *, size_t)); - -#define STRING_SIZE_SIZE (4) - /* Take a section header read from a coff file (in HOST byte order), and make a BFD "section" out of it. This is used by ECOFF. */ + static bfd_boolean -make_a_section_from_file (abfd, hdr, target_index) - bfd *abfd; - struct internal_scnhdr *hdr; - unsigned int target_index; +make_a_section_from_file (bfd *abfd, + struct internal_scnhdr *hdr, + unsigned int target_index) { asection *return_section; char *name; @@ -87,8 +59,13 @@ make_a_section_from_file (abfd, hdr, target_index) name = NULL; - /* Handle long section names as in PE. */ - if (bfd_coff_long_section_names (abfd) + /* Handle long section names as in PE. On reading, we want to + accept long names if the format permits them at all, regardless + of the current state of the flag that dictates if we would generate + them in outputs; this construct checks if that is the case by + attempting to set the flag, without changing its state; the call + will fail for formats that do not support long names at all. */ + if (bfd_coff_set_long_section_names (abfd, bfd_coff_long_section_names (abfd)) && hdr->s_name[0] == '/') { char buf[SCNNMLEN]; @@ -96,6 +73,11 @@ make_a_section_from_file (abfd, hdr, target_index) char *p; const char *strings; + /* Flag that this BFD uses long names, even though the format might + expect them to be off by default. This won't directly affect the + format of any output BFD created from this one, but the information + can be used to decide what to do. */ + bfd_coff_set_long_section_names (abfd, TRUE); memcpy (buf, hdr->s_name + 1, SCNNMLEN - 1); buf[SCNNMLEN - 1] = '\0'; strindex = strtol (buf, &p, 10); @@ -108,7 +90,8 @@ make_a_section_from_file (abfd, hdr, target_index) strindex does not run us past the end, but right now we don't know the length of the string table. */ strings += strindex; - name = bfd_alloc (abfd, (bfd_size_type) strlen (strings) + 1); + name = (char *) bfd_alloc (abfd, + (bfd_size_type) strlen (strings) + 1 + 1); if (name == NULL) return FALSE; strcpy (name, strings); @@ -118,7 +101,8 @@ make_a_section_from_file (abfd, hdr, target_index) if (name == NULL) { /* Assorted wastage to null-terminate the name, thanks AT&T! */ - name = bfd_alloc (abfd, (bfd_size_type) sizeof (hdr->s_name) + 1); + name = (char *) bfd_alloc (abfd, + (bfd_size_type) sizeof (hdr->s_name) + 1 + 1); if (name == NULL) return FALSE; strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name)); @@ -142,7 +126,7 @@ make_a_section_from_file (abfd, hdr, target_index) return_section->lineno_count = hdr->s_nlnno; return_section->userdata = NULL; - return_section->next = (asection *) NULL; + return_section->next = NULL; return_section->target_index = target_index; if (! bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, return_section, @@ -158,10 +142,80 @@ make_a_section_from_file (abfd, hdr, target_index) if (hdr->s_nreloc != 0) return_section->flags |= SEC_RELOC; - /* FIXME: should this check 'hdr->s_size > 0' */ + /* FIXME: should this check 'hdr->s_size > 0'. */ if (hdr->s_scnptr != 0) return_section->flags |= SEC_HAS_CONTENTS; + /* Compress/decompress DWARF debug sections with names: .debug_* and + .zdebug_*, after the section flags is set. */ + if ((flags & SEC_DEBUGGING) + && ((name[1] == 'd' && name[6] == '_') + || (name[1] == 'z' && name[7] == '_'))) + { + enum { nothing, compress, decompress } action = nothing; + char *new_name = NULL; + + if (bfd_is_section_compressed (abfd, return_section)) + { + /* Compressed section. Check if we should decompress. */ + if ((abfd->flags & BFD_DECOMPRESS)) + action = decompress; + } + else if (!bfd_is_section_compressed (abfd, return_section)) + { + /* Normal section. Check if we should compress. */ + if ((abfd->flags & BFD_COMPRESS) && return_section->size != 0) + action = compress; + } + + switch (action) + { + case nothing: + break; + case compress: + if (!bfd_init_section_compress_status (abfd, return_section)) + { + (*_bfd_error_handler) + (_("%B: unable to initialize compress status for section %s"), + abfd, name); + return FALSE; + } + if (name[1] != 'z') + { + unsigned int len = strlen (name); + + new_name = bfd_alloc (abfd, len + 2); + if (new_name == NULL) + return FALSE; + new_name[0] = '.'; + new_name[1] = 'z'; + memcpy (new_name + 2, name + 1, len); + } + break; + case decompress: + if (!bfd_init_section_decompress_status (abfd, return_section)) + { + (*_bfd_error_handler) + (_("%B: unable to initialize decompress status for section %s"), + abfd, name); + return FALSE; + } + if (name[1] == 'z') + { + unsigned int len = strlen (name); + + new_name = bfd_alloc (abfd, len); + if (new_name == NULL) + return FALSE; + new_name[0] = '.'; + memcpy (new_name + 1, name + 2, len - 1); + } + break; + } + if (new_name != NULL) + bfd_rename_section (abfd, return_section, new_name); + } + return result; } @@ -169,17 +223,16 @@ make_a_section_from_file (abfd, hdr, target_index) ECOFF as well. */ static const bfd_target * -coff_real_object_p (abfd, nscns, internal_f, internal_a) - bfd *abfd; - unsigned nscns; - struct internal_filehdr *internal_f; - struct internal_aouthdr *internal_a; +coff_real_object_p (bfd *abfd, + unsigned nscns, + struct internal_filehdr *internal_f, + struct internal_aouthdr *internal_a) { flagword oflags = abfd->flags; bfd_vma ostart = bfd_get_start_address (abfd); - PTR tdata; - PTR tdata_save; - bfd_size_type readsize; /* length of file_info */ + void * tdata; + void * tdata_save; + bfd_size_type readsize; /* Length of file_info. */ unsigned int scnhsz; char *external_sections; @@ -208,7 +261,7 @@ coff_real_object_p (abfd, nscns, internal_f, internal_a) /* Set up the tdata area. ECOFF uses its own routine, and overrides abfd->flags. */ tdata_save = abfd->tdata.any; - tdata = bfd_coff_mkobject_hook (abfd, (PTR) internal_f, (PTR) internal_a); + tdata = bfd_coff_mkobject_hook (abfd, (void *) internal_f, (void *) internal_a); if (tdata == NULL) goto fail2; @@ -218,12 +271,12 @@ coff_real_object_p (abfd, nscns, internal_f, internal_a) if (!external_sections) goto fail; - if (bfd_bread ((PTR) external_sections, readsize, abfd) != readsize) + if (bfd_bread ((void *) external_sections, readsize, abfd) != readsize) goto fail; /* Set the arch/mach *before* swapping in sections; section header swapping may depend on arch/mach info. */ - if (! bfd_coff_set_arch_mach_hook (abfd, (PTR) internal_f)) + if (! bfd_coff_set_arch_mach_hook (abfd, (void *) internal_f)) goto fail; /* Now copy data as required; construct all asections etc. */ @@ -234,8 +287,8 @@ coff_real_object_p (abfd, nscns, internal_f, internal_a) { struct internal_scnhdr tmp; bfd_coff_swap_scnhdr_in (abfd, - (PTR) (external_sections + i * scnhsz), - (PTR) & tmp); + (void *) (external_sections + i * scnhsz), + (void *) & tmp); if (! make_a_section_from_file (abfd, &tmp, i + 1)) goto fail; } @@ -256,17 +309,16 @@ coff_real_object_p (abfd, nscns, internal_f, internal_a) not a COFF file. This is also used by ECOFF. */ const bfd_target * -coff_object_p (abfd) - bfd *abfd; +coff_object_p (bfd *abfd) { bfd_size_type filhsz; bfd_size_type aoutsz; unsigned int nscns; - PTR filehdr; + void * filehdr; struct internal_filehdr internal_f; struct internal_aouthdr internal_a; - /* figure out how much to read */ + /* Figure out how much to read. */ filhsz = bfd_coff_filhsz (abfd); aoutsz = bfd_coff_aoutsz (abfd); @@ -301,7 +353,7 @@ coff_object_p (abfd) if (internal_f.f_opthdr) { - PTR opthdr; + void * opthdr; opthdr = bfd_alloc (abfd, aoutsz); if (opthdr == NULL) @@ -312,7 +364,7 @@ coff_object_p (abfd) bfd_release (abfd, opthdr); return NULL; } - bfd_coff_swap_aouthdr_in (abfd, opthdr, (PTR) &internal_a); + bfd_coff_swap_aouthdr_in (abfd, opthdr, (void *) &internal_a); bfd_release (abfd, opthdr); } @@ -325,22 +377,20 @@ coff_object_p (abfd) /* Get the BFD section from a COFF symbol section number. */ asection * -coff_section_from_bfd_index (abfd, index) - bfd *abfd; - int index; +coff_section_from_bfd_index (bfd *abfd, int section_index) { struct bfd_section *answer = abfd->sections; - if (index == N_ABS) + if (section_index == N_ABS) return bfd_abs_section_ptr; - if (index == N_UNDEF) + if (section_index == N_UNDEF) return bfd_und_section_ptr; - if (index == N_DEBUG) + if (section_index == N_DEBUG) return bfd_abs_section_ptr; while (answer) { - if (answer->target_index == index) + if (answer->target_index == section_index) return answer; answer = answer->next; } @@ -353,8 +403,7 @@ coff_section_from_bfd_index (abfd, index) /* Get the upper bound of a COFF symbol table. */ long -coff_get_symtab_upper_bound (abfd) - bfd *abfd; +coff_get_symtab_upper_bound (bfd *abfd) { if (!bfd_coff_slurp_symbol_table (abfd)) return -1; @@ -365,9 +414,7 @@ coff_get_symtab_upper_bound (abfd) /* Canonicalize a COFF symbol table. */ long -coff_canonicalize_symtab (abfd, alocation) - bfd *abfd; - asymbol **alocation; +coff_canonicalize_symtab (bfd *abfd, asymbol **alocation) { unsigned int counter; coff_symbol_type *symbase; @@ -390,10 +437,9 @@ coff_canonicalize_symtab (abfd, alocation) >= SYMNMLEN + 1. */ const char * -_bfd_coff_internal_syment_name (abfd, sym, buf) - bfd *abfd; - const struct internal_syment *sym; - char *buf; +_bfd_coff_internal_syment_name (bfd *abfd, + const struct internal_syment *sym, + char *buf) { /* FIXME: It's not clear this will work correctly if sizeof (_n_zeroes) != 4. */ @@ -430,14 +476,12 @@ _bfd_coff_internal_syment_name (abfd, sym, buf) value must be INTERNAL_RELOCS. The function returns NULL on error. */ struct internal_reloc * -_bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs, - require_internal, internal_relocs) - bfd *abfd; - asection *sec; - bfd_boolean cache; - bfd_byte *external_relocs; - bfd_boolean require_internal; - struct internal_reloc *internal_relocs; +_bfd_coff_read_internal_relocs (bfd *abfd, + asection *sec, + bfd_boolean cache, + bfd_byte *external_relocs, + bfd_boolean require_internal, + struct internal_reloc *internal_relocs) { bfd_size_type relsz; bfd_byte *free_external = NULL; @@ -447,6 +491,9 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs, struct internal_reloc *irel; bfd_size_type amt; + if (sec->reloc_count == 0) + return internal_relocs; /* Nothing to do. */ + if (coff_section_data (abfd, sec) != NULL && coff_section_data (abfd, sec)->relocs != NULL) { @@ -463,7 +510,7 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs, if (external_relocs == NULL) { free_external = (bfd_byte *) bfd_malloc (amt); - if (free_external == NULL && sec->reloc_count > 0) + if (free_external == NULL) goto error_return; external_relocs = free_external; } @@ -477,7 +524,7 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs, amt = sec->reloc_count; amt *= sizeof (struct internal_reloc); free_internal = (struct internal_reloc *) bfd_malloc (amt); - if (free_internal == NULL && sec->reloc_count > 0) + if (free_internal == NULL) goto error_return; internal_relocs = free_internal; } @@ -487,7 +534,7 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs, erel_end = erel + relsz * sec->reloc_count; irel = internal_relocs; for (; erel < erel_end; erel += relsz, irel++) - bfd_coff_swap_reloc_in (abfd, (PTR) erel, (PTR) irel); + bfd_coff_swap_reloc_in (abfd, (void *) erel, (void *) irel); if (free_external != NULL) { @@ -500,7 +547,7 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs, if (coff_section_data (abfd, sec) == NULL) { amt = sizeof (struct coff_section_tdata); - sec->used_by_bfd = (PTR) bfd_zalloc (abfd, amt); + sec->used_by_bfd = bfd_zalloc (abfd, amt); if (sec->used_by_bfd == NULL) goto error_return; coff_section_data (abfd, sec)->contents = NULL; @@ -521,8 +568,7 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs, /* Set lineno_count for the output sections of a COFF file. */ int -coff_count_linenumbers (abfd) - bfd *abfd; +coff_count_linenumbers (bfd *abfd) { unsigned int limit = bfd_get_symcount (abfd); unsigned int i; @@ -583,9 +629,8 @@ coff_count_linenumbers (abfd) area of the symbol if there is one. */ coff_symbol_type * -coff_symbol_from (ignore_abfd, symbol) - bfd *ignore_abfd ATTRIBUTE_UNUSED; - asymbol *symbol; +coff_symbol_from (bfd *ignore_abfd ATTRIBUTE_UNUSED, + asymbol *symbol) { if (!bfd_family_coff (bfd_asymbol_bfd (symbol))) return (coff_symbol_type *) NULL; @@ -597,16 +642,15 @@ coff_symbol_from (ignore_abfd, symbol) } static void -fixup_symbol_value (abfd, coff_symbol_ptr, syment) - bfd *abfd; - coff_symbol_type *coff_symbol_ptr; - struct internal_syment *syment; +fixup_symbol_value (bfd *abfd, + coff_symbol_type *coff_symbol_ptr, + struct internal_syment *syment) { - - /* Normalize the symbol flags */ - if (bfd_is_com_section (coff_symbol_ptr->symbol.section)) + /* Normalize the symbol flags. */ + if (coff_symbol_ptr->symbol.section + && bfd_is_com_section (coff_symbol_ptr->symbol.section)) { - /* a common symbol is undefined with a value */ + /* A common symbol is undefined with a value. */ syment->n_scnum = N_UNDEF; syment->n_value = coff_symbol_ptr->symbol.value; } @@ -655,14 +699,12 @@ fixup_symbol_value (abfd, coff_symbol_ptr, syment) do that here too. */ bfd_boolean -coff_renumber_symbols (bfd_ptr, first_undef) - bfd *bfd_ptr; - int *first_undef; +coff_renumber_symbols (bfd *bfd_ptr, int *first_undef) { unsigned int symbol_count = bfd_get_symcount (bfd_ptr); asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols; unsigned int native_index = 0; - struct internal_syment *last_file = (struct internal_syment *) NULL; + struct internal_syment *last_file = NULL; unsigned int symbol_index; /* COFF demands that undefined symbols come after all other symbols. @@ -724,26 +766,22 @@ coff_renumber_symbols (bfd_ptr, first_undef) if (s->u.syment.n_sclass == C_FILE) { - if (last_file != (struct internal_syment *) NULL) + if (last_file != NULL) last_file->n_value = native_index; last_file = &(s->u.syment); } else - { + /* Modify the symbol values according to their section and + type. */ + fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment)); - /* Modify the symbol values according to their section and - type */ - - fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment)); - } for (i = 0; i < s->u.syment.n_numaux + 1; i++) s[i].offset = native_index++; } else - { - native_index++; - } + native_index++; } + obj_conv_table_size (bfd_ptr) = native_index; return TRUE; @@ -754,8 +792,7 @@ coff_renumber_symbols (bfd_ptr, first_undef) symbol table. */ void -coff_mangle_symbols (bfd_ptr) - bfd *bfd_ptr; +coff_mangle_symbols (bfd *bfd_ptr) { unsigned int symbol_count = bfd_get_symcount (bfd_ptr); asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols; @@ -775,8 +812,8 @@ coff_mangle_symbols (bfd_ptr) { /* FIXME: We should use a union here. */ s->u.syment.n_value = - (bfd_vma)((combined_entry_type *) - ((unsigned long) s->u.syment.n_value))->offset; + (bfd_hostptr_t) ((combined_entry_type *) + ((bfd_hostptr_t) s->u.syment.n_value))->offset; s->fix_value = 0; } if (s->fix_line) @@ -818,22 +855,20 @@ coff_mangle_symbols (bfd_ptr) } static void -coff_fix_symbol_name (abfd, symbol, native, string_size_p, - debug_string_section_p, debug_string_size_p) - bfd *abfd; - asymbol *symbol; - combined_entry_type *native; - bfd_size_type *string_size_p; - asection **debug_string_section_p; - bfd_size_type *debug_string_size_p; +coff_fix_symbol_name (bfd *abfd, + asymbol *symbol, + combined_entry_type *native, + bfd_size_type *string_size_p, + asection **debug_string_section_p, + bfd_size_type *debug_string_size_p) { unsigned int name_length; union internal_auxent *auxent; char *name = (char *) (symbol->name); - if (name == (char *) NULL) + if (name == NULL) { - /* coff symbols always have names, so we'll make one up */ + /* COFF symbols always have names, so we'll make one up. */ symbol->name = "strange"; name = (char *) symbol->name; } @@ -861,9 +896,7 @@ coff_fix_symbol_name (abfd, symbol, native, string_size_p, if (bfd_coff_long_filenames (abfd)) { if (name_length <= filnmlen) - { - strncpy (auxent->x_file.x_fname, name, filnmlen); - } + strncpy (auxent->x_file.x_fname, name, filnmlen); else { auxent->x_file.x_n.x_offset = *string_size_p + STRING_SIZE_SIZE; @@ -881,10 +914,9 @@ coff_fix_symbol_name (abfd, symbol, native, string_size_p, else { if (name_length <= SYMNMLEN && !bfd_coff_force_symnames_in_strings (abfd)) - { - /* This name will fit into the symbol neatly */ - strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN); - } + /* This name will fit into the symbol neatly. */ + strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN); + else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment)) { native->u.syment._n._n_n._n_offset = (*string_size_p @@ -913,12 +945,12 @@ coff_fix_symbol_name (abfd, symbol, native, string_size_p, if (!bfd_set_section_contents (abfd, *debug_string_section_p, - (PTR) buf, + (void *) buf, (file_ptr) *debug_string_size_p, (bfd_size_type) prefix_len) || !bfd_set_section_contents (abfd, *debug_string_section_p, - (PTR) symbol->name, + (void *) symbol->name, (file_ptr) (*debug_string_size_p + prefix_len), (bfd_size_type) name_length + 1)) @@ -942,20 +974,21 @@ coff_fix_symbol_name (abfd, symbol, native, string_size_p, /* Write a symbol out to a COFF file. */ static bfd_boolean -coff_write_symbol (abfd, symbol, native, written, string_size_p, - debug_string_section_p, debug_string_size_p) - bfd *abfd; - asymbol *symbol; - combined_entry_type *native; - bfd_vma *written; - bfd_size_type *string_size_p; - asection **debug_string_section_p; - bfd_size_type *debug_string_size_p; +coff_write_symbol (bfd *abfd, + asymbol *symbol, + combined_entry_type *native, + bfd_vma *written, + bfd_size_type *string_size_p, + asection **debug_string_section_p, + bfd_size_type *debug_string_size_p) { unsigned int numaux = native->u.syment.n_numaux; int type = native->u.syment.n_type; - int class = native->u.syment.n_sclass; - PTR buf; + int n_sclass = (int) native->u.syment.n_sclass; + asection *output_section = symbol->section->output_section + ? symbol->section->output_section + : symbol->section; + void * buf; bfd_size_type symesz; if (native->u.syment.n_sclass == C_FILE) @@ -963,22 +996,17 @@ coff_write_symbol (abfd, symbol, native, written, string_size_p, if (symbol->flags & BSF_DEBUGGING && bfd_is_abs_section (symbol->section)) - { - native->u.syment.n_scnum = N_DEBUG; - } + native->u.syment.n_scnum = N_DEBUG; + else if (bfd_is_abs_section (symbol->section)) - { - native->u.syment.n_scnum = N_ABS; - } + native->u.syment.n_scnum = N_ABS; + else if (bfd_is_und_section (symbol->section)) - { - native->u.syment.n_scnum = N_UNDEF; - } + native->u.syment.n_scnum = N_UNDEF; + else - { - native->u.syment.n_scnum = - symbol->section->output_section->target_index; - } + native->u.syment.n_scnum = + output_section->target_index; coff_fix_symbol_name (abfd, symbol, native, string_size_p, debug_string_section_p, debug_string_size_p); @@ -1005,9 +1033,7 @@ coff_write_symbol (abfd, symbol, native, written, string_size_p, { bfd_coff_swap_aux_out (abfd, &((native + j + 1)->u.auxent), - type, - class, - (int) j, + type, n_sclass, (int) j, native->u.syment.n_numaux, buf); if (bfd_bwrite (buf, auxesz, abfd) != auxesz) @@ -1027,22 +1053,36 @@ coff_write_symbol (abfd, symbol, native, written, string_size_p, file originally. This symbol may have been created by the linker, or we may be linking a non COFF file to a COFF file. */ -static bfd_boolean -coff_write_alien_symbol (abfd, symbol, written, string_size_p, - debug_string_section_p, debug_string_size_p) - bfd *abfd; - asymbol *symbol; - bfd_vma *written; - bfd_size_type *string_size_p; - asection **debug_string_section_p; - bfd_size_type *debug_string_size_p; +bfd_boolean +coff_write_alien_symbol (bfd *abfd, + asymbol *symbol, + struct internal_syment *isym, + bfd_vma *written, + bfd_size_type *string_size_p, + asection **debug_string_section_p, + bfd_size_type *debug_string_size_p) { combined_entry_type *native; - combined_entry_type dummy; + combined_entry_type dummy[2]; + asection *output_section = symbol->section->output_section + ? symbol->section->output_section + : symbol->section; + struct bfd_link_info *link_info = coff_data (abfd)->link_info; + bfd_boolean ret; - native = &dummy; + if ((!link_info || link_info->strip_discarded) + && !bfd_is_abs_section (symbol->section) + && symbol->section->output_section == bfd_abs_section_ptr) + { + symbol->name = ""; + if (isym != NULL) + memset (isym, 0, sizeof(*isym)); + return TRUE; + } + native = dummy; native->u.syment.n_type = T_NULL; native->u.syment.n_flags = 0; + native->u.syment.n_numaux = 0; if (bfd_is_und_section (symbol->section)) { native->u.syment.n_scnum = N_UNDEF; @@ -1053,6 +1093,11 @@ coff_write_alien_symbol (abfd, symbol, written, string_size_p, native->u.syment.n_scnum = N_UNDEF; native->u.syment.n_value = symbol->value; } + else if (symbol->flags & BSF_FILE) + { + native->u.syment.n_scnum = N_DEBUG; + native->u.syment.n_numaux = 1; + } else if (symbol->flags & BSF_DEBUGGING) { /* There isn't much point to writing out a debugging symbol @@ -1060,16 +1105,17 @@ coff_write_alien_symbol (abfd, symbol, written, string_size_p, format. So, we just ignore them. We must clobber the symbol name to keep it from being put in the string table. */ symbol->name = ""; + if (isym != NULL) + memset (isym, 0, sizeof(*isym)); return TRUE; } else { - native->u.syment.n_scnum = - symbol->section->output_section->target_index; + native->u.syment.n_scnum = output_section->target_index; native->u.syment.n_value = (symbol->value + symbol->section->output_offset); if (! obj_pe (abfd)) - native->u.syment.n_value += symbol->section->output_section->vma; + native->u.syment.n_value += output_section->vma; /* Copy the any flags from the file header into the symbol. FIXME: Why? */ @@ -1081,32 +1127,43 @@ coff_write_alien_symbol (abfd, symbol, written, string_size_p, } native->u.syment.n_type = 0; - if (symbol->flags & BSF_LOCAL) + if (symbol->flags & BSF_FILE) + native->u.syment.n_sclass = C_FILE; + else if (symbol->flags & BSF_LOCAL) native->u.syment.n_sclass = C_STAT; else if (symbol->flags & BSF_WEAK) native->u.syment.n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT; else native->u.syment.n_sclass = C_EXT; - native->u.syment.n_numaux = 0; - return coff_write_symbol (abfd, symbol, native, written, string_size_p, - debug_string_section_p, debug_string_size_p); + ret = coff_write_symbol (abfd, symbol, native, written, string_size_p, + debug_string_section_p, debug_string_size_p); + if (isym != NULL) + *isym = native->u.syment; + return ret; } /* Write a native symbol to a COFF file. */ static bfd_boolean -coff_write_native_symbol (abfd, symbol, written, string_size_p, - debug_string_section_p, debug_string_size_p) - bfd *abfd; - coff_symbol_type *symbol; - bfd_vma *written; - bfd_size_type *string_size_p; - asection **debug_string_section_p; - bfd_size_type *debug_string_size_p; +coff_write_native_symbol (bfd *abfd, + coff_symbol_type *symbol, + bfd_vma *written, + bfd_size_type *string_size_p, + asection **debug_string_section_p, + bfd_size_type *debug_string_size_p) { combined_entry_type *native = symbol->native; alent *lineno = symbol->lineno; + struct bfd_link_info *link_info = coff_data (abfd)->link_info; + + if ((!link_info || link_info->strip_discarded) + && !bfd_is_abs_section (symbol->symbol.section) + && symbol->symbol.section->output_section == bfd_abs_section_ptr) + { + symbol->symbol.name = ""; + return TRUE; + } /* If this symbol has an associated line number, we must store the symbol index in the line number field. We also tag the auxent to @@ -1114,6 +1171,7 @@ coff_write_native_symbol (abfd, symbol, written, string_size_p, if (lineno && !symbol->done_lineno && symbol->symbol.section->owner != NULL) { unsigned int count = 0; + lineno[count].u.offset = *written; if (native->u.syment.n_numaux) { @@ -1127,28 +1185,9 @@ coff_write_native_symbol (abfd, symbol, written, string_size_p, count++; while (lineno[count].line_number != 0) { -#if 0 - /* 13 april 92. sac - I've been told this, but still need proof: - > The second bug is also in `bfd/coffcode.h'. This bug - > causes the linker to screw up the pc-relocations for - > all the line numbers in COFF code. This bug isn't only - > specific to A29K implementations, but affects all - > systems using COFF format binaries. Note that in COFF - > object files, the line number core offsets output by - > the assembler are relative to the start of each - > procedure, not to the start of the .text section. This - > patch relocates the line numbers relative to the - > `native->u.syment.n_value' instead of the section - > virtual address. - > modular!olson@cs.arizona.edu (Jon Olson) - */ - lineno[count].u.offset += native->u.syment.n_value; -#else lineno[count].u.offset += (symbol->symbol.section->output_section->vma + symbol->symbol.section->output_offset); -#endif count++; } symbol->done_lineno = TRUE; @@ -1163,18 +1202,22 @@ coff_write_native_symbol (abfd, symbol, written, string_size_p, debug_string_size_p); } +static void +null_error_handler (const char * fmt ATTRIBUTE_UNUSED, ...) +{ +} + /* Write out the COFF symbols. */ bfd_boolean -coff_write_symbols (abfd) - bfd *abfd; +coff_write_symbols (bfd *abfd) { bfd_size_type string_size; asection *debug_string_section; bfd_size_type debug_string_size; unsigned int i; unsigned int limit = bfd_get_symcount (abfd); - bfd_signed_vma written = 0; + bfd_vma written = 0; asymbol **p; string_size = 0; @@ -1199,12 +1242,11 @@ coff_write_symbols (abfd) } } - /* Seek to the right place */ + /* Seek to the right place. */ if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0) return FALSE; - /* Output all the symbols we have */ - + /* Output all the symbols we have. */ written = 0; for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) { @@ -1214,13 +1256,50 @@ coff_write_symbols (abfd) if (c_symbol == (coff_symbol_type *) NULL || c_symbol->native == (combined_entry_type *) NULL) { - if (!coff_write_alien_symbol (abfd, symbol, &written, &string_size, - &debug_string_section, + if (!coff_write_alien_symbol (abfd, symbol, NULL, &written, + &string_size, &debug_string_section, &debug_string_size)) return FALSE; } else { + if (coff_backend_info (abfd)->_bfd_coff_classify_symbol != NULL) + { + bfd_error_handler_type current_error_handler; + enum coff_symbol_classification sym_class; + unsigned char *n_sclass; + + /* Suppress error reporting by bfd_coff_classify_symbol. + Error messages can be generated when we are processing a local + symbol which has no associated section and we do not have to + worry about this, all we need to know is that it is local. */ + current_error_handler = bfd_set_error_handler (null_error_handler); + sym_class = bfd_coff_classify_symbol (abfd, + &c_symbol->native->u.syment); + (void) bfd_set_error_handler (current_error_handler); + + n_sclass = &c_symbol->native->u.syment.n_sclass; + + /* If the symbol class has been changed (eg objcopy/ld script/etc) + we cannot retain the existing sclass from the original symbol. + Weak symbols only have one valid sclass, so just set it always. + If it is not local class and should be, set it C_STAT. + If it is global and not classified as global, or if it is + weak (which is also classified as global), set it C_EXT. */ + + if (symbol->flags & BSF_WEAK) + *n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT; + else if (symbol->flags & BSF_LOCAL && sym_class != COFF_SYMBOL_LOCAL) + *n_sclass = C_STAT; + else if (symbol->flags & BSF_GLOBAL + && (sym_class != COFF_SYMBOL_GLOBAL +#ifdef COFF_WITH_PE + || *n_sclass == C_NT_WEAK +#endif + || *n_sclass == C_WEAKEXT)) + c_symbol->native->u.syment.n_sclass = C_EXT; + } + if (!coff_write_native_symbol (abfd, c_symbol, &written, &string_size, &debug_string_section, &debug_string_size)) @@ -1230,8 +1309,7 @@ coff_write_symbols (abfd) obj_raw_syment_count (abfd) = written; - /* Now write out strings */ - + /* Now write out strings. */ if (string_size != 0) { unsigned int size = string_size + STRING_SIZE_SIZE; @@ -1242,7 +1320,7 @@ coff_write_symbols (abfd) #else #error Change H_PUT_32 #endif - if (bfd_bwrite ((PTR) buffer, (bfd_size_type) sizeof (buffer), abfd) + if (bfd_bwrite ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd) != sizeof (buffer)) return FALSE; @@ -1284,18 +1362,16 @@ coff_write_symbols (abfd) if (c_symbol == NULL || c_symbol->native == NULL) - { - /* This is not a COFF symbol, so it certainly is not a - file name, nor does it go in the .debug section. */ - maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN; - } + /* This is not a COFF symbol, so it certainly is not a + file name, nor does it go in the .debug section. */ + maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN; + else if (bfd_coff_symname_in_debug (abfd, &c_symbol->native->u.syment)) - { - /* This symbol name is in the XCOFF .debug section. - Don't write it into the string table. */ - maxlen = name_length; - } + /* This symbol name is in the XCOFF .debug section. + Don't write it into the string table. */ + maxlen = name_length; + else if (c_symbol->native->u.syment.n_sclass == C_FILE && c_symbol->native->u.syment.n_numaux > 0) { @@ -1311,7 +1387,7 @@ coff_write_symbols (abfd) if (name_length > maxlen) { - if (bfd_bwrite ((PTR) (q->name), (bfd_size_type) name_length + 1, + if (bfd_bwrite ((void *) (q->name), (bfd_size_type) name_length + 1, abfd) != name_length + 1) return FALSE; } @@ -1330,7 +1406,7 @@ coff_write_symbols (abfd) #else #error Change H_PUT_32 #endif - if (bfd_bwrite ((PTR) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd) + if (bfd_bwrite ((void *) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd) != STRING_SIZE_SIZE) return FALSE; } @@ -1350,12 +1426,11 @@ coff_write_symbols (abfd) } bfd_boolean -coff_write_linenumbers (abfd) - bfd *abfd; +coff_write_linenumbers (bfd *abfd) { asection *s; bfd_size_type linesz; - PTR buff; + void * buff; linesz = bfd_coff_linesz (abfd); buff = bfd_alloc (abfd, linesz); @@ -1368,7 +1443,7 @@ coff_write_linenumbers (abfd) asymbol **q = abfd->outsymbols; if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0) return FALSE; - /* Find all the linenumbers in this section */ + /* Find all the linenumbers in this section. */ while (*q) { asymbol *p = *q; @@ -1379,9 +1454,9 @@ coff_write_linenumbers (abfd) (bfd_asymbol_bfd (p), p)); if (l) { - /* Found a linenumber entry, output */ + /* Found a linenumber entry, output. */ struct internal_lineno out; - memset ((PTR) & out, 0, sizeof (out)); + memset ((void *) & out, 0, sizeof (out)); out.l_lnno = 0; out.l_addr.l_symndx = l->u.offset; bfd_coff_swap_lineno_out (abfd, &out, buff); @@ -1410,79 +1485,23 @@ coff_write_linenumbers (abfd) } alent * -coff_get_lineno (ignore_abfd, symbol) - bfd *ignore_abfd ATTRIBUTE_UNUSED; - asymbol *symbol; +coff_get_lineno (bfd *ignore_abfd ATTRIBUTE_UNUSED, asymbol *symbol) { return coffsymbol (symbol)->lineno; } -#if 0 - -/* This is only called from coff_add_missing_symbols, which has been - disabled. */ - -asymbol * -coff_section_symbol (abfd, name) - bfd *abfd; - char *name; -{ - asection *sec = bfd_make_section_old_way (abfd, name); - asymbol *sym; - combined_entry_type *csym; - - sym = sec->symbol; - csym = coff_symbol_from (abfd, sym)->native; - /* Make sure back-end COFF stuff is there. */ - if (csym == 0) - { - struct foo - { - coff_symbol_type sym; - /* @@FIXME This shouldn't use a fixed size!! */ - combined_entry_type e[10]; - }; - struct foo *f; - - f = (struct foo *) bfd_zalloc (abfd, (bfd_size_type) sizeof (*f)); - if (!f) - { - bfd_set_error (bfd_error_no_error); - return NULL; - } - coff_symbol_from (abfd, sym)->native = csym = f->e; - } - csym[0].u.syment.n_sclass = C_STAT; - csym[0].u.syment.n_numaux = 1; -/* SF_SET_STATICS (sym); @@ ??? */ - csym[1].u.auxent.x_scn.x_scnlen = sec->size; - csym[1].u.auxent.x_scn.x_nreloc = sec->reloc_count; - csym[1].u.auxent.x_scn.x_nlinno = sec->lineno_count; - - if (sec->output_section == NULL) - { - sec->output_section = sec; - sec->output_offset = 0; - } - - return sym; -} - -#endif /* 0 */ - /* This function transforms the offsets into the symbol table into pointers to syments. */ static void -coff_pointerize_aux (abfd, table_base, symbol, indaux, auxent) - bfd *abfd; - combined_entry_type *table_base; - combined_entry_type *symbol; - unsigned int indaux; - combined_entry_type *auxent; +coff_pointerize_aux (bfd *abfd, + combined_entry_type *table_base, + combined_entry_type *symbol, + unsigned int indaux, + combined_entry_type *auxent) { unsigned int type = symbol->u.syment.n_type; - unsigned int class = symbol->u.syment.n_sclass; + unsigned int n_sclass = symbol->u.syment.n_sclass; if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook) { @@ -1491,16 +1510,18 @@ coff_pointerize_aux (abfd, table_base, symbol, indaux, auxent) return; } - /* Don't bother if this is a file or a section */ - if (class == C_STAT && type == T_NULL) + /* Don't bother if this is a file or a section. */ + if (n_sclass == C_STAT && type == T_NULL) return; - if (class == C_FILE) + if (n_sclass == C_FILE) return; - /* Otherwise patch up */ -#define N_TMASK coff_data (abfd)->local_n_tmask + /* Otherwise patch up. */ +#define N_TMASK coff_data (abfd)->local_n_tmask #define N_BTSHFT coff_data (abfd)->local_n_btshft - if ((ISFCN (type) || ISTAG (class) || class == C_BLOCK || class == C_FCN) + + if ((ISFCN (type) || ISTAG (n_sclass) || n_sclass == C_BLOCK + || n_sclass == C_FCN) && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0) { auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = @@ -1522,8 +1543,7 @@ coff_pointerize_aux (abfd, table_base, symbol, indaux, auxent) we didn't want to go to the trouble until someone needed it. */ static char * -build_debug_section (abfd) - bfd *abfd; +build_debug_section (bfd *abfd) { char *debug_section; file_ptr position; @@ -1538,7 +1558,7 @@ build_debug_section (abfd) } sec_size = sect->size; - debug_section = (PTR) bfd_alloc (abfd, sec_size); + debug_section = (char *) bfd_alloc (abfd, sec_size); if (debug_section == NULL) return NULL; @@ -1557,25 +1577,20 @@ build_debug_section (abfd) /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be \0-terminated, but will not exceed 'maxlen' characters. The copy *will* be \0-terminated. */ + static char * -copy_name (abfd, name, maxlen) - bfd *abfd; - char *name; - size_t maxlen; +copy_name (bfd *abfd, char *name, size_t maxlen) { size_t len; char *newname; for (len = 0; len < maxlen; ++len) - { - if (name[len] == '\0') - { - break; - } - } + if (name[len] == '\0') + break; + + if ((newname = (char *) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL) + return NULL; - if ((newname = (PTR) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL) - return (NULL); strncpy (newname, name, len); newname[len] = '\0'; return newname; @@ -1584,12 +1599,11 @@ copy_name (abfd, name, maxlen) /* Read in the external symbols. */ bfd_boolean -_bfd_coff_get_external_symbols (abfd) - bfd *abfd; +_bfd_coff_get_external_symbols (bfd *abfd) { bfd_size_type symesz; bfd_size_type size; - PTR syms; + void * syms; if (obj_coff_external_syms (abfd) != NULL) return TRUE; @@ -1597,9 +1611,11 @@ _bfd_coff_get_external_symbols (abfd) symesz = bfd_coff_symesz (abfd); size = obj_raw_syment_count (abfd) * symesz; + if (size == 0) + return TRUE; - syms = (PTR) bfd_malloc (size); - if (syms == NULL && size != 0) + syms = bfd_malloc (size); + if (syms == NULL) return FALSE; if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0 @@ -1620,8 +1636,7 @@ _bfd_coff_get_external_symbols (abfd) detecting a missing string table in an archive. */ const char * -_bfd_coff_read_string_table (abfd) - bfd *abfd; +_bfd_coff_read_string_table (bfd *abfd) { char extstrsize[STRING_SIZE_SIZE]; bfd_size_type strsize; @@ -1663,8 +1678,7 @@ _bfd_coff_read_string_table (abfd) if (strsize < STRING_SIZE_SIZE) { (*_bfd_error_handler) - (_("%s: bad string table size %lu"), bfd_archive_filename (abfd), - (unsigned long) strsize); + (_("%B: bad string table size %lu"), abfd, (unsigned long) strsize); bfd_set_error (bfd_error_bad_value); return NULL; } @@ -1688,8 +1702,7 @@ _bfd_coff_read_string_table (abfd) /* Free up the external symbols and strings read from a COFF file. */ bfd_boolean -_bfd_coff_free_symbols (abfd) - bfd *abfd; +_bfd_coff_free_symbols (bfd *abfd) { if (obj_coff_external_syms (abfd) != NULL && ! obj_coff_keep_syms (abfd)) @@ -1712,8 +1725,7 @@ _bfd_coff_free_symbols (abfd) terminated string. */ combined_entry_type * -coff_get_normalized_symtab (abfd) - bfd *abfd; +coff_get_normalized_symtab (bfd *abfd) { combined_entry_type *internal; combined_entry_type *internal_ptr; @@ -1740,22 +1752,22 @@ coff_get_normalized_symtab (abfd) raw_src = (char *) obj_coff_external_syms (abfd); - /* mark the end of the symbols */ + /* Mark the end of the symbols. */ symesz = bfd_coff_symesz (abfd); raw_end = (char *) raw_src + obj_raw_syment_count (abfd) * symesz; /* FIXME SOMEDAY. A string table size of zero is very weird, but probably possible. If one shows up, it will probably kill us. */ - /* Swap all the raw entries */ + /* Swap all the raw entries. */ for (internal_ptr = internal; raw_src < raw_end; raw_src += symesz, internal_ptr++) { unsigned int i; - bfd_coff_swap_sym_in (abfd, (PTR) raw_src, - (PTR) & internal_ptr->u.syment); + bfd_coff_swap_sym_in (abfd, (void *) raw_src, + (void *) & internal_ptr->u.syment); symbol_ptr = internal_ptr; for (i = 0; @@ -1764,7 +1776,7 @@ coff_get_normalized_symtab (abfd) { internal_ptr++; raw_src += symesz; - bfd_coff_swap_aux_in (abfd, (PTR) raw_src, + bfd_coff_swap_aux_in (abfd, (void *) raw_src, symbol_ptr->u.syment.n_type, symbol_ptr->u.syment.n_sclass, (int) i, symbol_ptr->u.syment.n_numaux, @@ -1785,11 +1797,11 @@ coff_get_normalized_symtab (abfd) if (internal_ptr->u.syment.n_sclass == C_FILE && internal_ptr->u.syment.n_numaux > 0) { - /* make a file symbol point to the name in the auxent, since - the text ".file" is redundant */ + /* Make a file symbol point to the name in the auxent, since + the text ".file" is redundant. */ if ((internal_ptr + 1)->u.auxent.x_file.x_n.x_zeroes == 0) { - /* the filename is a long one, point into the string table */ + /* The filename is a long one, point into the string table. */ if (string_table == NULL) { string_table = _bfd_coff_read_string_table (abfd); @@ -1798,7 +1810,7 @@ coff_get_normalized_symtab (abfd) } internal_ptr->u.syment._n._n_n._n_offset = - ((long) + ((bfd_hostptr_t) (string_table + (internal_ptr + 1)->u.auxent.x_file.x_n.x_offset)); } @@ -1809,21 +1821,17 @@ coff_get_normalized_symtab (abfd) multiple AUX entries. */ if (internal_ptr->u.syment.n_numaux > 1 && coff_data (abfd)->pe) - { - internal_ptr->u.syment._n._n_n._n_offset = - ((long) - copy_name (abfd, - (internal_ptr + 1)->u.auxent.x_file.x_fname, - internal_ptr->u.syment.n_numaux * symesz)); - } + internal_ptr->u.syment._n._n_n._n_offset = + ((bfd_hostptr_t) + copy_name (abfd, + (internal_ptr + 1)->u.auxent.x_file.x_fname, + internal_ptr->u.syment.n_numaux * symesz)); else - { - internal_ptr->u.syment._n._n_n._n_offset = - ((long) - copy_name (abfd, - (internal_ptr + 1)->u.auxent.x_file.x_fname, - (size_t) bfd_coff_filnmlen (abfd))); - } + internal_ptr->u.syment._n._n_n._n_offset = + ((bfd_hostptr_t) + copy_name (abfd, + (internal_ptr + 1)->u.auxent.x_file.x_fname, + (size_t) bfd_coff_filnmlen (abfd))); } } else @@ -1834,21 +1842,21 @@ coff_get_normalized_symtab (abfd) size_t i; char *newstring; - /* find the length of this string without walking into memory + /* Find the length of this string without walking into memory that isn't ours. */ for (i = 0; i < 8; ++i) if (internal_ptr->u.syment._n._n_name[i] == '\0') break; - newstring = (PTR) bfd_zalloc (abfd, (bfd_size_type) (i + 1)); + newstring = (char *) bfd_zalloc (abfd, (bfd_size_type) (i + 1)); if (newstring == NULL) - return (NULL); + return NULL; strncpy (newstring, internal_ptr->u.syment._n._n_name, i); - internal_ptr->u.syment._n._n_n._n_offset = (long int) newstring; + internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) 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) ""; + internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) ""; else if (!bfd_coff_symname_in_debug (abfd, &internal_ptr->u.syment)) { /* Long name already. Point symbol at the string in the @@ -1860,7 +1868,7 @@ coff_get_normalized_symtab (abfd) return NULL; } internal_ptr->u.syment._n._n_n._n_offset = - ((long int) + ((bfd_hostptr_t) (string_table + internal_ptr->u.syment._n._n_n._n_offset)); } @@ -1869,7 +1877,7 @@ coff_get_normalized_symtab (abfd) /* Long name in debug section. Very similar. */ if (debug_section == NULL) debug_section = build_debug_section (abfd); - internal_ptr->u.syment._n._n_n._n_offset = (long int) + internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) (debug_section + internal_ptr->u.syment._n._n_n._n_offset); } } @@ -1880,13 +1888,11 @@ coff_get_normalized_symtab (abfd) BFD_ASSERT (obj_raw_syment_count (abfd) == (unsigned int) (internal_ptr - internal)); - return (internal); -} /* coff_get_normalized_symtab() */ + return internal; +} long -coff_get_reloc_upper_bound (abfd, asect) - bfd *abfd; - sec_ptr asect; +coff_get_reloc_upper_bound (bfd *abfd, sec_ptr asect) { if (bfd_get_format (abfd) != bfd_object) { @@ -1897,69 +1903,66 @@ coff_get_reloc_upper_bound (abfd, asect) } asymbol * -coff_make_empty_symbol (abfd) - bfd *abfd; +coff_make_empty_symbol (bfd *abfd) { bfd_size_type amt = sizeof (coff_symbol_type); - coff_symbol_type *new = (coff_symbol_type *) bfd_zalloc (abfd, amt); - if (new == NULL) - return (NULL); - new->symbol.section = 0; - new->native = 0; - new->lineno = (alent *) NULL; - new->done_lineno = FALSE; - new->symbol.the_bfd = abfd; - return &new->symbol; + coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_zalloc (abfd, amt); + + if (new_symbol == NULL) + return NULL; + new_symbol->symbol.section = 0; + new_symbol->native = 0; + new_symbol->lineno = NULL; + new_symbol->done_lineno = FALSE; + new_symbol->symbol.the_bfd = abfd; + + return & new_symbol->symbol; } /* Make a debugging symbol. */ asymbol * -coff_bfd_make_debug_symbol (abfd, ptr, sz) - bfd *abfd; - PTR ptr ATTRIBUTE_UNUSED; - unsigned long sz ATTRIBUTE_UNUSED; +coff_bfd_make_debug_symbol (bfd *abfd, + void * ptr ATTRIBUTE_UNUSED, + unsigned long sz ATTRIBUTE_UNUSED) { bfd_size_type amt = sizeof (coff_symbol_type); - coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, amt); - if (new == NULL) - return (NULL); + coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_alloc (abfd, amt); + + if (new_symbol == NULL) + return NULL; /* @@ The 10 is a guess at a plausible maximum number of aux entries (but shouldn't be a constant). */ amt = sizeof (combined_entry_type) * 10; - new->native = (combined_entry_type *) bfd_zalloc (abfd, amt); - if (!new->native) - return (NULL); - new->symbol.section = bfd_abs_section_ptr; - new->symbol.flags = BSF_DEBUGGING; - new->lineno = (alent *) NULL; - new->done_lineno = FALSE; - new->symbol.the_bfd = abfd; - return &new->symbol; + new_symbol->native = (combined_entry_type *) bfd_zalloc (abfd, amt); + if (!new_symbol->native) + return NULL; + new_symbol->symbol.section = bfd_abs_section_ptr; + new_symbol->symbol.flags = BSF_DEBUGGING; + new_symbol->lineno = NULL; + new_symbol->done_lineno = FALSE; + new_symbol->symbol.the_bfd = abfd; + + return & new_symbol->symbol; } void -coff_get_symbol_info (abfd, symbol, ret) - bfd *abfd; - asymbol *symbol; - symbol_info *ret; +coff_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret) { bfd_symbol_info (symbol, ret); + if (coffsymbol (symbol)->native != NULL && coffsymbol (symbol)->native->fix_value) - { - ret->value = coffsymbol (symbol)->native->u.syment.n_value - - (unsigned long) obj_raw_syments (abfd); - } + ret->value = coffsymbol (symbol)->native->u.syment.n_value - + (bfd_hostptr_t) obj_raw_syments (abfd); } /* Return the COFF syment for a symbol. */ bfd_boolean -bfd_coff_get_syment (abfd, symbol, psyment) - bfd *abfd; - asymbol *symbol; - struct internal_syment *psyment; +bfd_coff_get_syment (bfd *abfd, + asymbol *symbol, + struct internal_syment *psyment) { coff_symbol_type *csym; @@ -1974,7 +1977,7 @@ bfd_coff_get_syment (abfd, symbol, psyment) if (csym->native->fix_value) psyment->n_value = psyment->n_value - - (unsigned long) obj_raw_syments (abfd); + (bfd_hostptr_t) obj_raw_syments (abfd); /* FIXME: We should handle fix_line here. */ @@ -1984,11 +1987,10 @@ bfd_coff_get_syment (abfd, symbol, psyment) /* Return the COFF auxent for a symbol. */ bfd_boolean -bfd_coff_get_auxent (abfd, symbol, indx, pauxent) - bfd *abfd; - asymbol *symbol; - int indx; - union internal_auxent *pauxent; +bfd_coff_get_auxent (bfd *abfd, + asymbol *symbol, + int indx, + union internal_auxent *pauxent) { coff_symbol_type *csym; combined_entry_type *ent; @@ -2028,13 +2030,12 @@ bfd_coff_get_auxent (abfd, symbol, indx, pauxent) /* Print out information about COFF symbol. */ void -coff_print_symbol (abfd, filep, symbol, how) - bfd *abfd; - PTR filep; - asymbol *symbol; - bfd_print_symbol_type how; +coff_print_symbol (bfd *abfd, + void * filep, + asymbol *symbol, + bfd_print_symbol_type how) { - FILE *file = (FILE *) filep; + FILE * file = (FILE *) filep; switch (how) { @@ -2062,30 +2063,16 @@ coff_print_symbol (abfd, filep, symbol, how) if (! combined->fix_value) val = (bfd_vma) combined->u.syment.n_value; else - val = combined->u.syment.n_value - (unsigned long) root; + val = combined->u.syment.n_value - (bfd_hostptr_t) root; -#ifndef XCOFF64 - fprintf (file, - "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%08lx %s", - combined->u.syment.n_scnum, - combined->u.syment.n_flags, - combined->u.syment.n_type, - combined->u.syment.n_sclass, - combined->u.syment.n_numaux, - (unsigned long) val, - symbol->name); -#else - /* Print out the wide, 64 bit, symbol value */ - fprintf (file, - "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%016llx %s", + fprintf (file, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x", combined->u.syment.n_scnum, combined->u.syment.n_flags, combined->u.syment.n_type, combined->u.syment.n_sclass, - combined->u.syment.n_numaux, - val, - symbol->name); -#endif + combined->u.syment.n_numaux); + bfd_fprintf_vma (abfd, file, val); + fprintf (file, " %s", symbol->name); for (aux = 0; aux < combined->u.syment.n_numaux; aux++) { @@ -2110,10 +2097,10 @@ coff_print_symbol (abfd, filep, symbol, how) case C_STAT: if (combined->u.syment.n_type == T_NULL) - /* probably a section symbol? */ + /* Probably a section symbol ? */ { fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d", - (long) auxp->u.auxent.x_scn.x_scnlen, + (unsigned long) auxp->u.auxent.x_scn.x_scnlen, auxp->u.auxent.x_scn.x_nreloc, auxp->u.auxent.x_scn.x_nlinno); if (auxp->u.auxent.x_scn.x_checksum != 0 @@ -2125,8 +2112,9 @@ coff_print_symbol (abfd, filep, symbol, how) auxp->u.auxent.x_scn.x_comdat); break; } - /* else fall through */ + /* Otherwise fall through. */ case C_EXT: + case C_AIX_WEAKEXT: if (ISFCN (combined->u.syment.n_type)) { long next, llnos; @@ -2139,11 +2127,12 @@ coff_print_symbol (abfd, filep, symbol, how) llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr; fprintf (file, "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld", - tagndx, auxp->u.auxent.x_sym.x_misc.x_fsize, + tagndx, + (unsigned long) auxp->u.auxent.x_sym.x_misc.x_fsize, llnos, next); break; } - /* else fall through */ + /* Otherwise fall through. */ default: fprintf (file, "AUX lnno %d size 0x%x tagndx %ld", auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno, @@ -2164,17 +2153,15 @@ coff_print_symbol (abfd, filep, symbol, how) l++; while (l->line_number) { - fprintf (file, "\n%4d : 0x%lx", - l->line_number, - ((unsigned long) - (l->u.offset + symbol->section->vma))); + fprintf (file, "\n%4d : ", l->line_number); + bfd_fprintf_vma (abfd, file, l->u.offset + symbol->section->vma); l++; } } } else { - bfd_print_symbol_vandf (abfd, (PTR) file, symbol); + bfd_print_symbol_vandf (abfd, (void *) file, symbol); fprintf (file, " %-5s %s %s %s", symbol->section->name, coffsymbol (symbol)->native ? "n" : "g", @@ -2190,9 +2177,8 @@ coff_print_symbol (abfd, filep, symbol, how) override it. */ bfd_boolean -_bfd_coff_is_local_label_name (abfd, name) - bfd *abfd ATTRIBUTE_UNUSED; - const char *name; +_bfd_coff_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, + const char *name) { return name[0] == '.' && name[1] == 'L'; } @@ -2202,21 +2188,20 @@ _bfd_coff_is_local_label_name (abfd, name) nearest to the wanted location. */ bfd_boolean -coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr, - functionname_ptr, line_ptr) - bfd *abfd; - asection *section; - asymbol **symbols; - bfd_vma offset; - const char **filename_ptr; - const char **functionname_ptr; - unsigned int *line_ptr; +coff_find_nearest_line_with_names (bfd *abfd, + const struct dwarf_debug_section *debug_sections, + asection *section, + asymbol **symbols, + bfd_vma offset, + const char **filename_ptr, + const char **functionname_ptr, + unsigned int *line_ptr) { bfd_boolean found; unsigned int i; unsigned int line_base; coff_data_type *cof = coff_data (abfd); - /* Run through the raw syments if available */ + /* Run through the raw syments if available. */ combined_entry_type *p; combined_entry_type *pend; alent *l; @@ -2235,9 +2220,10 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr, return TRUE; /* Also try examining DWARF2 debugging information. */ - if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset, + if (_bfd_dwarf2_find_nearest_line (abfd, debug_sections, + section, symbols, offset, filename_ptr, functionname_ptr, - line_ptr, 0, + line_ptr, NULL, 0, &coff_data(abfd)->dwarf2_find_line_info)) return TRUE; @@ -2245,7 +2231,7 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr, *functionname_ptr = 0; *line_ptr = 0; - /* Don't try and find line numbers in a non coff file */ + /* Don't try and find line numbers in a non coff file. */ if (!bfd_family_coff (abfd)) return FALSE; @@ -2276,6 +2262,7 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr, maxdiff = (bfd_vma) 0 - (bfd_vma) 1; while (1) { + bfd_vma file_addr; combined_entry_type *p2; for (p2 = p + 1 + p->u.syment.n_numaux; @@ -2294,11 +2281,16 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr, } } + file_addr = (bfd_vma) p2->u.syment.n_value; + /* PR 11512: Include the section address of the function name symbol. */ + if (p2->u.syment.n_scnum > 0) + file_addr += coff_section_from_bfd_index (abfd, + p2->u.syment.n_scnum)->vma; /* We use <= MAXDIFF here so that if we get a zero length file, we actually use the next file entry. */ if (p2 < pend - && offset + sec_vma >= (bfd_vma) p2->u.syment.n_value - && offset + sec_vma - (bfd_vma) p2->u.syment.n_value <= maxdiff) + && offset + sec_vma >= file_addr + && offset + sec_vma - file_addr <= maxdiff) { *filename_ptr = (char *) p->u.syment._n._n_n._n_offset; maxdiff = offset + sec_vma - p2->u.syment.n_value; @@ -2315,7 +2307,7 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr, } } - /* Now wander though the raw linenumbers of the section */ + /* Now wander though the raw linenumbers of the section. */ /* If we have been called on this section before, and the offset we want is further down then we can prime the lookup loop. */ sec_data = coff_section_data (abfd, section); @@ -2343,7 +2335,7 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr, { if (l->line_number == 0) { - /* Get the symbol this line number points at */ + /* Get the symbol this line number points at. */ coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym); if (coff->symbol.value > offset) break; @@ -2397,13 +2389,13 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr, if (sec_data == NULL && section->owner == abfd) { amt = sizeof (struct coff_section_tdata); - section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt); + section->used_by_bfd = bfd_zalloc (abfd, amt); sec_data = (struct coff_section_tdata *) section->used_by_bfd; } if (sec_data != NULL) { sec_data->offset = offset; - sec_data->i = i; + sec_data->i = i - 1; sec_data->function = *functionname_ptr; sec_data->line_base = line_base; } @@ -2411,32 +2403,73 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr, return TRUE; } +bfd_boolean +coff_find_nearest_line (bfd *abfd, + asection *section, + asymbol **symbols, + bfd_vma offset, + const char **filename_ptr, + const char **functionname_ptr, + unsigned int *line_ptr) +{ + return coff_find_nearest_line_with_names (abfd, dwarf_debug_sections, + section, symbols, offset, + filename_ptr, functionname_ptr, + line_ptr); +} + +bfd_boolean +coff_find_nearest_line_discriminator (bfd *abfd, + asection *section, + asymbol **symbols, + bfd_vma offset, + const char **filename_ptr, + const char **functionname_ptr, + unsigned int *line_ptr, + unsigned int *discriminator) +{ + *discriminator = 0; + return coff_find_nearest_line_with_names (abfd, dwarf_debug_sections, + section, symbols, offset, + filename_ptr, functionname_ptr, + line_ptr); +} + + +bfd_boolean +coff_find_inliner_info (bfd *abfd, + const char **filename_ptr, + const char **functionname_ptr, + unsigned int *line_ptr) +{ + bfd_boolean found; + + found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr, + functionname_ptr, line_ptr, + &coff_data(abfd)->dwarf2_find_line_info); + return (found); +} + int -coff_sizeof_headers (abfd, reloc) - bfd *abfd; - bfd_boolean reloc; +coff_sizeof_headers (bfd *abfd, struct bfd_link_info *info) { size_t size; - if (! reloc) - { - size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd); - } + if (!info->relocatable) + size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd); else - { - size = bfd_coff_filhsz (abfd); - } + size = bfd_coff_filhsz (abfd); size += abfd->section_count * bfd_coff_scnhsz (abfd); return size; } /* Change the class of a coff symbol held by BFD. */ + bfd_boolean -bfd_coff_set_symbol_class (abfd, symbol, class) - bfd * abfd; - asymbol * symbol; - unsigned int class; +bfd_coff_set_symbol_class (bfd * abfd, + asymbol * symbol, + unsigned int symbol_class) { coff_symbol_type * csym; @@ -2461,7 +2494,7 @@ bfd_coff_set_symbol_class (abfd, symbol, class) return FALSE; native->u.syment.n_type = T_NULL; - native->u.syment.n_sclass = class; + native->u.syment.n_sclass = symbol_class; if (bfd_is_und_section (symbol->section)) { @@ -2490,9 +2523,7 @@ bfd_coff_set_symbol_class (abfd, symbol, class) csym->native = native; } else - { - csym->native->u.syment.n_sclass = class; - } + csym->native->u.syment.n_sclass = symbol_class; return TRUE; } @@ -2500,8 +2531,76 @@ bfd_coff_set_symbol_class (abfd, symbol, class) struct coff_comdat_info * bfd_coff_get_comdat_section (bfd *abfd, struct bfd_section *sec) { - if (bfd_get_flavour (abfd) == bfd_target_coff_flavour) + if (bfd_get_flavour (abfd) == bfd_target_coff_flavour + && coff_section_data (abfd, sec) != NULL) return coff_section_data (abfd, sec)->comdat; else return NULL; } + +bfd_boolean +_bfd_coff_section_already_linked (bfd *abfd, + asection *sec, + struct bfd_link_info *info) +{ + flagword flags; + const char *name, *key; + struct bfd_section_already_linked *l; + struct bfd_section_already_linked_hash_entry *already_linked_list; + struct coff_comdat_info *s_comdat; + + flags = sec->flags; + if ((flags & SEC_LINK_ONCE) == 0) + return FALSE; + + /* The COFF backend linker doesn't support group sections. */ + if ((flags & SEC_GROUP) != 0) + return FALSE; + + name = bfd_get_section_name (abfd, sec); + s_comdat = bfd_coff_get_comdat_section (abfd, sec); + + if (s_comdat != NULL) + key = s_comdat->name; + else + { + if (CONST_STRNEQ (name, ".gnu.linkonce.") + && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL) + key++; + else + /* FIXME: gcc as of 2011-09 emits sections like .text$, + .xdata$ and .pdata$ only the first of which has a + comdat key. Should these all match the LTO IR key? */ + key = name; + } + + already_linked_list = bfd_section_already_linked_table_lookup (key); + + for (l = already_linked_list->entry; l != NULL; l = l->next) + { + struct coff_comdat_info *l_comdat; + + l_comdat = bfd_coff_get_comdat_section (l->sec->owner, l->sec); + + /* The section names must match, and both sections must be + comdat and have the same comdat name, or both sections must + be non-comdat. LTO IR plugin sections are an exception. They + are always named .gnu.linkonce.t. ( is some string) + and match any comdat section with comdat name of , and + any linkonce section with the same suffix, ie. + .gnu.linkonce.*.. */ + if (((s_comdat != NULL) == (l_comdat != NULL) + && strcmp (name, l->sec->name) == 0) + || (l->sec->owner->flags & BFD_PLUGIN) != 0) + { + /* The section has already been linked. See if we should + issue a warning. */ + return _bfd_handle_already_linked (sec, l, info); + } + } + + /* This is the first section with this name. Record it. */ + if (!bfd_section_already_linked_table_insert (already_linked_list, sec)) + info->callbacks->einfo (_("%F%P: already_linked_table: %E\n")); + return FALSE; +}