X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=bfd%2Fcoff-ppc.c;h=a931f6a876bc76d67482983a47ac6920630fd352;hb=8b8c7c9f49992750f66f81b4601d593a3858d98c;hp=14c9f56fb940deb806ee9ca734c04e500dd86c21;hpb=53e09e0aaf3d13e4b893744e2fe79edde7edfd20;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/coff-ppc.c b/bfd/coff-ppc.c index 14c9f56fb9..a931f6a876 100644 --- a/bfd/coff-ppc.c +++ b/bfd/coff-ppc.c @@ -1,7 +1,5 @@ /* BFD back-end for PowerPC Microsoft Portable Executable files. - Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, - 2000, 2001, 2002, 2003, 2004, 2005 - Free Software Foundation, Inc. + Copyright (C) 1990-2016 Free Software Foundation, Inc. Original version pieced together by Kim Knuttila (krk@cygnus.com) @@ -13,7 +11,7 @@ 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 + 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, @@ -23,7 +21,7 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, 59 Temple Place - Suite 330, + Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ /* Current State: @@ -33,9 +31,8 @@ - dlltool will not produce correct output in some .reloc cases, and will not produce the right glue code for dll function calls. */ -#include "bfd.h" #include "sysdep.h" - +#include "bfd.h" #include "libbfd.h" #include "coff/powerpc.h" @@ -53,9 +50,8 @@ /* This file is compiled more than once, but we only compile the final_link routine once. */ -extern bfd_boolean ppc_bfd_coff_final_link - PARAMS ((bfd *, struct bfd_link_info *)); -extern void dump_toc PARAMS ((PTR)); +extern bfd_boolean ppc_bfd_coff_final_link (bfd *, struct bfd_link_info *); +extern void dump_toc (void *); /* The toc is a set of bfd_vma fields. We use the fact that valid addresses are even (i.e. the bit representing "1" is off) to allow @@ -124,31 +120,12 @@ struct ppc_coff_link_hash_table struct coff_link_hash_table root; /* First entry, as required. */ }; -static struct bfd_hash_entry *ppc_coff_link_hash_newfunc - PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, - const char *)); -static bfd_boolean ppc_coff_link_hash_table_init - PARAMS ((struct ppc_coff_link_hash_table *, bfd *, - struct bfd_hash_entry *(*) (struct bfd_hash_entry *, - struct bfd_hash_table *, - const char *))); -static struct bfd_link_hash_table *ppc_coff_link_hash_table_create - PARAMS ((bfd *)); -static bfd_boolean coff_ppc_relocate_section - PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, - struct internal_reloc *, struct internal_syment *, asection **)); -static reloc_howto_type *coff_ppc_rtype_to_howto - PARAMS ((bfd *, asection *, struct internal_reloc *, - struct coff_link_hash_entry *, struct internal_syment *, - bfd_vma *)); - /* Routine to create an entry in the link hash table. */ static struct bfd_hash_entry * -ppc_coff_link_hash_newfunc (entry, table, string) - struct bfd_hash_entry *entry; - struct bfd_hash_table *table; - const char *string; +ppc_coff_link_hash_newfunc (struct bfd_hash_entry * entry, + struct bfd_hash_table * table, + const char * string) { struct ppc_coff_link_hash_entry *ret = (struct ppc_coff_link_hash_entry *) entry; @@ -184,21 +161,21 @@ ppc_coff_link_hash_newfunc (entry, table, string) /* Initialize a PE linker hash table. */ static bfd_boolean -ppc_coff_link_hash_table_init (table, abfd, newfunc) - struct ppc_coff_link_hash_table *table; - bfd *abfd; - struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *, - struct bfd_hash_table *, - const char *)); +ppc_coff_link_hash_table_init (struct ppc_coff_link_hash_table *table, + bfd *abfd, + struct bfd_hash_entry *(*newfunc) + (struct bfd_hash_entry *, + struct bfd_hash_table *, + const char *), + unsigned int entsize) { - return _bfd_coff_link_hash_table_init (&table->root, abfd, newfunc); + return _bfd_coff_link_hash_table_init (&table->root, abfd, newfunc, entsize); } /* Create a PE linker hash table. */ static struct bfd_link_hash_table * -ppc_coff_link_hash_table_create (abfd) - bfd *abfd; +ppc_coff_link_hash_table_create (bfd *abfd) { struct ppc_coff_link_hash_table *ret; bfd_size_type amt = sizeof (struct ppc_coff_link_hash_table); @@ -206,8 +183,9 @@ ppc_coff_link_hash_table_create (abfd) ret = (struct ppc_coff_link_hash_table *) bfd_malloc (amt); if (ret == NULL) return NULL; - if (! ppc_coff_link_hash_table_init (ret, abfd, - ppc_coff_link_hash_newfunc)) + if (!ppc_coff_link_hash_table_init (ret, abfd, + ppc_coff_link_hash_newfunc, + sizeof (struct ppc_coff_link_hash_entry))) { free (ret); return (struct bfd_link_hash_table *) NULL; @@ -319,60 +297,24 @@ ppc_coff_link_hash_table_create (abfd) /* Static helper functions to make relocation work. */ /* (Work In Progress) */ -static bfd_reloc_status_type ppc_refhi_reloc PARAMS ((bfd *abfd, - arelent *reloc, - asymbol *symbol, - PTR data, - asection *section, - bfd *output_bfd, - char **error)); -static bfd_reloc_status_type ppc_pair_reloc PARAMS ((bfd *abfd, - arelent *reloc, - asymbol *symbol, - PTR data, - asection *section, - bfd *output_bfd, - char **error)); - -static bfd_reloc_status_type ppc_toc16_reloc PARAMS ((bfd *abfd, - arelent *reloc, - asymbol *symbol, - PTR data, - asection *section, - bfd *output_bfd, - char **error)); - -static bfd_reloc_status_type ppc_section_reloc PARAMS ((bfd *abfd, - arelent *reloc, - asymbol *symbol, - PTR data, - asection *section, - bfd *output_bfd, - char **error)); - -static bfd_reloc_status_type ppc_secrel_reloc PARAMS ((bfd *abfd, - arelent *reloc, - asymbol *symbol, - PTR data, - asection *section, - bfd *output_bfd, - char **error)); - -static bfd_reloc_status_type ppc_imglue_reloc PARAMS ((bfd *abfd, - arelent *reloc, - asymbol *symbol, - PTR data, - asection *section, - bfd *output_bfd, - char **error)); - -static bfd_boolean in_reloc_p PARAMS((bfd *abfd, reloc_howto_type *howto)); - +static bfd_reloc_status_type ppc_refhi_reloc + (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); +static bfd_reloc_status_type ppc_pair_reloc + (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); +static bfd_reloc_status_type ppc_toc16_reloc + (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); +static bfd_reloc_status_type ppc_section_reloc + (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); +static bfd_reloc_status_type ppc_secrel_reloc + (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); +static bfd_reloc_status_type ppc_imglue_reloc + (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); + /* FIXME: It'll take a while to get through all of these. I only need a few to get us started, so those I'll make sure work. Those marked FIXME are either completely unverified or have a specific unknown marked in the comment. */ -/* Relocation entries for Windows/NT on PowerPC. +/* Relocation entries for Windows/NT on PowerPC. From the document "" we find the following listed as used relocs: @@ -821,15 +763,11 @@ struct list_ele extern struct list_ele *head; extern struct list_ele *tail; -static void record_toc - PARAMS ((asection *, bfd_signed_vma, enum ref_category, const char *)); - static void -record_toc (toc_section, our_toc_offset, cat, name) - asection *toc_section; - bfd_signed_vma our_toc_offset; - enum ref_category cat; - const char *name; +record_toc (asection *toc_section, + bfd_signed_vma our_toc_offset, + enum ref_category cat, + const char *name) { /* Add this entry to our toc addr-offset-name list. */ bfd_size_type amt = sizeof (struct list_ele); @@ -857,23 +795,15 @@ record_toc (toc_section, our_toc_offset, cat, name) #ifdef COFF_IMAGE_WITH_PE -static bfd_boolean ppc_record_toc_entry - PARAMS ((bfd *, struct bfd_link_info *, asection *, int, enum toc_type)); -static void ppc_mark_symbol_as_glue - PARAMS ((bfd *, int, struct internal_reloc *)); - /* Record a toc offset against a symbol. */ static bfd_boolean -ppc_record_toc_entry(abfd, info, sec, sym, toc_kind) - bfd *abfd; - struct bfd_link_info *info ATTRIBUTE_UNUSED; - asection *sec ATTRIBUTE_UNUSED; - int sym; - enum toc_type toc_kind ATTRIBUTE_UNUSED; +ppc_record_toc_entry (bfd *abfd, + struct bfd_link_info *info ATTRIBUTE_UNUSED, + asection *sec ATTRIBUTE_UNUSED, + int sym, + enum toc_type toc_kind ATTRIBUTE_UNUSED) { struct ppc_coff_link_hash_entry *h; - const char *name; - int *local_syms; h = 0; @@ -922,8 +852,6 @@ ppc_record_toc_entry(abfd, info, sec, sym, toc_kind) } else { - name = h->root.root.root.string; - /* Check to see if there's a toc slot allocated. If not, do it here. It will be used in relocate_section. */ if (IS_UNALLOCATED(h->toc_offset)) @@ -946,10 +874,9 @@ ppc_record_toc_entry(abfd, info, sec, sym, toc_kind) /* Record a toc offset against a symbol. */ static void -ppc_mark_symbol_as_glue(abfd, sym, rel) - bfd *abfd; - int sym; - struct internal_reloc *rel; +ppc_mark_symbol_as_glue (bfd *abfd, + int sym, + struct internal_reloc *rel) { struct ppc_coff_link_hash_entry *h; @@ -968,9 +895,9 @@ ppc_mark_symbol_as_glue(abfd, sym, rel) /* Return TRUE if this relocation should appear in the output .reloc section. */ -static bfd_boolean in_reloc_p(abfd, howto) - bfd * abfd ATTRIBUTE_UNUSED; - reloc_howto_type *howto; +static bfd_boolean +in_reloc_p (bfd * abfd ATTRIBUTE_UNUSED, + reloc_howto_type *howto) { return (! howto->pc_relative) @@ -987,24 +914,32 @@ static bfd_boolean in_reloc_p(abfd, howto) && (howto->type != IMAGE_REL_PPC_TOCREL16_DEFN) ; } +static bfd_boolean +write_base_file_entry (bfd *obfd, struct bfd_link_info *info, bfd_vma addr) +{ + if (coff_data (obfd)->pe) + addr -= pe_data (obfd)->pe_opthdr.ImageBase; + if (fwrite (&addr, sizeof (addr), 1, (FILE *) info->base_file) == 1) + return TRUE; + + bfd_set_error (bfd_error_system_call); + return FALSE; +} + /* The reloc processing routine for the optimized COFF linker. */ static bfd_boolean -coff_ppc_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; +coff_ppc_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; - bfd_boolean hihalf; - bfd_vma hihalf_val; asection *toc_section = 0; bfd_vma relocation; reloc_howto_type *howto = 0; @@ -1012,12 +947,9 @@ coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section, /* If we are performing a relocatable link, we don't need to do a thing. The caller will take care of adjusting the reloc addresses and symbol indices. */ - if (info->relocatable) + if (bfd_link_relocatable (info)) return TRUE; - hihalf = FALSE; - hihalf_val = 0; - rel = relocs; relend = rel + input_section->reloc_count; for (; rel < relend; rel++) @@ -1094,12 +1026,9 @@ coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section, + sec->output_offset); } else - { - if (! ((*info->callbacks->undefined_symbol) - (info, h->root.root.root.string, input_bfd, input_section, - rel->r_vaddr - input_section->vma, TRUE))) - return FALSE; - } + (*info->callbacks->undefined_symbol) + (info, h->root.root.root.string, input_bfd, input_section, + rel->r_vaddr - input_section->vma, TRUE); } rstat = bfd_reloc_ok; @@ -1141,10 +1070,11 @@ coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section, { /* It is a file local symbol. */ int *local_toc_table; - const char *name; + char name[SYMNMLEN + 1]; sym = syms + symndx; - name = sym->_n._n_name; + strncpy (name, sym->_n._n_name, SYMNMLEN); + name[SYMNMLEN] = '\0'; local_toc_table = obj_coff_local_toc_table(input_bfd); our_toc_offset = local_toc_table[symndx]; @@ -1242,10 +1172,8 @@ coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section, bfd_vma addr = (toc_section->output_section->vma + toc_section->output_offset + our_toc_offset); - if (coff_data (output_bfd)->pe) - addr -= pe_data(output_bfd)->pe_opthdr.ImageBase; - - fwrite (&addr, 1,4, (FILE *) info->base_file); + if (!write_base_file_entry (output_bfd, info, addr)) + return FALSE; } /* FIXME: this test is conservative. */ @@ -1268,19 +1196,14 @@ coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section, { /* To solve this, we need to know whether or not the symbol appearing on the call instruction is a glue function or not. - A glue function must announce itself via a IMGLUE reloc, and + A glue function must announce itself via a IMGLUE reloc, and the reloc contains the required toc restore instruction. */ - bfd_vma x; - const char *my_name; - DUMP_RELOC2 (howto->name, rel); if (h != 0) { - my_name = h->root.root.root.string; if (h->symbol_is_glue == 1) { - x = bfd_get_32 (input_bfd, loc); bfd_put_32 (input_bfd, (bfd_vma) h->glue_insn, loc); } } @@ -1300,9 +1223,14 @@ coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section, case IMAGE_REL_PPC_ABSOLUTE: { const char *my_name; + char buf[SYMNMLEN + 1]; if (h == 0) - my_name = (syms+symndx)->_n._n_name; + { + strncpy (buf, (syms+symndx)->_n._n_name, SYMNMLEN); + buf[SYMNMLEN] = '\0'; + my_name = buf; + } else my_name = h->root.root.root.string; @@ -1336,7 +1264,7 @@ coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section, DUMP_RELOC2 (howto->name, rel); - if (strncmp(".idata$2",input_section->name,8) == 0 && first_thunk_address == 0) + if (CONST_STRNEQ (input_section->name, ".idata$2") && first_thunk_address == 0) { /* Set magic values. */ int idata5offset; @@ -1363,11 +1291,8 @@ coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section, } if (h == 0) - { - /* It is a file local symbol. */ - sym = syms + symndx; - name = sym->_n._n_name; - } + /* It is a file local symbol. */ + sym = syms + symndx; else { char *target = 0; @@ -1458,15 +1383,13 @@ coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section, /* Relocation to a symbol in a section which isn't absolute - we output the address here to a file. */ - bfd_vma addr = rel->r_vaddr - - input_section->vma - + input_section->output_offset - + input_section->output_section->vma; + bfd_vma addr = (rel->r_vaddr + - input_section->vma + + input_section->output_offset + + input_section->output_section->vma); - if (coff_data (output_bfd)->pe) - addr -= pe_data (output_bfd)->pe_opthdr.ImageBase; - - fwrite (&addr, 1,4, (FILE *) info->base_file); + if (!write_base_file_entry (output_bfd, info, addr)) + return FALSE; } } @@ -1497,11 +1420,10 @@ coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section, name = buf; } - if (! ((*info->callbacks->reloc_overflow) - (info, (h ? &h->root.root : NULL), name, howto->name, - (bfd_vma) 0, input_bfd, - input_section, rel->r_vaddr - input_section->vma))) - return FALSE; + (*info->callbacks->reloc_overflow) + (info, (h ? &h->root.root : NULL), name, howto->name, + (bfd_vma) 0, input_bfd, input_section, + rel->r_vaddr - input_section->vma); } } } @@ -1534,15 +1456,14 @@ static char * h3 = N_(" Offset spelling (if present)\n"); void -dump_toc (vfile) - PTR vfile; +dump_toc (void * vfile) { FILE *file = (FILE *) vfile; struct list_ele *t; - fprintf (file, _(h1)); - fprintf (file, _(h2)); - fprintf (file, _(h3)); + fputs (_(h1), file); + fputs (_(h2), file); + fputs (_(h3), file); for (t = head; t != 0; t=t->next) { @@ -1563,8 +1484,8 @@ dump_toc (vfile) { fprintf (file, _("**** global_toc_size %ld(%lx), thunk_size %ld(%lx)\n"), - global_toc_size, global_toc_size, - thunk_size, thunk_size); + global_toc_size, (unsigned long) global_toc_size, + thunk_size, (unsigned long) thunk_size); cat = _("Out of bounds!"); } } @@ -1581,8 +1502,7 @@ dump_toc (vfile) } bfd_boolean -ppc_allocate_toc_section (info) - struct bfd_link_info *info ATTRIBUTE_UNUSED; +ppc_allocate_toc_section (struct bfd_link_info *info ATTRIBUTE_UNUSED) { asection *s; bfd_byte *foo; @@ -1612,9 +1532,8 @@ ppc_allocate_toc_section (info) } bfd_boolean -ppc_process_before_allocation (abfd, info) - bfd *abfd; - struct bfd_link_info *info; +ppc_process_before_allocation (bfd *abfd, + struct bfd_link_info *info) { asection *sec; struct internal_reloc *i, *rel; @@ -1675,15 +1594,13 @@ ppc_process_before_allocation (abfd, info) #endif static bfd_reloc_status_type -ppc_refhi_reloc (abfd, reloc_entry, symbol, data, - input_section, output_bfd, error_message) - bfd *abfd ATTRIBUTE_UNUSED; - arelent *reloc_entry ATTRIBUTE_UNUSED; - asymbol *symbol ATTRIBUTE_UNUSED; - PTR data ATTRIBUTE_UNUSED; - asection *input_section ATTRIBUTE_UNUSED; - bfd *output_bfd; - char **error_message ATTRIBUTE_UNUSED; +ppc_refhi_reloc (bfd *abfd ATTRIBUTE_UNUSED, + arelent *reloc_entry ATTRIBUTE_UNUSED, + asymbol *symbol ATTRIBUTE_UNUSED, + void * data ATTRIBUTE_UNUSED, + asection *input_section ATTRIBUTE_UNUSED, + bfd *output_bfd, + char **error_message ATTRIBUTE_UNUSED) { UN_IMPL("REFHI"); DUMP_RELOC("REFHI",reloc_entry); @@ -1695,15 +1612,13 @@ ppc_refhi_reloc (abfd, reloc_entry, symbol, data, } static bfd_reloc_status_type -ppc_pair_reloc (abfd, reloc_entry, symbol, data, - input_section, output_bfd, error_message) - bfd *abfd ATTRIBUTE_UNUSED; - arelent *reloc_entry ATTRIBUTE_UNUSED; - asymbol *symbol ATTRIBUTE_UNUSED; - PTR data ATTRIBUTE_UNUSED; - asection *input_section ATTRIBUTE_UNUSED; - bfd *output_bfd; - char **error_message ATTRIBUTE_UNUSED; +ppc_pair_reloc (bfd *abfd ATTRIBUTE_UNUSED, + arelent *reloc_entry ATTRIBUTE_UNUSED, + asymbol *symbol ATTRIBUTE_UNUSED, + void * data ATTRIBUTE_UNUSED, + asection *input_section ATTRIBUTE_UNUSED, + bfd *output_bfd, + char **error_message ATTRIBUTE_UNUSED) { UN_IMPL("PAIR"); DUMP_RELOC("PAIR",reloc_entry); @@ -1713,17 +1628,15 @@ ppc_pair_reloc (abfd, reloc_entry, symbol, data, return bfd_reloc_undefined; } - + static bfd_reloc_status_type -ppc_toc16_reloc (abfd, reloc_entry, symbol, data, - input_section, output_bfd, error_message) - bfd *abfd ATTRIBUTE_UNUSED; - arelent *reloc_entry ATTRIBUTE_UNUSED; - asymbol *symbol ATTRIBUTE_UNUSED; - PTR data ATTRIBUTE_UNUSED; - asection *input_section ATTRIBUTE_UNUSED; - bfd *output_bfd; - char **error_message ATTRIBUTE_UNUSED; +ppc_toc16_reloc (bfd *abfd ATTRIBUTE_UNUSED, + arelent *reloc_entry ATTRIBUTE_UNUSED, + asymbol *symbol ATTRIBUTE_UNUSED, + void * data ATTRIBUTE_UNUSED, + asection *input_section ATTRIBUTE_UNUSED, + bfd *output_bfd, + char **error_message ATTRIBUTE_UNUSED) { UN_IMPL ("TOCREL16"); DUMP_RELOC ("TOCREL16",reloc_entry); @@ -1735,15 +1648,13 @@ ppc_toc16_reloc (abfd, reloc_entry, symbol, data, } static bfd_reloc_status_type -ppc_secrel_reloc (abfd, reloc_entry, symbol, data, - input_section, output_bfd, error_message) - bfd *abfd ATTRIBUTE_UNUSED; - arelent *reloc_entry ATTRIBUTE_UNUSED; - asymbol *symbol ATTRIBUTE_UNUSED; - PTR data ATTRIBUTE_UNUSED; - asection *input_section ATTRIBUTE_UNUSED; - bfd *output_bfd; - char **error_message ATTRIBUTE_UNUSED; +ppc_secrel_reloc (bfd *abfd ATTRIBUTE_UNUSED, + arelent *reloc_entry ATTRIBUTE_UNUSED, + asymbol *symbol ATTRIBUTE_UNUSED, + void * data ATTRIBUTE_UNUSED, + asection *input_section ATTRIBUTE_UNUSED, + bfd *output_bfd, + char **error_message ATTRIBUTE_UNUSED) { UN_IMPL("SECREL"); DUMP_RELOC("SECREL",reloc_entry); @@ -1755,15 +1666,13 @@ ppc_secrel_reloc (abfd, reloc_entry, symbol, data, } static bfd_reloc_status_type -ppc_section_reloc (abfd, reloc_entry, symbol, data, - input_section, output_bfd, error_message) - bfd *abfd ATTRIBUTE_UNUSED; - arelent *reloc_entry ATTRIBUTE_UNUSED; - asymbol *symbol ATTRIBUTE_UNUSED; - PTR data ATTRIBUTE_UNUSED; - asection *input_section ATTRIBUTE_UNUSED; - bfd *output_bfd; - char **error_message ATTRIBUTE_UNUSED; +ppc_section_reloc (bfd *abfd ATTRIBUTE_UNUSED, + arelent *reloc_entry ATTRIBUTE_UNUSED, + asymbol *symbol ATTRIBUTE_UNUSED, + void * data ATTRIBUTE_UNUSED, + asection *input_section ATTRIBUTE_UNUSED, + bfd *output_bfd, + char **error_message ATTRIBUTE_UNUSED) { UN_IMPL("SECTION"); DUMP_RELOC("SECTION",reloc_entry); @@ -1775,15 +1684,14 @@ ppc_section_reloc (abfd, reloc_entry, symbol, data, } static bfd_reloc_status_type -ppc_imglue_reloc (abfd, reloc_entry, symbol, data, - input_section, output_bfd, error_message) - bfd *abfd ATTRIBUTE_UNUSED; - arelent *reloc_entry ATTRIBUTE_UNUSED; - asymbol *symbol ATTRIBUTE_UNUSED; - PTR data ATTRIBUTE_UNUSED; - asection *input_section ATTRIBUTE_UNUSED; - bfd *output_bfd; - char **error_message ATTRIBUTE_UNUSED; +ppc_imglue_reloc (bfd *abfd ATTRIBUTE_UNUSED, + arelent *reloc_entry ATTRIBUTE_UNUSED, + asymbol *symbol ATTRIBUTE_UNUSED, + void * data ATTRIBUTE_UNUSED, + asection *input_section ATTRIBUTE_UNUSED, + bfd *output_bfd, + char **error_message ATTRIBUTE_UNUSED) + { UN_IMPL("IMGLUE"); DUMP_RELOC("IMGLUE",reloc_entry); @@ -1800,12 +1708,9 @@ ppc_imglue_reloc (abfd, reloc_entry, symbol, data, /* FIXME: There is a possibility that when we read in a reloc from a file, that there are some bits encoded in the upper portion of the type field. Not yet implemented. */ -static void ppc_coff_rtype2howto PARAMS ((arelent *, struct internal_reloc *)); static void -ppc_coff_rtype2howto (relent, internal) - arelent *relent; - struct internal_reloc *internal; +ppc_coff_rtype2howto (arelent *relent, struct internal_reloc *internal) { /* We can encode one of three things in the type field, aside from the type: @@ -1854,10 +1759,9 @@ ppc_coff_rtype2howto (relent, internal) howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16; break; default: - fprintf (stderr, - _("Warning: Unsupported reloc %s [%d] used -- it may not work.\n"), - ppc_coff_howto_table[r_type].name, - r_type); + (*_bfd_error_handler) (_("warning: unsupported reloc %s [%d] used -- it may not work"), + ppc_coff_howto_table[r_type].name, + r_type); howto = ppc_coff_howto_table + r_type; break; } @@ -1866,13 +1770,12 @@ ppc_coff_rtype2howto (relent, internal) } static reloc_howto_type * -coff_ppc_rtype_to_howto (abfd, sec, rel, h, sym, addendp) - bfd *abfd ATTRIBUTE_UNUSED; - asection *sec; - struct internal_reloc *rel; - struct coff_link_hash_entry *h ATTRIBUTE_UNUSED; - struct internal_syment *sym ATTRIBUTE_UNUSED; - bfd_vma *addendp; +coff_ppc_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED, + asection *sec, + struct internal_reloc *rel, + struct coff_link_hash_entry *h ATTRIBUTE_UNUSED, + struct internal_syment *sym ATTRIBUTE_UNUSED, + bfd_vma *addendp) { reloc_howto_type *howto; @@ -1927,10 +1830,9 @@ coff_ppc_rtype_to_howto (abfd, sec, rel, h, sym, addendp) howto = ppc_coff_howto_table + r_type; break; default: - fprintf (stderr, - _("Warning: Unsupported reloc %s [%d] used -- it may not work.\n"), - ppc_coff_howto_table[r_type].name, - r_type); + (*_bfd_error_handler) (_("warning: unsupported reloc %s [%d] used -- it may not work"), + ppc_coff_howto_table[r_type].name, + r_type); howto = ppc_coff_howto_table + r_type; break; } @@ -1942,13 +1844,9 @@ coff_ppc_rtype_to_howto (abfd, sec, rel, h, sym, addendp) #define HOW2MAP(bfd_rtype,ppc_rtype) \ case bfd_rtype: return &ppc_coff_howto_table[ppc_rtype] -static reloc_howto_type *ppc_coff_reloc_type_lookup -PARAMS ((bfd *, bfd_reloc_code_real_type)); - static reloc_howto_type * -ppc_coff_reloc_type_lookup (abfd, code) - bfd *abfd ATTRIBUTE_UNUSED; - bfd_reloc_code_real_type code; +ppc_coff_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, + bfd_reloc_code_real_type code) { switch (code) { @@ -1965,8 +1863,23 @@ ppc_coff_reloc_type_lookup (abfd, code) return NULL; } } - #undef HOW2MAP + +static reloc_howto_type * +ppc_coff_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, + const char *r_name) +{ + unsigned int i; + + for (i = 0; + i < sizeof (ppc_coff_howto_table) / sizeof (ppc_coff_howto_table[0]); + i++) + if (ppc_coff_howto_table[i].name != NULL + && strcasecmp (ppc_coff_howto_table[i].name, r_name) == 0) + return &ppc_coff_howto_table[i]; + + return NULL; +} /* Tailor coffcode.h -- macro heaven. */ @@ -1975,6 +1888,7 @@ ppc_coff_reloc_type_lookup (abfd, code) /* We use the special COFF backend linker, with our own special touch. */ #define coff_bfd_reloc_type_lookup ppc_coff_reloc_type_lookup +#define coff_bfd_reloc_name_lookup ppc_coff_reloc_name_lookup #define coff_rtype_to_howto coff_ppc_rtype_to_howto #define coff_relocate_section coff_ppc_relocate_section #define coff_bfd_final_link ppc_bfd_coff_final_link @@ -2009,12 +1923,8 @@ ppc_coff_reloc_type_lookup (abfd, code) #ifndef COFF_IMAGE_WITH_PE -static bfd_boolean ppc_do_last PARAMS ((bfd *)); -static bfd *ppc_get_last PARAMS ((void)); - static bfd_boolean -ppc_do_last (abfd) - bfd *abfd; +ppc_do_last (bfd *abfd) { if (abfd == bfd_of_toc_owner) return TRUE; @@ -2023,7 +1933,7 @@ ppc_do_last (abfd) } static bfd * -ppc_get_last() +ppc_get_last (void) { return bfd_of_toc_owner; } @@ -2042,12 +1952,10 @@ ppc_get_last() /* Do the final link step. */ bfd_boolean -ppc_bfd_coff_final_link (abfd, info) - bfd *abfd; - struct bfd_link_info *info; +ppc_bfd_coff_final_link (bfd *abfd, struct bfd_link_info *info) { bfd_size_type symesz; - struct coff_final_link_info finfo; + struct coff_final_link_info flaginfo; bfd_boolean debug_merge_allocated; asection *o; struct bfd_link_order *p; @@ -2067,29 +1975,29 @@ ppc_bfd_coff_final_link (abfd, info) symesz = bfd_coff_symesz (abfd); - finfo.info = info; - finfo.output_bfd = abfd; - finfo.strtab = NULL; - finfo.section_info = NULL; - finfo.last_file_index = -1; - finfo.last_bf_index = -1; - finfo.internal_syms = NULL; - finfo.sec_ptrs = NULL; - finfo.sym_indices = NULL; - finfo.outsyms = NULL; - finfo.linenos = NULL; - finfo.contents = NULL; - finfo.external_relocs = NULL; - finfo.internal_relocs = NULL; + flaginfo.info = info; + flaginfo.output_bfd = abfd; + flaginfo.strtab = NULL; + flaginfo.section_info = NULL; + flaginfo.last_file_index = -1; + flaginfo.last_bf_index = -1; + flaginfo.internal_syms = NULL; + flaginfo.sec_ptrs = NULL; + flaginfo.sym_indices = NULL; + flaginfo.outsyms = NULL; + flaginfo.linenos = NULL; + flaginfo.contents = NULL; + flaginfo.external_relocs = NULL; + flaginfo.internal_relocs = NULL; debug_merge_allocated = FALSE; coff_data (abfd)->link_info = info; - finfo.strtab = _bfd_stringtab_init (); - if (finfo.strtab == NULL) + flaginfo.strtab = _bfd_stringtab_init (); + if (flaginfo.strtab == NULL) goto error_return; - if (! coff_debug_merge_hash_table_init (&finfo.debug_merge)) + if (! coff_debug_merge_hash_table_init (&flaginfo.debug_merge)) goto error_return; debug_merge_allocated = TRUE; @@ -2113,7 +2021,7 @@ ppc_bfd_coff_final_link (abfd, info) o->reloc_count = 0; o->lineno_count = 0; - for (p = o->link_order_head; p != NULL; p = p->next) + for (p = o->map_head.link_order; p != NULL; p = p->next) { if (p->type == bfd_indirect_link_order) { @@ -2131,7 +2039,7 @@ ppc_bfd_coff_final_link (abfd, info) || info->strip == strip_some) o->lineno_count += sec->lineno_count; - if (info->relocatable) + if (bfd_link_relocatable (info)) o->reloc_count += sec->reloc_count; if (sec->rawsize > max_contents_size) @@ -2143,7 +2051,7 @@ ppc_bfd_coff_final_link (abfd, info) if (sec->reloc_count > max_reloc_count) max_reloc_count = sec->reloc_count; } - else if (info->relocatable + else if (bfd_link_relocatable (info) && (p->type == bfd_section_reloc_link_order || p->type == bfd_symbol_reloc_link_order)) ++o->reloc_count; @@ -2160,7 +2068,7 @@ ppc_bfd_coff_final_link (abfd, info) /* If doing a relocatable link, allocate space for the pointers we need to keep. */ - if (info->relocatable) + if (bfd_link_relocatable (info)) { unsigned int i; @@ -2168,15 +2076,15 @@ ppc_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); + flaginfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt); - if (finfo.section_info == NULL) + if (flaginfo.section_info == NULL) goto error_return; for (i = 0; i <= abfd->section_count; i++) { - finfo.section_info[i].relocs = NULL; - finfo.section_info[i].rel_hashes = NULL; + flaginfo.section_info[i].relocs = NULL; + flaginfo.section_info[i].rel_hashes = NULL; } } @@ -2211,17 +2119,17 @@ ppc_bfd_coff_final_link (abfd, info) memory until the end of the link. This wastes memory, but only when doing a relocatable link, which is not the common case. */ - BFD_ASSERT (info->relocatable); + BFD_ASSERT (bfd_link_relocatable (info)); amt = o->reloc_count; amt *= sizeof (struct internal_reloc); - finfo.section_info[o->target_index].relocs = + flaginfo.section_info[o->target_index].relocs = (struct internal_reloc *) bfd_malloc (amt); amt = o->reloc_count; amt *= sizeof (struct coff_link_hash_entry *); - finfo.section_info[o->target_index].rel_hashes = + flaginfo.section_info[o->target_index].rel_hashes = (struct coff_link_hash_entry **) bfd_malloc (amt); - if (finfo.section_info[o->target_index].relocs == NULL - || finfo.section_info[o->target_index].rel_hashes == NULL) + if (flaginfo.section_info[o->target_index].relocs == NULL + || flaginfo.section_info[o->target_index].rel_hashes == NULL) goto error_return; if (o->reloc_count > max_output_reloc_count) @@ -2240,7 +2148,7 @@ ppc_bfd_coff_final_link (abfd, info) the opportunity to clear the output_has_begun fields of all the input BFD's. */ max_sym_count = 0; - for (sub = info->input_bfds; sub != NULL; sub = sub->link_next) + for (sub = info->input_bfds; sub != NULL; sub = sub->link.next) { bfd_size_type sz; @@ -2252,31 +2160,31 @@ ppc_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); + flaginfo.internal_syms = (struct internal_syment *) bfd_malloc (amt); amt = max_sym_count * sizeof (asection *); - finfo.sec_ptrs = (asection **) bfd_malloc (amt); + flaginfo.sec_ptrs = (asection **) bfd_malloc (amt); amt = max_sym_count * sizeof (long); - finfo.sym_indices = (long *) bfd_malloc (amt); + flaginfo.sym_indices = (long *) bfd_malloc (amt); amt = (max_sym_count + 1) * symesz; - finfo.outsyms = (bfd_byte *) bfd_malloc (amt); + flaginfo.outsyms = (bfd_byte *) bfd_malloc (amt); 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.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz); - if (! info->relocatable) + flaginfo.linenos = (bfd_byte *) bfd_malloc (amt); + flaginfo.contents = (bfd_byte *) bfd_malloc (max_contents_size); + flaginfo.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz); + if (! bfd_link_relocatable (info)) { amt = max_reloc_count * sizeof (struct internal_reloc); - finfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt); + flaginfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt); } - if ((finfo.internal_syms == NULL && max_sym_count > 0) - || (finfo.sec_ptrs == NULL && max_sym_count > 0) - || (finfo.sym_indices == NULL && max_sym_count > 0) - || finfo.outsyms == NULL - || (finfo.linenos == NULL && max_lineno_count > 0) - || (finfo.contents == NULL && max_contents_size > 0) - || (finfo.external_relocs == NULL && max_reloc_count > 0) - || (! info->relocatable - && finfo.internal_relocs == NULL + if ((flaginfo.internal_syms == NULL && max_sym_count > 0) + || (flaginfo.sec_ptrs == NULL && max_sym_count > 0) + || (flaginfo.sym_indices == NULL && max_sym_count > 0) + || flaginfo.outsyms == NULL + || (flaginfo.linenos == NULL && max_lineno_count > 0) + || (flaginfo.contents == NULL && max_contents_size > 0) + || (flaginfo.external_relocs == NULL && max_reloc_count > 0) + || (! bfd_link_relocatable (info) + && flaginfo.internal_relocs == NULL && max_reloc_count > 0)) goto error_return; @@ -2295,7 +2203,7 @@ ppc_bfd_coff_final_link (abfd, info) for (o = abfd->sections; o != NULL; o = o->next) { - for (p = o->link_order_head; p != NULL; p = p->next) + for (p = o->map_head.link_order; p != NULL; p = p->next) { if (p->type == bfd_indirect_link_order && (bfd_get_flavour (p->u.indirect.section->owner) @@ -2308,7 +2216,7 @@ ppc_bfd_coff_final_link (abfd, info) if (! sub->output_has_begun) #endif { - if (! _bfd_coff_link_input_bfd (&finfo, sub)) + if (! _bfd_coff_link_input_bfd (&flaginfo, sub)) goto error_return; sub->output_has_begun = TRUE; } @@ -2316,7 +2224,7 @@ ppc_bfd_coff_final_link (abfd, info) else if (p->type == bfd_section_reloc_link_order || p->type == bfd_symbol_reloc_link_order) { - if (! _bfd_coff_reloc_link_order (abfd, &finfo, o, p)) + if (! _bfd_coff_reloc_link_order (abfd, &flaginfo, o, p)) goto error_return; } else @@ -2332,7 +2240,7 @@ ppc_bfd_coff_final_link (abfd, info) bfd* last_one = ppc_get_last(); if (last_one) { - if (! _bfd_coff_link_input_bfd (&finfo, last_one)) + if (! _bfd_coff_link_input_bfd (&flaginfo, last_one)) goto error_return; } last_one->output_has_begun = TRUE; @@ -2340,77 +2248,76 @@ ppc_bfd_coff_final_link (abfd, info) #endif /* Free up the buffers used by _bfd_coff_link_input_bfd. */ - coff_debug_merge_hash_table_free (&finfo.debug_merge); + coff_debug_merge_hash_table_free (&flaginfo.debug_merge); debug_merge_allocated = FALSE; - if (finfo.internal_syms != NULL) + if (flaginfo.internal_syms != NULL) { - free (finfo.internal_syms); - finfo.internal_syms = NULL; + free (flaginfo.internal_syms); + flaginfo.internal_syms = NULL; } - if (finfo.sec_ptrs != NULL) + if (flaginfo.sec_ptrs != NULL) { - free (finfo.sec_ptrs); - finfo.sec_ptrs = NULL; + free (flaginfo.sec_ptrs); + flaginfo.sec_ptrs = NULL; } - if (finfo.sym_indices != NULL) + if (flaginfo.sym_indices != NULL) { - free (finfo.sym_indices); - finfo.sym_indices = NULL; + free (flaginfo.sym_indices); + flaginfo.sym_indices = NULL; } - if (finfo.linenos != NULL) + if (flaginfo.linenos != NULL) { - free (finfo.linenos); - finfo.linenos = NULL; + free (flaginfo.linenos); + flaginfo.linenos = NULL; } - if (finfo.contents != NULL) + if (flaginfo.contents != NULL) { - free (finfo.contents); - finfo.contents = NULL; + free (flaginfo.contents); + flaginfo.contents = NULL; } - if (finfo.external_relocs != NULL) + if (flaginfo.external_relocs != NULL) { - free (finfo.external_relocs); - finfo.external_relocs = NULL; + free (flaginfo.external_relocs); + flaginfo.external_relocs = NULL; } - if (finfo.internal_relocs != NULL) + if (flaginfo.internal_relocs != NULL) { - free (finfo.internal_relocs); - finfo.internal_relocs = NULL; + free (flaginfo.internal_relocs); + flaginfo.internal_relocs = NULL; } /* The value of the last C_FILE symbol is supposed to be the symbol index of the first external symbol. Write it out again if necessary. */ - if (finfo.last_file_index != -1 - && (unsigned int) finfo.last_file.n_value != obj_raw_syment_count (abfd)) + if (flaginfo.last_file_index != -1 + && (unsigned int) flaginfo.last_file.n_value != obj_raw_syment_count (abfd)) { 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); - pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz; + flaginfo.last_file.n_value = obj_raw_syment_count (abfd); + bfd_coff_swap_sym_out (abfd, &flaginfo.last_file, + flaginfo.outsyms); + pos = obj_sym_filepos (abfd) + flaginfo.last_file_index * symesz; if (bfd_seek (abfd, pos, SEEK_SET) != 0 - || bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz) + || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz) return FALSE; } /* Write out the global symbols. */ - finfo.failed = FALSE; - coff_link_hash_traverse (coff_hash_table (info), _bfd_coff_write_global_sym, - (PTR) &finfo); - if (finfo.failed) + flaginfo.failed = FALSE; + bfd_hash_traverse (&info->hash->table, _bfd_coff_write_global_sym, &flaginfo); + if (flaginfo.failed) goto error_return; /* The outsyms buffer is used by _bfd_coff_write_global_sym. */ - if (finfo.outsyms != NULL) + if (flaginfo.outsyms != NULL) { - free (finfo.outsyms); - finfo.outsyms = NULL; + free (flaginfo.outsyms); + flaginfo.outsyms = NULL; } - if (info->relocatable) + if (bfd_link_relocatable (info)) { /* Now that we have written out all the global symbols, we know the symbol indices to use for relocs against them, and we can @@ -2430,9 +2337,9 @@ ppc_bfd_coff_final_link (abfd, info) if (o->reloc_count == 0) continue; - irel = finfo.section_info[o->target_index].relocs; + irel = flaginfo.section_info[o->target_index].relocs; irelend = irel + o->reloc_count; - rel_hash = finfo.section_info[o->target_index].rel_hashes; + rel_hash = flaginfo.section_info[o->target_index].rel_hashes; erel = external_relocs; for (; irel < irelend; irel++, rel_hash++, erel += relsz) { @@ -2441,12 +2348,12 @@ ppc_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); } amt = relsz * o->reloc_count; if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0 - || bfd_bwrite ((PTR) external_relocs, amt, abfd) != amt) + || bfd_bwrite (external_relocs, amt, abfd) != amt) goto error_return; } @@ -2455,19 +2362,19 @@ ppc_bfd_coff_final_link (abfd, info) } /* Free up the section information. */ - if (finfo.section_info != NULL) + if (flaginfo.section_info != NULL) { unsigned int i; for (i = 0; i < abfd->section_count; i++) { - if (finfo.section_info[i].relocs != NULL) - free (finfo.section_info[i].relocs); - if (finfo.section_info[i].rel_hashes != NULL) - free (finfo.section_info[i].rel_hashes); + if (flaginfo.section_info[i].relocs != NULL) + free (flaginfo.section_info[i].relocs); + if (flaginfo.section_info[i].rel_hashes != NULL) + free (flaginfo.section_info[i].rel_hashes); } - free (finfo.section_info); - finfo.section_info = NULL; + free (flaginfo.section_info); + flaginfo.section_info = NULL; } /* If we have optimized stabs strings, output them. */ @@ -2488,7 +2395,7 @@ ppc_bfd_coff_final_link (abfd, info) #if STRING_SIZE_SIZE == 4 H_PUT_32 (abfd, - _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE, + _bfd_stringtab_size (flaginfo.strtab) + STRING_SIZE_SIZE, strbuf); #else #error Change H_PUT_32 above @@ -2498,11 +2405,11 @@ ppc_bfd_coff_final_link (abfd, info) != STRING_SIZE_SIZE) return FALSE; - if (! _bfd_stringtab_emit (abfd, finfo.strtab)) + if (! _bfd_stringtab_emit (abfd, flaginfo.strtab)) return FALSE; } - _bfd_stringtab_free (finfo.strtab); + _bfd_stringtab_free (flaginfo.strtab); /* Setting bfd_get_symcount to 0 will cause write_object_contents to not try to write out the symbols. */ @@ -2512,38 +2419,38 @@ ppc_bfd_coff_final_link (abfd, info) error_return: if (debug_merge_allocated) - coff_debug_merge_hash_table_free (&finfo.debug_merge); - if (finfo.strtab != NULL) - _bfd_stringtab_free (finfo.strtab); - if (finfo.section_info != NULL) + coff_debug_merge_hash_table_free (&flaginfo.debug_merge); + if (flaginfo.strtab != NULL) + _bfd_stringtab_free (flaginfo.strtab); + if (flaginfo.section_info != NULL) { unsigned int i; for (i = 0; i < abfd->section_count; i++) { - if (finfo.section_info[i].relocs != NULL) - free (finfo.section_info[i].relocs); - if (finfo.section_info[i].rel_hashes != NULL) - free (finfo.section_info[i].rel_hashes); + if (flaginfo.section_info[i].relocs != NULL) + free (flaginfo.section_info[i].relocs); + if (flaginfo.section_info[i].rel_hashes != NULL) + free (flaginfo.section_info[i].rel_hashes); } - free (finfo.section_info); + free (flaginfo.section_info); } - if (finfo.internal_syms != NULL) - free (finfo.internal_syms); - if (finfo.sec_ptrs != NULL) - free (finfo.sec_ptrs); - if (finfo.sym_indices != NULL) - free (finfo.sym_indices); - if (finfo.outsyms != NULL) - free (finfo.outsyms); - if (finfo.linenos != NULL) - free (finfo.linenos); - if (finfo.contents != NULL) - free (finfo.contents); - if (finfo.external_relocs != NULL) - free (finfo.external_relocs); - if (finfo.internal_relocs != NULL) - free (finfo.internal_relocs); + if (flaginfo.internal_syms != NULL) + free (flaginfo.internal_syms); + if (flaginfo.sec_ptrs != NULL) + free (flaginfo.sec_ptrs); + if (flaginfo.sym_indices != NULL) + free (flaginfo.sym_indices); + if (flaginfo.outsyms != NULL) + free (flaginfo.outsyms); + if (flaginfo.linenos != NULL) + free (flaginfo.linenos); + if (flaginfo.contents != NULL) + free (flaginfo.contents); + if (flaginfo.external_relocs != NULL) + free (flaginfo.external_relocs); + if (flaginfo.internal_relocs != NULL) + free (flaginfo.internal_relocs); if (external_relocs != NULL) free (external_relocs); return FALSE; @@ -2570,15 +2477,17 @@ const bfd_target TARGET_LITTLE_SYM = HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED), #ifndef COFF_WITH_PE - (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ + (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY + | SEC_RELOC), /* section flags */ #else - (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */ - | SEC_LINK_ONCE | SEC_LINK_DUPLICATES), + (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY + | SEC_RELOC | SEC_LINK_ONCE | SEC_LINK_DUPLICATES), #endif 0, /* leading char */ '/', /* ar_pad_char */ 15, /* ar_max_namelen??? FIXMEmgo */ + 0, /* match priority. */ bfd_getl64, bfd_getl_signed_64, bfd_putl64, bfd_getl32, bfd_getl_signed_32, bfd_putl32, @@ -2629,15 +2538,17 @@ const bfd_target TARGET_BIG_SYM = HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED), #ifndef COFF_WITH_PE - (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ + (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY + | SEC_RELOC), /* section flags */ #else - (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC /* section flags */ - | SEC_LINK_ONCE | SEC_LINK_DUPLICATES), + (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY + | SEC_RELOC | SEC_LINK_ONCE | SEC_LINK_DUPLICATES), #endif 0, /* leading char */ '/', /* ar_pad_char */ 15, /* ar_max_namelen??? FIXMEmgo */ + 0, /* match priority. */ bfd_getb64, bfd_getb_signed_64, bfd_putb64, bfd_getb32, bfd_getb_signed_32, bfd_putb32,