bfd/

[pf3gnuchains/pf3gnuchains4x.git] / bfd / cofflink.c

diff --git a/bfd/cofflink.c b/bfd/cofflink.c
index fd4b3fe..1ebdfdd 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, 2005, 2006 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., 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 "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;


@@ -109,7 +110,7 @@ _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 (ret == NULL)
     return NULL;
 


@@ -196,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;


@@ -242,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;


@@ -266,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;
 }
 


@@ -301,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);


@@ -311,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;
 


@@ -478,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


@@ -570,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;


@@ -768,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++)


@@ -811,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;


@@ -840,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)


@@ -917,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;
 


@@ -993,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;
 


@@ -1011,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;
 


@@ -1278,6 +1389,15 @@ process_embedded_commands (bfd *output_bfd,
       else if (CONST_STRNEQ (s, "-stack"))
        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++;
     }


@@ -1499,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
 


@@ -1589,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.  */


@@ -1616,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;
 


@@ -1626,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);


@@ -1681,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;


@@ -2327,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,


@@ -2449,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;


@@ -2543,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)


@@ -2678,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:


@@ -2716,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;
 


@@ -2929,7 +3082,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.


@@ -2943,7 +3096,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)


@@ -2981,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;