From 8b9561304c8996f317aa13675a424f951873bf59 Mon Sep 17 00:00:00 2001 From: Nick Clifton Date: Thu, 21 Aug 2003 16:20:39 +0000 Subject: [PATCH] Convert to ISO C90. Tidy up formatting. --- bfd/ChangeLog | 4 + bfd/cofflink.c | 552 +++++++++++++++++++++---------------------------- 2 files changed, 243 insertions(+), 313 deletions(-) diff --git a/bfd/ChangeLog b/bfd/ChangeLog index 58b1aeec56b..765fbc74d89 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,3 +1,7 @@ +2003-08-21 Nick Clifton + + * cofflink.c: Update to IISO C90. + 2003-08-21 Randolph Chung * elf32-hppa.c (elf32_hppa_object_p): For elf32-hppa-linux, objects diff --git a/bfd/cofflink.c b/bfd/cofflink.c index 59b32ed1f6f..09f03f03ef0 100644 --- a/bfd/cofflink.c +++ b/bfd/cofflink.c @@ -3,21 +3,21 @@ Free Software Foundation, Inc. Written by Ian Lance Taylor, 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* This file contains the COFF backend linker code. */ @@ -28,22 +28,9 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "coff/internal.h" #include "libcoff.h" -static bfd_boolean coff_link_add_object_symbols - PARAMS ((bfd *, struct bfd_link_info *)); -static bfd_boolean coff_link_check_archive_element - PARAMS ((bfd *, struct bfd_link_info *, bfd_boolean *)); -static bfd_boolean coff_link_check_ar_symbols - PARAMS ((bfd *, struct bfd_link_info *, bfd_boolean *)); -static bfd_boolean coff_link_add_symbols - PARAMS ((bfd *, struct bfd_link_info *)); -static char *dores_com - PARAMS ((char *, bfd *, int)); -static char *get_name - PARAMS ((char *, char **)); -static int process_embedded_commands - PARAMS ((bfd *, struct bfd_link_info *, bfd *)); -static void mark_relocs - PARAMS ((struct coff_final_link_info *, bfd *)); +static bfd_boolean coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info); +static bfd_boolean coff_link_check_archive_element (bfd *abfd, struct bfd_link_info *info, bfd_boolean *pneeded); +static bfd_boolean coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info); /* Return TRUE if SYM is a weak, external symbol. */ #define IS_WEAK_EXTERNAL(abfd, sym) \ @@ -67,10 +54,9 @@ static void mark_relocs /* Create an entry in a COFF linker hash table. */ struct bfd_hash_entry * -_bfd_coff_link_hash_newfunc (entry, table, string) - struct bfd_hash_entry *entry; - struct bfd_hash_table *table; - const char *string; +_bfd_coff_link_hash_newfunc (struct bfd_hash_entry *entry, + struct bfd_hash_table *table, + const char *string) { struct coff_link_hash_entry *ret = (struct coff_link_hash_entry *) entry; @@ -103,12 +89,11 @@ _bfd_coff_link_hash_newfunc (entry, table, string) /* Initialize a COFF linker hash table. */ bfd_boolean -_bfd_coff_link_hash_table_init (table, abfd, newfunc) - struct coff_link_hash_table *table; - bfd *abfd; - struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *, - struct bfd_hash_table *, - const char *)); +_bfd_coff_link_hash_table_init (struct coff_link_hash_table *table, + bfd *abfd, + struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *, + struct bfd_hash_table *, + const char *)) { table->stab_info = NULL; return _bfd_link_hash_table_init (&table->root, abfd, newfunc); @@ -117,15 +102,15 @@ _bfd_coff_link_hash_table_init (table, abfd, newfunc) /* Create a COFF linker hash table. */ struct bfd_link_hash_table * -_bfd_coff_link_hash_table_create (abfd) - bfd *abfd; +_bfd_coff_link_hash_table_create (bfd *abfd) { struct coff_link_hash_table *ret; bfd_size_type amt = sizeof (struct coff_link_hash_table); - ret = (struct coff_link_hash_table *) bfd_malloc (amt); + ret = bfd_malloc (amt); if (ret == NULL) return NULL; + if (! _bfd_coff_link_hash_table_init (ret, abfd, _bfd_coff_link_hash_newfunc)) { @@ -138,10 +123,9 @@ _bfd_coff_link_hash_table_create (abfd) /* Create an entry in a COFF debug merge hash table. */ struct bfd_hash_entry * -_bfd_coff_debug_merge_hash_newfunc (entry, table, string) - struct bfd_hash_entry *entry; - struct bfd_hash_table *table; - const char *string; +_bfd_coff_debug_merge_hash_newfunc (struct bfd_hash_entry *entry, + struct bfd_hash_table *table, + const char *string) { struct coff_debug_merge_hash_entry *ret = (struct coff_debug_merge_hash_entry *) entry; @@ -171,17 +155,15 @@ _bfd_coff_debug_merge_hash_newfunc (entry, table, string) appropriate. */ bfd_boolean -_bfd_coff_link_add_symbols (abfd, info) - bfd *abfd; - struct bfd_link_info *info; +_bfd_coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info) { switch (bfd_get_format (abfd)) { case bfd_object: return coff_link_add_object_symbols (abfd, info); case bfd_archive: - return (_bfd_generic_link_add_archive_symbols - (abfd, info, coff_link_check_archive_element)); + return _bfd_generic_link_add_archive_symbols + (abfd, info, coff_link_check_archive_element); default: bfd_set_error (bfd_error_wrong_format); return FALSE; @@ -191,52 +173,17 @@ _bfd_coff_link_add_symbols (abfd, info) /* Add symbols from a COFF object file. */ static bfd_boolean -coff_link_add_object_symbols (abfd, info) - bfd *abfd; - struct bfd_link_info *info; +coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info) { if (! _bfd_coff_get_external_symbols (abfd)) return FALSE; if (! coff_link_add_symbols (abfd, info)) return FALSE; - if (! info->keep_memory) - { - if (! _bfd_coff_free_symbols (abfd)) - return FALSE; - } - return TRUE; -} - -/* Check a single archive element to see if we need to include it in - the link. *PNEEDED is set according to whether this element is - needed in the link or not. This is called via - _bfd_generic_link_add_archive_symbols. */ - -static bfd_boolean -coff_link_check_archive_element (abfd, info, pneeded) - bfd *abfd; - struct bfd_link_info *info; - bfd_boolean *pneeded; -{ - if (! _bfd_coff_get_external_symbols (abfd)) - return FALSE; - - if (! coff_link_check_ar_symbols (abfd, info, pneeded)) + if (! info->keep_memory + && ! _bfd_coff_free_symbols (abfd)) return FALSE; - if (*pneeded) - { - if (! coff_link_add_symbols (abfd, info)) - return FALSE; - } - - if (! info->keep_memory || ! *pneeded) - { - if (! _bfd_coff_free_symbols (abfd)) - return FALSE; - } - return TRUE; } @@ -244,10 +191,9 @@ coff_link_check_archive_element (abfd, info, pneeded) included in the link. */ static bfd_boolean -coff_link_check_ar_symbols (abfd, info, pneeded) - bfd *abfd; - struct bfd_link_info *info; - bfd_boolean *pneeded; +coff_link_check_ar_symbols (bfd *abfd, + struct bfd_link_info *info, + bfd_boolean *pneeded) { bfd_size_type symesz; bfd_byte *esym; @@ -263,7 +209,7 @@ coff_link_check_ar_symbols (abfd, info, pneeded) struct internal_syment sym; enum coff_symbol_classification classification; - bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym); + bfd_coff_swap_sym_in (abfd, esym, &sym); classification = bfd_coff_classify_symbol (abfd, &sym); if (classification == COFF_SYMBOL_GLOBAL @@ -275,22 +221,17 @@ coff_link_check_ar_symbols (abfd, info, pneeded) /* This symbol is externally visible, and is defined by this object file. */ - name = _bfd_coff_internal_syment_name (abfd, &sym, buf); if (name == NULL) return FALSE; h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE); - /* auto import */ - if (!h && info->pei386_auto_import) - { - if (!strncmp (name,"__imp_", 6)) - { - h = - bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, - TRUE); - } - } + /* Auto import. */ + if (!h + && info->pei386_auto_import + && !strncmp (name,"__imp_", 6)) + h = bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, TRUE); + /* We are only interested in symbols that are currently undefined. If a symbol is currently known to be common, COFF linkers do not bring in an object file which defines @@ -312,12 +253,38 @@ coff_link_check_ar_symbols (abfd, info, pneeded) return TRUE; } +/* Check a single archive element to see if we need to include it in + the link. *PNEEDED is set according to whether this element is + needed in the link or not. This is called via + _bfd_generic_link_add_archive_symbols. */ + +static bfd_boolean +coff_link_check_archive_element (bfd *abfd, + struct bfd_link_info *info, + bfd_boolean *pneeded) +{ + if (! _bfd_coff_get_external_symbols (abfd)) + return FALSE; + + if (! coff_link_check_ar_symbols (abfd, info, pneeded)) + return FALSE; + + if (*pneeded + && ! coff_link_add_symbols (abfd, info)) + return FALSE; + + if ((! info->keep_memory || ! *pneeded) + && ! _bfd_coff_free_symbols (abfd)) + return FALSE; + + return TRUE; +} + /* Add all the symbols from an object file to the hash table. */ static bfd_boolean -coff_link_add_symbols (abfd, info) - bfd *abfd; - struct bfd_link_info *info; +coff_link_add_symbols (bfd *abfd, + struct bfd_link_info *info) { unsigned int n_tmask = coff_data (abfd)->local_n_tmask; unsigned int n_btshft = coff_data (abfd)->local_n_btshft; @@ -346,7 +313,7 @@ coff_link_add_symbols (abfd, info) /* We keep a list of the linker hash table entries that correspond to particular symbols. */ amt = symcount * sizeof (struct coff_link_hash_entry *); - sym_hash = (struct coff_link_hash_entry **) bfd_zalloc (abfd, amt); + sym_hash = bfd_zalloc (abfd, amt); if (sym_hash == NULL && symcount != 0) goto error_return; obj_coff_sym_hashes (abfd) = sym_hash; @@ -361,7 +328,7 @@ coff_link_add_symbols (abfd, info) enum coff_symbol_classification classification; bfd_boolean copy; - bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &sym); + bfd_coff_swap_sym_in (abfd, esym, &sym); classification = bfd_coff_classify_symbol (abfd, &sym); if (classification != COFF_SYMBOL_LOCAL) @@ -564,9 +531,9 @@ coff_link_add_symbols (abfd, info) for (i = 0, eaux = esym + symesz, iaux = alloc; i < sym.n_numaux; i++, eaux += symesz, iaux++) - bfd_coff_swap_aux_in (abfd, (PTR) eaux, sym.n_type, + bfd_coff_swap_aux_in (abfd, eaux, sym.n_type, sym.n_sclass, (int) i, - sym.n_numaux, (PTR) iaux); + sym.n_numaux, iaux); (*sym_hash)->aux = alloc; } } @@ -582,7 +549,6 @@ coff_link_add_symbols (abfd, info) FIXME: This is not at all the right place to do this. For example, it won't help objdump. This needs to be done when we swap in the section header. */ - BFD_ASSERT ((*sym_hash)->numaux == 1); if (section->_raw_size == 0) section->_raw_size = (*sym_hash)->aux[0].x_scn.x_scnlen; @@ -620,7 +586,7 @@ coff_link_add_symbols (abfd, info) if (secdata == NULL) { amt = sizeof (struct coff_section_tdata); - stab->used_by_bfd = (PTR) bfd_zalloc (abfd, amt); + stab->used_by_bfd = bfd_zalloc (abfd, amt); if (stab->used_by_bfd == NULL) goto error_return; secdata = coff_section_data (abfd, stab); @@ -648,9 +614,8 @@ coff_link_add_symbols (abfd, info) /* Do the final link step. */ bfd_boolean -_bfd_coff_final_link (abfd, info) - bfd *abfd; - struct bfd_link_info *info; +_bfd_coff_final_link (bfd *abfd, + struct bfd_link_info *info) { bfd_size_type symesz; struct coff_final_link_info finfo; @@ -792,7 +757,7 @@ _bfd_coff_final_link (abfd, info) the target_index fields are 1 based. */ amt = abfd->section_count + 1; amt *= sizeof (struct coff_link_section_info); - finfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt); + finfo.section_info = bfd_malloc (amt); if (finfo.section_info == NULL) goto error_return; for (i = 0; i <= abfd->section_count; i++) @@ -835,12 +800,10 @@ _bfd_coff_final_link (abfd, info) BFD_ASSERT (info->relocatable); amt = o->reloc_count; amt *= sizeof (struct internal_reloc); - finfo.section_info[o->target_index].relocs = - (struct internal_reloc *) bfd_malloc (amt); + finfo.section_info[o->target_index].relocs = bfd_malloc (amt); amt = o->reloc_count; amt *= sizeof (struct coff_link_hash_entry *); - finfo.section_info[o->target_index].rel_hashes = - (struct coff_link_hash_entry **) bfd_malloc (amt); + finfo.section_info[o->target_index].rel_hashes = bfd_malloc (amt); if (finfo.section_info[o->target_index].relocs == NULL || finfo.section_info[o->target_index].rel_hashes == NULL) goto error_return; @@ -873,21 +836,21 @@ _bfd_coff_final_link (abfd, info) /* Allocate some buffers used while linking. */ amt = max_sym_count * sizeof (struct internal_syment); - finfo.internal_syms = (struct internal_syment *) bfd_malloc (amt); + finfo.internal_syms = bfd_malloc (amt); amt = max_sym_count * sizeof (asection *); - finfo.sec_ptrs = (asection **) bfd_malloc (amt); + finfo.sec_ptrs = bfd_malloc (amt); amt = max_sym_count * sizeof (long); - finfo.sym_indices = (long *) bfd_malloc (amt); - finfo.outsyms = (bfd_byte *) bfd_malloc ((max_sym_count + 1) * symesz); + finfo.sym_indices = bfd_malloc (amt); + finfo.outsyms = bfd_malloc ((max_sym_count + 1) * symesz); amt = max_lineno_count * bfd_coff_linesz (abfd); - finfo.linenos = (bfd_byte *) bfd_malloc (amt); - finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size); + finfo.linenos = bfd_malloc (amt); + finfo.contents = bfd_malloc (max_contents_size); amt = max_reloc_count * relsz; - finfo.external_relocs = (bfd_byte *) bfd_malloc (amt); + finfo.external_relocs = bfd_malloc (amt); if (! info->relocatable) { amt = max_reloc_count * sizeof (struct internal_reloc); - finfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt); + finfo.internal_relocs = bfd_malloc (amt); } if ((finfo.internal_syms == NULL && max_sym_count > 0) || (finfo.sec_ptrs == NULL && max_sym_count > 0) @@ -996,8 +959,8 @@ _bfd_coff_final_link (abfd, info) file_ptr pos; finfo.last_file.n_value = obj_raw_syment_count (abfd); - bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file, - (PTR) finfo.outsyms); + bfd_coff_swap_sym_out (abfd, &finfo.last_file, + finfo.outsyms); pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz; if (bfd_seek (abfd, pos, SEEK_SET) != 0 @@ -1012,8 +975,7 @@ _bfd_coff_final_link (abfd, info) { finfo.failed = FALSE; coff_link_hash_traverse (coff_hash_table (info), - _bfd_coff_write_task_globals, - (PTR) &finfo); + _bfd_coff_write_task_globals, &finfo); if (finfo.failed) goto error_return; } @@ -1021,8 +983,7 @@ _bfd_coff_final_link (abfd, info) /* Write out the global symbols. */ finfo.failed = FALSE; coff_link_hash_traverse (coff_hash_table (info), - _bfd_coff_write_global_sym, - (PTR) &finfo); + _bfd_coff_write_global_sym, &finfo); if (finfo.failed) goto error_return; @@ -1039,7 +1000,7 @@ _bfd_coff_final_link (abfd, info) the symbol indices to use for relocs against them, and we can finally write out the relocs. */ amt = max_output_reloc_count * relsz; - external_relocs = (bfd_byte *) bfd_malloc (amt); + external_relocs = bfd_malloc (amt); if (external_relocs == NULL) goto error_return; @@ -1064,11 +1025,11 @@ _bfd_coff_final_link (abfd, info) BFD_ASSERT ((*rel_hash)->indx >= 0); irel->r_symndx = (*rel_hash)->indx; } - bfd_coff_swap_reloc_out (abfd, (PTR) irel, (PTR) erel); + bfd_coff_swap_reloc_out (abfd, irel, erel); } if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0 - || (bfd_bwrite ((PTR) external_relocs, + || (bfd_bwrite (external_relocs, (bfd_size_type) relsz * o->reloc_count, abfd) != (bfd_size_type) relsz * o->reloc_count)) goto error_return; @@ -1175,17 +1136,15 @@ _bfd_coff_final_link (abfd, info) return FALSE; } -/* parse out a -heap , line */ +/* Parse out a -heap , line. */ static char * -dores_com (ptr, output_bfd, heap) - char *ptr; - bfd *output_bfd; - int heap; +dores_com (char *ptr, bfd *output_bfd, int heap) { if (coff_data(output_bfd)->pe) { int val = strtoul (ptr, &ptr, 0); + if (heap) pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve = val; else @@ -1203,9 +1162,8 @@ dores_com (ptr, output_bfd, heap) return ptr; } -static char *get_name(ptr, dst) -char *ptr; -char **dst; +static char * +get_name (char *ptr, char **dst) { while (*ptr == ' ') ptr++; @@ -1216,85 +1174,89 @@ char **dst; return ptr+1; } -/* Process any magic embedded commands in a section called .drectve */ +/* Process any magic embedded commands in a section called .drectve. */ static int -process_embedded_commands (output_bfd, info, abfd) - bfd *output_bfd; - struct bfd_link_info *info ATTRIBUTE_UNUSED; - bfd *abfd; +process_embedded_commands (bfd *output_bfd, + struct bfd_link_info *info ATTRIBUTE_UNUSED, + bfd *abfd) { asection *sec = bfd_get_section_by_name (abfd, ".drectve"); char *s; char *e; char *copy; + if (!sec) return 1; copy = bfd_malloc (sec->_raw_size); if (!copy) return 0; - if (! bfd_get_section_contents(abfd, sec, copy, (bfd_vma) 0, sec->_raw_size)) + + if (! bfd_get_section_contents (abfd, sec, copy, (bfd_vma) 0, sec->_raw_size)) { free (copy); return 0; } e = copy + sec->_raw_size; + for (s = copy; s < e ; ) { - if (s[0]!= '-') { - s++; - continue; - } + if (s[0]!= '-') + { + s++; + continue; + } if (strncmp (s,"-attr", 5) == 0) { char *name; char *attribs; asection *asec; - int loop = 1; int had_write = 0; int had_read = 0; int had_exec= 0; int had_shared= 0; + s += 5; - s = get_name(s, &name); - s = get_name(s, &attribs); - while (loop) { - switch (*attribs++) - { - case 'W': - had_write = 1; - break; - case 'R': - had_read = 1; - break; - case 'S': - had_shared = 1; - break; - case 'X': - had_exec = 1; - break; - default: - loop = 0; - } - } + s = get_name (s, &name); + s = get_name (s, &attribs); + + while (loop) + { + switch (*attribs++) + { + case 'W': + had_write = 1; + break; + case 'R': + had_read = 1; + break; + case 'S': + had_shared = 1; + break; + case 'X': + had_exec = 1; + break; + default: + loop = 0; + } + } asec = bfd_get_section_by_name (abfd, name); - if (asec) { - if (had_exec) - asec->flags |= SEC_CODE; - if (!had_write) - asec->flags |= SEC_READONLY; - } + if (asec) + { + if (had_exec) + asec->flags |= SEC_CODE; + if (!had_write) + asec->flags |= SEC_READONLY; + } } else if (strncmp (s,"-heap", 5) == 0) - { - s = dores_com (s+5, output_bfd, 1); - } + s = dores_com (s+5, output_bfd, 1); + else if (strncmp (s,"-stack", 6) == 0) - { - s = dores_com (s+6, output_bfd, 0); - } + s = dores_com (s+6, output_bfd, 0); + else s++; } @@ -1305,13 +1267,10 @@ process_embedded_commands (output_bfd, info, abfd) /* Place a marker against all symbols which are used by relocations. This marker can be picked up by the 'do we skip this symbol ?' loop in _bfd_coff_link_input_bfd() and used to prevent skipping - that symbol. - */ + that symbol. */ static void -mark_relocs (finfo, input_bfd) - struct coff_final_link_info * finfo; - bfd * input_bfd; +mark_relocs (struct coff_final_link_info *finfo, bfd *input_bfd) { asection * a; @@ -1349,12 +1308,9 @@ mark_relocs (finfo, input_bfd) /* Place a mark in the sym_indices array (whose entries have been initialised to 0) for all of the symbols that are used in the relocation table. This will then be picked up in the - skip/don't pass */ - + skip/don't-skip pass. */ for (; irel < irelend; irel++) - { - finfo->sym_indices[ irel->r_symndx ] = -1; - } + finfo->sym_indices[ irel->r_symndx ] = -1; } } @@ -1362,9 +1318,7 @@ mark_relocs (finfo, input_bfd) handles all the sections and relocations of the input file at once. */ bfd_boolean -_bfd_coff_link_input_bfd (finfo, input_bfd) - struct coff_final_link_info *finfo; - bfd *input_bfd; +_bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd) { unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask; unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft; @@ -1372,8 +1326,8 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) unsigned int n_btmask = coff_data (input_bfd)->local_n_btmask; #endif bfd_boolean (*adjust_symndx) - PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, - struct internal_reloc *, bfd_boolean *)); + (bfd *, struct bfd_link_info *, bfd *, asection *, + struct internal_reloc *, bfd_boolean *); bfd *output_bfd; const char *strings; bfd_size_type syment_base; @@ -1419,20 +1373,18 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) output_index = syment_base; outsym = finfo->outsyms; - if (coff_data (output_bfd)->pe) - { - if (! process_embedded_commands (output_bfd, finfo->info, input_bfd)) - return FALSE; - } + if (coff_data (output_bfd)->pe + && ! process_embedded_commands (output_bfd, finfo->info, input_bfd)) + return FALSE; - /* If we are going to perform relocations and also strip/discard some symbols - then we must make sure that we do not strip/discard those symbols that are - going to be involved in the relocations */ + /* If we are going to perform relocations and also strip/discard some + symbols then we must make sure that we do not strip/discard those + symbols that are going to be involved in the relocations. */ if (( finfo->info->strip != strip_none || finfo->info->discard != discard_none) && finfo->info->relocatable) { - /* mark the symbol array as 'not-used' */ + /* Mark the symbol array as 'not-used'. */ memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp); mark_relocs (finfo, input_bfd); @@ -1447,7 +1399,7 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) bfd_boolean dont_skip_symbol; int add; - bfd_coff_swap_sym_in (input_bfd, (PTR) esym, (PTR) isymp); + bfd_coff_swap_sym_in (input_bfd, esym, isymp); /* Make a copy of *isymp so that the relocate_section function always sees the original values. This is more reliable than @@ -1534,7 +1486,7 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) && isym.n_numaux > 0) { if ((*secpp)->output_section == bfd_abs_section_ptr) - skip = TRUE; + skip = TRUE; } #endif @@ -1620,16 +1572,16 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) out to be a duplicate, we pass this address to bfd_release. */ amt = sizeof (struct coff_debug_merge_type); - mt = (struct coff_debug_merge_type *) bfd_alloc (input_bfd, amt); + mt = bfd_alloc (input_bfd, amt); if (mt == NULL) return FALSE; mt->class = isym.n_sclass; /* Pick up the aux entry, which points to the end of the tag entries. */ - bfd_coff_swap_aux_in (input_bfd, (PTR) (esym + isymesz), + bfd_coff_swap_aux_in (input_bfd, (esym + isymesz), isym.n_type, isym.n_sclass, 0, isym.n_numaux, - (PTR) &aux); + &aux); /* Gather the elements. */ epp = &mt->elements; @@ -1644,11 +1596,10 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) char elebuf[SYMNMLEN + 1]; char *name_copy; - bfd_coff_swap_sym_in (input_bfd, (PTR) esl, (PTR) islp); + bfd_coff_swap_sym_in (input_bfd, esl, islp); amt = sizeof (struct coff_debug_merge_element); - *epp = ((struct coff_debug_merge_element *) - bfd_alloc (input_bfd, amt)); + *epp = bfd_alloc (input_bfd, amt); if (*epp == NULL) return FALSE; @@ -1658,7 +1609,7 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) return FALSE; amt = strlen (elename) + 1; - name_copy = (char *) bfd_alloc (input_bfd, amt); + name_copy = bfd_alloc (input_bfd, amt); if (name_copy == NULL) return FALSE; strcpy (name_copy, elename); @@ -1673,16 +1624,15 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) union internal_auxent eleaux; long indx; - bfd_coff_swap_aux_in (input_bfd, (PTR) (esl + isymesz), + bfd_coff_swap_aux_in (input_bfd, (esl + isymesz), islp->n_type, islp->n_sclass, 0, - islp->n_numaux, (PTR) &eleaux); + islp->n_numaux, &eleaux); indx = eleaux.x_sym.x_tagndx.l; /* FIXME: If this tagndx entry refers to a symbol defined later in this file, we just ignore it. Handling this correctly would be tedious, and may not be required. */ - if (indx > 0 && (indx < ((esym - @@ -1705,7 +1655,7 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) type. We always output the type if it has no elements, for simplicity. */ if (mt->elements == NULL) - bfd_release (input_bfd, (PTR) mt); + bfd_release (input_bfd, mt); else { struct coff_debug_merge_type *mtl; @@ -1741,7 +1691,7 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) else { /* This is a redefinition which can be merged. */ - bfd_release (input_bfd, (PTR) mt); + bfd_release (input_bfd, mt); *indexp = mtl->indx; add = (eslend - esym) / isymesz; skip = TRUE; @@ -1765,8 +1715,7 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) bfd_coff_symname_in_debug. That is only true for XCOFF, and XCOFF requires different linking code anyhow. */ - name = _bfd_coff_internal_syment_name (input_bfd, &isym, - (char *) NULL); + name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL); if (name == NULL) return FALSE; indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy); @@ -1839,7 +1788,6 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) it). We try to get this right, below, just before we write the symbols out, but in the general case we may have to write the symbol out twice. */ - if (finfo->last_file_index != -1 && finfo->last_file.n_value != (bfd_vma) output_index) { @@ -1850,11 +1798,11 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) { /* The last C_FILE symbol is in this input file. */ bfd_coff_swap_sym_out (output_bfd, - (PTR) &finfo->last_file, - (PTR) (finfo->outsyms - + ((finfo->last_file_index - - syment_base) - * osymesz))); + &finfo->last_file, + (finfo->outsyms + + ((finfo->last_file_index + - syment_base) + * osymesz))); } else { @@ -1864,8 +1812,7 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) symbol. We need to write it out again. We borrow *outsym temporarily. */ bfd_coff_swap_sym_out (output_bfd, - (PTR) &finfo->last_file, - (PTR) outsym); + &finfo->last_file, outsym); pos = obj_sym_filepos (output_bfd); pos += finfo->last_file_index * osymesz; if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 @@ -1885,8 +1832,7 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) isym.n_sclass = C_STAT; /* Output the symbol. */ - - bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) outsym); + bfd_coff_swap_sym_out (output_bfd, &isym, outsym); *indexp = output_index; @@ -1926,13 +1872,13 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) /* Fix up the aux entries. This must be done in a separate pass, because we don't know the correct symbol indices until we have already decided which symbols we are going to keep. */ - esym = (bfd_byte *) obj_coff_external_syms (input_bfd); esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz; isymp = finfo->internal_syms; indexp = finfo->sym_indices; sym_hash = obj_coff_sym_hashes (input_bfd); outsym = finfo->outsyms; + while (esym < esym_end) { int add; @@ -1977,9 +1923,8 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) auxp = h->aux + i; else { - bfd_coff_swap_aux_in (input_bfd, (PTR) esym, isymp->n_type, - isymp->n_sclass, i, isymp->n_numaux, - (PTR) &aux); + bfd_coff_swap_aux_in (input_bfd, esym, isymp->n_type, + isymp->n_sclass, i, isymp->n_numaux, &aux); auxp = &aux; } @@ -2072,18 +2017,19 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) if ((bfd_size_type) finfo->last_bf_index >= syment_base) { - PTR auxout; + void *auxout; /* The last .bf symbol is in this input file. This will only happen if the assembler did not set up the .bf endndx symbols correctly. */ - auxout = (PTR) (finfo->outsyms - + ((finfo->last_bf_index - - syment_base) - * osymesz)); + auxout = (finfo->outsyms + + ((finfo->last_bf_index + - syment_base) + * osymesz)); + bfd_coff_swap_aux_out (output_bfd, - (PTR) &finfo->last_bf, + &finfo->last_bf, isymp->n_type, isymp->n_sclass, 0, isymp->n_numaux, @@ -2099,11 +2045,11 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) temporarily. FIXME: This case should be made faster. */ bfd_coff_swap_aux_out (output_bfd, - (PTR) &finfo->last_bf, + &finfo->last_bf, isymp->n_type, isymp->n_sclass, 0, isymp->n_numaux, - (PTR) outsym); + outsym); pos = obj_sym_filepos (output_bfd); pos += finfo->last_bf_index * osymesz; if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 @@ -2130,9 +2076,9 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) if (h == NULL) { - bfd_coff_swap_aux_out (output_bfd, (PTR) auxp, isymp->n_type, + bfd_coff_swap_aux_out (output_bfd, auxp, isymp->n_type, isymp->n_sclass, i, isymp->n_numaux, - (PTR) outsym); + outsym); outsym += osymesz; } @@ -2186,7 +2132,7 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) { struct internal_lineno iline; - bfd_coff_swap_lineno_in (input_bfd, (PTR) eline, (PTR) &iline); + bfd_coff_swap_lineno_in (input_bfd, eline, &iline); if (iline.l_lnno != 0) iline.l_addr.l_paddr += offset; @@ -2222,27 +2168,26 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) of the line numbers rather than an absolute file index. */ bfd_coff_swap_sym_in (output_bfd, - (PTR) (finfo->outsyms - + ((indx - syment_base) - * osymesz)), - (PTR) &is); + (finfo->outsyms + + ((indx - syment_base) + * osymesz)), &is); if ((ISFCN (is.n_type) || is.n_sclass == C_BLOCK) && is.n_numaux >= 1) { - PTR auxptr; + void *auxptr; - auxptr = (PTR) (finfo->outsyms - + ((indx - syment_base + 1) - * osymesz)); + auxptr = (finfo->outsyms + + ((indx - syment_base + 1) + * osymesz)); bfd_coff_swap_aux_in (output_bfd, auxptr, is.n_type, is.n_sclass, - 0, is.n_numaux, (PTR) &ia); + 0, is.n_numaux, &ia); ia.x_sym.x_fcnary.x_fcn.x_lnnoptr = (o->output_section->line_filepos + o->output_section->lineno_count * linesz + eline - finfo->linenos); - bfd_coff_swap_aux_out (output_bfd, (PTR) &ia, + bfd_coff_swap_aux_out (output_bfd, &ia, is.n_type, is.n_sclass, 0, is.n_numaux, auxptr); } @@ -2255,8 +2200,7 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) if (!skipping) { - bfd_coff_swap_lineno_out (output_bfd, (PTR) &iline, - (PTR) oeline); + bfd_coff_swap_lineno_out (output_bfd, &iline, oeline); oeline += linesz; } } @@ -2280,10 +2224,10 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) && (bfd_size_type) finfo->last_file_index >= syment_base) { finfo->last_file.n_value = output_index; - bfd_coff_swap_sym_out (output_bfd, (PTR) &finfo->last_file, - (PTR) (finfo->outsyms - + ((finfo->last_file_index - syment_base) - * osymesz))); + bfd_coff_swap_sym_out (output_bfd, &finfo->last_file, + (finfo->outsyms + + ((finfo->last_file_index - syment_base) + * osymesz))); } /* Write the modified symbols to the output file. */ @@ -2313,10 +2257,8 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) struct coff_section_tdata *secdata; if (! o->linker_mark) - { - /* This section was omitted from the link. */ - continue; - } + /* This section was omitted from the link. */ + continue; if ((o->flags & SEC_HAS_CONTENTS) == 0 || (o->_raw_size == 0 && (o->flags & SEC_RELOC) == 0)) @@ -2393,7 +2335,6 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) *rel_hash = NULL; /* Adjust the reloc address and symbol index. */ - irel->r_vaddr += offset; if (irel->r_symndx == -1) @@ -2444,7 +2385,6 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) stripping. This should have been handled by the 'dont_skip_symbol' code in the while loop at the top of this function. */ - is = finfo->internal_syms + irel->r_symndx; name = (_bfd_coff_internal_syment_name @@ -2483,11 +2423,9 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) } } - if (! finfo->info->keep_memory) - { - if (! _bfd_coff_free_symbols (input_bfd)) - return FALSE; - } + if (! finfo->info->keep_memory + && ! _bfd_coff_free_symbols (input_bfd)) + return FALSE; return TRUE; } @@ -2495,9 +2433,7 @@ _bfd_coff_link_input_bfd (finfo, input_bfd) /* Write out a global symbol. Called via coff_link_hash_traverse. */ bfd_boolean -_bfd_coff_write_global_sym (h, data) - struct coff_link_hash_entry *h; - PTR data; +_bfd_coff_write_global_sym (struct coff_link_hash_entry *h, void *data) { struct coff_final_link_info *finfo = (struct coff_final_link_info *) data; bfd *output_bfd; @@ -2616,7 +2552,7 @@ _bfd_coff_write_global_sym (h, data) isym.n_numaux = h->numaux; - bfd_coff_swap_sym_out (output_bfd, (PTR) &isym, (PTR) finfo->outsyms); + bfd_coff_swap_sym_out (output_bfd, &isym, finfo->outsyms); symesz = bfd_coff_symesz (output_bfd); @@ -2663,7 +2599,6 @@ _bfd_coff_write_global_sym (h, data) /* For PE, an overflow on the final link reportedly does not matter. FIXME: Why not? */ - if (sec->reloc_count > 0xffff && (! obj_pe (output_bfd) || finfo->info->relocatable)) @@ -2690,9 +2625,9 @@ _bfd_coff_write_global_sym (h, data) } } - bfd_coff_swap_aux_out (output_bfd, (PTR) auxp, isym.n_type, + bfd_coff_swap_aux_out (output_bfd, auxp, isym.n_type, isym.n_sclass, (int) i, isym.n_numaux, - (PTR) finfo->outsyms); + finfo->outsyms); if (bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz) { finfo->failed = TRUE; @@ -2709,9 +2644,7 @@ _bfd_coff_write_global_sym (h, data) the dirty work, if the symbol we are processing needs conversion. */ bfd_boolean -_bfd_coff_write_task_globals (h, data) - struct coff_link_hash_entry *h; - PTR data; +_bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data) { struct coff_final_link_info *finfo = (struct coff_final_link_info *) data; bfd_boolean rtnval = TRUE; @@ -2741,11 +2674,10 @@ _bfd_coff_write_task_globals (h, data) /* Handle a link order which is supposed to generate a reloc. */ bfd_boolean -_bfd_coff_reloc_link_order (output_bfd, finfo, output_section, link_order) - bfd *output_bfd; - struct coff_final_link_info *finfo; - asection *output_section; - struct bfd_link_order *link_order; +_bfd_coff_reloc_link_order (bfd *output_bfd, + struct coff_final_link_info *finfo, + asection *output_section, + struct bfd_link_order *link_order) { reloc_howto_type *howto; struct internal_reloc *irel; @@ -2767,7 +2699,7 @@ _bfd_coff_reloc_link_order (output_bfd, finfo, output_section, link_order) file_ptr loc; size = bfd_get_reloc_size (howto); - buf = (bfd_byte *) bfd_zmalloc (size); + buf = bfd_zmalloc (size); if (buf == NULL) return FALSE; @@ -2797,7 +2729,7 @@ _bfd_coff_reloc_link_order (output_bfd, finfo, output_section, link_order) break; } loc = link_order->offset * bfd_octets_per_byte (output_bfd); - ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf, + ok = bfd_set_section_contents (output_bfd, output_section, buf, loc, size); free (buf); if (! ok) @@ -2806,7 +2738,6 @@ _bfd_coff_reloc_link_order (output_bfd, finfo, output_section, link_order) /* Store the reloc information in the right place. It will get swapped and written out at the end of the final_link routine. */ - irel = (finfo->section_info[output_section->target_index].relocs + output_section->reloc_count); rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes @@ -2865,7 +2796,6 @@ _bfd_coff_reloc_link_order (output_bfd, finfo, output_section, link_order) routines anyhow. r_extern is only used for ECOFF. */ /* FIXME: What is the right value for r_offset? Is zero OK? */ - ++output_section->reloc_count; return TRUE; @@ -2875,17 +2805,14 @@ _bfd_coff_reloc_link_order (output_bfd, finfo, output_section, link_order) simple relocs. */ bfd_boolean -_bfd_coff_generic_relocate_section (output_bfd, info, input_bfd, - input_section, contents, relocs, syms, - sections) - bfd *output_bfd; - struct bfd_link_info *info; - bfd *input_bfd; - asection *input_section; - bfd_byte *contents; - struct internal_reloc *relocs; - struct internal_syment *syms; - asection **sections; +_bfd_coff_generic_relocate_section (bfd *output_bfd, + struct bfd_link_info *info, + bfd *input_bfd, + asection *input_section, + bfd_byte *contents, + struct internal_reloc *relocs, + struct internal_syment *syms, + asection **sections) { struct internal_reloc *rel; struct internal_reloc *relend; @@ -2927,7 +2854,6 @@ _bfd_coff_generic_relocate_section (output_bfd, info, input_bfd, size of the symbol is included in the section contents, or it is not. We assume that the size is not included, and force the rtype_to_howto function to adjust the addend as needed. */ - if (sym != NULL && sym->n_scnum != 0) addend = - sym->n_value; else -- 2.30.2