Add a testcase for PR ld/13839

[deliverable/binutils-gdb.git] / bfd / cofflink.c

diff --git a/bfd/cofflink.c b/bfd/cofflink.c
index 815c8d58020cc925a6abef8b209864e244d8b92a..1ebdfdd8009d78fdf5464b0a235534128ef89512 100644 (file)
--- a/bfd/cofflink.c
+++ b/bfd/cofflink.c
@@ -1,13 +1,13 @@
 /* COFF specific linker code.
    Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
 /* COFF specific linker code.
    Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,

-   2004 Free Software Foundation, Inc.
+   2004, 2005, 2006, 2007, 2008, 2009, 2011 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,12 +17,13 @@
 
    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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 "bfdlink.h"
 #include "libbfd.h"
 #include "coff/internal.h"


@@ -78,7 +79,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 +95,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 +110,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;


@@ -194,7 +197,8 @@ coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 static bfd_boolean
 coff_link_check_ar_symbols (bfd *abfd,
                            struct bfd_link_info *info,
 static bfd_boolean
 coff_link_check_ar_symbols (bfd *abfd,
                            struct bfd_link_info *info,

-                           bfd_boolean *pneeded)
+                           bfd_boolean *pneeded,
+                           bfd **subsbfd)

 {
   bfd_size_type symesz;
   bfd_byte *esym;
 {
   bfd_size_type symesz;
   bfd_byte *esym;


@@ -230,7 +234,7 @@ coff_link_check_ar_symbols (bfd *abfd,
          /* Auto import.  */
          if (!h
              && info->pei386_auto_import
          /* Auto import.  */
          if (!h
              && info->pei386_auto_import

-             && !strncmp (name,"__imp_", 6))
+             && CONST_STRNEQ (name, "__imp_"))

            h = bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, TRUE);
 
          /* We are only interested in symbols that are currently
            h = bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, TRUE);
 
          /* We are only interested in symbols that are currently


@@ -240,7 +244,8 @@ coff_link_check_ar_symbols (bfd *abfd,
          if (h != (struct bfd_link_hash_entry *) NULL
              && h->type == bfd_link_hash_undefined)
            {
          if (h != (struct bfd_link_hash_entry *) NULL
              && h->type == bfd_link_hash_undefined)
            {

-             if (! (*info->callbacks->add_archive_element) (info, abfd, name))
+             if (!(*info->callbacks
+                   ->add_archive_element) (info, abfd, name, subsbfd))

                return FALSE;
              *pneeded = TRUE;
              return TRUE;
                return FALSE;
              *pneeded = TRUE;
              return TRUE;


@@ -264,20 +269,38 @@ coff_link_check_archive_element (bfd *abfd,
                                 struct bfd_link_info *info,
                                 bfd_boolean *pneeded)
 {
                                 struct bfd_link_info *info,
                                 bfd_boolean *pneeded)
 {

-  if (! _bfd_coff_get_external_symbols (abfd))
-    return FALSE;
+  bfd *oldbfd;
+  bfd_boolean needed;

 
 

-  if (! coff_link_check_ar_symbols (abfd, info, pneeded))
+  if (!_bfd_coff_get_external_symbols (abfd))

     return FALSE;
 
     return FALSE;
 

-  if (*pneeded
-      && ! coff_link_add_symbols (abfd, info))
+  oldbfd = abfd;
+  if (!coff_link_check_ar_symbols (abfd, info, pneeded, &abfd))

     return FALSE;
 
     return FALSE;
 

-  if ((! info->keep_memory || ! *pneeded)
-      && ! _bfd_coff_free_symbols (abfd))
-    return FALSE;
+  needed = *pneeded;
+  if (needed)
+    {
+      /* Potentially, the add_archive_element hook may have set a
+        substitute BFD for us.  */
+      if (abfd != oldbfd)
+       {
+         if (!info->keep_memory
+             && !_bfd_coff_free_symbols (oldbfd))
+           return FALSE;
+         if (!_bfd_coff_get_external_symbols (abfd))
+           return FALSE;
+       }
+      if (!coff_link_add_symbols (abfd, info))
+       return FALSE;
+    }

 
 

+  if (!info->keep_memory || !needed)
+    {
+      if (!_bfd_coff_free_symbols (abfd))
+       return FALSE;
+    }

   return TRUE;
 }
 
   return TRUE;
 }
 


@@ -299,6 +322,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 +337,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 +463,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 +502,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 +594,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;


@@ -581,7 +607,7 @@ coff_link_add_symbols (bfd *abfd,
          asection *stab;
          
          for (stab = abfd->sections; stab; stab = stab->next)
          asection *stab;
          
          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]))))
            {
                && (!stab->name[5]
                    || (stab->name[5] == '.' && ISDIGIT (stab->name[6]))))
            {


@@ -693,7 +719,7 @@ _bfd_coff_final_link (bfd *abfd,
     {
       o->reloc_count = 0;
       o->lineno_count = 0;
     {
       o->reloc_count = 0;
       o->lineno_count = 0;

-      for (p = o->link_order_head; p != NULL; p = p->next)
+      for (p = o->map_head.link_order; p != NULL; p = p->next)

        {
          if (p->type == bfd_indirect_link_order)
            {
        {
          if (p->type == bfd_indirect_link_order)
            {


@@ -766,7 +792,7 @@ _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);
+      finfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);

       if (finfo.section_info == NULL)
        goto error_return;
       for (i = 0; i <= abfd->section_count; i++)
       if (finfo.section_info == NULL)
        goto error_return;
       for (i = 0; i <= abfd->section_count; i++)


@@ -809,10 +835,12 @@ _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);
+         finfo.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);
+         finfo.section_info[o->target_index].rel_hashes =
+              (struct coff_link_hash_entry **) bfd_malloc (amt);

          if (finfo.section_info[o->target_index].relocs == NULL
              || finfo.section_info[o->target_index].rel_hashes == NULL)
            goto error_return;
          if (finfo.section_info[o->target_index].relocs == NULL
              || finfo.section_info[o->target_index].rel_hashes == NULL)
            goto error_return;


@@ -838,28 +866,28 @@ _bfd_coff_final_link (bfd *abfd,
       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);
+  finfo.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);
+  finfo.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);
+  finfo.sym_indices = (long int *) bfd_malloc (amt);
+  finfo.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);
+  finfo.linenos = (bfd_byte *) bfd_malloc (amt);
+  finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);

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

-  finfo.external_relocs = bfd_malloc (amt);
+  finfo.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);
+      finfo.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)
     }
   if ((finfo.internal_syms == NULL && max_sym_count > 0)
       || (finfo.sec_ptrs == NULL && max_sym_count > 0)


@@ -888,7 +916,7 @@ _bfd_coff_final_link (bfd *abfd,
 
   for (o = abfd->sections; o != NULL; o = o->next)
     {
 
   for (o = abfd->sections; o != NULL; o = o->next)
     {

-      for (p = o->link_order_head; p != NULL; p = p->next)
+      for (p = o->map_head.link_order; p != NULL; p = p->next)

        {
          if (p->type == bfd_indirect_link_order
              && bfd_family_coff (p->u.indirect.section->owner))
        {
          if (p->type == bfd_indirect_link_order
              && bfd_family_coff (p->u.indirect.section->owner))


@@ -915,6 +943,92 @@ _bfd_coff_final_link (bfd *abfd,
        }
     }
 
        }
     }
 

+  if (finfo.info->strip != strip_all && finfo.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 ((finfo.info->strip == strip_some
+                  && (bfd_hash_lookup (finfo.info->keep_hash,
+                                       bfd_asymbol_name(sym), FALSE, FALSE)
+                      == NULL))
+                 || (((finfo.info->discard == discard_sec_merge
+                       && (bfd_get_section (sym)->flags & SEC_MERGE)
+                       && ! finfo.info->relocatable)
+                      || finfo.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 (finfo.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, finfo.outsyms);
+                 rewrite = TRUE;
+               }
+
+             if (isym.n_sclass == C_FILE)
+               {
+                 if (finfo.last_file_index != -1)
+                   {
+                     finfo.last_file.n_value = obj_raw_syment_count (abfd);
+                     bfd_coff_swap_sym_out (abfd, &finfo.last_file,
+                                            finfo.outsyms);
+                     pos = obj_sym_filepos (abfd) + finfo.last_file_index
+                                                    * symesz;
+                     rewrite = TRUE;
+                   }
+                 finfo.last_file_index = obj_raw_syment_count (abfd);
+                 finfo.last_file = isym;
+               }
+
+             if (rewrite
+                 && (bfd_seek (abfd, pos, SEEK_SET) != 0
+                     || bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz))
+               goto error_return;
+
+             obj_raw_syment_count (abfd) += written;
+           }
+       }
+    }
+

   if (! bfd_coff_final_link_postscript (abfd, & finfo))
     goto error_return;
 
   if (! bfd_coff_final_link_postscript (abfd, & finfo))
     goto error_return;
 


@@ -991,8 +1105,7 @@ _bfd_coff_final_link (bfd *abfd,
 
   /* Write out the global symbols.  */
   finfo.failed = FALSE;
 
   /* Write out the global symbols.  */
   finfo.failed = FALSE;

-  coff_link_hash_traverse (coff_hash_table (info),
-                          _bfd_coff_write_global_sym, &finfo);
+  bfd_hash_traverse (&info->hash->table, _bfd_coff_write_global_sym, &finfo);

   if (finfo.failed)
     goto error_return;
 
   if (finfo.failed)
     goto error_return;
 


@@ -1009,7 +1122,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;
 


@@ -1221,25 +1334,23 @@ process_embedded_commands (bfd *output_bfd,
        free (copy);
       return 0;
     }
        free (copy);
       return 0;
     }

-  e = copy + sec->size;
+  e = (char *) copy + sec->size;

 
 

-  for (s = copy;  s < e ; )
+  for (s = (char *) copy; s < e ; )

     {
     {

-      if (s[0]!= '-')
+      if (s[0] != '-')

        {
          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 +1364,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 +1383,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++;


@@ -1345,9 +1463,6 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
 {
   unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
   unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;
 {
   unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
   unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;

-#if 0
-  unsigned int n_btmask = coff_data (input_bfd)->local_n_btmask;
-#endif

   bfd_boolean (*adjust_symndx)
     (bfd *, struct bfd_link_info *, bfd *, asection *,
      struct internal_reloc *, bfd_boolean *);
   bfd_boolean (*adjust_symndx)
     (bfd *, struct bfd_link_info *, bfd *, asection *,
      struct internal_reloc *, bfd_boolean *);


@@ -1504,11 +1619,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
 


@@ -1594,10 +1711,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.  */


@@ -1621,7 +1738,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;
 


@@ -1631,7 +1749,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);


@@ -1686,7 +1804,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;


@@ -1926,6 +2044,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);
            }
 


@@ -1941,7 +2060,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
                {


@@ -2331,6 +2450,35 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
          if (internal_relocs == NULL)
            return FALSE;
 
          if (internal_relocs == NULL)
            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)
+               (*finfo->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.  */
          if (! bfd_coff_relocate_section (output_bfd, finfo->info,
          /* Call processor specific code to relocate the section
              contents.  */
          if (! bfd_coff_relocate_section (output_bfd, finfo->info,


@@ -2453,11 +2601,12 @@ _bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
   return TRUE;
 }
 
   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_link_hash_entry *h = (struct coff_link_hash_entry *) bh;

   struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
   bfd *output_bfd;
   struct internal_syment isym;
   struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
   bfd *output_bfd;
   struct internal_syment isym;


@@ -2547,7 +2696,7 @@ _bfd_coff_write_global_sym (struct coff_link_hash_entry *h, void *data)
       isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
     }
 
       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)


@@ -2682,7 +2831,7 @@ _bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data)
        case bfd_link_hash_defweak:
          save_global_to_static = finfo->global_to_static;
          finfo->global_to_static = TRUE;
        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);
+         rtnval = _bfd_coff_write_global_sym (&h->root.root, data);

          finfo->global_to_static = save_global_to_static;
          break;
        default:
          finfo->global_to_static = save_global_to_static;
          break;
        default:


@@ -2720,7 +2869,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;
 


@@ -2933,19 +3082,21 @@ _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.
                     Note that weak symbols without aux records are a GNU
                     extension.
                     FIXME: All weak externals are treated as having
                {
                  /* See _Microsoft Portable Executable and Common Object
                      File Format Specification_, section 5.5.3.
                     Note that weak symbols without aux records are a GNU
                     extension.
                     FIXME: All weak externals are treated as having

-                    characteristics IMAGE_WEAK_EXTERN_SEARCH_LIBRARY (2).
-                    There are no known uses of the other two types of
-                    weak externals.  */
+                    characteristic IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY (1).
+                    These behave as per SVR4 ABI:  A library member
+                    will resolve a weak external only if a normal
+                    external causes the library member to be linked.
+                    See also linker.c: generic_link_check_archive_element. */

                  asection *sec;
                  struct coff_link_hash_entry *h2 =
                  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)


@@ -2983,16 +3134,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;