X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=bfd%2Fcoffgen.c;h=0a1c97c2faad5afab9c06e372cda5af7c945c0df;hb=9af17804e939a7d07adb86d8c16992e4c92b46ff;hp=a2b0d5d0ddc2942f984c4cd6e9bb7c16855074ef;hpb=d003868ea7bfa700dd91cbb6198b75f341a456e7;p=deliverable%2Fbinutils-gdb.git

diff --git a/bfd/coffgen.c b/bfd/coffgen.c
index a2b0d5d0dd..0a1c97c2fa 100644
--- a/bfd/coffgen.c
+++ b/bfd/coffgen.c
@@ -1,24 +1,25 @@
 /* Support for the generic parts of COFF, for BFD.
    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-   2000, 2001, 2002, 2003, 2004
+   2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
    Free Software Foundation, Inc.
    Written by Cygnus Support.
 
-This file is part of BFD, the Binary File Descriptor library.
+   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
-(at your option) any later version.
+   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 3 of the License, or
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-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.  */
+   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.  */
 
 /* Most of this hacked by  Steve Chamberlain, sac@cygnus.com.
    Split out of coffcode.h by Ian Taylor, ian@cygnus.com.  */
@@ -37,48 +38,19 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
    Those functions may not use any COFF specific information, such as
    coff_data (abfd).  */
 
-#include "bfd.h"
 #include "sysdep.h"
+#include "bfd.h"
 #include "libbfd.h"
 #include "coff/internal.h"
 #include "libcoff.h"
 
-static void coff_fix_symbol_name
-  PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_size_type *,
-	   asection **, bfd_size_type *));
-static bfd_boolean coff_write_symbol
-  PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_vma *,
-	   bfd_size_type *, asection **, bfd_size_type *));
-static bfd_boolean coff_write_alien_symbol
-  PARAMS ((bfd *, asymbol *, bfd_vma *, bfd_size_type *,
-	   asection **, bfd_size_type *));
-static bfd_boolean coff_write_native_symbol
-  PARAMS ((bfd *, coff_symbol_type *, bfd_vma *, bfd_size_type *,
-	   asection **, bfd_size_type *));
-static void coff_pointerize_aux
-  PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
-	   unsigned int, combined_entry_type *));
-static bfd_boolean make_a_section_from_file
-  PARAMS ((bfd *, struct internal_scnhdr *, unsigned int));
-static const bfd_target *coff_real_object_p
-  PARAMS ((bfd *, unsigned, struct internal_filehdr *,
-	   struct internal_aouthdr *));
-static void fixup_symbol_value
-  PARAMS ((bfd *, coff_symbol_type *, struct internal_syment *));
-static char *build_debug_section
-  PARAMS ((bfd *));
-static char *copy_name
-  PARAMS ((bfd *, char *, size_t));
-
-#define STRING_SIZE_SIZE (4)
-
 /* Take a section header read from a coff file (in HOST byte order),
    and make a BFD "section" out of it.  This is used by ECOFF.  */
+
 static bfd_boolean
-make_a_section_from_file (abfd, hdr, target_index)
-     bfd *abfd;
-     struct internal_scnhdr *hdr;
-     unsigned int target_index;
+make_a_section_from_file (bfd *abfd,
+			  struct internal_scnhdr *hdr,
+			  unsigned int target_index)
 {
   asection *return_section;
   char *name;
@@ -87,8 +59,13 @@ make_a_section_from_file (abfd, hdr, target_index)
 
   name = NULL;
 
-  /* Handle long section names as in PE.  */
-  if (bfd_coff_long_section_names (abfd)
+  /* Handle long section names as in PE.  On reading, we want to
+    accept long names if the format permits them at all, regardless
+    of the current state of the flag that dictates if we would generate
+    them in outputs; this construct checks if that is the case by
+    attempting to set the flag, without changing its state; the call
+    will fail for formats that do not support long names at all.  */
+  if (bfd_coff_set_long_section_names (abfd, bfd_coff_long_section_names (abfd))
       && hdr->s_name[0] == '/')
     {
       char buf[SCNNMLEN];
@@ -142,7 +119,7 @@ make_a_section_from_file (abfd, hdr, target_index)
 
   return_section->lineno_count = hdr->s_nlnno;
   return_section->userdata = NULL;
-  return_section->next = (asection *) NULL;
+  return_section->next = NULL;
   return_section->target_index = target_index;
 
   if (! bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, return_section,
@@ -158,7 +135,7 @@ make_a_section_from_file (abfd, hdr, target_index)
 
   if (hdr->s_nreloc != 0)
     return_section->flags |= SEC_RELOC;
-  /* FIXME: should this check 'hdr->s_size > 0' */
+  /* FIXME: should this check 'hdr->s_size > 0'.  */
   if (hdr->s_scnptr != 0)
     return_section->flags |= SEC_HAS_CONTENTS;
 
@@ -169,17 +146,16 @@ make_a_section_from_file (abfd, hdr, target_index)
    ECOFF as well.  */
 
 static const bfd_target *
-coff_real_object_p (abfd, nscns, internal_f, internal_a)
-     bfd *abfd;
-     unsigned nscns;
-     struct internal_filehdr *internal_f;
-     struct internal_aouthdr *internal_a;
+coff_real_object_p (bfd *abfd,
+		    unsigned nscns,
+		    struct internal_filehdr *internal_f,
+		    struct internal_aouthdr *internal_a)
 {
   flagword oflags = abfd->flags;
   bfd_vma ostart = bfd_get_start_address (abfd);
-  PTR tdata;
-  PTR tdata_save;
-  bfd_size_type readsize;	/* length of file_info */
+  void * tdata;
+  void * tdata_save;
+  bfd_size_type readsize;	/* Length of file_info.  */
   unsigned int scnhsz;
   char *external_sections;
 
@@ -208,22 +184,22 @@ coff_real_object_p (abfd, nscns, internal_f, internal_a)
   /* Set up the tdata area.  ECOFF uses its own routine, and overrides
      abfd->flags.  */
   tdata_save = abfd->tdata.any;
-  tdata = bfd_coff_mkobject_hook (abfd, (PTR) internal_f, (PTR) internal_a);
+  tdata = bfd_coff_mkobject_hook (abfd, (void *) internal_f, (void *) internal_a);
   if (tdata == NULL)
     goto fail2;
 
   scnhsz = bfd_coff_scnhsz (abfd);
   readsize = (bfd_size_type) nscns * scnhsz;
-  external_sections = (char *) bfd_alloc (abfd, readsize);
+  external_sections = bfd_alloc (abfd, readsize);
   if (!external_sections)
     goto fail;
 
-  if (bfd_bread ((PTR) external_sections, readsize, abfd) != readsize)
+  if (bfd_bread ((void *) external_sections, readsize, abfd) != readsize)
     goto fail;
 
   /* Set the arch/mach *before* swapping in sections; section header swapping
      may depend on arch/mach info.  */
-  if (! bfd_coff_set_arch_mach_hook (abfd, (PTR) internal_f))
+  if (! bfd_coff_set_arch_mach_hook (abfd, (void *) internal_f))
     goto fail;
 
   /* Now copy data as required; construct all asections etc.  */
@@ -234,8 +210,8 @@ coff_real_object_p (abfd, nscns, internal_f, internal_a)
 	{
 	  struct internal_scnhdr tmp;
 	  bfd_coff_swap_scnhdr_in (abfd,
-				   (PTR) (external_sections + i * scnhsz),
-				   (PTR) & tmp);
+				   (void *) (external_sections + i * scnhsz),
+				   (void *) & tmp);
 	  if (! make_a_section_from_file (abfd, &tmp, i + 1))
 	    goto fail;
 	}
@@ -256,17 +232,16 @@ coff_real_object_p (abfd, nscns, internal_f, internal_a)
    not a COFF file.  This is also used by ECOFF.  */
 
 const bfd_target *
-coff_object_p (abfd)
-     bfd *abfd;
+coff_object_p (bfd *abfd)
 {
   bfd_size_type filhsz;
   bfd_size_type aoutsz;
   unsigned int nscns;
-  PTR filehdr;
+  void * filehdr;
   struct internal_filehdr internal_f;
   struct internal_aouthdr internal_a;
 
-  /* figure out how much to read */
+  /* Figure out how much to read.  */
   filhsz = bfd_coff_filhsz (abfd);
   aoutsz = bfd_coff_aoutsz (abfd);
 
@@ -301,7 +276,7 @@ coff_object_p (abfd)
 
   if (internal_f.f_opthdr)
     {
-      PTR opthdr;
+      void * opthdr;
 
       opthdr = bfd_alloc (abfd, aoutsz);
       if (opthdr == NULL)
@@ -312,7 +287,7 @@ coff_object_p (abfd)
 	  bfd_release (abfd, opthdr);
 	  return NULL;
 	}
-      bfd_coff_swap_aouthdr_in (abfd, opthdr, (PTR) &internal_a);
+      bfd_coff_swap_aouthdr_in (abfd, opthdr, (void *) &internal_a);
       bfd_release (abfd, opthdr);
     }
 
@@ -325,9 +300,7 @@ coff_object_p (abfd)
 /* Get the BFD section from a COFF symbol section number.  */
 
 asection *
-coff_section_from_bfd_index (abfd, index)
-     bfd *abfd;
-     int index;
+coff_section_from_bfd_index (bfd *abfd, int index)
 {
   struct bfd_section *answer = abfd->sections;
 
@@ -353,8 +326,7 @@ coff_section_from_bfd_index (abfd, index)
 /* Get the upper bound of a COFF symbol table.  */
 
 long
-coff_get_symtab_upper_bound (abfd)
-     bfd *abfd;
+coff_get_symtab_upper_bound (bfd *abfd)
 {
   if (!bfd_coff_slurp_symbol_table (abfd))
     return -1;
@@ -365,9 +337,7 @@ coff_get_symtab_upper_bound (abfd)
 /* Canonicalize a COFF symbol table.  */
 
 long
-coff_canonicalize_symtab (abfd, alocation)
-     bfd *abfd;
-     asymbol **alocation;
+coff_canonicalize_symtab (bfd *abfd, asymbol **alocation)
 {
   unsigned int counter;
   coff_symbol_type *symbase;
@@ -390,10 +360,9 @@ coff_canonicalize_symtab (abfd, alocation)
    >= SYMNMLEN + 1.  */
 
 const char *
-_bfd_coff_internal_syment_name (abfd, sym, buf)
-     bfd *abfd;
-     const struct internal_syment *sym;
-     char *buf;
+_bfd_coff_internal_syment_name (bfd *abfd,
+				const struct internal_syment *sym,
+				char *buf)
 {
   /* FIXME: It's not clear this will work correctly if sizeof
      (_n_zeroes) != 4.  */
@@ -430,14 +399,12 @@ _bfd_coff_internal_syment_name (abfd, sym, buf)
    value must be INTERNAL_RELOCS.  The function returns NULL on error.  */
 
 struct internal_reloc *
-_bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
-				require_internal, internal_relocs)
-     bfd *abfd;
-     asection *sec;
-     bfd_boolean cache;
-     bfd_byte *external_relocs;
-     bfd_boolean require_internal;
-     struct internal_reloc *internal_relocs;
+_bfd_coff_read_internal_relocs (bfd *abfd,
+				asection *sec,
+				bfd_boolean cache,
+				bfd_byte *external_relocs,
+				bfd_boolean require_internal,
+				struct internal_reloc *internal_relocs)
 {
   bfd_size_type relsz;
   bfd_byte *free_external = NULL;
@@ -447,6 +414,9 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
   struct internal_reloc *irel;
   bfd_size_type amt;
 
+  if (sec->reloc_count == 0)
+    return internal_relocs;	/* Nothing to do.  */
+
   if (coff_section_data (abfd, sec) != NULL
       && coff_section_data (abfd, sec)->relocs != NULL)
     {
@@ -462,8 +432,8 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
   amt = sec->reloc_count * relsz;
   if (external_relocs == NULL)
     {
-      free_external = (bfd_byte *) bfd_malloc (amt);
-      if (free_external == NULL && sec->reloc_count > 0)
+      free_external = bfd_malloc (amt);
+      if (free_external == NULL)
 	goto error_return;
       external_relocs = free_external;
     }
@@ -476,8 +446,8 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
     {
       amt = sec->reloc_count;
       amt *= sizeof (struct internal_reloc);
-      free_internal = (struct internal_reloc *) bfd_malloc (amt);
-      if (free_internal == NULL && sec->reloc_count > 0)
+      free_internal = bfd_malloc (amt);
+      if (free_internal == NULL)
 	goto error_return;
       internal_relocs = free_internal;
     }
@@ -487,7 +457,7 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
   erel_end = erel + relsz * sec->reloc_count;
   irel = internal_relocs;
   for (; erel < erel_end; erel += relsz, irel++)
-    bfd_coff_swap_reloc_in (abfd, (PTR) erel, (PTR) irel);
+    bfd_coff_swap_reloc_in (abfd, (void *) erel, (void *) irel);
 
   if (free_external != NULL)
     {
@@ -500,7 +470,7 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
       if (coff_section_data (abfd, sec) == NULL)
 	{
 	  amt = sizeof (struct coff_section_tdata);
-	  sec->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
+	  sec->used_by_bfd = bfd_zalloc (abfd, amt);
 	  if (sec->used_by_bfd == NULL)
 	    goto error_return;
 	  coff_section_data (abfd, sec)->contents = NULL;
@@ -521,8 +491,7 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
 /* Set lineno_count for the output sections of a COFF file.  */
 
 int
-coff_count_linenumbers (abfd)
-     bfd *abfd;
+coff_count_linenumbers (bfd *abfd)
 {
   unsigned int limit = bfd_get_symcount (abfd);
   unsigned int i;
@@ -583,9 +552,8 @@ coff_count_linenumbers (abfd)
    area of the symbol if there is one.  */
 
 coff_symbol_type *
-coff_symbol_from (ignore_abfd, symbol)
-     bfd *ignore_abfd ATTRIBUTE_UNUSED;
-     asymbol *symbol;
+coff_symbol_from (bfd *ignore_abfd ATTRIBUTE_UNUSED,
+		  asymbol *symbol)
 {
   if (!bfd_family_coff (bfd_asymbol_bfd (symbol)))
     return (coff_symbol_type *) NULL;
@@ -597,16 +565,15 @@ coff_symbol_from (ignore_abfd, symbol)
 }
 
 static void
-fixup_symbol_value (abfd, coff_symbol_ptr, syment)
-     bfd *abfd;
-     coff_symbol_type *coff_symbol_ptr;
-     struct internal_syment *syment;
+fixup_symbol_value (bfd *abfd,
+		    coff_symbol_type *coff_symbol_ptr,
+		    struct internal_syment *syment)
 {
-
-  /* Normalize the symbol flags */
-  if (bfd_is_com_section (coff_symbol_ptr->symbol.section))
+  /* Normalize the symbol flags.  */
+  if (coff_symbol_ptr->symbol.section 
+      && bfd_is_com_section (coff_symbol_ptr->symbol.section))
     {
-      /* a common symbol is undefined with a value */
+      /* A common symbol is undefined with a value.  */
       syment->n_scnum = N_UNDEF;
       syment->n_value = coff_symbol_ptr->symbol.value;
     }
@@ -655,14 +622,12 @@ fixup_symbol_value (abfd, coff_symbol_ptr, syment)
    do that here too.  */
 
 bfd_boolean
-coff_renumber_symbols (bfd_ptr, first_undef)
-     bfd *bfd_ptr;
-     int *first_undef;
+coff_renumber_symbols (bfd *bfd_ptr, int *first_undef)
 {
   unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
   asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
   unsigned int native_index = 0;
-  struct internal_syment *last_file = (struct internal_syment *) NULL;
+  struct internal_syment *last_file = NULL;
   unsigned int symbol_index;
 
   /* COFF demands that undefined symbols come after all other symbols.
@@ -681,7 +646,7 @@ coff_renumber_symbols (bfd_ptr, first_undef)
     bfd_size_type amt;
 
     amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1);
-    newsyms = (asymbol **) bfd_alloc (bfd_ptr, amt);
+    newsyms = bfd_alloc (bfd_ptr, amt);
     if (!newsyms)
       return FALSE;
     bfd_ptr->outsymbols = newsyms;
@@ -724,26 +689,22 @@ coff_renumber_symbols (bfd_ptr, first_undef)
 
 	  if (s->u.syment.n_sclass == C_FILE)
 	    {
-	      if (last_file != (struct internal_syment *) NULL)
+	      if (last_file != NULL)
 		last_file->n_value = native_index;
 	      last_file = &(s->u.syment);
 	    }
 	  else
-	    {
+	    /* Modify the symbol values according to their section and
+	       type.  */
+	    fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment));
 
-	      /* Modify the symbol values according to their section and
-	         type */
-
-	      fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment));
-	    }
 	  for (i = 0; i < s->u.syment.n_numaux + 1; i++)
 	    s[i].offset = native_index++;
 	}
       else
-	{
-	  native_index++;
-	}
+	native_index++;
     }
+
   obj_conv_table_size (bfd_ptr) = native_index;
 
   return TRUE;
@@ -754,8 +715,7 @@ coff_renumber_symbols (bfd_ptr, first_undef)
    symbol table.  */
 
 void
-coff_mangle_symbols (bfd_ptr)
-     bfd *bfd_ptr;
+coff_mangle_symbols (bfd *bfd_ptr)
 {
   unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
   asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
@@ -775,8 +735,8 @@ coff_mangle_symbols (bfd_ptr)
 	    {
 	      /* FIXME: We should use a union here.  */
 	      s->u.syment.n_value =
-		(bfd_vma)((combined_entry_type *)
-			  ((unsigned long) s->u.syment.n_value))->offset;
+		(bfd_hostptr_t) ((combined_entry_type *)
+			  ((bfd_hostptr_t) s->u.syment.n_value))->offset;
 	      s->fix_value = 0;
 	    }
 	  if (s->fix_line)
@@ -818,22 +778,20 @@ coff_mangle_symbols (bfd_ptr)
 }
 
 static void
-coff_fix_symbol_name (abfd, symbol, native, string_size_p,
-		      debug_string_section_p, debug_string_size_p)
-     bfd *abfd;
-     asymbol *symbol;
-     combined_entry_type *native;
-     bfd_size_type *string_size_p;
-     asection **debug_string_section_p;
-     bfd_size_type *debug_string_size_p;
+coff_fix_symbol_name (bfd *abfd,
+		      asymbol *symbol,
+		      combined_entry_type *native,
+		      bfd_size_type *string_size_p,
+		      asection **debug_string_section_p,
+		      bfd_size_type *debug_string_size_p)
 {
   unsigned int name_length;
   union internal_auxent *auxent;
   char *name = (char *) (symbol->name);
 
-  if (name == (char *) NULL)
+  if (name == NULL)
     {
-      /* coff symbols always have names, so we'll make one up */
+      /* COFF symbols always have names, so we'll make one up.  */
       symbol->name = "strange";
       name = (char *) symbol->name;
     }
@@ -861,9 +819,7 @@ coff_fix_symbol_name (abfd, symbol, native, string_size_p,
       if (bfd_coff_long_filenames (abfd))
 	{
 	  if (name_length <= filnmlen)
-	    {
-	      strncpy (auxent->x_file.x_fname, name, filnmlen);
-	    }
+	    strncpy (auxent->x_file.x_fname, name, filnmlen);
 	  else
 	    {
 	      auxent->x_file.x_n.x_offset = *string_size_p + STRING_SIZE_SIZE;
@@ -881,10 +837,9 @@ coff_fix_symbol_name (abfd, symbol, native, string_size_p,
   else
     {
       if (name_length <= SYMNMLEN && !bfd_coff_force_symnames_in_strings (abfd))
-	{
-	  /* This name will fit into the symbol neatly */
-	  strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN);
-	}
+	/* This name will fit into the symbol neatly.  */
+	strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN);
+
       else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment))
 	{
 	  native->u.syment._n._n_n._n_offset = (*string_size_p
@@ -913,12 +868,12 @@ coff_fix_symbol_name (abfd, symbol, native, string_size_p,
 
 	  if (!bfd_set_section_contents (abfd,
 					 *debug_string_section_p,
-					 (PTR) buf,
+					 (void *) buf,
 					 (file_ptr) *debug_string_size_p,
 					 (bfd_size_type) prefix_len)
 	      || !bfd_set_section_contents (abfd,
 					    *debug_string_section_p,
-					    (PTR) symbol->name,
+					    (void *) symbol->name,
 					    (file_ptr) (*debug_string_size_p
 							+ prefix_len),
 					    (bfd_size_type) name_length + 1))
@@ -942,20 +897,18 @@ coff_fix_symbol_name (abfd, symbol, native, string_size_p,
 /* Write a symbol out to a COFF file.  */
 
 static bfd_boolean
-coff_write_symbol (abfd, symbol, native, written, string_size_p,
-		   debug_string_section_p, debug_string_size_p)
-     bfd *abfd;
-     asymbol *symbol;
-     combined_entry_type *native;
-     bfd_vma *written;
-     bfd_size_type *string_size_p;
-     asection **debug_string_section_p;
-     bfd_size_type *debug_string_size_p;
+coff_write_symbol (bfd *abfd,
+		   asymbol *symbol,
+		   combined_entry_type *native,
+		   bfd_vma *written,
+		   bfd_size_type *string_size_p,
+		   asection **debug_string_section_p,
+		   bfd_size_type *debug_string_size_p)
 {
   unsigned int numaux = native->u.syment.n_numaux;
   int type = native->u.syment.n_type;
   int class = native->u.syment.n_sclass;
-  PTR buf;
+  void * buf;
   bfd_size_type symesz;
 
   if (native->u.syment.n_sclass == C_FILE)
@@ -963,22 +916,17 @@ coff_write_symbol (abfd, symbol, native, written, string_size_p,
 
   if (symbol->flags & BSF_DEBUGGING
       && bfd_is_abs_section (symbol->section))
-    {
-      native->u.syment.n_scnum = N_DEBUG;
-    }
+    native->u.syment.n_scnum = N_DEBUG;
+
   else if (bfd_is_abs_section (symbol->section))
-    {
-      native->u.syment.n_scnum = N_ABS;
-    }
+    native->u.syment.n_scnum = N_ABS;
+
   else if (bfd_is_und_section (symbol->section))
-    {
-      native->u.syment.n_scnum = N_UNDEF;
-    }
+    native->u.syment.n_scnum = N_UNDEF;
+
   else
-    {
-      native->u.syment.n_scnum =
-	symbol->section->output_section->target_index;
-    }
+    native->u.syment.n_scnum =
+      symbol->section->output_section->target_index;
 
   coff_fix_symbol_name (abfd, symbol, native, string_size_p,
 			debug_string_section_p, debug_string_size_p);
@@ -1005,9 +953,7 @@ coff_write_symbol (abfd, symbol, native, written, string_size_p,
 	{
 	  bfd_coff_swap_aux_out (abfd,
 				 &((native + j + 1)->u.auxent),
-				 type,
-				 class,
-				 (int) j,
+				 type, class, (int) j,
 				 native->u.syment.n_numaux,
 				 buf);
 	  if (bfd_bwrite (buf, auxesz, abfd) != auxesz)
@@ -1028,14 +974,12 @@ coff_write_symbol (abfd, symbol, native, written, string_size_p,
    or we may be linking a non COFF file to a COFF file.  */
 
 static bfd_boolean
-coff_write_alien_symbol (abfd, symbol, written, string_size_p,
-			 debug_string_section_p, debug_string_size_p)
-     bfd *abfd;
-     asymbol *symbol;
-     bfd_vma *written;
-     bfd_size_type *string_size_p;
-     asection **debug_string_section_p;
-     bfd_size_type *debug_string_size_p;
+coff_write_alien_symbol (bfd *abfd,
+			 asymbol *symbol,
+			 bfd_vma *written,
+			 bfd_size_type *string_size_p,
+			 asection **debug_string_section_p,
+			 bfd_size_type *debug_string_size_p)
 {
   combined_entry_type *native;
   combined_entry_type dummy;
@@ -1096,14 +1040,12 @@ coff_write_alien_symbol (abfd, symbol, written, string_size_p,
 /* Write a native symbol to a COFF file.  */
 
 static bfd_boolean
-coff_write_native_symbol (abfd, symbol, written, string_size_p,
-			  debug_string_section_p, debug_string_size_p)
-     bfd *abfd;
-     coff_symbol_type *symbol;
-     bfd_vma *written;
-     bfd_size_type *string_size_p;
-     asection **debug_string_section_p;
-     bfd_size_type *debug_string_size_p;
+coff_write_native_symbol (bfd *abfd,
+			  coff_symbol_type *symbol,
+			  bfd_vma *written,
+			  bfd_size_type *string_size_p,
+			  asection **debug_string_section_p,
+			  bfd_size_type *debug_string_size_p)
 {
   combined_entry_type *native = symbol->native;
   alent *lineno = symbol->lineno;
@@ -1114,6 +1056,7 @@ coff_write_native_symbol (abfd, symbol, written, string_size_p,
   if (lineno && !symbol->done_lineno && symbol->symbol.section->owner != NULL)
     {
       unsigned int count = 0;
+
       lineno[count].u.offset = *written;
       if (native->u.syment.n_numaux)
 	{
@@ -1127,28 +1070,9 @@ coff_write_native_symbol (abfd, symbol, written, string_size_p,
       count++;
       while (lineno[count].line_number != 0)
 	{
-#if 0
-	  /* 13 april 92. sac
-	     I've been told this, but still need proof:
-	     > The second bug is also in `bfd/coffcode.h'.  This bug
-	     > causes the linker to screw up the pc-relocations for
-	     > all the line numbers in COFF code.  This bug isn't only
-	     > specific to A29K implementations, but affects all
-	     > systems using COFF format binaries.  Note that in COFF
-	     > object files, the line number core offsets output by
-	     > the assembler are relative to the start of each
-	     > procedure, not to the start of the .text section.  This
-	     > patch relocates the line numbers relative to the
-	     > `native->u.syment.n_value' instead of the section
-	     > virtual address.
-	     > modular!olson@cs.arizona.edu (Jon Olson)
-	   */
-	  lineno[count].u.offset += native->u.syment.n_value;
-#else
 	  lineno[count].u.offset +=
 	    (symbol->symbol.section->output_section->vma
 	     + symbol->symbol.section->output_offset);
-#endif
 	  count++;
 	}
       symbol->done_lineno = TRUE;
@@ -1163,18 +1087,22 @@ coff_write_native_symbol (abfd, symbol, written, string_size_p,
 			    debug_string_size_p);
 }
 
+static void
+null_error_handler (const char * fmt ATTRIBUTE_UNUSED, ...)
+{
+}
+
 /* Write out the COFF symbols.  */
 
 bfd_boolean
-coff_write_symbols (abfd)
-     bfd *abfd;
+coff_write_symbols (bfd *abfd)
 {
   bfd_size_type string_size;
   asection *debug_string_section;
   bfd_size_type debug_string_size;
   unsigned int i;
   unsigned int limit = bfd_get_symcount (abfd);
-  bfd_signed_vma written = 0;
+  bfd_vma written = 0;
   asymbol **p;
 
   string_size = 0;
@@ -1199,12 +1127,11 @@ coff_write_symbols (abfd)
 	}
     }
 
-  /* Seek to the right place */
+  /* Seek to the right place.  */
   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
     return FALSE;
 
-  /* Output all the symbols we have */
-
+  /* Output all the symbols we have.  */
   written = 0;
   for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
     {
@@ -1221,6 +1148,42 @@ coff_write_symbols (abfd)
 	}
       else
 	{
+	  if (coff_backend_info (abfd)->_bfd_coff_classify_symbol != NULL)
+	    {
+	      bfd_error_handler_type current_error_handler;
+	      enum coff_symbol_classification class;
+	      unsigned char *n_sclass;
+
+	      /* Suppress error reporting by bfd_coff_classify_symbol.
+		 Error messages can be generated when we are processing a local
+		 symbol which has no associated section and we do not have to
+		 worry about this, all we need to know is that it is local.  */
+	      current_error_handler = bfd_set_error_handler (null_error_handler);
+	      class = bfd_coff_classify_symbol (abfd, &c_symbol->native->u.syment);
+	      (void) bfd_set_error_handler (current_error_handler);
+	  
+	      n_sclass = &c_symbol->native->u.syment.n_sclass;
+
+	      /* If the symbol class has been changed (eg objcopy/ld script/etc)
+		 we cannot retain the existing sclass from the original symbol.
+		 Weak symbols only have one valid sclass, so just set it always.
+		 If it is not local class and should be, set it C_STAT.
+		 If it is global and not classified as global, or if it is
+		 weak (which is also classified as global), set it C_EXT.  */
+
+	      if (symbol->flags & BSF_WEAK)
+		*n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
+	      else if (symbol->flags & BSF_LOCAL && class != COFF_SYMBOL_LOCAL)
+		*n_sclass = C_STAT;
+	      else if (symbol->flags & BSF_GLOBAL
+		       && (class != COFF_SYMBOL_GLOBAL
+#ifdef COFF_WITH_PE
+			   || *n_sclass == C_NT_WEAK
+#endif
+			   || *n_sclass == C_WEAKEXT))
+		c_symbol->native->u.syment.n_sclass = C_EXT;
+	    }
+
 	  if (!coff_write_native_symbol (abfd, c_symbol, &written,
 					 &string_size, &debug_string_section,
 					 &debug_string_size))
@@ -1230,8 +1193,7 @@ coff_write_symbols (abfd)
 
   obj_raw_syment_count (abfd) = written;
 
-  /* Now write out strings */
-
+  /* Now write out strings.  */
   if (string_size != 0)
     {
       unsigned int size = string_size + STRING_SIZE_SIZE;
@@ -1242,7 +1204,7 @@ coff_write_symbols (abfd)
 #else
  #error Change H_PUT_32
 #endif
-      if (bfd_bwrite ((PTR) buffer, (bfd_size_type) sizeof (buffer), abfd)
+      if (bfd_bwrite ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd)
 	  != sizeof (buffer))
 	return FALSE;
 
@@ -1284,18 +1246,16 @@ coff_write_symbols (abfd)
 
 	  if (c_symbol == NULL
 	      || c_symbol->native == NULL)
-	    {
-	      /* This is not a COFF symbol, so it certainly is not a
-	         file name, nor does it go in the .debug section.  */
-	      maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
-	    }
+	    /* This is not a COFF symbol, so it certainly is not a
+	       file name, nor does it go in the .debug section.  */
+	    maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
+
 	  else if (bfd_coff_symname_in_debug (abfd,
 					      &c_symbol->native->u.syment))
-	    {
-	      /* This symbol name is in the XCOFF .debug section.
-	         Don't write it into the string table.  */
-	      maxlen = name_length;
-	    }
+	    /* This symbol name is in the XCOFF .debug section.
+	       Don't write it into the string table.  */
+	    maxlen = name_length;
+
 	  else if (c_symbol->native->u.syment.n_sclass == C_FILE
 		   && c_symbol->native->u.syment.n_numaux > 0)
 	    {
@@ -1311,7 +1271,7 @@ coff_write_symbols (abfd)
 
 	  if (name_length > maxlen)
 	    {
-	      if (bfd_bwrite ((PTR) (q->name), (bfd_size_type) name_length + 1,
+	      if (bfd_bwrite ((void *) (q->name), (bfd_size_type) name_length + 1,
 			     abfd) != name_length + 1)
 		return FALSE;
 	    }
@@ -1330,7 +1290,7 @@ coff_write_symbols (abfd)
 #else
  #error Change H_PUT_32
 #endif
-      if (bfd_bwrite ((PTR) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd)
+      if (bfd_bwrite ((void *) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd)
 	  != STRING_SIZE_SIZE)
 	return FALSE;
     }
@@ -1350,12 +1310,11 @@ coff_write_symbols (abfd)
 }
 
 bfd_boolean
-coff_write_linenumbers (abfd)
-     bfd *abfd;
+coff_write_linenumbers (bfd *abfd)
 {
   asection *s;
   bfd_size_type linesz;
-  PTR buff;
+  void * buff;
 
   linesz = bfd_coff_linesz (abfd);
   buff = bfd_alloc (abfd, linesz);
@@ -1368,7 +1327,7 @@ coff_write_linenumbers (abfd)
 	  asymbol **q = abfd->outsymbols;
 	  if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0)
 	    return FALSE;
-	  /* Find all the linenumbers in this section */
+	  /* Find all the linenumbers in this section.  */
 	  while (*q)
 	    {
 	      asymbol *p = *q;
@@ -1379,9 +1338,9 @@ coff_write_linenumbers (abfd)
 			    (bfd_asymbol_bfd (p), p));
 		  if (l)
 		    {
-		      /* Found a linenumber entry, output */
+		      /* Found a linenumber entry, output.  */
 		      struct internal_lineno out;
-		      memset ((PTR) & out, 0, sizeof (out));
+		      memset ((void *) & out, 0, sizeof (out));
 		      out.l_lnno = 0;
 		      out.l_addr.l_symndx = l->u.offset;
 		      bfd_coff_swap_lineno_out (abfd, &out, buff);
@@ -1410,76 +1369,20 @@ coff_write_linenumbers (abfd)
 }
 
 alent *
-coff_get_lineno (ignore_abfd, symbol)
-     bfd *ignore_abfd ATTRIBUTE_UNUSED;
-     asymbol *symbol;
+coff_get_lineno (bfd *ignore_abfd ATTRIBUTE_UNUSED, asymbol *symbol)
 {
   return coffsymbol (symbol)->lineno;
 }
 
-#if 0
-
-/* This is only called from coff_add_missing_symbols, which has been
-   disabled.  */
-
-asymbol *
-coff_section_symbol (abfd, name)
-     bfd *abfd;
-     char *name;
-{
-  asection *sec = bfd_make_section_old_way (abfd, name);
-  asymbol *sym;
-  combined_entry_type *csym;
-
-  sym = sec->symbol;
-  csym = coff_symbol_from (abfd, sym)->native;
-  /* Make sure back-end COFF stuff is there.  */
-  if (csym == 0)
-    {
-      struct foo
-	{
-	  coff_symbol_type sym;
-	  /* @@FIXME This shouldn't use a fixed size!!  */
-	  combined_entry_type e[10];
-	};
-      struct foo *f;
-
-      f = (struct foo *) bfd_zalloc (abfd, (bfd_size_type) sizeof (*f));
-      if (!f)
-	{
-	  bfd_set_error (bfd_error_no_error);
-	  return NULL;
-	}
-      coff_symbol_from (abfd, sym)->native = csym = f->e;
-    }
-  csym[0].u.syment.n_sclass = C_STAT;
-  csym[0].u.syment.n_numaux = 1;
-/*  SF_SET_STATICS (sym);       @@ ??? */
-  csym[1].u.auxent.x_scn.x_scnlen = sec->size;
-  csym[1].u.auxent.x_scn.x_nreloc = sec->reloc_count;
-  csym[1].u.auxent.x_scn.x_nlinno = sec->lineno_count;
-
-  if (sec->output_section == NULL)
-    {
-      sec->output_section = sec;
-      sec->output_offset = 0;
-    }
-
-  return sym;
-}
-
-#endif /* 0 */
-
 /* This function transforms the offsets into the symbol table into
    pointers to syments.  */
 
 static void
-coff_pointerize_aux (abfd, table_base, symbol, indaux, auxent)
-     bfd *abfd;
-     combined_entry_type *table_base;
-     combined_entry_type *symbol;
-     unsigned int indaux;
-     combined_entry_type *auxent;
+coff_pointerize_aux (bfd *abfd,
+		     combined_entry_type *table_base,
+		     combined_entry_type *symbol,
+		     unsigned int indaux,
+		     combined_entry_type *auxent)
 {
   unsigned int type = symbol->u.syment.n_type;
   unsigned int class = symbol->u.syment.n_sclass;
@@ -1491,15 +1394,16 @@ coff_pointerize_aux (abfd, table_base, symbol, indaux, auxent)
 	return;
     }
 
-  /* Don't bother if this is a file or a section */
+  /* Don't bother if this is a file or a section.  */
   if (class == C_STAT && type == T_NULL)
     return;
   if (class == C_FILE)
     return;
 
-  /* Otherwise patch up */
-#define N_TMASK coff_data (abfd)->local_n_tmask
+  /* Otherwise patch up.  */
+#define N_TMASK coff_data  (abfd)->local_n_tmask
 #define N_BTSHFT coff_data (abfd)->local_n_btshft
+  
   if ((ISFCN (type) || ISTAG (class) || class == C_BLOCK || class == C_FCN)
       && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0)
     {
@@ -1522,8 +1426,7 @@ coff_pointerize_aux (abfd, table_base, symbol, indaux, auxent)
    we didn't want to go to the trouble until someone needed it.  */
 
 static char *
-build_debug_section (abfd)
-     bfd *abfd;
+build_debug_section (bfd *abfd)
 {
   char *debug_section;
   file_ptr position;
@@ -1538,7 +1441,7 @@ build_debug_section (abfd)
     }
 
   sec_size = sect->size;
-  debug_section = (PTR) bfd_alloc (abfd, sec_size);
+  debug_section = bfd_alloc (abfd, sec_size);
   if (debug_section == NULL)
     return NULL;
 
@@ -1557,25 +1460,20 @@ build_debug_section (abfd)
 /* Return a pointer to a malloc'd copy of 'name'.  'name' may not be
    \0-terminated, but will not exceed 'maxlen' characters.  The copy *will*
    be \0-terminated.  */
+
 static char *
-copy_name (abfd, name, maxlen)
-     bfd *abfd;
-     char *name;
-     size_t maxlen;
+copy_name (bfd *abfd, char *name, size_t maxlen)
 {
   size_t len;
   char *newname;
 
   for (len = 0; len < maxlen; ++len)
-    {
-      if (name[len] == '\0')
-	{
-	  break;
-	}
-    }
+    if (name[len] == '\0')
+      break;
+
+  if ((newname = bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
+    return NULL;
 
-  if ((newname = (PTR) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
-    return (NULL);
   strncpy (newname, name, len);
   newname[len] = '\0';
   return newname;
@@ -1584,12 +1482,11 @@ copy_name (abfd, name, maxlen)
 /* Read in the external symbols.  */
 
 bfd_boolean
-_bfd_coff_get_external_symbols (abfd)
-     bfd *abfd;
+_bfd_coff_get_external_symbols (bfd *abfd)
 {
   bfd_size_type symesz;
   bfd_size_type size;
-  PTR syms;
+  void * syms;
 
   if (obj_coff_external_syms (abfd) != NULL)
     return TRUE;
@@ -1597,9 +1494,11 @@ _bfd_coff_get_external_symbols (abfd)
   symesz = bfd_coff_symesz (abfd);
 
   size = obj_raw_syment_count (abfd) * symesz;
+  if (size == 0)
+    return TRUE;
 
-  syms = (PTR) bfd_malloc (size);
-  if (syms == NULL && size != 0)
+  syms = bfd_malloc (size);
+  if (syms == NULL)
     return FALSE;
 
   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
@@ -1620,8 +1519,7 @@ _bfd_coff_get_external_symbols (abfd)
    detecting a missing string table in an archive.  */
 
 const char *
-_bfd_coff_read_string_table (abfd)
-     bfd *abfd;
+_bfd_coff_read_string_table (bfd *abfd)
 {
   char extstrsize[STRING_SIZE_SIZE];
   bfd_size_type strsize;
@@ -1668,7 +1566,7 @@ _bfd_coff_read_string_table (abfd)
       return NULL;
     }
 
-  strings = (char *) bfd_malloc (strsize);
+  strings = bfd_malloc (strsize);
   if (strings == NULL)
     return NULL;
 
@@ -1687,8 +1585,7 @@ _bfd_coff_read_string_table (abfd)
 /* Free up the external symbols and strings read from a COFF file.  */
 
 bfd_boolean
-_bfd_coff_free_symbols (abfd)
-     bfd *abfd;
+_bfd_coff_free_symbols (bfd *abfd)
 {
   if (obj_coff_external_syms (abfd) != NULL
       && ! obj_coff_keep_syms (abfd))
@@ -1711,8 +1608,7 @@ _bfd_coff_free_symbols (abfd)
    terminated string.  */
 
 combined_entry_type *
-coff_get_normalized_symtab (abfd)
-     bfd *abfd;
+coff_get_normalized_symtab (bfd *abfd)
 {
   combined_entry_type *internal;
   combined_entry_type *internal_ptr;
@@ -1729,7 +1625,7 @@ coff_get_normalized_symtab (abfd)
     return obj_raw_syments (abfd);
 
   size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type);
-  internal = (combined_entry_type *) bfd_zalloc (abfd, size);
+  internal = bfd_zalloc (abfd, size);
   if (internal == NULL && size != 0)
     return NULL;
   internal_end = internal + obj_raw_syment_count (abfd);
@@ -1739,22 +1635,22 @@ coff_get_normalized_symtab (abfd)
 
   raw_src = (char *) obj_coff_external_syms (abfd);
 
-  /* mark the end of the symbols */
+  /* Mark the end of the symbols.  */
   symesz = bfd_coff_symesz (abfd);
   raw_end = (char *) raw_src + obj_raw_syment_count (abfd) * symesz;
 
   /* FIXME SOMEDAY.  A string table size of zero is very weird, but
      probably possible.  If one shows up, it will probably kill us.  */
 
-  /* Swap all the raw entries */
+  /* Swap all the raw entries.  */
   for (internal_ptr = internal;
        raw_src < raw_end;
        raw_src += symesz, internal_ptr++)
     {
 
       unsigned int i;
-      bfd_coff_swap_sym_in (abfd, (PTR) raw_src,
-			    (PTR) & internal_ptr->u.syment);
+      bfd_coff_swap_sym_in (abfd, (void *) raw_src,
+			    (void *) & internal_ptr->u.syment);
       symbol_ptr = internal_ptr;
 
       for (i = 0;
@@ -1763,7 +1659,7 @@ coff_get_normalized_symtab (abfd)
 	{
 	  internal_ptr++;
 	  raw_src += symesz;
-	  bfd_coff_swap_aux_in (abfd, (PTR) raw_src,
+	  bfd_coff_swap_aux_in (abfd, (void *) raw_src,
 				symbol_ptr->u.syment.n_type,
 				symbol_ptr->u.syment.n_sclass,
 				(int) i, symbol_ptr->u.syment.n_numaux,
@@ -1784,11 +1680,11 @@ coff_get_normalized_symtab (abfd)
       if (internal_ptr->u.syment.n_sclass == C_FILE
 	  && internal_ptr->u.syment.n_numaux > 0)
 	{
-	  /* make a file symbol point to the name in the auxent, since
-	     the text ".file" is redundant */
+	  /* Make a file symbol point to the name in the auxent, since
+	     the text ".file" is redundant.  */
 	  if ((internal_ptr + 1)->u.auxent.x_file.x_n.x_zeroes == 0)
 	    {
-	      /* the filename is a long one, point into the string table */
+	      /* The filename is a long one, point into the string table.  */
 	      if (string_table == NULL)
 		{
 		  string_table = _bfd_coff_read_string_table (abfd);
@@ -1797,7 +1693,7 @@ coff_get_normalized_symtab (abfd)
 		}
 
 	      internal_ptr->u.syment._n._n_n._n_offset =
-		((long)
+		((bfd_hostptr_t)
 		 (string_table
 		  + (internal_ptr + 1)->u.auxent.x_file.x_n.x_offset));
 	    }
@@ -1808,21 +1704,17 @@ coff_get_normalized_symtab (abfd)
                  multiple AUX entries.  */
 	      if (internal_ptr->u.syment.n_numaux > 1
 		  && coff_data (abfd)->pe)
-		{
-		  internal_ptr->u.syment._n._n_n._n_offset =
-		    ((long)
-		     copy_name (abfd,
-				(internal_ptr + 1)->u.auxent.x_file.x_fname,
-				internal_ptr->u.syment.n_numaux * symesz));
-		}
+		internal_ptr->u.syment._n._n_n._n_offset =
+		  ((bfd_hostptr_t)
+		   copy_name (abfd,
+			      (internal_ptr + 1)->u.auxent.x_file.x_fname,
+			      internal_ptr->u.syment.n_numaux * symesz));
 	      else
-		{
-		  internal_ptr->u.syment._n._n_n._n_offset =
-		    ((long)
-		     copy_name (abfd,
-				(internal_ptr + 1)->u.auxent.x_file.x_fname,
-				(size_t) bfd_coff_filnmlen (abfd)));
-		}
+		internal_ptr->u.syment._n._n_n._n_offset =
+		  ((bfd_hostptr_t)
+		   copy_name (abfd,
+			      (internal_ptr + 1)->u.auxent.x_file.x_fname,
+			      (size_t) bfd_coff_filnmlen (abfd)));
 	    }
 	}
       else
@@ -1833,21 +1725,21 @@ coff_get_normalized_symtab (abfd)
 	      size_t i;
 	      char *newstring;
 
-	      /* find the length of this string without walking into memory
+	      /* Find the length of this string without walking into memory
 	         that isn't ours.  */
 	      for (i = 0; i < 8; ++i)
 		if (internal_ptr->u.syment._n._n_name[i] == '\0')
 		  break;
 
-	      newstring = (PTR) bfd_zalloc (abfd, (bfd_size_type) (i + 1));
+	      newstring = bfd_zalloc (abfd, (bfd_size_type) (i + 1));
 	      if (newstring == NULL)
-		return (NULL);
+		return NULL;
 	      strncpy (newstring, internal_ptr->u.syment._n._n_name, i);
-	      internal_ptr->u.syment._n._n_n._n_offset = (long int) newstring;
+	      internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) newstring;
 	      internal_ptr->u.syment._n._n_n._n_zeroes = 0;
 	    }
 	  else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
-	    internal_ptr->u.syment._n._n_n._n_offset = (long int) "";
+	    internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) "";
 	  else if (!bfd_coff_symname_in_debug (abfd, &internal_ptr->u.syment))
 	    {
 	      /* Long name already.  Point symbol at the string in the
@@ -1859,7 +1751,7 @@ coff_get_normalized_symtab (abfd)
 		    return NULL;
 		}
 	      internal_ptr->u.syment._n._n_n._n_offset =
-		((long int)
+		((bfd_hostptr_t)
 		 (string_table
 		  + internal_ptr->u.syment._n._n_n._n_offset));
 	    }
@@ -1868,7 +1760,7 @@ coff_get_normalized_symtab (abfd)
 	      /* Long name in debug section.  Very similar.  */
 	      if (debug_section == NULL)
 		debug_section = build_debug_section (abfd);
-	      internal_ptr->u.syment._n._n_n._n_offset = (long int)
+	      internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t)
 		(debug_section + internal_ptr->u.syment._n._n_n._n_offset);
 	    }
 	}
@@ -1879,13 +1771,11 @@ coff_get_normalized_symtab (abfd)
   BFD_ASSERT (obj_raw_syment_count (abfd)
 	      == (unsigned int) (internal_ptr - internal));
 
-  return (internal);
-}				/* coff_get_normalized_symtab() */
+  return internal;
+}
 
 long
-coff_get_reloc_upper_bound (abfd, asect)
-     bfd *abfd;
-     sec_ptr asect;
+coff_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
 {
   if (bfd_get_format (abfd) != bfd_object)
     {
@@ -1896,69 +1786,66 @@ coff_get_reloc_upper_bound (abfd, asect)
 }
 
 asymbol *
-coff_make_empty_symbol (abfd)
-     bfd *abfd;
+coff_make_empty_symbol (bfd *abfd)
 {
   bfd_size_type amt = sizeof (coff_symbol_type);
-  coff_symbol_type *new = (coff_symbol_type *) bfd_zalloc (abfd, amt);
+  coff_symbol_type *new = bfd_zalloc (abfd, amt);
+
   if (new == NULL)
-    return (NULL);
+    return NULL;
   new->symbol.section = 0;
   new->native = 0;
-  new->lineno = (alent *) NULL;
+  new->lineno = NULL;
   new->done_lineno = FALSE;
   new->symbol.the_bfd = abfd;
-  return &new->symbol;
+
+  return & new->symbol;
 }
 
 /* Make a debugging symbol.  */
 
 asymbol *
-coff_bfd_make_debug_symbol (abfd, ptr, sz)
-     bfd *abfd;
-     PTR ptr ATTRIBUTE_UNUSED;
-     unsigned long sz ATTRIBUTE_UNUSED;
+coff_bfd_make_debug_symbol (bfd *abfd,
+			    void * ptr ATTRIBUTE_UNUSED,
+			    unsigned long sz ATTRIBUTE_UNUSED)
 {
   bfd_size_type amt = sizeof (coff_symbol_type);
-  coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, amt);
+  coff_symbol_type *new = bfd_alloc (abfd, amt);
+
   if (new == NULL)
-    return (NULL);
+    return NULL;
   /* @@ The 10 is a guess at a plausible maximum number of aux entries
      (but shouldn't be a constant).  */
   amt = sizeof (combined_entry_type) * 10;
-  new->native = (combined_entry_type *) bfd_zalloc (abfd, amt);
+  new->native = bfd_zalloc (abfd, amt);
   if (!new->native)
-    return (NULL);
+    return NULL;
   new->symbol.section = bfd_abs_section_ptr;
   new->symbol.flags = BSF_DEBUGGING;
-  new->lineno = (alent *) NULL;
+  new->lineno = NULL;
   new->done_lineno = FALSE;
   new->symbol.the_bfd = abfd;
-  return &new->symbol;
+  
+  return & new->symbol;
 }
 
 void
-coff_get_symbol_info (abfd, symbol, ret)
-     bfd *abfd;
-     asymbol *symbol;
-     symbol_info *ret;
+coff_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret)
 {
   bfd_symbol_info (symbol, ret);
+
   if (coffsymbol (symbol)->native != NULL
       && coffsymbol (symbol)->native->fix_value)
-    {
-      ret->value = coffsymbol (symbol)->native->u.syment.n_value -
-	(unsigned long) obj_raw_syments (abfd);
-    }
+    ret->value = coffsymbol (symbol)->native->u.syment.n_value -
+      (bfd_hostptr_t) obj_raw_syments (abfd);
 }
 
 /* Return the COFF syment for a symbol.  */
 
 bfd_boolean
-bfd_coff_get_syment (abfd, symbol, psyment)
-     bfd *abfd;
-     asymbol *symbol;
-     struct internal_syment *psyment;
+bfd_coff_get_syment (bfd *abfd,
+		     asymbol *symbol,
+		     struct internal_syment *psyment)
 {
   coff_symbol_type *csym;
 
@@ -1973,7 +1860,7 @@ bfd_coff_get_syment (abfd, symbol, psyment)
 
   if (csym->native->fix_value)
     psyment->n_value = psyment->n_value -
-      (unsigned long) obj_raw_syments (abfd);
+      (bfd_hostptr_t) obj_raw_syments (abfd);
 
   /* FIXME: We should handle fix_line here.  */
 
@@ -1983,11 +1870,10 @@ bfd_coff_get_syment (abfd, symbol, psyment)
 /* Return the COFF auxent for a symbol.  */
 
 bfd_boolean
-bfd_coff_get_auxent (abfd, symbol, indx, pauxent)
-     bfd *abfd;
-     asymbol *symbol;
-     int indx;
-     union internal_auxent *pauxent;
+bfd_coff_get_auxent (bfd *abfd,
+		     asymbol *symbol,
+		     int indx,
+		     union internal_auxent *pauxent)
 {
   coff_symbol_type *csym;
   combined_entry_type *ent;
@@ -2027,13 +1913,12 @@ bfd_coff_get_auxent (abfd, symbol, indx, pauxent)
 /* Print out information about COFF symbol.  */
 
 void
-coff_print_symbol (abfd, filep, symbol, how)
-     bfd *abfd;
-     PTR filep;
-     asymbol *symbol;
-     bfd_print_symbol_type how;
+coff_print_symbol (bfd *abfd,
+		   void * filep,
+		   asymbol *symbol,
+		   bfd_print_symbol_type how)
 {
-  FILE *file = (FILE *) filep;
+  FILE * file = (FILE *) filep;
 
   switch (how)
     {
@@ -2061,30 +1946,25 @@ coff_print_symbol (abfd, filep, symbol, how)
 	  if (! combined->fix_value)
 	    val = (bfd_vma) combined->u.syment.n_value;
 	  else
-	    val = combined->u.syment.n_value - (unsigned long) root;
+	    val = combined->u.syment.n_value - (bfd_hostptr_t) root;
 
-#ifndef XCOFF64
-	  fprintf (file,
-		   "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%08lx %s",
+	  fprintf (file, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
 		   combined->u.syment.n_scnum,
 		   combined->u.syment.n_flags,
 		   combined->u.syment.n_type,
 		   combined->u.syment.n_sclass,
-		   combined->u.syment.n_numaux,
-		   (unsigned long) val,
-		   symbol->name);
-#else
-	  /* Print out the wide, 64 bit, symbol value */
-	  fprintf (file,
-		   "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%016llx %s",
-		   combined->u.syment.n_scnum,
-		   combined->u.syment.n_flags,
-		   combined->u.syment.n_type,
-		   combined->u.syment.n_sclass,
-		   combined->u.syment.n_numaux,
-		   val,
-		   symbol->name);
+		   combined->u.syment.n_numaux);
+#ifdef BFD64
+	  /* fprintf_vma() on a 64-bit enabled host will always print a 64-bit
+	     value, but really we want to display the address in the target's
+	     address size.  Since we do not have a field in the bfd structure
+	     to tell us this, we take a guess, based on the target's name.  */
+	  if (strstr (bfd_get_target (abfd), "64") == NULL)
+	    fprintf (file, "%08lx", (unsigned long) (val & 0xffffffff));
+	  else
 #endif
+	    fprintf_vma (file, val);
+	  fprintf (file, " %s", symbol->name);
 
 	  for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
 	    {
@@ -2109,10 +1989,10 @@ coff_print_symbol (abfd, filep, symbol, how)
 
 		case C_STAT:
 		  if (combined->u.syment.n_type == T_NULL)
-		    /* probably a section symbol? */
+		    /* Probably a section symbol ?  */
 		    {
 		      fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
-			       (long) auxp->u.auxent.x_scn.x_scnlen,
+			       (unsigned long) auxp->u.auxent.x_scn.x_scnlen,
 			       auxp->u.auxent.x_scn.x_nreloc,
 			       auxp->u.auxent.x_scn.x_nlinno);
 		      if (auxp->u.auxent.x_scn.x_checksum != 0
@@ -2124,7 +2004,7 @@ coff_print_symbol (abfd, filep, symbol, how)
 				 auxp->u.auxent.x_scn.x_comdat);
 		      break;
 		    }
-		    /* else fall through */
+		    /* Otherwise fall through.  */
 		case C_EXT:
 		  if (ISFCN (combined->u.syment.n_type))
 		    {
@@ -2138,11 +2018,12 @@ coff_print_symbol (abfd, filep, symbol, how)
 		      llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr;
 		      fprintf (file,
 			       "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
-			       tagndx, auxp->u.auxent.x_sym.x_misc.x_fsize,
+			       tagndx,
+			       (unsigned long) auxp->u.auxent.x_sym.x_misc.x_fsize,
 			       llnos, next);
 		      break;
 		    }
-		  /* else fall through */
+		  /* Otherwise fall through.  */
 		default:
 		  fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
 			   auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
@@ -2163,17 +2044,15 @@ coff_print_symbol (abfd, filep, symbol, how)
 	      l++;
 	      while (l->line_number)
 		{
-		  fprintf (file, "\n%4d : 0x%lx",
-			   l->line_number,
-			   ((unsigned long)
-			    (l->u.offset + symbol->section->vma)));
+		  fprintf (file, "\n%4d : ", l->line_number);
+		  fprintf_vma (file, l->u.offset + symbol->section->vma);
 		  l++;
 		}
 	    }
 	}
       else
 	{
-	  bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
+	  bfd_print_symbol_vandf (abfd, (void *) file, symbol);
 	  fprintf (file, " %-5s %s %s %s",
 		   symbol->section->name,
 		   coffsymbol (symbol)->native ? "n" : "g",
@@ -2189,9 +2068,8 @@ coff_print_symbol (abfd, filep, symbol, how)
    override it.  */
 
 bfd_boolean
-_bfd_coff_is_local_label_name (abfd, name)
-     bfd *abfd ATTRIBUTE_UNUSED;
-     const char *name;
+_bfd_coff_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
+			       const char *name)
 {
   return name[0] == '.' && name[1] == 'L';
 }
@@ -2201,21 +2079,19 @@ _bfd_coff_is_local_label_name (abfd, name)
    nearest to the wanted location.  */
 
 bfd_boolean
-coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
-			functionname_ptr, line_ptr)
-     bfd *abfd;
-     asection *section;
-     asymbol **symbols;
-     bfd_vma offset;
-     const char **filename_ptr;
-     const char **functionname_ptr;
-     unsigned int *line_ptr;
+coff_find_nearest_line (bfd *abfd,
+			asection *section,
+			asymbol **symbols,
+			bfd_vma offset,
+			const char **filename_ptr,
+			const char **functionname_ptr,
+			unsigned int *line_ptr)
 {
   bfd_boolean found;
   unsigned int i;
   unsigned int line_base;
   coff_data_type *cof = coff_data (abfd);
-  /* Run through the raw syments if available */
+  /* Run through the raw syments if available.  */
   combined_entry_type *p;
   combined_entry_type *pend;
   alent *l;
@@ -2244,7 +2120,7 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
   *functionname_ptr = 0;
   *line_ptr = 0;
 
-  /* Don't try and find line numbers in a non coff file */
+  /* Don't try and find line numbers in a non coff file.  */
   if (!bfd_family_coff (abfd))
     return FALSE;
 
@@ -2314,7 +2190,7 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
 	}
     }
 
-  /* Now wander though the raw linenumbers of the section */
+  /* Now wander though the raw linenumbers of the section.  */
   /* If we have been called on this section before, and the offset we
      want is further down then we can prime the lookup loop.  */
   sec_data = coff_section_data (abfd, section);
@@ -2342,7 +2218,7 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
 	{
 	  if (l->line_number == 0)
 	    {
-	      /* Get the symbol this line number points at */
+	      /* Get the symbol this line number points at.  */
 	      coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
 	      if (coff->symbol.value > offset)
 		break;
@@ -2396,13 +2272,13 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
   if (sec_data == NULL && section->owner == abfd)
     {
       amt = sizeof (struct coff_section_tdata);
-      section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
+      section->used_by_bfd = bfd_zalloc (abfd, amt);
       sec_data = (struct coff_section_tdata *) section->used_by_bfd;
     }
   if (sec_data != NULL)
     {
       sec_data->offset = offset;
-      sec_data->i = i;
+      sec_data->i = i - 1;
       sec_data->function = *functionname_ptr;
       sec_data->line_base = line_base;
     }
@@ -2410,32 +2286,40 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
   return TRUE;
 }
 
+bfd_boolean
+coff_find_inliner_info (bfd *abfd,
+			const char **filename_ptr,
+			const char **functionname_ptr,
+			unsigned int *line_ptr)
+{
+  bfd_boolean found;
+
+  found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
+					 functionname_ptr, line_ptr,
+					 &coff_data(abfd)->dwarf2_find_line_info);
+  return (found);
+}
+
 int
-coff_sizeof_headers (abfd, reloc)
-     bfd *abfd;
-     bfd_boolean reloc;
+coff_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
 {
   size_t size;
 
-  if (! reloc)
-    {
-      size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
-    }
+  if (!info->relocatable)
+    size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
   else
-    {
-      size = bfd_coff_filhsz (abfd);
-    }
+    size = bfd_coff_filhsz (abfd);
 
   size += abfd->section_count * bfd_coff_scnhsz (abfd);
   return size;
 }
 
 /* Change the class of a coff symbol held by BFD.  */
+
 bfd_boolean
-bfd_coff_set_symbol_class (abfd, symbol, class)
-     bfd *         abfd;
-     asymbol *     symbol;
-     unsigned int  class;
+bfd_coff_set_symbol_class (bfd *         abfd,
+			   asymbol *     symbol,
+			   unsigned int  class)
 {
   coff_symbol_type * csym;
 
@@ -2455,7 +2339,7 @@ bfd_coff_set_symbol_class (abfd, symbol, class)
       combined_entry_type * native;
       bfd_size_type amt = sizeof (* native);
 
-      native = (combined_entry_type *) bfd_zalloc (abfd, amt);
+      native = bfd_zalloc (abfd, amt);
       if (native == NULL)
 	return FALSE;
 
@@ -2489,9 +2373,7 @@ bfd_coff_set_symbol_class (abfd, symbol, class)
       csym->native = native;
     }
   else
-    {
-      csym->native->u.syment.n_sclass = class;
-    }
+    csym->native->u.syment.n_sclass = class;
 
   return TRUE;
 }
@@ -2499,7 +2381,8 @@ bfd_coff_set_symbol_class (abfd, symbol, class)
 struct coff_comdat_info *
 bfd_coff_get_comdat_section (bfd *abfd, struct bfd_section *sec)
 {
-  if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
+  if (bfd_get_flavour (abfd) == bfd_target_coff_flavour
+      && coff_section_data (abfd, sec) != NULL)
     return coff_section_data (abfd, sec)->comdat;
   else
     return NULL;