Automatic date update in version.in

[platform/upstream/binutils.git] / bfd / cofflink.c

diff --git a/bfd/cofflink.c b/bfd/cofflink.c
index 151b1ff..2782795 100644 (file)
--- a/bfd/cofflink.c
+++ b/bfd/cofflink.c
@@ -1,13 +1,12 @@
 /* COFF specific linker code.
 /* COFF specific linker code.

-   Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
-   2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 1994-2014 Free Software Foundation, Inc.

    Written by Ian Lance Taylor, Cygnus Support.
 
    This file is part of BFD, the Binary File Descriptor library.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    Written by Ian Lance Taylor, Cygnus Support.
 
    This file is part of BFD, the Binary File Descriptor library.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by

-   the Free Software Foundation; either version 2 of the License, or
+   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,


@@ -17,21 +16,24 @@
 
    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, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+   MA 02110-1301, USA.  */

 
 /* This file contains the COFF backend linker code.  */
 
 
 /* This file contains the COFF backend linker code.  */
 

-#include "bfd.h"

 #include "sysdep.h"
 #include "sysdep.h"

+#include "bfd.h"

 #include "bfdlink.h"
 #include "libbfd.h"
 #include "coff/internal.h"
 #include "libcoff.h"
 #include "safe-ctype.h"
 
 #include "bfdlink.h"
 #include "libbfd.h"
 #include "coff/internal.h"
 #include "libcoff.h"
 #include "safe-ctype.h"
 

-static bfd_boolean coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info);
-static bfd_boolean coff_link_check_archive_element (bfd *abfd, struct bfd_link_info *info, bfd_boolean *pneeded);
-static bfd_boolean coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info);
+static bfd_boolean coff_link_add_object_symbols (bfd *, struct bfd_link_info *);
+static bfd_boolean coff_link_check_archive_element
+  (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
+   bfd_boolean *);
+static bfd_boolean coff_link_add_symbols (bfd *, struct bfd_link_info *);

 
 /* Return TRUE if SYM is a weak, external symbol.  */
 #define IS_WEAK_EXTERNAL(abfd, sym)                    \
 
 /* Return TRUE if SYM is a weak, external symbol.  */
 #define IS_WEAK_EXTERNAL(abfd, sym)                    \


@@ -78,7 +80,7 @@ _bfd_coff_link_hash_newfunc (struct bfd_hash_entry *entry,
       /* Set local fields.  */
       ret->indx = -1;
       ret->type = T_NULL;
       /* Set local fields.  */
       ret->indx = -1;
       ret->type = T_NULL;

-      ret->class = C_NULL;
+      ret->symbol_class = C_NULL;

       ret->numaux = 0;
       ret->auxbfd = NULL;
       ret->aux = NULL;
       ret->numaux = 0;
       ret->auxbfd = NULL;
       ret->aux = NULL;


@@ -94,10 +96,11 @@ _bfd_coff_link_hash_table_init (struct coff_link_hash_table *table,
                                bfd *abfd,
                                struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
                                                                   struct bfd_hash_table *,
                                bfd *abfd,
                                struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
                                                                   struct bfd_hash_table *,

-                                                                  const char *))
+                                                                  const char *),
+                               unsigned int entsize)

 {
   memset (&table->stab_info, 0, sizeof (table->stab_info));
 {
   memset (&table->stab_info, 0, sizeof (table->stab_info));

-  return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
+  return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);

 }
 
 /* Create a COFF linker hash table.  */
 }
 
 /* Create a COFF linker hash table.  */


@@ -108,12 +111,13 @@ _bfd_coff_link_hash_table_create (bfd *abfd)
   struct coff_link_hash_table *ret;
   bfd_size_type amt = sizeof (struct coff_link_hash_table);
 
   struct coff_link_hash_table *ret;
   bfd_size_type amt = sizeof (struct coff_link_hash_table);
 

-  ret = bfd_malloc (amt);
+  ret = (struct coff_link_hash_table *) bfd_malloc (amt);

   if (ret == NULL)
     return NULL;
 
   if (! _bfd_coff_link_hash_table_init (ret, abfd,
   if (ret == NULL)
     return NULL;
 
   if (! _bfd_coff_link_hash_table_init (ret, abfd,

-                                       _bfd_coff_link_hash_newfunc))
+                                       _bfd_coff_link_hash_newfunc,
+                                       sizeof (struct coff_link_hash_entry)))

     {
       free (ret);
       return (struct bfd_link_hash_table *) NULL;
     {
       free (ret);
       return (struct bfd_link_hash_table *) NULL;


@@ -188,72 +192,6 @@ coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
   return TRUE;
 }
 
   return TRUE;
 }
 

-/* Look through the symbols to see if this object file should be
-   included in the link.  */
-
-static bfd_boolean
-coff_link_check_ar_symbols (bfd *abfd,
-                           struct bfd_link_info *info,
-                           bfd_boolean *pneeded)
-{
-  bfd_size_type symesz;
-  bfd_byte *esym;
-  bfd_byte *esym_end;
-
-  *pneeded = FALSE;
-
-  symesz = bfd_coff_symesz (abfd);
-  esym = (bfd_byte *) obj_coff_external_syms (abfd);
-  esym_end = esym + obj_raw_syment_count (abfd) * symesz;
-  while (esym < esym_end)
-    {
-      struct internal_syment sym;
-      enum coff_symbol_classification classification;
-
-      bfd_coff_swap_sym_in (abfd, esym, &sym);
-
-      classification = bfd_coff_classify_symbol (abfd, &sym);
-      if (classification == COFF_SYMBOL_GLOBAL
-         || classification == COFF_SYMBOL_COMMON)
-       {
-         const char *name;
-         char buf[SYMNMLEN + 1];
-         struct bfd_link_hash_entry *h;
-
-         /* This symbol is externally visible, and is defined by this
-             object file.  */
-         name = _bfd_coff_internal_syment_name (abfd, &sym, buf);
-         if (name == NULL)
-           return FALSE;
-         h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
-
-         /* Auto import.  */
-         if (!h
-             && info->pei386_auto_import
-             && !strncmp (name,"__imp_", 6))
-           h = bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, TRUE);
-
-         /* We are only interested in symbols that are currently
-            undefined.  If a symbol is currently known to be common,
-            COFF linkers do not bring in an object file which defines
-            it.  */
-         if (h != (struct bfd_link_hash_entry *) NULL
-             && h->type == bfd_link_hash_undefined)
-           {
-             if (! (*info->callbacks->add_archive_element) (info, abfd, name))
-               return FALSE;
-             *pneeded = TRUE;
-             return TRUE;
-           }
-       }
-
-      esym += (sym.n_numaux + 1) * symesz;
-    }
-
-  /* We do not need this object file.  */
-  return TRUE;
-}
-

 /* Check a single archive element to see if we need to include it in
    the link.  *PNEEDED is set according to whether this element is
    needed in the link or not.  This is called via
 /* Check a single archive element to see if we need to include it in
    the link.  *PNEEDED is set according to whether this element is
    needed in the link or not.  This is called via


@@ -262,23 +200,23 @@ coff_link_check_ar_symbols (bfd *abfd,
 static bfd_boolean
 coff_link_check_archive_element (bfd *abfd,
                                 struct bfd_link_info *info,
 static bfd_boolean
 coff_link_check_archive_element (bfd *abfd,
                                 struct bfd_link_info *info,

+                                struct bfd_link_hash_entry *h,
+                                const char *name,

                                 bfd_boolean *pneeded)
 {
                                 bfd_boolean *pneeded)
 {

-  if (! _bfd_coff_get_external_symbols (abfd))
-    return FALSE;
+  *pneeded = FALSE;

 
 

-  if (! coff_link_check_ar_symbols (abfd, info, pneeded))
-    return FALSE;
+  /* We are only interested in symbols that are currently undefined.
+     If a symbol is currently known to be common, COFF linkers do not
+     bring in an object file which defines it.  */
+  if (h->type != bfd_link_hash_undefined)
+    return TRUE;

 
 

-  if (*pneeded
-      && ! coff_link_add_symbols (abfd, info))
+  if (!(*info->callbacks->add_archive_element) (info, abfd, name, &abfd))

     return FALSE;
     return FALSE;

+  *pneeded = TRUE;

 
 

-  if ((! info->keep_memory || ! *pneeded)
-      && ! _bfd_coff_free_symbols (abfd))
-    return FALSE;
-
-  return TRUE;
+  return coff_link_add_object_symbols (abfd, info);

 }
 
 /* Add all the symbols from an object file to the hash table.  */
 }
 
 /* Add all the symbols from an object file to the hash table.  */


@@ -299,6 +237,11 @@ coff_link_add_symbols (bfd *abfd,
   bfd_byte *esym_end;
   bfd_size_type amt;
 
   bfd_byte *esym_end;
   bfd_size_type amt;
 

+  symcount = obj_raw_syment_count (abfd);
+
+  if (symcount == 0)
+    return TRUE;               /* Nothing to do.  */
+

   /* Keep the symbols during this function, in case the linker needs
      to read the generic symbols in order to report an error message.  */
   keep_syms = obj_coff_keep_syms (abfd);
   /* Keep the symbols during this function, in case the linker needs
      to read the generic symbols in order to report an error message.  */
   keep_syms = obj_coff_keep_syms (abfd);


@@ -309,13 +252,11 @@ coff_link_add_symbols (bfd *abfd,
   else
     default_copy = TRUE;
 
   else
     default_copy = TRUE;
 

-  symcount = obj_raw_syment_count (abfd);
-

   /* We keep a list of the linker hash table entries that correspond
      to particular symbols.  */
   amt = symcount * sizeof (struct coff_link_hash_entry *);
   /* We keep a list of the linker hash table entries that correspond
      to particular symbols.  */
   amt = symcount * sizeof (struct coff_link_hash_entry *);

-  sym_hash = bfd_zalloc (abfd, amt);
-  if (sym_hash == NULL && symcount != 0)
+  sym_hash = (struct coff_link_hash_entry **) bfd_zalloc (abfd, amt);
+  if (sym_hash == NULL)

     goto error_return;
   obj_coff_sym_hashes (abfd) = sym_hash;
 
     goto error_return;
   obj_coff_sym_hashes (abfd) = sym_hash;
 


@@ -437,7 +378,7 @@ coff_link_add_symbols (bfd *abfd,
                  || classification == COFF_SYMBOL_PE_SECTION)
              && coff_section_data (abfd, section) != NULL
              && coff_section_data (abfd, section)->comdat != NULL
                  || classification == COFF_SYMBOL_PE_SECTION)
              && coff_section_data (abfd, section) != NULL
              && coff_section_data (abfd, section)->comdat != NULL

-             && strncmp (name, "??_", 3) == 0
+             && CONST_STRNEQ (name, "??_")

              && strcmp (name, coff_section_data (abfd, section)->comdat->name) == 0)
            {
              if (*sym_hash == NULL)
              && strcmp (name, coff_section_data (abfd, section)->comdat->name) == 0)
            {
              if (*sym_hash == NULL)


@@ -476,20 +417,20 @@ coff_link_add_symbols (bfd *abfd,
            (*sym_hash)->root.u.c.p->alignment_power
              = bfd_coff_default_section_alignment_power (abfd);
 
            (*sym_hash)->root.u.c.p->alignment_power
              = bfd_coff_default_section_alignment_power (abfd);
 

-         if (info->hash->creator->flavour == bfd_get_flavour (abfd))
+         if (bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd))

            {
              /* If we don't have any symbol information currently in
                  the hash table, or if we are looking at a symbol
                  definition, then update the symbol class and type in
                  the hash table.  */
            {
              /* If we don't have any symbol information currently in
                  the hash table, or if we are looking at a symbol
                  definition, then update the symbol class and type in
                  the hash table.  */

-             if (((*sym_hash)->class == C_NULL
+             if (((*sym_hash)->symbol_class == C_NULL

                   && (*sym_hash)->type == T_NULL)
                  || sym.n_scnum != 0
                  || (sym.n_value != 0
                      && (*sym_hash)->root.type != bfd_link_hash_defined
                      && (*sym_hash)->root.type != bfd_link_hash_defweak))
                {
                   && (*sym_hash)->type == T_NULL)
                  || sym.n_scnum != 0
                  || (sym.n_value != 0
                      && (*sym_hash)->root.type != bfd_link_hash_defined
                      && (*sym_hash)->root.type != bfd_link_hash_defweak))
                {

-                 (*sym_hash)->class = sym.n_sclass;
+                 (*sym_hash)->symbol_class = sym.n_sclass;

                  if (sym.n_type != T_NULL)
                    {
                      /* We want to warn if the type changed, but not
                  if (sym.n_type != T_NULL)
                    {
                      /* We want to warn if the type changed, but not


@@ -568,7 +509,7 @@ coff_link_add_symbols (bfd *abfd,
      optimize the handling of any .stab/.stabstr sections.  */
   if (! info->relocatable
       && ! info->traditional_format
      optimize the handling of any .stab/.stabstr sections.  */
   if (! info->relocatable
       && ! info->traditional_format

-      && info->hash->creator->flavour == bfd_get_flavour (abfd)
+      && bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd)

       && (info->strip != strip_all && info->strip != strip_debugger))
     {
       asection *stabstr;
       && (info->strip != strip_all && info->strip != strip_debugger))
     {
       asection *stabstr;


@@ -579,16 +520,16 @@ coff_link_add_symbols (bfd *abfd,
        {
          bfd_size_type string_offset = 0;
          asection *stab;
        {
          bfd_size_type string_offset = 0;
          asection *stab;

-         
+

          for (stab = abfd->sections; stab; stab = stab->next)
          for (stab = abfd->sections; stab; stab = stab->next)

-           if (strncmp (".stab", stab->name, 5) == 0
+           if (CONST_STRNEQ (stab->name, ".stab")

                && (!stab->name[5]
                    || (stab->name[5] == '.' && ISDIGIT (stab->name[6]))))
            {
              struct coff_link_hash_table *table;
              struct coff_section_tdata *secdata
                = coff_section_data (abfd, stab);
                && (!stab->name[5]
                    || (stab->name[5] == '.' && ISDIGIT (stab->name[6]))))
            {
              struct coff_link_hash_table *table;
              struct coff_section_tdata *secdata
                = coff_section_data (abfd, stab);

-             
+

              if (secdata == NULL)
                {
                  amt = sizeof (struct coff_section_tdata);
              if (secdata == NULL)
                {
                  amt = sizeof (struct coff_section_tdata);


@@ -625,7 +566,7 @@ _bfd_coff_final_link (bfd *abfd,
                      struct bfd_link_info *info)
 {
   bfd_size_type symesz;
                      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;
   bfd_boolean long_section_names;
   asection *o;
   bfd_boolean debug_merge_allocated;
   bfd_boolean long_section_names;
   asection *o;


@@ -646,30 +587,30 @@ _bfd_coff_final_link (bfd *abfd,
 
   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;
-  finfo.global_to_static = FALSE;
+  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;
+  flaginfo.global_to_static = FALSE;

   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;
 


@@ -749,7 +690,7 @@ _bfd_coff_final_link (bfd *abfd,
              coff_write_object_contents which puts the string index
              into the s_name field of the section header.  That is why
              we pass hash as FALSE.  */
              coff_write_object_contents which puts the string index
              into the s_name field of the section header.  That is why
              we pass hash as FALSE.  */

-         if (_bfd_stringtab_add (finfo.strtab, o->name, FALSE, FALSE)
+         if (_bfd_stringtab_add (flaginfo.strtab, o->name, FALSE, FALSE)

              == (bfd_size_type) -1)
            goto error_return;
          long_section_names = TRUE;
              == (bfd_size_type) -1)
            goto error_return;
          long_section_names = TRUE;


@@ -766,13 +707,13 @@ _bfd_coff_final_link (bfd *abfd,
          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 = bfd_malloc (amt);
-      if (finfo.section_info == NULL)
+      flaginfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
+      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;

        }
     }
 
        }
     }
 


@@ -809,12 +750,14 @@ _bfd_coff_final_link (bfd *abfd,
          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 = bfd_malloc (amt);
+         flaginfo.section_info[o->target_index].relocs =
+              (struct internal_reloc *) bfd_malloc (amt);

          amt = o->reloc_count;
          amt *= sizeof (struct coff_link_hash_entry *);
          amt = o->reloc_count;
          amt *= sizeof (struct coff_link_hash_entry *);

-         finfo.section_info[o->target_index].rel_hashes = bfd_malloc (amt);
-         if (finfo.section_info[o->target_index].relocs == NULL
-             || finfo.section_info[o->target_index].rel_hashes == NULL)
+         flaginfo.section_info[o->target_index].rel_hashes =
+              (struct coff_link_hash_entry **) bfd_malloc (amt);
+         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)


@@ -833,43 +776,43 @@ _bfd_coff_final_link (bfd *abfd,
      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)

     {
       size_t sz;
 
       sub->output_has_begun = FALSE;
     {
       size_t sz;
 
       sub->output_has_begun = FALSE;

-      sz = obj_raw_syment_count (sub);
+      sz = bfd_family_coff (sub) ? obj_raw_syment_count (sub) : 2;

       if (sz > max_sym_count)
        max_sym_count = sz;
     }
 
   /* Allocate some buffers used while linking.  */
   amt = max_sym_count * sizeof (struct internal_syment);
       if (sz > max_sym_count)
        max_sym_count = sz;
     }
 
   /* Allocate some buffers used while linking.  */
   amt = max_sym_count * sizeof (struct internal_syment);

-  finfo.internal_syms = 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 = 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 = bfd_malloc (amt);
-  finfo.outsyms = bfd_malloc ((max_sym_count + 1) * symesz);
+  flaginfo.sym_indices = (long int *) bfd_malloc (amt);
+  flaginfo.outsyms = (bfd_byte *) bfd_malloc ((max_sym_count + 1) * symesz);

   amt = max_lineno_count * bfd_coff_linesz (abfd);
   amt = max_lineno_count * bfd_coff_linesz (abfd);

-  finfo.linenos = bfd_malloc (amt);
-  finfo.contents = bfd_malloc (max_contents_size);
+  flaginfo.linenos = (bfd_byte *) bfd_malloc (amt);
+  flaginfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);

   amt = max_reloc_count * relsz;
   amt = max_reloc_count * relsz;

-  finfo.external_relocs = bfd_malloc (amt);
+  flaginfo.external_relocs = (bfd_byte *) bfd_malloc (amt);

   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 = 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;
 


@@ -894,9 +837,9 @@ _bfd_coff_final_link (bfd *abfd,
              && bfd_family_coff (p->u.indirect.section->owner))
            {
              sub = p->u.indirect.section->owner;
              && bfd_family_coff (p->u.indirect.section->owner))
            {
              sub = p->u.indirect.section->owner;

-             if (! bfd_coff_link_output_has_begun (sub, & finfo))
+             if (! bfd_coff_link_output_has_begun (sub, & flaginfo))

                {
                {

-                 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;
                }


@@ -904,7 +847,7 @@ _bfd_coff_final_link (bfd *abfd,
          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


@@ -915,65 +858,151 @@ _bfd_coff_final_link (bfd *abfd,
        }
     }
 
        }
     }
 

-  if (! bfd_coff_final_link_postscript (abfd, & finfo))
+  if (flaginfo.info->strip != strip_all && flaginfo.info->discard != discard_all)
+    {
+      /* Add local symbols from foreign inputs.  */
+      for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
+       {
+         unsigned int i;
+
+         if (bfd_family_coff (sub) || ! bfd_get_outsymbols (sub))
+           continue;
+         for (i = 0; i < bfd_get_symcount (sub); ++i)
+           {
+             asymbol *sym = bfd_get_outsymbols (sub) [i];
+             file_ptr pos;
+             struct internal_syment isym;
+             bfd_size_type string_size = 0;
+             bfd_vma written = 0;
+             bfd_boolean rewrite = FALSE;
+
+             if (! (sym->flags & BSF_LOCAL)
+                 || (sym->flags & (BSF_SECTION_SYM | BSF_DEBUGGING_RELOC
+                                   | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC
+                                   | BSF_SYNTHETIC))
+                 || ((sym->flags & BSF_DEBUGGING)
+                     && ! (sym->flags & BSF_FILE)))
+               continue;
+
+             /* See if we are discarding symbols with this name.  */
+             if ((flaginfo.info->strip == strip_some
+                  && (bfd_hash_lookup (flaginfo.info->keep_hash,
+                                       bfd_asymbol_name(sym), FALSE, FALSE)
+                      == NULL))
+                 || (((flaginfo.info->discard == discard_sec_merge
+                       && (bfd_get_section (sym)->flags & SEC_MERGE)
+                       && ! flaginfo.info->relocatable)
+                      || flaginfo.info->discard == discard_l)
+                     && bfd_is_local_label_name (sub, bfd_asymbol_name(sym))))
+               continue;
+
+             pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd)
+                                            * symesz;
+             if (bfd_seek (abfd, pos, SEEK_SET) != 0)
+               goto error_return;
+             if (! coff_write_alien_symbol(abfd, sym, &isym, &written,
+                                           &string_size, NULL, NULL))
+               goto error_return;
+
+             if (string_size)
+               {
+                 bfd_boolean hash = ! (abfd->flags & BFD_TRADITIONAL_FORMAT);
+                 bfd_size_type indx;
+
+                 indx = _bfd_stringtab_add (flaginfo.strtab,
+                                            bfd_asymbol_name (sym), hash,
+                                            FALSE);
+                 if (indx == (bfd_size_type) -1)
+                   goto error_return;
+                 isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
+                 bfd_coff_swap_sym_out (abfd, &isym, flaginfo.outsyms);
+                 rewrite = TRUE;
+               }
+
+             if (isym.n_sclass == C_FILE)
+               {
+                 if (flaginfo.last_file_index != -1)
+                   {
+                     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;
+                     rewrite = TRUE;
+                   }
+                 flaginfo.last_file_index = obj_raw_syment_count (abfd);
+                 flaginfo.last_file = isym;
+               }
+
+             if (rewrite
+                 && (bfd_seek (abfd, pos, SEEK_SET) != 0
+                     || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz))
+               goto error_return;
+
+             obj_raw_syment_count (abfd) += written;
+           }
+       }
+    }
+
+  if (! bfd_coff_final_link_postscript (abfd, & flaginfo))

     goto error_return;
 
   /* Free up the buffers used by _bfd_coff_link_input_bfd.  */
 
     goto error_return;
 
   /* 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, &finfo.last_file,
-                            finfo.outsyms);
+      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) + finfo.last_file_index * symesz;
+      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;
     }
 
        return FALSE;
     }
 


@@ -982,25 +1011,24 @@ _bfd_coff_final_link (bfd *abfd,
      static.  */
   if (info->task_link)
     {
      static.  */
   if (info->task_link)
     {

-      finfo.failed = FALSE;
+      flaginfo.failed = FALSE;

       coff_link_hash_traverse (coff_hash_table (info),
       coff_link_hash_traverse (coff_hash_table (info),

-                              _bfd_coff_write_task_globals, &finfo);
-      if (finfo.failed)
+                              _bfd_coff_write_task_globals, &flaginfo);
+      if (flaginfo.failed)

        goto error_return;
     }
 
   /* Write out the global symbols.  */
        goto error_return;
     }
 
   /* Write out the global symbols.  */

-  finfo.failed = FALSE;
-  coff_link_hash_traverse (coff_hash_table (info),
-                          _bfd_coff_write_global_sym, &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 && max_output_reloc_count > 0)
     }
 
   if (info->relocatable && max_output_reloc_count > 0)


@@ -1009,7 +1037,7 @@ _bfd_coff_final_link (bfd *abfd,
         the symbol indices to use for relocs against them, and we can
         finally write out the relocs.  */
       amt = max_output_reloc_count * relsz;
         the symbol indices to use for relocs against them, and we can
         finally write out the relocs.  */
       amt = max_output_reloc_count * relsz;

-      external_relocs = bfd_malloc (amt);
+      external_relocs = (bfd_byte *) bfd_malloc (amt);

       if (external_relocs == NULL)
        goto error_return;
 
       if (external_relocs == NULL)
        goto error_return;
 


@@ -1023,9 +1051,9 @@ _bfd_coff_final_link (bfd *abfd,
          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)
            {


@@ -1046,10 +1074,10 @@ _bfd_coff_final_link (bfd *abfd,
                 elsewhere. */
              struct internal_reloc incount;
              bfd_byte *excount = (bfd_byte *)bfd_malloc (relsz);
                 elsewhere. */
              struct internal_reloc incount;
              bfd_byte *excount = (bfd_byte *)bfd_malloc (relsz);

-             
+

              memset (&incount, 0, sizeof (incount));
              incount.r_vaddr = o->reloc_count + 1;
              memset (&incount, 0, sizeof (incount));
              incount.r_vaddr = o->reloc_count + 1;

-             bfd_coff_swap_reloc_out (abfd, (PTR) &incount, (PTR) excount);
+             bfd_coff_swap_reloc_out (abfd, &incount, excount);

              if (bfd_bwrite (excount, relsz, abfd) != relsz)
                /* We'll leak, but it's an error anyway. */
                goto error_return;
              if (bfd_bwrite (excount, relsz, abfd) != relsz)
                /* We'll leak, but it's an error anyway. */
                goto error_return;


@@ -1066,19 +1094,19 @@ _bfd_coff_final_link (bfd *abfd,
     }
 
   /* 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.  */


@@ -1099,7 +1127,7 @@ _bfd_coff_final_link (bfd *abfd,
 
 #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


@@ -1109,13 +1137,13 @@ _bfd_coff_final_link (bfd *abfd,
          != 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;
 
       obj_coff_strings_written (abfd) = TRUE;
     }
 
        return FALSE;
 
       obj_coff_strings_written (abfd) = TRUE;
     }
 

-  _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.  */


@@ -1125,38 +1153,38 @@ _bfd_coff_final_link (bfd *abfd,
 
  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;


@@ -1230,16 +1258,14 @@ process_embedded_commands (bfd *output_bfd,
          s++;
          continue;
        }
          s++;
          continue;
        }

-      if (strncmp (s, "-attr", 5) == 0)
+      if (CONST_STRNEQ (s, "-attr"))

        {
          char *name;
          char *attribs;
          asection *asec;
          int loop = 1;
          int had_write = 0;
        {
          char *name;
          char *attribs;
          asection *asec;
          int loop = 1;
          int had_write = 0;

-         int had_read = 0;

          int had_exec= 0;
          int had_exec= 0;

-         int had_shared= 0;

 
          s += 5;
          s = get_name (s, &name);
 
          s += 5;
          s = get_name (s, &name);


@@ -1253,10 +1279,8 @@ process_embedded_commands (bfd *output_bfd,
                  had_write = 1;
                  break;
                case 'R':
                  had_write = 1;
                  break;
                case 'R':

-                 had_read = 1;

                  break;
                case 'S':
                  break;
                case 'S':

-                 had_shared = 1;

                  break;
                case 'X':
                  had_exec = 1;
                  break;
                case 'X':
                  had_exec = 1;


@@ -1274,11 +1298,20 @@ process_embedded_commands (bfd *output_bfd,
                asec->flags |= SEC_READONLY;
            }
        }
                asec->flags |= SEC_READONLY;
            }
        }

-      else if (strncmp (s,"-heap", 5) == 0)
-       s = dores_com (s+5, output_bfd, 1);
+      else if (CONST_STRNEQ (s, "-heap"))
+       s = dores_com (s + 5, output_bfd, 1);

 
 

-      else if (strncmp (s,"-stack", 6) == 0)
-       s = dores_com (s+6, output_bfd, 0);
+      else if (CONST_STRNEQ (s, "-stack"))
+       s = dores_com (s + 6, output_bfd, 0);
+
+      /* GNU extension for aligned commons.  */
+      else if (CONST_STRNEQ (s, "-aligncomm:"))
+       {
+         /* Common symbols must be aligned on reading, as it
+         is too late to do anything here, after they have
+         already been allocated, so just skip the directive.  */
+         s += 11;
+       }

 
       else
        s++;
 
       else
        s++;


@@ -1293,7 +1326,7 @@ process_embedded_commands (bfd *output_bfd,
    that symbol.  */
 
 static void
    that symbol.  */
 
 static void

-mark_relocs (struct coff_final_link_info *finfo, bfd *input_bfd)
+mark_relocs (struct coff_final_link_info *flaginfo, bfd *input_bfd)

 {
   asection * a;
 
 {
   asection * a;
 


@@ -1306,7 +1339,8 @@ mark_relocs (struct coff_final_link_info *finfo, bfd *input_bfd)
       struct internal_reloc *  irel;
       struct internal_reloc *  irelend;
 
       struct internal_reloc *  irel;
       struct internal_reloc *  irelend;
 

-      if ((a->flags & SEC_RELOC) == 0 || a->reloc_count  < 1)
+      if ((a->flags & SEC_RELOC) == 0 || a->reloc_count  < 1
+         || a->linker_mark == 0)

        continue;
       /* Don't mark relocs in excluded sections.  */
       if (a->output_section == bfd_abs_section_ptr)
        continue;
       /* Don't mark relocs in excluded sections.  */
       if (a->output_section == bfd_abs_section_ptr)


@@ -1315,11 +1349,11 @@ mark_relocs (struct coff_final_link_info *finfo, bfd *input_bfd)
       /* Read in the relocs.  */
       internal_relocs = _bfd_coff_read_internal_relocs
        (input_bfd, a, FALSE,
       /* Read in the relocs.  */
       internal_relocs = _bfd_coff_read_internal_relocs
        (input_bfd, a, FALSE,

-        finfo->external_relocs,
-        finfo->info->relocatable,
-        (finfo->info->relocatable
-         ? (finfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
-         : finfo->internal_relocs)
+        flaginfo->external_relocs,
+        flaginfo->info->relocatable,
+        (flaginfo->info->relocatable
+         ? (flaginfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
+         : flaginfo->internal_relocs)

        );
 
       if (internal_relocs == NULL)
        );
 
       if (internal_relocs == NULL)


@@ -1333,7 +1367,7 @@ mark_relocs (struct coff_final_link_info *finfo, bfd *input_bfd)
         in the relocation table.  This will then be picked up in the
         skip/don't-skip pass.  */
       for (; irel < irelend; irel++)
         in the relocation table.  This will then be picked up in the
         skip/don't-skip pass.  */
       for (; irel < irelend; irel++)

-       finfo->sym_indices[ irel->r_symndx ] = -1;
+       flaginfo->sym_indices[ irel->r_symndx ] = -1;

     }
 }
 
     }
 }
 


@@ -1341,7 +1375,7 @@ mark_relocs (struct coff_final_link_info *finfo, bfd *input_bfd)
    handles all the sections and relocations of the input file at once.  */
 
 bfd_boolean
    handles all the sections and relocations of the input file at once.  */
 
 bfd_boolean

-_bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
+_bfd_coff_link_input_bfd (struct coff_final_link_info *flaginfo, bfd *input_bfd)

 {
   unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
   unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;
 {
   unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
   unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;


@@ -1367,7 +1401,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
 
   /* Move all the symbols to the output file.  */
 
 
   /* Move all the symbols to the output file.  */
 

-  output_bfd = finfo->output_bfd;
+  output_bfd = flaginfo->output_bfd;

   strings = NULL;
   syment_base = obj_raw_syment_count (output_bfd);
   isymesz = bfd_coff_symesz (input_bfd);
   strings = NULL;
   syment_base = obj_raw_syment_count (output_bfd);
   isymesz = bfd_coff_symesz (input_bfd);


@@ -1376,7 +1410,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
   BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
 
   copy = FALSE;
   BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
 
   copy = FALSE;

-  if (! finfo->info->keep_memory)
+  if (! flaginfo->info->keep_memory)

     copy = TRUE;
   hash = TRUE;
   if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
     copy = TRUE;
   hash = TRUE;
   if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)


@@ -1387,27 +1421,27 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
 
   esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
   esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
 
   esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
   esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;

-  isymp = finfo->internal_syms;
-  secpp = finfo->sec_ptrs;
-  indexp = finfo->sym_indices;
+  isymp = flaginfo->internal_syms;
+  secpp = flaginfo->sec_ptrs;
+  indexp = flaginfo->sym_indices;

   output_index = syment_base;
   output_index = syment_base;

-  outsym = finfo->outsyms;
+  outsym = flaginfo->outsyms;

 
   if (coff_data (output_bfd)->pe
 
   if (coff_data (output_bfd)->pe

-      && ! process_embedded_commands (output_bfd, finfo->info, input_bfd))
+      && ! process_embedded_commands (output_bfd, flaginfo->info, input_bfd))

     return FALSE;
 
   /* If we are going to perform relocations and also strip/discard some
      symbols then we must make sure that we do not strip/discard those
      symbols that are going to be involved in the relocations.  */
     return FALSE;
 
   /* If we are going to perform relocations and also strip/discard some
      symbols then we must make sure that we do not strip/discard those
      symbols that are going to be involved in the relocations.  */

-  if ((   finfo->info->strip   != strip_none
-       || finfo->info->discard != discard_none)
-      && finfo->info->relocatable)
+  if ((   flaginfo->info->strip   != strip_none
+       || flaginfo->info->discard != discard_none)
+      && flaginfo->info->relocatable)

     {
       /* Mark the symbol array as 'not-used'.  */
       memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
 
     {
       /* Mark the symbol array as 'not-used'.  */
       memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
 

-      mark_relocs (finfo, input_bfd);
+      mark_relocs (flaginfo, input_bfd);

     }
 
   while (esym < esym_end)
     }
 
   while (esym < esym_end)


@@ -1447,9 +1481,9 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
 
       /* Extract the flag indicating if this symbol is used by a
          relocation.  */
 
       /* Extract the flag indicating if this symbol is used by a
          relocation.  */

-      if ((finfo->info->strip != strip_none
-          || finfo->info->discard != discard_none)
-         && finfo->info->relocatable)
+      if ((flaginfo->info->strip != strip_none
+          || flaginfo->info->discard != discard_none)
+         && flaginfo->info->relocatable)

        dont_skip_symbol = *indexp;
       else
        dont_skip_symbol = FALSE;
        dont_skip_symbol = *indexp;
       else
        dont_skip_symbol = FALSE;


@@ -1461,7 +1495,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
       add = 1 + isym.n_numaux;
 
       /* If we are stripping all symbols, we want to skip this one.  */
       add = 1 + isym.n_numaux;
 
       /* If we are stripping all symbols, we want to skip this one.  */

-      if (finfo->info->strip == strip_all && ! dont_skip_symbol)
+      if (flaginfo->info->strip == strip_all && ! dont_skip_symbol)

        skip = TRUE;
 
       if (! skip)
        skip = TRUE;
 
       if (! skip)


@@ -1491,7 +1525,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
            case COFF_SYMBOL_LOCAL:
              /* This is a local symbol.  Skip it if we are discarding
                  local symbols.  */
            case COFF_SYMBOL_LOCAL:
              /* This is a local symbol.  Skip it if we are discarding
                  local symbols.  */

-             if (finfo->info->discard == discard_all && ! dont_skip_symbol)
+             if (flaginfo->info->discard == discard_all && ! dont_skip_symbol)

                skip = TRUE;
              break;
            }
                skip = TRUE;
              break;
            }


@@ -1501,11 +1535,13 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
       /* Skip section symbols for sections which are not going to be
         emitted.  */
       if (!skip
       /* Skip section symbols for sections which are not going to be
         emitted.  */
       if (!skip

-         && dont_skip_symbol == 0
+         && !dont_skip_symbol

          && isym.n_sclass == C_STAT
          && isym.n_type == T_NULL
          && isym.n_sclass == C_STAT
          && isym.n_type == T_NULL

-          && isym.n_numaux > 0
-         && (*secpp)->output_section == bfd_abs_section_ptr)
+         && isym.n_numaux > 0
+         && ((*secpp)->output_section == bfd_abs_section_ptr
+             || bfd_section_removed_from_list (output_bfd,
+                                               (*secpp)->output_section)))

        skip = TRUE;
 #endif
 
        skip = TRUE;
 #endif
 


@@ -1514,7 +1550,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
          for some types of debugging symbols; I don't know if this is
          a bug or not.  In any case, we handle it here.  */
       if (! skip
          for some types of debugging symbols; I don't know if this is
          a bug or not.  In any case, we handle it here.  */
       if (! skip

-         && finfo->info->strip == strip_debugger
+         && flaginfo->info->strip == strip_debugger

          && ! dont_skip_symbol
          && (isym.n_scnum == N_DEBUG
              || (isym.n_scnum == N_ABS
          && ! dont_skip_symbol
          && (isym.n_scnum == N_DEBUG
              || (isym.n_scnum == N_ABS


@@ -1532,8 +1568,8 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
       /* If some symbols are stripped based on the name, work out the
         name and decide whether to skip this symbol.  */
       if (! skip
       /* If some symbols are stripped based on the name, work out the
         name and decide whether to skip this symbol.  */
       if (! skip

-         && (finfo->info->strip == strip_some
-             || finfo->info->discard == discard_l))
+         && (flaginfo->info->strip == strip_some
+             || flaginfo->info->discard == discard_l))

        {
          const char *name;
          char buf[SYMNMLEN + 1];
        {
          const char *name;
          char buf[SYMNMLEN + 1];


@@ -1543,11 +1579,11 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
            return FALSE;
 
          if (! dont_skip_symbol
            return FALSE;
 
          if (! dont_skip_symbol

-             && ((finfo->info->strip == strip_some
-                  && (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE,
+             && ((flaginfo->info->strip == strip_some
+                  && (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE,

                                    FALSE) == NULL))
                   || (! global
                                    FALSE) == NULL))
                   || (! global

-                      && finfo->info->discard == discard_l
+                      && flaginfo->info->discard == discard_l

                       && bfd_is_local_label_name (input_bfd, name))))
            skip = TRUE;
        }
                       && bfd_is_local_label_name (input_bfd, name))))
            skip = TRUE;
        }


@@ -1555,7 +1591,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
       /* If this is an enum, struct, or union tag, see if we have
          already output an identical type.  */
       if (! skip
       /* If this is an enum, struct, or union tag, see if we have
          already output an identical type.  */
       if (! skip

-         && (finfo->output_bfd->flags & BFD_TRADITIONAL_FORMAT) == 0
+         && (flaginfo->output_bfd->flags & BFD_TRADITIONAL_FORMAT) == 0

          && (isym.n_sclass == C_ENTAG
              || isym.n_sclass == C_STRTAG
              || isym.n_sclass == C_UNTAG)
          && (isym.n_sclass == C_ENTAG
              || isym.n_sclass == C_STRTAG
              || isym.n_sclass == C_UNTAG)


@@ -1582,7 +1618,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                  && (name[1] == '~' || name[1] == '.' || name[1] == '$')))
            name = "";
 
                  && (name[1] == '~' || name[1] == '.' || name[1] == '$')))
            name = "";
 

-         mh = coff_debug_merge_hash_lookup (&finfo->debug_merge, name,
+         mh = coff_debug_merge_hash_lookup (&flaginfo->debug_merge, name,

                                             TRUE, TRUE);
          if (mh == NULL)
            return FALSE;
                                             TRUE, TRUE);
          if (mh == NULL)
            return FALSE;


@@ -1591,10 +1627,10 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
              out to be a duplicate, we pass this address to
              bfd_release.  */
          amt = sizeof (struct coff_debug_merge_type);
              out to be a duplicate, we pass this address to
              bfd_release.  */
          amt = sizeof (struct coff_debug_merge_type);

-         mt = bfd_alloc (input_bfd, amt);
+         mt = (struct coff_debug_merge_type *) bfd_alloc (input_bfd, amt);

          if (mt == NULL)
            return FALSE;
          if (mt == NULL)
            return FALSE;

-         mt->class = isym.n_sclass;
+         mt->type_class = isym.n_sclass;

 
          /* Pick up the aux entry, which points to the end of the tag
              entries.  */
 
          /* Pick up the aux entry, which points to the end of the tag
              entries.  */


@@ -1618,7 +1654,8 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
              bfd_coff_swap_sym_in (input_bfd, esl, islp);
 
              amt = sizeof (struct coff_debug_merge_element);
              bfd_coff_swap_sym_in (input_bfd, esl, islp);
 
              amt = sizeof (struct coff_debug_merge_element);

-             *epp = bfd_alloc (input_bfd, amt);
+             *epp = (struct coff_debug_merge_element *)
+                  bfd_alloc (input_bfd, amt);

              if (*epp == NULL)
                return FALSE;
 
              if (*epp == NULL)
                return FALSE;
 


@@ -1628,7 +1665,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                return FALSE;
 
              amt = strlen (elename) + 1;
                return FALSE;
 
              amt = strlen (elename) + 1;

-             name_copy = bfd_alloc (input_bfd, amt);
+             name_copy = (char *) bfd_alloc (input_bfd, amt);

              if (name_copy == NULL)
                return FALSE;
              strcpy (name_copy, elename);
              if (name_copy == NULL)
                return FALSE;
              strcpy (name_copy, elename);


@@ -1658,7 +1695,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                              (bfd_byte *) obj_coff_external_syms (input_bfd))
                             / (long) isymesz)))
                    {
                              (bfd_byte *) obj_coff_external_syms (input_bfd))
                             / (long) isymesz)))
                    {

-                     (*epp)->tagndx = finfo->sym_indices[indx];
+                     (*epp)->tagndx = flaginfo->sym_indices[indx];

                      if ((*epp)->tagndx < 0)
                        (*epp)->tagndx = 0;
                    }
                      if ((*epp)->tagndx < 0)
                        (*epp)->tagndx = 0;
                    }


@@ -1683,7 +1720,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                {
                  struct coff_debug_merge_element *me, *mel;
 
                {
                  struct coff_debug_merge_element *me, *mel;
 

-                 if (mtl->class != mt->class)
+                 if (mtl->type_class != mt->type_class)

                    continue;
 
                  for (me = mt->elements, mel = mtl->elements;
                    continue;
 
                  for (me = mt->elements, mel = mtl->elements;


@@ -1737,7 +1774,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
              name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL);
              if (name == NULL)
                return FALSE;
              name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL);
              if (name == NULL)
                return FALSE;

-             indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
+             indx = _bfd_stringtab_add (flaginfo->strtab, name, hash, copy);

              if (indx == (bfd_size_type) -1)
                return FALSE;
              isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
              if (indx == (bfd_size_type) -1)
                return FALSE;
              isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;


@@ -1792,7 +1829,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                isym.n_value += (*secpp)->output_offset;
                if (! obj_pe (input_bfd))
                  isym.n_value -= (*secpp)->vma;
                isym.n_value += (*secpp)->output_offset;
                if (! obj_pe (input_bfd))
                  isym.n_value -= (*secpp)->vma;

-               if (! obj_pe (finfo->output_bfd))
+               if (! obj_pe (flaginfo->output_bfd))

                  isym.n_value += (*secpp)->output_section->vma;
              }
            break;
                  isym.n_value += (*secpp)->output_section->vma;
              }
            break;


@@ -1807,19 +1844,19 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                 it).  We try to get this right, below, just before we
                 write the symbols out, but in the general case we may
                 have to write the symbol out twice.  */
                 it).  We try to get this right, below, just before we
                 write the symbols out, but in the general case we may
                 have to write the symbol out twice.  */

-             if (finfo->last_file_index != -1
-                 && finfo->last_file.n_value != (bfd_vma) output_index)
+             if (flaginfo->last_file_index != -1
+                 && flaginfo->last_file.n_value != (bfd_vma) output_index)

                {
                  /* We must correct the value of the last C_FILE
                      entry.  */
                {
                  /* We must correct the value of the last C_FILE
                      entry.  */

-                 finfo->last_file.n_value = output_index;
-                 if ((bfd_size_type) finfo->last_file_index >= syment_base)
+                 flaginfo->last_file.n_value = output_index;
+                 if ((bfd_size_type) flaginfo->last_file_index >= syment_base)

                    {
                      /* The last C_FILE symbol is in this input file.  */
                      bfd_coff_swap_sym_out (output_bfd,
                    {
                      /* The last C_FILE symbol is in this input file.  */
                      bfd_coff_swap_sym_out (output_bfd,

-                                            &finfo->last_file,
-                                            (finfo->outsyms
-                                             + ((finfo->last_file_index
+                                            &flaginfo->last_file,
+                                            (flaginfo->outsyms
+                                             + ((flaginfo->last_file_index

                                                  - syment_base)
                                                 * osymesz)));
                    }
                                                  - syment_base)
                                                 * osymesz)));
                    }


@@ -1831,23 +1868,23 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                         symbol.  We need to write it out again.  We
                         borrow *outsym temporarily.  */
                      bfd_coff_swap_sym_out (output_bfd,
                         symbol.  We need to write it out again.  We
                         borrow *outsym temporarily.  */
                      bfd_coff_swap_sym_out (output_bfd,

-                                            &finfo->last_file, outsym);
+                                            &flaginfo->last_file, outsym);

                      pos = obj_sym_filepos (output_bfd);
                      pos = obj_sym_filepos (output_bfd);

-                     pos += finfo->last_file_index * osymesz;
+                     pos += flaginfo->last_file_index * osymesz;

                      if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
                          || bfd_bwrite (outsym, osymesz, output_bfd) != osymesz)
                        return FALSE;
                    }
                }
 
                      if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
                          || bfd_bwrite (outsym, osymesz, output_bfd) != osymesz)
                        return FALSE;
                    }
                }
 

-             finfo->last_file_index = output_index;
-             finfo->last_file = isym;
+             flaginfo->last_file_index = output_index;
+             flaginfo->last_file = isym;

              break;
            }
 
          /* If doing task linking, convert normal global function symbols to
             static functions.  */
              break;
            }
 
          /* If doing task linking, convert normal global function symbols to
             static functions.  */

-         if (finfo->info->task_link && IS_EXTERNAL (input_bfd, isym))
+         if (flaginfo->info->task_link && IS_EXTERNAL (input_bfd, isym))

            isym.n_sclass = C_STAT;
 
          /* Output the symbol.  */
            isym.n_sclass = C_STAT;
 
          /* Output the symbol.  */


@@ -1893,10 +1930,10 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
      already decided which symbols we are going to keep.  */
   esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
   esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
      already decided which symbols we are going to keep.  */
   esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
   esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;

-  isymp = finfo->internal_syms;
-  indexp = finfo->sym_indices;
+  isymp = flaginfo->internal_syms;
+  indexp = flaginfo->sym_indices;

   sym_hash = obj_coff_sym_hashes (input_bfd);
   sym_hash = obj_coff_sym_hashes (input_bfd);

-  outsym = finfo->outsyms;
+  outsym = flaginfo->outsyms;

 
   while (esym < esym_end)
     {
 
   while (esym < esym_end)
     {


@@ -1923,6 +1960,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                  generate two symbols with the same name, but only one
                  will have aux entries.  */
              BFD_ASSERT (isymp->n_numaux == 0
                  generate two symbols with the same name, but only one
                  will have aux entries.  */
              BFD_ASSERT (isymp->n_numaux == 0

+                         || h->numaux == 0

                          || h->numaux == isymp->n_numaux);
            }
 
                          || h->numaux == isymp->n_numaux);
            }
 


@@ -1938,7 +1976,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
              union internal_auxent aux;
              union internal_auxent *auxp;
 
              union internal_auxent aux;
              union internal_auxent *auxp;
 

-             if (h != NULL)
+             if (h != NULL && h->aux != NULL && (h->numaux > i))

                auxp = h->aux + i;
              else
                {
                auxp = h->aux + i;
              else
                {


@@ -1965,8 +2003,11 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                          if (strings == NULL)
                            return FALSE;
                        }
                          if (strings == NULL)
                            return FALSE;
                        }

-                     filename = strings + auxp->x_file.x_n.x_offset;
-                     indx = _bfd_stringtab_add (finfo->strtab, filename,
+                     if ((bfd_size_type) auxp->x_file.x_n.x_offset >= obj_coff_strings_len (input_bfd))
+                       filename = _("<corrupt>");
+                     else
+                       filename = strings + auxp->x_file.x_n.x_offset;
+                     indx = _bfd_stringtab_add (flaginfo->strtab, filename,

                                                 hash, copy);
                      if (indx == (bfd_size_type) -1)
                        return FALSE;
                                                 hash, copy);
                      if (indx == (bfd_size_type) -1)
                        return FALSE;


@@ -1991,15 +2032,15 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                              the index of the next symbol we are going
                              to include.  I don't know if this is
                              entirely right.  */
                              the index of the next symbol we are going
                              to include.  I don't know if this is
                              entirely right.  */

-                         while ((finfo->sym_indices[indx] < 0
-                                 || ((bfd_size_type) finfo->sym_indices[indx]
+                         while ((flaginfo->sym_indices[indx] < 0
+                                 || ((bfd_size_type) flaginfo->sym_indices[indx]

                                      < syment_base))
                                 && indx < obj_raw_syment_count (input_bfd))
                            ++indx;
                          if (indx >= obj_raw_syment_count (input_bfd))
                            indx = output_index;
                          else
                                      < syment_base))
                                 && indx < obj_raw_syment_count (input_bfd))
                            ++indx;
                          if (indx >= obj_raw_syment_count (input_bfd))
                            indx = output_index;
                          else

-                           indx = finfo->sym_indices[indx];
+                           indx = flaginfo->sym_indices[indx];

                          auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
                        }
                    }
                          auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
                        }
                    }


@@ -2009,7 +2050,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                    {
                      long symindx;
 
                    {
                      long symindx;
 

-                     symindx = finfo->sym_indices[indx];
+                     symindx = flaginfo->sym_indices[indx];

                      if (symindx < 0)
                        auxp->x_sym.x_tagndx.l = 0;
                      else
                      if (symindx < 0)
                        auxp->x_sym.x_tagndx.l = 0;
                      else


@@ -2029,12 +2070,12 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                      && isymp->_n._n_name[2] == 'f'
                      && isymp->_n._n_name[3] == '\0')
                    {
                      && isymp->_n._n_name[2] == 'f'
                      && isymp->_n._n_name[3] == '\0')
                    {

-                     if (finfo->last_bf_index != -1)
+                     if (flaginfo->last_bf_index != -1)

                        {
                        {

-                         finfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =
+                         flaginfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =

                            *indexp;
 
                            *indexp;
 

-                         if ((bfd_size_type) finfo->last_bf_index
+                         if ((bfd_size_type) flaginfo->last_bf_index

                              >= syment_base)
                            {
                              void *auxout;
                              >= syment_base)
                            {
                              void *auxout;


@@ -2043,13 +2084,13 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                                 file.  This will only happen if the
                                 assembler did not set up the .bf
                                 endndx symbols correctly.  */
                                 file.  This will only happen if the
                                 assembler did not set up the .bf
                                 endndx symbols correctly.  */

-                             auxout = (finfo->outsyms
-                                       + ((finfo->last_bf_index
+                             auxout = (flaginfo->outsyms
+                                       + ((flaginfo->last_bf_index

                                            - syment_base)
                                           * osymesz));
 
                              bfd_coff_swap_aux_out (output_bfd,
                                            - syment_base)
                                           * osymesz));
 
                              bfd_coff_swap_aux_out (output_bfd,

-                                                    &finfo->last_bf,
+                                                    &flaginfo->last_bf,

                                                     isymp->n_type,
                                                     isymp->n_sclass,
                                                     0, isymp->n_numaux,
                                                     isymp->n_type,
                                                     isymp->n_sclass,
                                                     0, isymp->n_numaux,


@@ -2065,13 +2106,13 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                                  temporarily.  FIXME: This case should
                                  be made faster.  */
                              bfd_coff_swap_aux_out (output_bfd,
                                  temporarily.  FIXME: This case should
                                  be made faster.  */
                              bfd_coff_swap_aux_out (output_bfd,

-                                                    &finfo->last_bf,
+                                                    &flaginfo->last_bf,

                                                     isymp->n_type,
                                                     isymp->n_sclass,
                                                     0, isymp->n_numaux,
                                                     outsym);
                              pos = obj_sym_filepos (output_bfd);
                                                     isymp->n_type,
                                                     isymp->n_sclass,
                                                     0, isymp->n_numaux,
                                                     outsym);
                              pos = obj_sym_filepos (output_bfd);

-                             pos += finfo->last_bf_index * osymesz;
+                             pos += flaginfo->last_bf_index * osymesz;

                              if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
                                  || (bfd_bwrite (outsym, osymesz, output_bfd)
                                      != osymesz))
                              if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
                                  || (bfd_bwrite (outsym, osymesz, output_bfd)
                                      != osymesz))


@@ -2080,14 +2121,14 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                        }
 
                      if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)
                        }
 
                      if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)

-                       finfo->last_bf_index = -1;
+                       flaginfo->last_bf_index = -1;

                      else
                        {
                          /* The endndx field of this aux entry must
                              be updated with the symbol number of the
                              next .bf symbol.  */
                      else
                        {
                          /* The endndx field of this aux entry must
                              be updated with the symbol number of the
                              next .bf symbol.  */

-                         finfo->last_bf = *auxp;
-                         finfo->last_bf_index = (((outsym - finfo->outsyms)
+                         flaginfo->last_bf = *auxp;
+                         flaginfo->last_bf_index = (((outsym - flaginfo->outsyms)

                                                   / osymesz)
                                                  + syment_base);
                        }
                                                   / osymesz)
                                                  + syment_base);
                        }


@@ -2112,8 +2153,8 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
     }
 
   /* Relocate the line numbers, unless we are stripping them.  */
     }
 
   /* Relocate the line numbers, unless we are stripping them.  */

-  if (finfo->info->strip == strip_none
-      || finfo->info->strip == strip_some)
+  if (flaginfo->info->strip == strip_none
+      || flaginfo->info->strip == strip_some)

     {
       for (o = input_bfd->sections; o != NULL; o = o->next)
        {
     {
       for (o = input_bfd->sections; o != NULL; o = o->next)
        {


@@ -2139,13 +2180,13 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
            continue;
 
          if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
            continue;
 
          if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0

-             || bfd_bread (finfo->linenos, linesz * o->lineno_count,
+             || bfd_bread (flaginfo->linenos, linesz * o->lineno_count,

                           input_bfd) != linesz * o->lineno_count)
            return FALSE;
 
          offset = o->output_section->vma + o->output_offset - o->vma;
                           input_bfd) != linesz * o->lineno_count)
            return FALSE;
 
          offset = o->output_section->vma + o->output_offset - o->vma;

-         eline = finfo->linenos;
-         oeline = finfo->linenos;
+         eline = flaginfo->linenos;
+         oeline = flaginfo->linenos;

          elineend = eline + linesz * o->lineno_count;
          skipping = FALSE;
          for (; eline < elineend; eline += linesz)
          elineend = eline + linesz * o->lineno_count;
          skipping = FALSE;
          for (; eline < elineend; eline += linesz)


@@ -2162,7 +2203,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                {
                  long indx;
 
                {
                  long indx;
 

-                 indx = finfo->sym_indices[iline.l_addr.l_symndx];
+                 indx = flaginfo->sym_indices[iline.l_addr.l_symndx];

 
                  if (indx < 0)
                    {
 
                  if (indx < 0)
                    {


@@ -2188,7 +2229,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                         of the line numbers rather than an absolute
                         file index.  */
                      bfd_coff_swap_sym_in (output_bfd,
                         of the line numbers rather than an absolute
                         file index.  */
                      bfd_coff_swap_sym_in (output_bfd,

-                                           (finfo->outsyms
+                                           (flaginfo->outsyms

                                             + ((indx - syment_base)
                                                * osymesz)), &is);
                      if ((ISFCN (is.n_type)
                                             + ((indx - syment_base)
                                                * osymesz)), &is);
                      if ((ISFCN (is.n_type)


@@ -2197,7 +2238,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                        {
                          void *auxptr;
 
                        {
                          void *auxptr;
 

-                         auxptr = (finfo->outsyms
+                         auxptr = (flaginfo->outsyms

                                    + ((indx - syment_base + 1)
                                       * osymesz));
                          bfd_coff_swap_aux_in (output_bfd, auxptr,
                                    + ((indx - syment_base + 1)
                                       * osymesz));
                          bfd_coff_swap_aux_in (output_bfd, auxptr,


@@ -2206,7 +2247,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                          ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
                            (o->output_section->line_filepos
                             + o->output_section->lineno_count * linesz
                          ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
                            (o->output_section->line_filepos
                             + o->output_section->lineno_count * linesz

-                            + eline - finfo->linenos);
+                            + eline - flaginfo->linenos);

                          bfd_coff_swap_aux_out (output_bfd, &ia,
                                                 is.n_type, is.n_sclass, 0,
                                                 is.n_numaux, auxptr);
                          bfd_coff_swap_aux_out (output_bfd, &ia,
                                                 is.n_type, is.n_sclass, 0,
                                                 is.n_numaux, auxptr);


@@ -2227,9 +2268,9 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
 
          pos = o->output_section->line_filepos;
          pos += o->output_section->lineno_count * linesz;
 
          pos = o->output_section->line_filepos;
          pos += o->output_section->lineno_count * linesz;

-         amt = oeline - finfo->linenos;
+         amt = oeline - flaginfo->linenos;

          if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
          if (bfd_seek (output_bfd, pos, SEEK_SET) != 0

-             || bfd_bwrite (finfo->linenos, amt, output_bfd) != amt)
+             || bfd_bwrite (flaginfo->linenos, amt, output_bfd) != amt)

            return FALSE;
 
          o->output_section->lineno_count += amt / linesz;
            return FALSE;
 
          o->output_section->lineno_count += amt / linesz;


@@ -2240,30 +2281,30 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
      symbol will be the first symbol in the next input file.  In the
      normal case, this will save us from writing out the C_FILE symbol
      again.  */
      symbol will be the first symbol in the next input file.  In the
      normal case, this will save us from writing out the C_FILE symbol
      again.  */

-  if (finfo->last_file_index != -1
-      && (bfd_size_type) finfo->last_file_index >= syment_base)
+  if (flaginfo->last_file_index != -1
+      && (bfd_size_type) flaginfo->last_file_index >= syment_base)

     {
     {

-      finfo->last_file.n_value = output_index;
-      bfd_coff_swap_sym_out (output_bfd, &finfo->last_file,
-                            (finfo->outsyms
-                             + ((finfo->last_file_index - syment_base)
+      flaginfo->last_file.n_value = output_index;
+      bfd_coff_swap_sym_out (output_bfd, &flaginfo->last_file,
+                            (flaginfo->outsyms
+                             + ((flaginfo->last_file_index - syment_base)

                                 * osymesz)));
     }
 
   /* Write the modified symbols to the output file.  */
                                 * osymesz)));
     }
 
   /* Write the modified symbols to the output file.  */

-  if (outsym > finfo->outsyms)
+  if (outsym > flaginfo->outsyms)

     {
       file_ptr pos;
       bfd_size_type amt;
 
       pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;
     {
       file_ptr pos;
       bfd_size_type amt;
 
       pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;

-      amt = outsym - finfo->outsyms;
+      amt = outsym - flaginfo->outsyms;

       if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
       if (bfd_seek (output_bfd, pos, SEEK_SET) != 0

-         || bfd_bwrite (finfo->outsyms, amt, output_bfd) != amt)
+         || bfd_bwrite (flaginfo->outsyms, amt, output_bfd) != amt)

        return FALSE;
 
       BFD_ASSERT ((obj_raw_syment_count (output_bfd)
        return FALSE;
 
       BFD_ASSERT ((obj_raw_syment_count (output_bfd)

-                  + (outsym - finfo->outsyms) / osymesz)
+                  + (outsym - flaginfo->outsyms) / osymesz)

                  == output_index);
 
       obj_raw_syment_count (output_bfd) = output_index;
                  == output_index);
 
       obj_raw_syment_count (output_bfd) = output_index;


@@ -2304,10 +2345,9 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
        contents = secdata->contents;
       else
        {
        contents = secdata->contents;
       else
        {

-         bfd_size_type x = o->rawsize ? o->rawsize : o->size;
-         if (! bfd_get_section_contents (input_bfd, o, finfo->contents, 0, x))
+         contents = flaginfo->contents;
+         if (! bfd_get_full_section_contents (input_bfd, o, &contents))

            return FALSE;
            return FALSE;

-         contents = finfo->contents;

        }
 
       if ((o->flags & SEC_RELOC) != 0)
        }
 
       if ((o->flags & SEC_RELOC) != 0)


@@ -2319,26 +2359,56 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
          /* Read in the relocs.  */
          target_index = o->output_section->target_index;
          internal_relocs = (_bfd_coff_read_internal_relocs
          /* Read in the relocs.  */
          target_index = o->output_section->target_index;
          internal_relocs = (_bfd_coff_read_internal_relocs

-                            (input_bfd, o, FALSE, finfo->external_relocs,
-                             finfo->info->relocatable,
-                             (finfo->info->relocatable
-                              ? (finfo->section_info[target_index].relocs
+                            (input_bfd, o, FALSE, flaginfo->external_relocs,
+                             flaginfo->info->relocatable,
+                             (flaginfo->info->relocatable
+                              ? (flaginfo->section_info[target_index].relocs

                                  + o->output_section->reloc_count)
                                  + o->output_section->reloc_count)

-                              : finfo->internal_relocs)));
-         if (internal_relocs == NULL)
+                              : flaginfo->internal_relocs)));
+         if (internal_relocs == NULL
+             && o->reloc_count > 0)

            return FALSE;
 
            return FALSE;
 

+         /* Run through the relocs looking for relocs against symbols
+            coming from discarded sections and complain about them.  */
+         irel = internal_relocs;
+         for (; irel < &internal_relocs[o->reloc_count]; irel++)
+           {
+             struct coff_link_hash_entry *h;
+             asection *ps = NULL;
+             long symndx = irel->r_symndx;
+             if (symndx < 0)
+               continue;
+             h = obj_coff_sym_hashes (input_bfd)[symndx];
+             if (h == NULL)
+               continue;
+             while (h->root.type == bfd_link_hash_indirect
+                    || h->root.type == bfd_link_hash_warning)
+               h = (struct coff_link_hash_entry *) h->root.u.i.link;
+             if (h->root.type == bfd_link_hash_defined
+                 || h->root.type == bfd_link_hash_defweak)
+               ps = h->root.u.def.section;
+             if (ps == NULL)
+               continue;
+             /* Complain if definition comes from an excluded section.  */
+             if (ps->flags & SEC_EXCLUDE)
+               (*flaginfo->info->callbacks->einfo)
+                 (_("%X`%s' referenced in section `%A' of %B: "
+                    "defined in discarded section `%A' of %B\n"),
+                  h->root.root.string, o, input_bfd, ps, ps->owner);
+           }
+

          /* Call processor specific code to relocate the section
              contents.  */
          /* Call processor specific code to relocate the section
              contents.  */

-         if (! bfd_coff_relocate_section (output_bfd, finfo->info,
+         if (! bfd_coff_relocate_section (output_bfd, flaginfo->info,

                                           input_bfd, o,
                                           contents,
                                           internal_relocs,
                                           input_bfd, o,
                                           contents,
                                           internal_relocs,

-                                          finfo->internal_syms,
-                                          finfo->sec_ptrs))
+                                          flaginfo->internal_syms,
+                                          flaginfo->sec_ptrs))

            return FALSE;
 
            return FALSE;
 

-         if (finfo->info->relocatable)
+         if (flaginfo->info->relocatable)

            {
              bfd_vma offset;
              struct internal_reloc *irelend;
            {
              bfd_vma offset;
              struct internal_reloc *irelend;


@@ -2347,7 +2417,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
              offset = o->output_section->vma + o->output_offset - o->vma;
              irel = internal_relocs;
              irelend = irel + o->reloc_count;
              offset = o->output_section->vma + o->output_offset - o->vma;
              irel = internal_relocs;
              irelend = irel + o->reloc_count;

-             rel_hash = (finfo->section_info[target_index].rel_hashes
+             rel_hash = (flaginfo->section_info[target_index].rel_hashes

                          + o->output_section->reloc_count);
              for (; irel < irelend; irel++, rel_hash++)
                {
                          + o->output_section->reloc_count);
              for (; irel < irelend; irel++, rel_hash++)
                {


@@ -2364,7 +2434,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
 
                  if (adjust_symndx)
                    {
 
                  if (adjust_symndx)
                    {

-                     if (! (*adjust_symndx) (output_bfd, finfo->info,
+                     if (! (*adjust_symndx) (output_bfd, flaginfo->info,

                                              input_bfd, o, irel,
                                              &adjusted))
                        return FALSE;
                                              input_bfd, o, irel,
                                              &adjusted))
                        return FALSE;


@@ -2394,7 +2464,7 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                    {
                      long indx;
 
                    {
                      long indx;
 

-                     indx = finfo->sym_indices[irel->r_symndx];
+                     indx = flaginfo->sym_indices[irel->r_symndx];

                      if (indx != -1)
                        irel->r_symndx = indx;
                      else
                      if (indx != -1)
                        irel->r_symndx = indx;
                      else


@@ -2407,15 +2477,15 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
                              stripping.  This should have been handled
                             by the 'dont_skip_symbol' code in the while
                             loop at the top of this function.  */
                              stripping.  This should have been handled
                             by the 'dont_skip_symbol' code in the while
                             loop at the top of this function.  */

-                         is = finfo->internal_syms + irel->r_symndx;
+                         is = flaginfo->internal_syms + irel->r_symndx;

 
                          name = (_bfd_coff_internal_syment_name
                                  (input_bfd, is, buf));
                          if (name == NULL)
                            return FALSE;
 
 
                          name = (_bfd_coff_internal_syment_name
                                  (input_bfd, is, buf));
                          if (name == NULL)
                            return FALSE;
 

-                         if (! ((*finfo->info->callbacks->unattached_reloc)
-                                (finfo->info, name, input_bfd, o,
+                         if (! ((*flaginfo->info->callbacks->unattached_reloc)
+                                (flaginfo->info, name, input_bfd, o,

                                  irel->r_vaddr)))
                            return FALSE;
                        }
                                  irel->r_vaddr)))
                            return FALSE;
                        }


@@ -2437,32 +2507,33 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
       else
        {
          if (! (_bfd_write_section_stabs
       else
        {
          if (! (_bfd_write_section_stabs

-                (output_bfd, &coff_hash_table (finfo->info)->stab_info,
+                (output_bfd, &coff_hash_table (flaginfo->info)->stab_info,

                  o, &secdata->stab_info, contents)))
            return FALSE;
        }
     }
 
                  o, &secdata->stab_info, contents)))
            return FALSE;
        }
     }
 

-  if (! finfo->info->keep_memory
+  if (! flaginfo->info->keep_memory

       && ! _bfd_coff_free_symbols (input_bfd))
     return FALSE;
 
   return TRUE;
 }
 
       && ! _bfd_coff_free_symbols (input_bfd))
     return FALSE;
 
   return TRUE;
 }
 

-/* Write out a global symbol.  Called via coff_link_hash_traverse.  */
+/* Write out a global symbol.  Called via bfd_hash_traverse.  */

 
 bfd_boolean
 
 bfd_boolean

-_bfd_coff_write_global_sym (struct coff_link_hash_entry *h, void *data)
+_bfd_coff_write_global_sym (struct bfd_hash_entry *bh, void *data)

 {
 {

-  struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
+  struct coff_link_hash_entry *h = (struct coff_link_hash_entry *) bh;
+  struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data;

   bfd *output_bfd;
   struct internal_syment isym;
   bfd_size_type symesz;
   unsigned int i;
   file_ptr pos;
 
   bfd *output_bfd;
   struct internal_syment isym;
   bfd_size_type symesz;
   unsigned int i;
   file_ptr pos;
 

-  output_bfd = finfo->output_bfd;
+  output_bfd = flaginfo->output_bfd;

 
   if (h->root.type == bfd_link_hash_warning)
     {
 
   if (h->root.type == bfd_link_hash_warning)
     {


@@ -2475,9 +2546,9 @@ _bfd_coff_write_global_sym (struct coff_link_hash_entry *h, void *data)
     return TRUE;
 
   if (h->indx != -2
     return TRUE;
 
   if (h->indx != -2

-      && (finfo->info->strip == strip_all
-         || (finfo->info->strip == strip_some
-             && (bfd_hash_lookup (finfo->info->keep_hash,
+      && (flaginfo->info->strip == strip_all
+         || (flaginfo->info->strip == strip_some
+             && (bfd_hash_lookup (flaginfo->info->keep_hash,

                                   h->root.root.string, FALSE, FALSE)
                  == NULL))))
     return TRUE;
                                   h->root.root.string, FALSE, FALSE)
                  == NULL))))
     return TRUE;


@@ -2508,7 +2579,7 @@ _bfd_coff_write_global_sym (struct coff_link_hash_entry *h, void *data)
          isym.n_scnum = sec->target_index;
        isym.n_value = (h->root.u.def.value
                        + h->root.u.def.section->output_offset);
          isym.n_scnum = sec->target_index;
        isym.n_value = (h->root.u.def.value
                        + h->root.u.def.section->output_offset);

-       if (! obj_pe (finfo->output_bfd))
+       if (! obj_pe (flaginfo->output_bfd))

          isym.n_value += sec->vma;
       }
       break;
          isym.n_value += sec->vma;
       }
       break;


@@ -2533,18 +2604,18 @@ _bfd_coff_write_global_sym (struct coff_link_hash_entry *h, void *data)
       hash = TRUE;
       if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
        hash = FALSE;
       hash = TRUE;
       if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
        hash = FALSE;

-      indx = _bfd_stringtab_add (finfo->strtab, h->root.root.string, hash,
+      indx = _bfd_stringtab_add (flaginfo->strtab, h->root.root.string, hash,

                                 FALSE);
       if (indx == (bfd_size_type) -1)
        {
                                 FALSE);
       if (indx == (bfd_size_type) -1)
        {

-         finfo->failed = TRUE;
+         flaginfo->failed = TRUE;

          return FALSE;
        }
       isym._n._n_n._n_zeroes = 0;
       isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
     }
 
          return FALSE;
        }
       isym._n._n_n._n_zeroes = 0;
       isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
     }
 

-  isym.n_sclass = h->class;
+  isym.n_sclass = h->symbol_class;

   isym.n_type = h->type;
 
   if (isym.n_sclass == C_NULL)
   isym.n_type = h->type;
 
   if (isym.n_sclass == C_NULL)


@@ -2554,7 +2625,7 @@ _bfd_coff_write_global_sym (struct coff_link_hash_entry *h, void *data)
      defined globals to statics, then do that conversion now.  If the
      symbol is not being converted, just ignore it and it will be
      output during a later pass.  */
      defined globals to statics, then do that conversion now.  If the
      symbol is not being converted, just ignore it and it will be
      output during a later pass.  */

-  if (finfo->global_to_static)
+  if (flaginfo->global_to_static)

     {
       if (! IS_EXTERNAL (output_bfd, isym))
        return TRUE;
     {
       if (! IS_EXTERNAL (output_bfd, isym))
        return TRUE;


@@ -2565,23 +2636,23 @@ _bfd_coff_write_global_sym (struct coff_link_hash_entry *h, void *data)
   /* When a weak symbol is not overridden by a strong one,
      turn it into an external symbol when not building a
      shared or relocatable object.  */
   /* When a weak symbol is not overridden by a strong one,
      turn it into an external symbol when not building a
      shared or relocatable object.  */

-  if (! finfo->info->shared
-      && ! finfo->info->relocatable
-      && IS_WEAK_EXTERNAL (finfo->output_bfd, isym))
+  if (! flaginfo->info->shared
+      && ! flaginfo->info->relocatable
+      && IS_WEAK_EXTERNAL (flaginfo->output_bfd, isym))

     isym.n_sclass = C_EXT;
 
   isym.n_numaux = h->numaux;
 
     isym.n_sclass = C_EXT;
 
   isym.n_numaux = h->numaux;
 

-  bfd_coff_swap_sym_out (output_bfd, &isym, finfo->outsyms);
+  bfd_coff_swap_sym_out (output_bfd, &isym, flaginfo->outsyms);

 
   symesz = bfd_coff_symesz (output_bfd);
 
   pos = obj_sym_filepos (output_bfd);
   pos += obj_raw_syment_count (output_bfd) * symesz;
   if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
 
   symesz = bfd_coff_symesz (output_bfd);
 
   pos = obj_sym_filepos (output_bfd);
   pos += obj_raw_syment_count (output_bfd) * symesz;
   if (bfd_seek (output_bfd, pos, SEEK_SET) != 0

-      || bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
+      || bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz)

     {
     {

-      finfo->failed = TRUE;
+      flaginfo->failed = TRUE;

       return FALSE;
     }
 
       return FALSE;
     }
 


@@ -2619,7 +2690,7 @@ _bfd_coff_write_global_sym (struct coff_link_hash_entry *h, void *data)
                  not matter.  FIXME: Why not?  */
              if (sec->reloc_count > 0xffff
                  && (! obj_pe (output_bfd)
                  not matter.  FIXME: Why not?  */
              if (sec->reloc_count > 0xffff
                  && (! obj_pe (output_bfd)

-                     || finfo->info->relocatable))
+                     || flaginfo->info->relocatable))

                (*_bfd_error_handler)
                  (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
                   bfd_get_filename (output_bfd),
                (*_bfd_error_handler)
                  (_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
                   bfd_get_filename (output_bfd),


@@ -2628,7 +2699,7 @@ _bfd_coff_write_global_sym (struct coff_link_hash_entry *h, void *data)
 
              if (sec->lineno_count > 0xffff
                  && (! obj_pe (output_bfd)
 
              if (sec->lineno_count > 0xffff
                  && (! obj_pe (output_bfd)

-                     || finfo->info->relocatable))
+                     || flaginfo->info->relocatable))

                (*_bfd_error_handler)
                  (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
                   bfd_get_filename (output_bfd),
                (*_bfd_error_handler)
                  (_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
                   bfd_get_filename (output_bfd),


@@ -2645,10 +2716,10 @@ _bfd_coff_write_global_sym (struct coff_link_hash_entry *h, void *data)
 
       bfd_coff_swap_aux_out (output_bfd, auxp, isym.n_type,
                             isym.n_sclass, (int) i, isym.n_numaux,
 
       bfd_coff_swap_aux_out (output_bfd, auxp, isym.n_type,
                             isym.n_sclass, (int) i, isym.n_numaux,

-                            finfo->outsyms);
-      if (bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
+                            flaginfo->outsyms);
+      if (bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz)

        {
        {

-         finfo->failed = TRUE;
+         flaginfo->failed = TRUE;

          return FALSE;
        }
       ++obj_raw_syment_count (output_bfd);
          return FALSE;
        }
       ++obj_raw_syment_count (output_bfd);


@@ -2664,7 +2735,7 @@ _bfd_coff_write_global_sym (struct coff_link_hash_entry *h, void *data)
 bfd_boolean
 _bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data)
 {
 bfd_boolean
 _bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data)
 {

-  struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
+  struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data;

   bfd_boolean rtnval = TRUE;
   bfd_boolean save_global_to_static;
 
   bfd_boolean rtnval = TRUE;
   bfd_boolean save_global_to_static;
 


@@ -2677,10 +2748,10 @@ _bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data)
        {
        case bfd_link_hash_defined:
        case bfd_link_hash_defweak:
        {
        case bfd_link_hash_defined:
        case bfd_link_hash_defweak:

-         save_global_to_static = finfo->global_to_static;
-         finfo->global_to_static = TRUE;
-         rtnval = _bfd_coff_write_global_sym (h, data);
-         finfo->global_to_static = save_global_to_static;
+         save_global_to_static = flaginfo->global_to_static;
+         flaginfo->global_to_static = TRUE;
+         rtnval = _bfd_coff_write_global_sym (&h->root.root, data);
+         flaginfo->global_to_static = save_global_to_static;

          break;
        default:
          break;
          break;
        default:
          break;


@@ -2693,7 +2764,7 @@ _bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data)
 
 bfd_boolean
 _bfd_coff_reloc_link_order (bfd *output_bfd,
 
 bfd_boolean
 _bfd_coff_reloc_link_order (bfd *output_bfd,

-                           struct coff_final_link_info *finfo,
+                           struct coff_final_link_info *flaginfo,

                            asection *output_section,
                            struct bfd_link_order *link_order)
 {
                            asection *output_section,
                            struct bfd_link_order *link_order)
 {


@@ -2717,7 +2788,7 @@ _bfd_coff_reloc_link_order (bfd *output_bfd,
       file_ptr loc;
 
       size = bfd_get_reloc_size (howto);
       file_ptr loc;
 
       size = bfd_get_reloc_size (howto);

-      buf = bfd_zmalloc (size);
+      buf = (bfd_byte *) bfd_zmalloc (size);

       if (buf == NULL)
        return FALSE;
 
       if (buf == NULL)
        return FALSE;
 


@@ -2732,8 +2803,8 @@ _bfd_coff_reloc_link_order (bfd *output_bfd,
        case bfd_reloc_outofrange:
          abort ();
        case bfd_reloc_overflow:
        case bfd_reloc_outofrange:
          abort ();
        case bfd_reloc_overflow:

-         if (! ((*finfo->info->callbacks->reloc_overflow)
-                (finfo->info, NULL,
+         if (! ((*flaginfo->info->callbacks->reloc_overflow)
+                (flaginfo->info, NULL,

                  (link_order->type == bfd_section_reloc_link_order
                   ? bfd_section_name (output_bfd,
                                       link_order->u.reloc.p->u.section)
                  (link_order->type == bfd_section_reloc_link_order
                   ? bfd_section_name (output_bfd,
                                       link_order->u.reloc.p->u.section)


@@ -2756,9 +2827,9 @@ _bfd_coff_reloc_link_order (bfd *output_bfd,
 
   /* Store the reloc information in the right place.  It will get
      swapped and written out at the end of the final_link routine.  */
 
   /* Store the reloc information in the right place.  It will get
      swapped and written out at the end of the final_link routine.  */

-  irel = (finfo->section_info[output_section->target_index].relocs
+  irel = (flaginfo->section_info[output_section->target_index].relocs

          + output_section->reloc_count);
          + output_section->reloc_count);

-  rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
+  rel_hash_ptr = (flaginfo->section_info[output_section->target_index].rel_hashes

                  + output_section->reloc_count);
 
   memset (irel, 0, sizeof (struct internal_reloc));
                  + output_section->reloc_count);
 
   memset (irel, 0, sizeof (struct internal_reloc));


@@ -2781,7 +2852,7 @@ _bfd_coff_reloc_link_order (bfd *output_bfd,
       struct coff_link_hash_entry *h;
 
       h = ((struct coff_link_hash_entry *)
       struct coff_link_hash_entry *h;
 
       h = ((struct coff_link_hash_entry *)

-          bfd_wrapped_link_hash_lookup (output_bfd, finfo->info,
+          bfd_wrapped_link_hash_lookup (output_bfd, flaginfo->info,

                                         link_order->u.reloc.p->u.name,
                                         FALSE, FALSE, TRUE));
       if (h != NULL)
                                         link_order->u.reloc.p->u.name,
                                         FALSE, FALSE, TRUE));
       if (h != NULL)


@@ -2799,8 +2870,8 @@ _bfd_coff_reloc_link_order (bfd *output_bfd,
        }
       else
        {
        }
       else
        {

-         if (! ((*finfo->info->callbacks->unattached_reloc)
-                (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
+         if (! ((*flaginfo->info->callbacks->unattached_reloc)
+                (flaginfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,

                  (asection *) NULL, (bfd_vma) 0)))
            return FALSE;
          irel->r_symndx = 0;
                  (asection *) NULL, (bfd_vma) 0)))
            return FALSE;
          irel->r_symndx = 0;


@@ -2907,6 +2978,11 @@ _bfd_coff_generic_relocate_section (bfd *output_bfd,
          else
            {
              sec = sections[symndx];
          else
            {
              sec = sections[symndx];

+
+             /* If the output section has been discarded then ignore this reloc.  */
+             if (sec->output_section->vma == 0)
+               continue;
+

               val = (sec->output_section->vma
                     + sec->output_offset
                     + sym->n_value);
               val = (sec->output_section->vma
                     + sec->output_offset
                     + sym->n_value);


@@ -2930,7 +3006,7 @@ _bfd_coff_generic_relocate_section (bfd *output_bfd,
 
          else if (h->root.type == bfd_link_hash_undefweak)
            {
 
          else if (h->root.type == bfd_link_hash_undefweak)
            {

-              if (h->class == C_NT_WEAK && h->numaux == 1)
+              if (h->symbol_class == C_NT_WEAK && h->numaux == 1)

                {
                  /* See _Microsoft Portable Executable and Common Object
                      File Format Specification_, section 5.5.3.
                {
                  /* See _Microsoft Portable Executable and Common Object
                      File Format Specification_, section 5.5.3.


@@ -2944,7 +3020,7 @@ _bfd_coff_generic_relocate_section (bfd *output_bfd,
                     See also linker.c: generic_link_check_archive_element. */
                  asection *sec;
                  struct coff_link_hash_entry *h2 =
                     See also linker.c: generic_link_check_archive_element. */
                  asection *sec;
                  struct coff_link_hash_entry *h2 =

-                   input_bfd->tdata.coff_obj_data->sym_hashes[
+                   h->auxbfd->tdata.coff_obj_data->sym_hashes[

                    h->aux->x_sym.x_tagndx.l];
 
                  if (!h2 || h2->root.type == bfd_link_hash_undefined)
                    h->aux->x_sym.x_tagndx.l];
 
                  if (!h2 || h2->root.type == bfd_link_hash_undefined)


@@ -2982,16 +3058,16 @@ _bfd_coff_generic_relocate_section (bfd *output_bfd,
                 absolute.  We output the address here to a file.
                 This file is then read by dlltool when generating the
                 reloc section.  Note that the base file is not
                 absolute.  We output the address here to a file.
                 This file is then read by dlltool when generating the
                 reloc section.  Note that the base file is not

-                portable between systems.  We write out a long here,
-                and dlltool reads in a long.  */
-             long addr = (rel->r_vaddr
+                portable between systems.  We write out a bfd_vma here,
+                and dlltool reads in a bfd_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;
                           - 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;

-             if (fwrite (&addr, 1, sizeof (long), (FILE *) info->base_file)
-                 != sizeof (long))
+             if (fwrite (&addr, 1, sizeof (bfd_vma), (FILE *) info->base_file)
+                 != sizeof (bfd_vma))

                {
                  bfd_set_error (bfd_error_system_call);
                  return FALSE;
                {
                  bfd_set_error (bfd_error_system_call);
                  return FALSE;