Fixes problems building the V850 simulator introduced with the previous delta.
[deliverable/binutils-gdb.git] / bfd / coff-ppc.c
index 28d7985bfea182168a50d782f6b9e46ab9e69bea..237980d6a84f8a36e863d08f9c4fd6ea8d4c1e68 100644 (file)
@@ -1,7 +1,5 @@
 /* BFD back-end for PowerPC Microsoft Portable Executable files.
 /* 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
-   Free Software Foundation, Inc.
+   Copyright (C) 1990-2015 Free Software Foundation, Inc.
 
    Original version pieced together by Kim Knuttila (krk@cygnus.com)
 
 
    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
 
    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,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -23,8 +21,8 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
 
    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,
-   Boston, MA 02111-1307, USA.  */
+   Foundation, 51 Franklin Street - Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
 
 /* Current State:
    - objdump works
 
 /* Current State:
    - objdump works
@@ -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.  */
 
    - 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 "sysdep.h"
-
+#include "bfd.h"
 #include "libbfd.h"
 
 #include "coff/powerpc.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.  */
 
 /* 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
 
 /* 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.  */
 };
 
   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 *
 /* 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;
 {
   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
 /* 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 *
 }
 
 /* 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);
 {
   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;
   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;
     {
       free (ret);
       return (struct bfd_link_hash_table *) NULL;
@@ -319,78 +297,24 @@ ppc_coff_link_hash_table_create (abfd)
 /* Static helper functions to make relocation work.  */
 /* (Work In Progress) */
 
 /* 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));
-#if 0
-static bfd_reloc_status_type ppc_reflo_reloc PARAMS ((bfd *abfd,
-                                                     arelent *reloc,
-                                                     asymbol *symbol,
-                                                     PTR data,
-                                                     asection *section,
-                                                     bfd *output_bfd,
-                                                     char **error));
-#endif
-static bfd_reloc_status_type ppc_pair_reloc PARAMS ((bfd *abfd,
-                                                    arelent *reloc,
-                                                    asymbol *symbol,
-                                                    PTR data,
-                                                    asection *section,
-                                                    bfd *output_bfd,
-                                                    char **error));
-\f
-static bfd_reloc_status_type ppc_toc16_reloc PARAMS ((bfd *abfd,
-                                                     arelent *reloc,
-                                                     asymbol *symbol,
-                                                     PTR data,
-                                                     asection *section,
-                                                     bfd *output_bfd,
-                                                     char **error));
-
-#if 0
-static bfd_reloc_status_type ppc_addr32nb_reloc PARAMS ((bfd *abfd,
-                                                        arelent *reloc,
-                                                        asymbol *symbol,
-                                                        PTR data,
-                                                        asection *section,
-                                                        bfd *output_bfd,
-                                                        char **error));
-#endif
-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));
-\f
+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.  */
 
 /* 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:
 
 
    From the document "" we find the following listed as used relocs:
 
@@ -839,15 +763,11 @@ struct list_ele
 extern struct list_ele *head;
 extern struct list_ele *tail;
 
 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
 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);
 {
   /* Add this entry to our toc addr-offset-name list.  */
   bfd_size_type amt = sizeof (struct list_ele);
@@ -875,23 +795,15 @@ record_toc (toc_section, our_toc_offset, cat, name)
 
 #ifdef COFF_IMAGE_WITH_PE
 
 
 #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
 /* 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;
 {
   struct ppc_coff_link_hash_entry *h;
-  const char *name;
-
   int *local_syms;
 
   h = 0;
   int *local_syms;
 
   h = 0;
@@ -940,8 +852,6 @@ ppc_record_toc_entry(abfd, info, sec, sym, toc_kind)
     }
   else
     {
     }
   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))
       /* 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))
@@ -964,10 +874,9 @@ ppc_record_toc_entry(abfd, info, sec, sym, toc_kind)
 
 /* Record a toc offset against a symbol.  */
 static void
 
 /* 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;
 
 {
   struct ppc_coff_link_hash_entry *h;
 
@@ -986,9 +895,9 @@ ppc_mark_symbol_as_glue(abfd, sym, rel)
 /* Return TRUE if this relocation should
    appear in the output .reloc section.  */
 
 /* 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)
 {
   return
     (! howto->pc_relative)
@@ -1005,85 +914,32 @@ static bfd_boolean in_reloc_p(abfd, howto)
       && (howto->type != IMAGE_REL_PPC_TOCREL16_DEFN) ;
 }
 
       && (howto->type != IMAGE_REL_PPC_TOCREL16_DEFN) ;
 }
 
-#if 0
-
-/* This function is in charge of performing all the ppc PE relocations
-   Don't yet know if we want to do this this particular way ... (krk).  */
-/* FIXME: (it is not yet enabled).  */
-
-static bfd_reloc_status_type
-pe_ppc_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
-             error_message)
-     bfd *abfd;
-     arelent *reloc_entry;
-     asymbol *symbol_in;
-     PTR data;
-     asection *input_section;
-     bfd *output_bfd;
-     char **error_message;
+static bfd_boolean
+write_base_file_entry (bfd *obfd, struct bfd_link_info *info, bfd_vma addr)
 {
 {
-  /* The consth relocation comes in two parts, we have to remember
-     the state between calls, in these variables.  */
-  static bfd_boolean part1_consth_active = FALSE;
-  static unsigned long part1_consth_value;
-
-  unsigned long sym_value;
-  unsigned short r_type;
-  unsigned long addr = reloc_entry->address ; /*+ input_section->vma*/
-
-  r_type = reloc_entry->howto->type;
-
-  if (output_bfd)
-    {
-      /* Partial linking - do nothing.  */
-      reloc_entry->address += input_section->output_offset;
-      return bfd_reloc_ok;
-    }
-
-  if (symbol_in != NULL
-      && bfd_is_und_section (symbol_in->section))
-    {
-      /* Keep the state machine happy in case we're called again.  */
-      if (r_type == IMAGE_REL_PPC_REFHI)
-       {
-         part1_consth_active = TRUE;
-         part1_consth_value  = 0;
-       }
-      return(bfd_reloc_undefined);
-    }
-
-  if ((part1_consth_active) && (r_type != IMAGE_REL_PPC_PAIR))
-    {
-      part1_consth_active = FALSE;
-      *error_message = (char *) _("Missing PAIR");
-      return(bfd_reloc_dangerous);
-    }
-
-  sym_value = get_symbol_value(symbol_in);
+  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;
 
 
-  return(bfd_reloc_ok);
+  bfd_set_error (bfd_error_system_call);
+  return FALSE;
 }
 
 }
 
-#endif /* 0 */
-
 /* The reloc processing routine for the optimized COFF linker.  */
 
 static bfd_boolean
 /* 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;
 {
   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;
   asection *toc_section = 0;
   bfd_vma relocation;
   reloc_howto_type *howto = 0;
@@ -1094,9 +950,6 @@ coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section,
   if (info->relocatable)
     return TRUE;
 
   if (info->relocatable)
     return TRUE;
 
-  hihalf = FALSE;
-  hihalf_val = 0;
-
   rel = relocs;
   relend = rel + input_section->reloc_count;
   for (; rel < relend; rel++)
   rel = relocs;
   relend = rel + input_section->reloc_count;
   for (; rel < relend; rel++)
@@ -1220,10 +1073,11 @@ coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section,
              {
                /* It is a file local symbol.  */
                int *local_toc_table;
              {
                /* It is a file local symbol.  */
                int *local_toc_table;
-               const char *name;
+               char name[SYMNMLEN + 1];
 
                sym = syms + symndx;
 
                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];
 
                local_toc_table = obj_coff_local_toc_table(input_bfd);
                our_toc_offset = local_toc_table[symndx];
@@ -1321,10 +1175,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);
 
                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.  */
              }
 
            /* FIXME: this test is conservative.  */
@@ -1347,19 +1199,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.
          {
            /* 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.  */
               the reloc contains the required toc restore instruction.  */
-           bfd_vma x;
-           const char *my_name;
-           
            DUMP_RELOC2 (howto->name, rel);
 
            if (h != 0)
              {
            DUMP_RELOC2 (howto->name, rel);
 
            if (h != 0)
              {
-               my_name = h->root.root.root.string;
                if (h->symbol_is_glue == 1)
                  {
                if (h->symbol_is_glue == 1)
                  {
-                   x = bfd_get_32 (input_bfd, loc);
                    bfd_put_32 (input_bfd, (bfd_vma) h->glue_insn, loc);
                  }
              }
                    bfd_put_32 (input_bfd, (bfd_vma) h->glue_insn, loc);
                  }
              }
@@ -1379,9 +1226,14 @@ coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section,
        case IMAGE_REL_PPC_ABSOLUTE:
          {
            const char *my_name;
        case IMAGE_REL_PPC_ABSOLUTE:
          {
            const char *my_name;
+           char buf[SYMNMLEN + 1];
 
            if (h == 0)
 
            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;
 
            else
              my_name = h->root.root.root.string;
 
@@ -1415,7 +1267,7 @@ coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section,
 
            DUMP_RELOC2 (howto->name, rel);
 
 
            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;
              {
                /* Set magic values.  */
                int idata5offset;
@@ -1442,11 +1294,8 @@ coff_ppc_relocate_section (output_bfd, info, input_bfd, input_section,
              }
 
            if (h == 0)
              }
 
            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;
            else
              {
                char *target = 0;
@@ -1537,15 +1386,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.  */
              /* 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;
-
-             if (coff_data (output_bfd)->pe)
-               addr -= pe_data (output_bfd)->pe_opthdr.ImageBase;
+             bfd_vma addr = (rel->r_vaddr
+                             - input_section->vma
+                             + input_section->output_offset
+                             + input_section->output_section->vma);
 
 
-             fwrite (&addr, 1,4, (FILE *) info->base_file);
+             if (!write_base_file_entry (output_bfd, info, addr))
+               return FALSE;
            }
        }
 
            }
        }
 
@@ -1613,15 +1460,14 @@ static char *
 h3 = N_(" Offset  spelling                   (if present)\n");
 
 void
 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;
 
 {
   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)
     {
 
   for (t = head; t != 0; t=t->next)
     {
@@ -1642,8 +1488,8 @@ dump_toc (vfile)
            {
              fprintf (file,
                      _("**** global_toc_size %ld(%lx), thunk_size %ld(%lx)\n"),
            {
              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!");
            }
        }
              cat = _("Out of bounds!");
            }
        }
@@ -1660,8 +1506,7 @@ dump_toc (vfile)
 }
 
 bfd_boolean
 }
 
 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;
 {
   asection *s;
   bfd_byte *foo;
@@ -1691,9 +1536,8 @@ ppc_allocate_toc_section (info)
 }
 
 bfd_boolean
 }
 
 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;
 {
   asection *sec;
   struct internal_reloc *i, *rel;
@@ -1754,15 +1598,13 @@ ppc_process_before_allocation (abfd, info)
 #endif
 
 static bfd_reloc_status_type
 #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);
 {
   UN_IMPL("REFHI");
   DUMP_RELOC("REFHI",reloc_entry);
@@ -1773,40 +1615,14 @@ ppc_refhi_reloc (abfd, reloc_entry, symbol, data,
   return bfd_reloc_undefined;
 }
 
   return bfd_reloc_undefined;
 }
 
-#if 0
-
-static bfd_reloc_status_type
-ppc_reflo_reloc (abfd, reloc_entry, symbol, data,
-                input_section, output_bfd, error_message)
-     bfd *abfd;
-     arelent *reloc_entry;
-     asymbol *symbol;
-     PTR data;
-     asection *input_section;
-     bfd *output_bfd;
-     char **error_message;
-{
-  UN_IMPL("REFLO");
-  DUMP_RELOC("REFLO",reloc_entry);
-
-  if (output_bfd == (bfd *) NULL)
-    return bfd_reloc_continue;
-
-  return bfd_reloc_undefined;
-}
-
-#endif
-
 static bfd_reloc_status_type
 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);
 {
   UN_IMPL("PAIR");
   DUMP_RELOC("PAIR",reloc_entry);
@@ -1816,17 +1632,15 @@ ppc_pair_reloc (abfd, reloc_entry, symbol, data,
 
   return bfd_reloc_undefined;
 }
 
   return bfd_reloc_undefined;
 }
-\f
+
 static bfd_reloc_status_type
 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);
 {
   UN_IMPL ("TOCREL16");
   DUMP_RELOC ("TOCREL16",reloc_entry);
@@ -1837,41 +1651,14 @@ ppc_toc16_reloc (abfd, reloc_entry, symbol, data,
   return bfd_reloc_ok;
 }
 
   return bfd_reloc_ok;
 }
 
-#if 0
-
-/* ADDR32NB : 32 bit address relative to the virtual origin.
-              (On the alpha, this is always a linker generated thunk)
-              (i.e. 32bit addr relative to the image base).  */
-
-static bfd_reloc_status_type
-ppc_addr32nb_reloc (abfd, reloc_entry, symbol, data,
-                   input_section, output_bfd, error_message)
-     bfd *abfd;
-     arelent *reloc_entry;
-     asymbol *symbol;
-     PTR data;
-     asection *input_section;
-     bfd *output_bfd;
-     char **error_message;
-{
-  UN_IMPL("ADDR32NB");
-  DUMP_RELOC("ADDR32NB",reloc_entry);
-
-  return bfd_reloc_ok;
-}
-
-#endif
-
 static bfd_reloc_status_type
 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);
 {
   UN_IMPL("SECREL");
   DUMP_RELOC("SECREL",reloc_entry);
@@ -1883,15 +1670,13 @@ ppc_secrel_reloc (abfd, reloc_entry, symbol, data,
 }
 
 static bfd_reloc_status_type
 }
 
 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);
 {
   UN_IMPL("SECTION");
   DUMP_RELOC("SECTION",reloc_entry);
@@ -1903,15 +1688,14 @@ ppc_section_reloc (abfd, reloc_entry, symbol, data,
 }
 
 static bfd_reloc_status_type
 }
 
 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);
 {
   UN_IMPL("IMGLUE");
   DUMP_RELOC("IMGLUE",reloc_entry);
@@ -1928,12 +1712,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.  */
 /* 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
 
 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:
 {
   /* We can encode one of three things in the type field, aside from the
      type:
@@ -1982,10 +1763,9 @@ ppc_coff_rtype2howto (relent, internal)
        howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16;
       break;
     default:
        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;
     }
       howto = ppc_coff_howto_table + r_type;
       break;
     }
@@ -1994,13 +1774,12 @@ ppc_coff_rtype2howto (relent, internal)
 }
 
 static reloc_howto_type *
 }
 
 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;
 
 {
   reloc_howto_type *howto;
 
@@ -2055,10 +1834,9 @@ coff_ppc_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
       howto = ppc_coff_howto_table + r_type;
       break;
     default:
       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;
     }
       howto = ppc_coff_howto_table + r_type;
       break;
     }
@@ -2070,13 +1848,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]
 
 #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 *
 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)
     {
 {
   switch (code)
     {
@@ -2093,8 +1867,23 @@ ppc_coff_reloc_type_lookup (abfd, code)
       return NULL;
     }
 }
       return NULL;
     }
 }
-
 #undef HOW2MAP
 #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;
+}
 \f
 /* Tailor coffcode.h -- macro heaven.  */
 
 \f
 /* Tailor coffcode.h -- macro heaven.  */
 
@@ -2103,15 +1892,12 @@ 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
 /* 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
 
 #ifndef COFF_IMAGE_WITH_PE
 #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
 
 #ifndef COFF_IMAGE_WITH_PE
-/* FIXME: This no longer works.  */
-#if 0
-#define coff_swap_sym_in_hook        ppc_coff_swap_sym_in_hook
-#endif
 #endif
 
 #define SELECT_RELOC(internal, howto) {internal.r_type=howto->type;}
 #endif
 
 #define SELECT_RELOC(internal, howto) {internal.r_type=howto->type;}
@@ -2140,69 +1926,9 @@ ppc_coff_reloc_type_lookup (abfd, code)
 #include "coffcode.h"
 \f
 #ifndef COFF_IMAGE_WITH_PE
 #include "coffcode.h"
 \f
 #ifndef COFF_IMAGE_WITH_PE
-/* FIXME: This no longer works.  */
-#if 0
-/* FIXME:
-   What we're trying to do here is allocate a toc section (early), and attach
-   it to the last bfd to be processed. This avoids the problem of having a toc
-   written out before all files have been processed. This code allocates
-   a toc section for every file, and records the last one seen. There are
-   at least two problems with this approach:
-   1. We allocate whole bunches of toc sections that are ignored, but at
-      at least we will not allocate a toc if no .toc is present.
-   2. It's not clear to me that being the last bfd read necessarily means
-      that you are the last bfd closed.
-   3. Doing it on a "swap in" hook depends on when the "swap in" is called,
-      and how often, etc. It's not clear to me that there isn't a hole here.  */
-static void ppc_coff_swap_sym_in_hook PARAMS ((bfd *, PTR, PTR));
-
-static void
-ppc_coff_swap_sym_in_hook (abfd, ext1, in1)
-     bfd            *abfd;
-     PTR ext1 ATTRIBUTE_UNUSED;
-     PTR in1;
-{
-  struct internal_syment * in = (struct internal_syment *)in1;
-
-  if (bfd_of_toc_owner != 0) /* We already have a toc, so go home.  */
-    return;
-
-  if (strcmp (in->_n._n_name, ".toc") == 0)
-    {
-      flagword flags;
-      register asection *s;
-
-      s = bfd_get_section_by_name (abfd, TOC_SECTION_NAME);
-      if (s != NULL)
-       return;
-
-      flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY ;
-
-      s = bfd_make_section (abfd, TOC_SECTION_NAME);
-
-      if (s == NULL
-         || !bfd_set_section_flags (abfd, s, flags)
-         || !bfd_set_section_alignment (abfd, s, 2))
-       /* FIXME: set appropriate bfd error.  */
-       abort ();
-
-      /* Save the bfd for later allocation.  */
-      bfd_of_toc_owner = abfd;
-    }
-
-  return;
-}
-#endif
-#endif
-
-#ifndef COFF_IMAGE_WITH_PE
-
-static bfd_boolean ppc_do_last PARAMS ((bfd *));
-static bfd *ppc_get_last PARAMS ((void));
 
 static bfd_boolean
 
 static bfd_boolean
-ppc_do_last (abfd)
-     bfd *abfd;
+ppc_do_last (bfd *abfd)
 {
   if (abfd == bfd_of_toc_owner)
     return TRUE;
 {
   if (abfd == bfd_of_toc_owner)
     return TRUE;
@@ -2211,7 +1937,7 @@ ppc_do_last (abfd)
 }
 
 static bfd *
 }
 
 static bfd *
-ppc_get_last()
+ppc_get_last (void)
 {
   return bfd_of_toc_owner;
 }
 {
   return bfd_of_toc_owner;
 }
@@ -2230,12 +1956,10 @@ ppc_get_last()
 /* Do the final link step.  */
 
 bfd_boolean
 /* 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;
 {
   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;
   bfd_boolean debug_merge_allocated;
   asection *o;
   struct bfd_link_order *p;
@@ -2255,29 +1979,29 @@ ppc_bfd_coff_final_link (abfd, info)
 
   symesz = bfd_coff_symesz (abfd);
 
 
   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;
 
   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;
 
     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;
 
     goto error_return;
   debug_merge_allocated = TRUE;
 
@@ -2301,7 +2025,7 @@ ppc_bfd_coff_final_link (abfd, info)
       o->reloc_count = 0;
       o->lineno_count = 0;
 
       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)
            {
        {
          if (p->type == bfd_indirect_link_order)
            {
@@ -2356,15 +2080,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);
          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++)
        {
        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;
        }
     }
 
        }
     }
 
@@ -2402,14 +2126,14 @@ ppc_bfd_coff_final_link (abfd, info)
          BFD_ASSERT (info->relocatable);
          amt = o->reloc_count;
          amt *= sizeof (struct internal_reloc);
          BFD_ASSERT (info->relocatable);
          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 *);
            (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);
            (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)
            goto error_return;
 
          if (o->reloc_count > max_output_reloc_count)
@@ -2428,7 +2152,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;
      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;
 
     {
       bfd_size_type sz;
 
@@ -2440,31 +2164,31 @@ ppc_bfd_coff_final_link (abfd, info)
 
   /* Allocate some buffers used while linking.  */
   amt = max_sym_count * sizeof (struct internal_syment);
 
   /* 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 *);
   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);
   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;
   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);
   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);
+  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 (! info->relocatable)
     {
       amt = max_reloc_count * sizeof (struct internal_reloc);
   if (! info->relocatable)
     {
       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)
+  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)
       || (! info->relocatable
       || (! info->relocatable
-         && finfo.internal_relocs == NULL
+         && flaginfo.internal_relocs == NULL
          && max_reloc_count > 0))
     goto error_return;
 
          && max_reloc_count > 0))
     goto error_return;
 
@@ -2483,7 +2207,7 @@ ppc_bfd_coff_final_link (abfd, info)
 
   for (o = abfd->sections; o != NULL; o = o->next)
     {
 
   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)
        {
          if (p->type == bfd_indirect_link_order
              && (bfd_get_flavour (p->u.indirect.section->owner)
@@ -2496,7 +2220,7 @@ ppc_bfd_coff_final_link (abfd, info)
              if (! sub->output_has_begun)
 #endif
                {
              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;
                }
                    goto error_return;
                  sub->output_has_begun = TRUE;
                }
@@ -2504,7 +2228,7 @@ ppc_bfd_coff_final_link (abfd, info)
          else if (p->type == bfd_section_reloc_link_order
                   || p->type == bfd_symbol_reloc_link_order)
            {
          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
                goto error_return;
            }
          else
@@ -2520,7 +2244,7 @@ ppc_bfd_coff_final_link (abfd, info)
     bfd* last_one = ppc_get_last();
     if (last_one)
       {
     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;
          goto error_return;
       }
     last_one->output_has_begun = TRUE;
@@ -2528,74 +2252,73 @@ ppc_bfd_coff_final_link (abfd, info)
 #endif
 
   /* Free up the buffers used by _bfd_coff_link_input_bfd.  */
 #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;
 
   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.  */
     }
 
   /* 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;
 
     {
       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
       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.  */
        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.  */
     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 (info->relocatable)
@@ -2618,9 +2341,9 @@ ppc_bfd_coff_final_link (abfd, info)
          if (o->reloc_count == 0)
            continue;
 
          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;
          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)
            {
          erel = external_relocs;
          for (; irel < irelend; irel++, rel_hash++, erel += relsz)
            {
@@ -2629,12 +2352,12 @@ ppc_bfd_coff_final_link (abfd, info)
                  BFD_ASSERT ((*rel_hash)->indx >= 0);
                  irel->r_symndx = (*rel_hash)->indx;
                }
                  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
            }
 
          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;
        }
 
            goto error_return;
        }
 
@@ -2643,19 +2366,19 @@ ppc_bfd_coff_final_link (abfd, info)
     }
 
   /* Free up the section information.  */
     }
 
   /* 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++)
        {
     {
       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.  */
     }
 
   /* If we have optimized stabs strings, output them.  */
@@ -2676,7 +2399,7 @@ ppc_bfd_coff_final_link (abfd, info)
 
 #if STRING_SIZE_SIZE == 4
       H_PUT_32 (abfd,
 
 #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
                strbuf);
 #else
  #error Change H_PUT_32 above
@@ -2686,11 +2409,11 @@ ppc_bfd_coff_final_link (abfd, info)
          != STRING_SIZE_SIZE)
        return FALSE;
 
          != STRING_SIZE_SIZE)
        return FALSE;
 
-      if (! _bfd_stringtab_emit (abfd, finfo.strtab))
+      if (! _bfd_stringtab_emit (abfd, flaginfo.strtab))
        return FALSE;
     }
 
        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.  */
 
   /* Setting bfd_get_symcount to 0 will cause write_object_contents to
      not try to write out the symbols.  */
@@ -2700,38 +2423,38 @@ ppc_bfd_coff_final_link (abfd, info)
 
  error_return:
   if (debug_merge_allocated)
 
  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++)
        {
     {
       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;
   if (external_relocs != NULL)
     free (external_relocs);
   return FALSE;
@@ -2758,15 +2481,17 @@ const bfd_target TARGET_LITTLE_SYM =
    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
 
 #ifndef COFF_WITH_PE
    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
 #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 */
 #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,
 
   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
@@ -2817,15 +2542,17 @@ const bfd_target TARGET_BIG_SYM =
    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
 
 #ifndef COFF_WITH_PE
    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
 #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 */
 #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,
 
   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
This page took 0.061768 seconds and 4 git commands to generate.