* elfcode.h: Convert to C90, remove unneeded casts and prototypes.
authorAlan Modra <amodra@gmail.com>
Mon, 4 Aug 2003 09:39:46 +0000 (09:39 +0000)
committerAlan Modra <amodra@gmail.com>
Mon, 4 Aug 2003 09:39:46 +0000 (09:39 +0000)
* elfcore.h: Likewise.
* elflink.c: Likewise.
* elflink.h: Likewise.
* elf.c (sym_is_global): Remove INLINE.
(align_file_position): Replace INLINE with inline.
* elfcode.h (elf_swap_dyn_in, elf_swap_dyn_out): Remove INLINE.
(elf_file_p): Replace INLINE with inline.

bfd/ChangeLog
bfd/elf.c
bfd/elfcode.h
bfd/elfcore.h
bfd/elflink.c
bfd/elflink.h

index 1b4b2ccc73318da3a9bde350a6c862643821e661..b2686ef969d5d9ee4ee901351b78ee99453f435e 100644 (file)
@@ -1,3 +1,14 @@
+2003-08-04  Alan Modra  <amodra@bigpond.net.au>
+
+       * elfcode.h: Convert to C90, remove unneeded casts and prototypes.
+       * elfcore.h: Likewise.
+       * elflink.c: Likewise.
+       * elflink.h: Likewise.
+       * elf.c (sym_is_global): Remove INLINE.
+       (align_file_position): Replace INLINE with inline.
+       * elfcode.h (elf_swap_dyn_in, elf_swap_dyn_out): Remove INLINE.
+       (elf_file_p): Replace INLINE with inline.
+
 2003-08-02  Kaz Kojima  <kkojima@rr.iij4u.or.jp>
 
        * elf32-sh.c (sh_elf_check_relocs): Don't set DF_TEXTREL here.
index f97d507dbb97f3ed74073db2cc403459db12dc4f..33848a2b4dc802c4d8073c6d7fbd03525d9a5d3a 100644 (file)
--- a/bfd/elf.c
+++ b/bfd/elf.c
@@ -2868,7 +2868,7 @@ assign_section_numbers (bfd *abfd)
 /* Map symbol from it's internal number to the external number, moving
    all local symbols to be at the head of the list.  */
 
-static INLINE int
+static int
 sym_is_global (bfd *abfd, asymbol *sym)
 {
   /* If the backend has a special mapping, use it.  */
@@ -3028,7 +3028,7 @@ elf_map_symbols (bfd *abfd)
 /* Align to the maximum file alignment that could be required for any
    ELF data structure.  */
 
-static INLINE file_ptr
+static inline file_ptr
 align_file_position (file_ptr off, int align)
 {
   return (off + align - 1) & ~(align - 1);
index abd7e0460fca80ab13a0ffb63105b8a1521e781c..601d208d9c7d7175cf4982f94d32d22feb266425 100644 (file)
@@ -151,31 +151,14 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #define LOG_FILE_ALIGN 2
 #endif
 
-/* Static functions */
-
-static void elf_swap_ehdr_in
-  PARAMS ((bfd *, const Elf_External_Ehdr *, Elf_Internal_Ehdr *));
-static void elf_swap_ehdr_out
-  PARAMS ((bfd *, const Elf_Internal_Ehdr *, Elf_External_Ehdr *));
-static void elf_swap_shdr_in
-  PARAMS ((bfd *, const Elf_External_Shdr *, Elf_Internal_Shdr *));
-static void elf_swap_shdr_out
-  PARAMS ((bfd *, const Elf_Internal_Shdr *, Elf_External_Shdr *));
-
 #define elf_stringtab_init _bfd_elf_stringtab_init
 
 #define section_from_elf_index bfd_section_from_elf_index
 
-static bfd_boolean elf_slurp_reloc_table_from_section
-  PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, bfd_size_type,
-          arelent *, asymbol **, bfd_boolean));
-
-static bfd_boolean elf_file_p PARAMS ((Elf_External_Ehdr *));
-
 #ifdef DEBUG
-static void elf_debug_section PARAMS ((int, Elf_Internal_Shdr *));
-static void elf_debug_file PARAMS ((Elf_Internal_Ehdr *));
-static char *elf_symbol_flags PARAMS ((flagword));
+static void elf_debug_section (int, Elf_Internal_Shdr *);
+static void elf_debug_file (Elf_Internal_Ehdr *);
+static char *elf_symbol_flags (flagword);
 #endif
 \f
 /* Structure swapping routines */
@@ -199,14 +182,13 @@ static char *elf_symbol_flags PARAMS ((flagword));
    format.  */
 
 void
-elf_swap_symbol_in (abfd, psrc, pshn, dst)
-     bfd *abfd;
-     const PTR psrc;
-     const PTR pshn;
-     Elf_Internal_Sym *dst;
+elf_swap_symbol_in (bfd *abfd,
+                   const void *psrc,
+                   const void *pshn,
+                   Elf_Internal_Sym *dst)
 {
-  const Elf_External_Sym *src = (const Elf_External_Sym *) psrc;
-  const Elf_External_Sym_Shndx *shndx = (const Elf_External_Sym_Shndx *) pshn;
+  const Elf_External_Sym *src = psrc;
+  const Elf_External_Sym_Shndx *shndx = pshn;
   int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
 
   dst->st_name = H_GET_32 (abfd, src->st_name);
@@ -230,14 +212,13 @@ elf_swap_symbol_in (abfd, psrc, pshn, dst)
    format.  */
 
 void
-elf_swap_symbol_out (abfd, src, cdst, shndx)
-     bfd *abfd;
-     const Elf_Internal_Sym *src;
-     PTR cdst;
-     PTR shndx;
+elf_swap_symbol_out (bfd *abfd,
+                    const Elf_Internal_Sym *src,
+                    void *cdst,
+                    void *shndx)
 {
   unsigned int tmp;
-  Elf_External_Sym *dst = (Elf_External_Sym *) cdst;
+  Elf_External_Sym *dst = cdst;
   H_PUT_32 (abfd, src->st_name, dst->st_name);
   H_PUT_WORD (abfd, src->st_value, dst->st_value);
   H_PUT_WORD (abfd, src->st_size, dst->st_size);
@@ -258,10 +239,9 @@ elf_swap_symbol_out (abfd, src, cdst, shndx)
    internal format.  */
 
 static void
-elf_swap_ehdr_in (abfd, src, dst)
-     bfd *abfd;
-     const Elf_External_Ehdr *src;
-     Elf_Internal_Ehdr *dst;
+elf_swap_ehdr_in (bfd *abfd,
+                 const Elf_External_Ehdr *src,
+                 Elf_Internal_Ehdr *dst)
 {
   int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
   memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
@@ -287,10 +267,9 @@ elf_swap_ehdr_in (abfd, src, dst)
    external format.  */
 
 static void
-elf_swap_ehdr_out (abfd, src, dst)
-     bfd *abfd;
-     const Elf_Internal_Ehdr *src;
-     Elf_External_Ehdr *dst;
+elf_swap_ehdr_out (bfd *abfd,
+                  const Elf_Internal_Ehdr *src,
+                  Elf_External_Ehdr *dst)
 {
   unsigned int tmp;
   int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
@@ -324,10 +303,9 @@ elf_swap_ehdr_out (abfd, src, dst)
    ELF section header table entry in internal format.  */
 
 static void
-elf_swap_shdr_in (abfd, src, dst)
-     bfd *abfd;
-     const Elf_External_Shdr *src;
-     Elf_Internal_Shdr *dst;
+elf_swap_shdr_in (bfd *abfd,
+                 const Elf_External_Shdr *src,
+                 Elf_Internal_Shdr *dst)
 {
   int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
 
@@ -352,10 +330,9 @@ elf_swap_shdr_in (abfd, src, dst)
    ELF section header table entry in external format.  */
 
 static void
-elf_swap_shdr_out (abfd, src, dst)
-     bfd *abfd;
-     const Elf_Internal_Shdr *src;
-     Elf_External_Shdr *dst;
+elf_swap_shdr_out (bfd *abfd,
+                  const Elf_Internal_Shdr *src,
+                  Elf_External_Shdr *dst)
 {
   /* note that all elements of dst are *arrays of unsigned char* already...  */
   H_PUT_32 (abfd, src->sh_name, dst->sh_name);
@@ -374,10 +351,9 @@ elf_swap_shdr_out (abfd, src, dst)
    ELF program header table entry in internal format.  */
 
 void
-elf_swap_phdr_in (abfd, src, dst)
-     bfd *abfd;
-     const Elf_External_Phdr *src;
-     Elf_Internal_Phdr *dst;
+elf_swap_phdr_in (bfd *abfd,
+                 const Elf_External_Phdr *src,
+                 Elf_Internal_Phdr *dst)
 {
   int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
 
@@ -400,10 +376,9 @@ elf_swap_phdr_in (abfd, src, dst)
 }
 
 void
-elf_swap_phdr_out (abfd, src, dst)
-     bfd *abfd;
-     const Elf_Internal_Phdr *src;
-     Elf_External_Phdr *dst;
+elf_swap_phdr_out (bfd *abfd,
+                  const Elf_Internal_Phdr *src,
+                  Elf_External_Phdr *dst)
 {
   /* note that all elements of dst are *arrays of unsigned char* already...  */
   H_PUT_32 (abfd, src->p_type, dst->p_type);
@@ -418,10 +393,9 @@ elf_swap_phdr_out (abfd, src, dst)
 
 /* Translate an ELF reloc from external format to internal format.  */
 void
-elf_swap_reloc_in (abfd, s, dst)
-     bfd *abfd;
-     const bfd_byte *s;
-     Elf_Internal_Rela *dst;
+elf_swap_reloc_in (bfd *abfd,
+                  const bfd_byte *s,
+                  Elf_Internal_Rela *dst)
 {
   const Elf_External_Rel *src = (const Elf_External_Rel *) s;
   dst->r_offset = H_GET_WORD (abfd, src->r_offset);
@@ -430,10 +404,9 @@ elf_swap_reloc_in (abfd, s, dst)
 }
 
 void
-elf_swap_reloca_in (abfd, s, dst)
-     bfd *abfd;
-     const bfd_byte *s;
-     Elf_Internal_Rela *dst;
+elf_swap_reloca_in (bfd *abfd,
+                   const bfd_byte *s,
+                   Elf_Internal_Rela *dst)
 {
   const Elf_External_Rela *src = (const Elf_External_Rela *) s;
   dst->r_offset = H_GET_WORD (abfd, src->r_offset);
@@ -443,10 +416,9 @@ elf_swap_reloca_in (abfd, s, dst)
 
 /* Translate an ELF reloc from internal format to external format.  */
 void
-elf_swap_reloc_out (abfd, src, d)
-     bfd *abfd;
-     const Elf_Internal_Rela *src;
-     bfd_byte *d;
+elf_swap_reloc_out (bfd *abfd,
+                   const Elf_Internal_Rela *src,
+                   bfd_byte *d)
 {
   Elf_External_Rel *dst = (Elf_External_Rel *) d;
   H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
@@ -454,10 +426,9 @@ elf_swap_reloc_out (abfd, src, d)
 }
 
 void
-elf_swap_reloca_out (abfd, src, d)
-     bfd *abfd;
-     const Elf_Internal_Rela *src;
-     bfd_byte *d;
+elf_swap_reloca_out (bfd *abfd,
+                    const Elf_Internal_Rela *src,
+                    bfd_byte *d)
 {
   Elf_External_Rela *dst = (Elf_External_Rela *) d;
   H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
@@ -465,25 +436,23 @@ elf_swap_reloca_out (abfd, src, d)
   H_PUT_SIGNED_WORD (abfd, src->r_addend, dst->r_addend);
 }
 
-INLINE void
-elf_swap_dyn_in (abfd, p, dst)
-     bfd *abfd;
-     const PTR p;
-     Elf_Internal_Dyn *dst;
+void
+elf_swap_dyn_in (bfd *abfd,
+                const void *p,
+                Elf_Internal_Dyn *dst)
 {
-  const Elf_External_Dyn *src = (const Elf_External_Dyn *) p;
+  const Elf_External_Dyn *src = p;
 
   dst->d_tag = H_GET_WORD (abfd, src->d_tag);
   dst->d_un.d_val = H_GET_WORD (abfd, src->d_un.d_val);
 }
 
-INLINE void
-elf_swap_dyn_out (abfd, src, p)
-     bfd *abfd;
-     const Elf_Internal_Dyn *src;
-     PTR p;
+void
+elf_swap_dyn_out (bfd *abfd,
+                 const Elf_Internal_Dyn *src,
+                 void *p)
 {
-  Elf_External_Dyn *dst = (Elf_External_Dyn *) p;
+  Elf_External_Dyn *dst = p;
 
   H_PUT_WORD (abfd, src->d_tag, dst->d_tag);
   H_PUT_WORD (abfd, src->d_un.d_val, dst->d_un.d_val);
@@ -496,9 +465,8 @@ elf_swap_dyn_out (abfd, src, p)
    First we validate the file by reading in the ELF header and checking
    the magic number.  */
 
-static INLINE bfd_boolean
-elf_file_p (x_ehdrp)
-     Elf_External_Ehdr *x_ehdrp;
+static inline bfd_boolean
+elf_file_p (Elf_External_Ehdr *x_ehdrp)
 {
   return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
          && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
@@ -515,8 +483,7 @@ elf_file_p (x_ehdrp)
    file does not match the target vector.  */
 
 const bfd_target *
-elf_object_p (abfd)
-     bfd *abfd;
+elf_object_p (bfd *abfd)
 {
   Elf_External_Ehdr x_ehdr;    /* Elf file header, external form */
   Elf_Internal_Ehdr *i_ehdrp;  /* Elf file header, internal form */
@@ -534,8 +501,7 @@ elf_object_p (abfd)
 
   /* Read in the ELF header in external format.  */
 
-  if (bfd_bread ((PTR) & x_ehdr, (bfd_size_type) sizeof (x_ehdr), abfd)
-      != sizeof (x_ehdr))
+  if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr))
     {
       if (bfd_get_error () != bfd_error_system_call)
        goto got_wrong_format_error;
@@ -669,8 +635,7 @@ elf_object_p (abfd)
 
       /* Read the first section header at index 0, and convert to internal
         form.  */
-      if (bfd_bread ((PTR) & x_shdr, (bfd_size_type) sizeof x_shdr, abfd)
-         != sizeof (x_shdr))
+      if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
        goto got_no_match;
       elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);
 
@@ -692,7 +657,7 @@ elf_object_p (abfd)
       unsigned int num_sec;
 
       amt = sizeof (*i_shdrp) * i_ehdrp->e_shnum;
-      i_shdrp = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
+      i_shdrp = bfd_alloc (abfd, amt);
       if (!i_shdrp)
        goto got_no_match;
       num_sec = i_ehdrp->e_shnum;
@@ -700,7 +665,7 @@ elf_object_p (abfd)
        num_sec += SHN_HIRESERVE + 1 - SHN_LORESERVE;
       elf_numsections (abfd) = num_sec;
       amt = sizeof (i_shdrp) * num_sec;
-      elf_elfsections (abfd) = (Elf_Internal_Shdr **) bfd_alloc (abfd, amt);
+      elf_elfsections (abfd) = bfd_alloc (abfd, amt);
       if (!elf_elfsections (abfd))
        goto got_no_match;
 
@@ -721,8 +686,7 @@ elf_object_p (abfd)
         to internal form.  */
       for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
        {
-         if (bfd_bread ((PTR) & x_shdr, (bfd_size_type) sizeof x_shdr, abfd)
-             != sizeof (x_shdr))
+         if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
            goto got_no_match;
          elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
 
@@ -753,7 +717,7 @@ elf_object_p (abfd)
       unsigned int i;
 
       amt = i_ehdrp->e_phnum * sizeof (Elf_Internal_Phdr);
-      elf_tdata (abfd)->phdr = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
+      elf_tdata (abfd)->phdr = bfd_alloc (abfd, amt);
       if (elf_tdata (abfd)->phdr == NULL)
        goto got_no_match;
       if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
@@ -763,8 +727,7 @@ elf_object_p (abfd)
        {
          Elf_External_Phdr x_phdr;
 
-         if (bfd_bread ((PTR) &x_phdr, (bfd_size_type) sizeof x_phdr, abfd)
-             != sizeof x_phdr)
+         if (bfd_bread (&x_phdr, sizeof x_phdr, abfd) != sizeof x_phdr)
            goto got_no_match;
          elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
        }
@@ -850,12 +813,9 @@ elf_object_p (abfd)
 /* Write out the relocs.  */
 
 void
-elf_write_relocs (abfd, sec, data)
-     bfd *abfd;
-     asection *sec;
-     PTR data;
+elf_write_relocs (bfd *abfd, asection *sec, void *data)
 {
-  bfd_boolean *failedp = (bfd_boolean *) data;
+  bfd_boolean *failedp = data;
   Elf_Internal_Shdr *rela_hdr;
   bfd_vma addr_offset;
   void (*swap_out) PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *));
@@ -882,7 +842,7 @@ elf_write_relocs (abfd, sec, data)
   rela_hdr = &elf_section_data (sec)->rel_hdr;
 
   rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
-  rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
+  rela_hdr->contents = bfd_alloc (abfd, rela_hdr->sh_size);
   if (rela_hdr->contents == NULL)
     {
       *failedp = TRUE;
@@ -960,17 +920,16 @@ elf_write_relocs (abfd, sec, data)
 /* Write out the program headers.  */
 
 int
-elf_write_out_phdrs (abfd, phdr, count)
-     bfd *abfd;
-     const Elf_Internal_Phdr *phdr;
-     unsigned int count;
+elf_write_out_phdrs (bfd *abfd,
+                    const Elf_Internal_Phdr *phdr,
+                    unsigned int count)
 {
   while (count--)
     {
       Elf_External_Phdr extphdr;
       elf_swap_phdr_out (abfd, phdr, &extphdr);
-      if (bfd_bwrite (&extphdr, (bfd_size_type) sizeof (Elf_External_Phdr),
-                    abfd) != sizeof (Elf_External_Phdr))
+      if (bfd_bwrite (&extphdr, sizeof (Elf_External_Phdr), abfd)
+         != sizeof (Elf_External_Phdr))
        return -1;
       phdr++;
     }
@@ -980,8 +939,7 @@ elf_write_out_phdrs (abfd, phdr, count)
 /* Write out the section headers and the ELF file header.  */
 
 bfd_boolean
-elf_write_shdrs_and_ehdr (abfd)
-     bfd *abfd;
+elf_write_shdrs_and_ehdr (bfd *abfd)
 {
   Elf_External_Ehdr x_ehdr;    /* Elf file header, external form */
   Elf_Internal_Ehdr *i_ehdrp;  /* Elf file header, internal form */
@@ -1001,7 +959,7 @@ elf_write_shdrs_and_ehdr (abfd)
   elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
   amt = sizeof (x_ehdr);
   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
-      || bfd_bwrite ((PTR) & x_ehdr, amt, abfd) != amt)
+      || bfd_bwrite (&x_ehdr, amt, abfd) != amt)
     return FALSE;
 
   /* Some fields in the first section header handle overflow of ehdr
@@ -1014,7 +972,7 @@ elf_write_shdrs_and_ehdr (abfd)
   /* at this point we've concocted all the ELF sections...  */
   amt = i_ehdrp->e_shnum;
   amt *= sizeof (*x_shdrp);
-  x_shdrp = (Elf_External_Shdr *) bfd_alloc (abfd, amt);
+  x_shdrp = bfd_alloc (abfd, amt);
   if (!x_shdrp)
     return FALSE;
 
@@ -1029,7 +987,7 @@ elf_write_shdrs_and_ehdr (abfd)
        i_shdrp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
     }
   if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
-      || bfd_bwrite ((PTR) x_shdrp, amt, abfd) != amt)
+      || bfd_bwrite (x_shdrp, amt, abfd) != amt)
     return FALSE;
 
   /* need to dump the string table too...  */
@@ -1038,10 +996,7 @@ elf_write_shdrs_and_ehdr (abfd)
 }
 
 long
-elf_slurp_symbol_table (abfd, symptrs, dynamic)
-     bfd *abfd;
-     asymbol **symptrs;                /* Buffer for generated bfd symbols */
-     bfd_boolean dynamic;
+elf_slurp_symbol_table (bfd *abfd, asymbol **symptrs, bfd_boolean dynamic)
 {
   Elf_Internal_Shdr *hdr;
   Elf_Internal_Shdr *verhdr;
@@ -1101,7 +1056,7 @@ elf_slurp_symbol_table (abfd, symptrs, dynamic)
 
       amt = symcount;
       amt *= sizeof (elf_symbol_type);
-      symbase = (elf_symbol_type *) bfd_zalloc (abfd, amt);
+      symbase = bfd_zalloc (abfd, amt);
       if (symbase == (elf_symbol_type *) NULL)
        goto error_return;
 
@@ -1125,12 +1080,11 @@ elf_slurp_symbol_table (abfd, symptrs, dynamic)
          if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
            goto error_return;
 
-         xverbuf = (Elf_External_Versym *) bfd_malloc (verhdr->sh_size);
+         xverbuf = bfd_malloc (verhdr->sh_size);
          if (xverbuf == NULL && verhdr->sh_size != 0)
            goto error_return;
 
-         if (bfd_bread ((PTR) xverbuf, verhdr->sh_size, abfd)
-             != verhdr->sh_size)
+         if (bfd_bread (xverbuf, verhdr->sh_size, abfd) != verhdr->sh_size)
            goto error_return;
        }
 
@@ -1276,25 +1230,23 @@ error_return:
    them.  */
 
 static bfd_boolean
-elf_slurp_reloc_table_from_section (abfd, asect, rel_hdr, reloc_count,
-                                   relents, symbols, dynamic)
-     bfd *abfd;
-     asection *asect;
-     Elf_Internal_Shdr *rel_hdr;
-     bfd_size_type reloc_count;
-     arelent *relents;
-     asymbol **symbols;
-     bfd_boolean dynamic;
+elf_slurp_reloc_table_from_section (bfd *abfd,
+                                   asection *asect,
+                                   Elf_Internal_Shdr *rel_hdr,
+                                   bfd_size_type reloc_count,
+                                   arelent *relents,
+                                   asymbol **symbols,
+                                   bfd_boolean dynamic)
 {
   struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
-  PTR allocated = NULL;
+  void *allocated = NULL;
   bfd_byte *native_relocs;
   arelent *relent;
   unsigned int i;
   int entsize;
   unsigned int symcount;
 
-  allocated = (PTR) bfd_malloc (rel_hdr->sh_size);
+  allocated = bfd_malloc (rel_hdr->sh_size);
   if (allocated == NULL)
     goto error_return;
 
@@ -1303,7 +1255,7 @@ elf_slurp_reloc_table_from_section (abfd, asect, rel_hdr, reloc_count,
          != rel_hdr->sh_size))
     goto error_return;
 
-  native_relocs = (bfd_byte *) allocated;
+  native_relocs = allocated;
 
   entsize = rel_hdr->sh_entsize;
   BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
@@ -1381,11 +1333,10 @@ elf_slurp_reloc_table_from_section (abfd, asect, rel_hdr, reloc_count,
 /* Read in and swap the external relocs.  */
 
 bfd_boolean
-elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
-     bfd *abfd;
-     asection *asect;
-     asymbol **symbols;
-     bfd_boolean dynamic;
+elf_slurp_reloc_table (bfd *abfd,
+                      asection *asect,
+                      asymbol **symbols,
+                      bfd_boolean dynamic)
 {
   struct bfd_elf_section_data * const d = elf_section_data (asect);
   Elf_Internal_Shdr *rel_hdr;
@@ -1430,7 +1381,7 @@ elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
     }
 
   amt = (reloc_count + reloc_count2) * sizeof (arelent);
-  relents = (arelent *) bfd_alloc (abfd, amt);
+  relents = bfd_alloc (abfd, amt);
   if (relents == NULL)
     return FALSE;
 
@@ -1453,9 +1404,7 @@ elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
 
 #ifdef DEBUG
 static void
-elf_debug_section (num, hdr)
-     int num;
-     Elf_Internal_Shdr *hdr;
+elf_debug_section (int num, Elf_Internal_Shdr *hdr)
 {
   fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
           hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
@@ -1481,8 +1430,7 @@ elf_debug_section (num, hdr)
 }
 
 static void
-elf_debug_file (ehdrp)
-     Elf_Internal_Ehdr *ehdrp;
+elf_debug_file (Elf_Internal_Ehdr *ehdrp)
 {
   fprintf (stderr, "e_entry      = 0x%.8lx\n", (long) ehdrp->e_entry);
   fprintf (stderr, "e_phoff      = %ld\n", (long) ehdrp->e_phoff);
@@ -1494,8 +1442,7 @@ elf_debug_file (ehdrp)
 }
 
 static char *
-elf_symbol_flags (flags)
-     flagword flags;
+elf_symbol_flags (flagword flags)
 {
   static char buffer[1024];
 
@@ -1580,12 +1527,11 @@ elf_symbol_flags (flags)
    remote memory.  */
 
 bfd *
-NAME(_bfd_elf,bfd_from_remote_memory) (templ, ehdr_vma, loadbasep,
-                                      target_read_memory)
-     bfd *templ;
-     bfd_vma ehdr_vma;
-     bfd_vma *loadbasep;
-     int (*target_read_memory) PARAMS ((bfd_vma vma, char *myaddr, int len));
+NAME(_bfd_elf,bfd_from_remote_memory)
+  (bfd *templ,
+   bfd_vma ehdr_vma,
+   bfd_vma *loadbasep,
+   int (*target_read_memory) (bfd_vma, char *, int))
 {
   Elf_External_Ehdr x_ehdr;    /* Elf file header, external form */
   Elf_Internal_Ehdr i_ehdr;    /* Elf file header, internal form */
@@ -1654,8 +1600,7 @@ NAME(_bfd_elf,bfd_from_remote_memory) (templ, ehdr_vma, loadbasep,
       return NULL;
     }
 
-  x_phdrs = (Elf_External_Phdr *)
-    bfd_malloc (i_ehdr.e_phnum * (sizeof *x_phdrs + sizeof *i_phdrs));
+  x_phdrs = bfd_malloc (i_ehdr.e_phnum * (sizeof *x_phdrs + sizeof *i_phdrs));
   if (x_phdrs == NULL)
     {
       bfd_set_error (bfd_error_no_memory);
@@ -1716,7 +1661,7 @@ NAME(_bfd_elf,bfd_from_remote_memory) (templ, ehdr_vma, loadbasep,
     contents_size = last_phdr->p_offset + last_phdr->p_filesz;
 
   /* Now we know the size of the whole image we want read in.  */
-  contents = (char *) bfd_zmalloc ((bfd_size_type) contents_size);
+  contents = bfd_zmalloc (contents_size);
   if (contents == NULL)
     {
       free (x_phdrs);
@@ -1761,8 +1706,7 @@ NAME(_bfd_elf,bfd_from_remote_memory) (templ, ehdr_vma, loadbasep,
   memcpy (contents, &x_ehdr, sizeof x_ehdr);
 
   /* Now we have a memory image of the ELF file contents.  Make a BFD.  */
-  bim = ((struct bfd_in_memory *)
-        bfd_malloc ((bfd_size_type) sizeof (struct bfd_in_memory)));
+  bim = bfd_malloc (sizeof (struct bfd_in_memory));
   if (bim == NULL)
     {
       free (contents);
@@ -1781,7 +1725,7 @@ NAME(_bfd_elf,bfd_from_remote_memory) (templ, ehdr_vma, loadbasep,
   nbfd->xvec = templ->xvec;
   bim->size = contents_size;
   bim->buffer = contents;
-  nbfd->iostream = (PTR) bim;
+  nbfd->iostream = bim;
   nbfd->flags = BFD_IN_MEMORY;
   nbfd->direction = read_direction;
   nbfd->mtime = time (NULL);
index cd218066dc494172be11ac319b1d9a9b2e553b4a..865edcd0650de7bc06baa979706cc0b71f13d4f5 100644 (file)
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 char*
-elf_core_file_failing_command (abfd)
-     bfd *abfd;
+elf_core_file_failing_command (bfd *abfd)
 {
   return elf_tdata (abfd)->core_command;
 }
 
 int
-elf_core_file_failing_signal (abfd)
-     bfd *abfd;
+elf_core_file_failing_signal (bfd *abfd)
 {
   return elf_tdata (abfd)->core_signal;
 }
 
 bfd_boolean
-elf_core_file_matches_executable_p (core_bfd, exec_bfd)
-     bfd *core_bfd;
-     bfd *exec_bfd;
+elf_core_file_matches_executable_p (bfd *core_bfd, bfd *exec_bfd)
 {
   char* corename;
 
@@ -55,7 +51,7 @@ elf_core_file_matches_executable_p (core_bfd, exec_bfd)
 
       execname = execname ? execname + 1 : exec_bfd->filename;
 
-      if (strcmp(execname, corename) != 0)
+      if (strcmp (execname, corename) != 0)
        return FALSE;
     }
 
@@ -74,8 +70,7 @@ elf_core_file_matches_executable_p (core_bfd, exec_bfd)
     floating point registers (.reg2).  */
 
 const bfd_target *
-elf_core_file_p (abfd)
-     bfd *abfd;
+elf_core_file_p (bfd *abfd)
 {
   Elf_External_Ehdr x_ehdr;    /* Elf file header, external form.  */
   Elf_Internal_Ehdr *i_ehdrp;  /* Elf file header, internal form.  */
@@ -88,8 +83,7 @@ elf_core_file_p (abfd)
   preserve.marker = NULL;
 
   /* Read in the ELF header in external format.  */
-  if (bfd_bread ((PTR) &x_ehdr, (bfd_size_type) sizeof (x_ehdr), abfd)
-      != sizeof (x_ehdr))
+  if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr))
     {
       if (bfd_get_error () != bfd_error_system_call)
        goto wrong;
@@ -193,7 +187,7 @@ elf_core_file_p (abfd)
 
   /* Allocate space for the program headers.  */
   amt = sizeof (*i_phdrp) * i_ehdrp->e_phnum;
-  i_phdrp = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
+  i_phdrp = bfd_alloc (abfd, amt);
   if (!i_phdrp)
     goto fail;
 
@@ -204,8 +198,7 @@ elf_core_file_p (abfd)
     {
       Elf_External_Phdr x_phdr;
 
-      if (bfd_bread ((PTR) &x_phdr, (bfd_size_type) sizeof (x_phdr), abfd)
-         != sizeof (x_phdr))
+      if (bfd_bread (&x_phdr, sizeof (x_phdr), abfd) != sizeof (x_phdr))
        goto fail;
 
       elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
index ea0b8d0cd569d3f8982e9dded08203605d4e1fef..cb6b0b2ba1f9aa170cd095a5125e8f35f278286b 100644 (file)
@@ -25,13 +25,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #define ARCH_SIZE 0
 #include "elf-bfd.h"
 
-static bfd_boolean elf_link_read_relocs_from_section
-  PARAMS ((bfd *, Elf_Internal_Shdr *, PTR, Elf_Internal_Rela *));
-
 bfd_boolean
-_bfd_elf_create_got_section (abfd, info)
-     bfd *abfd;
-     struct bfd_link_info *info;
+_bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
 {
   flagword flags;
   asection *s;
@@ -87,8 +82,7 @@ _bfd_elf_create_got_section (abfd, info)
       bh = NULL;
       if (!(_bfd_generic_link_add_one_symbol
            (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
-            bed->got_symbol_offset, (const char *) NULL, FALSE,
-            bed->collect, &bh)))
+            bed->got_symbol_offset, NULL, FALSE, bed->collect, &bh)))
        return FALSE;
       h = (struct elf_link_hash_entry *) bh;
       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
@@ -115,9 +109,7 @@ _bfd_elf_create_got_section (abfd, info)
    actual contents and size of these sections later.  */
 
 bfd_boolean
-_bfd_elf_link_create_dynamic_sections (abfd, info)
-     bfd *abfd;
-     struct bfd_link_info *info;
+_bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 {
   flagword flags;
   register asection *s;
@@ -220,8 +212,8 @@ _bfd_elf_link_create_dynamic_sections (abfd, info)
      code examines it to decide how to initialize the process.  */
   bh = NULL;
   if (! (_bfd_generic_link_add_one_symbol
-        (info, abfd, "_DYNAMIC", BSF_GLOBAL, s, (bfd_vma) 0,
-         (const char *) 0, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
+        (info, abfd, "_DYNAMIC", BSF_GLOBAL, s, 0, NULL, FALSE,
+         get_elf_backend_data (abfd)->collect, &bh)))
     return FALSE;
   h = (struct elf_link_hash_entry *) bh;
   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
@@ -252,9 +244,7 @@ _bfd_elf_link_create_dynamic_sections (abfd, info)
 /* Create dynamic sections when linking against a dynamic object.  */
 
 bfd_boolean
-_bfd_elf_create_dynamic_sections (abfd, info)
-     bfd *abfd;
-     struct bfd_link_info *info;
+_bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 {
   flagword flags, pltflags;
   asection *s;
@@ -287,9 +277,8 @@ _bfd_elf_create_dynamic_sections (abfd, info)
       struct bfd_link_hash_entry *bh = NULL;
 
       if (! (_bfd_generic_link_add_one_symbol
-            (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
-             (bfd_vma) 0, (const char *) NULL, FALSE,
-             get_elf_backend_data (abfd)->collect, &bh)))
+            (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 0, NULL,
+             FALSE, get_elf_backend_data (abfd)->collect, &bh)))
        return FALSE;
       h = (struct elf_link_hash_entry *) bh;
       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
@@ -358,9 +347,8 @@ _bfd_elf_create_dynamic_sections (abfd, info)
    one.  */
 
 bfd_boolean
-_bfd_elf_link_record_dynamic_symbol (info, h)
-     struct bfd_link_info *info;
-     struct elf_link_hash_entry *h;
+_bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
+                                    struct elf_link_hash_entry *h)
 {
   if (h->dynindx == -1)
     {
@@ -414,7 +402,7 @@ _bfd_elf_link_record_dynamic_symbol (info, h)
        {
          size_t len = p - name + 1;
 
-         alc = bfd_malloc ((bfd_size_type) len);
+         alc = bfd_malloc (len);
          if (alc == NULL)
            return FALSE;
          memcpy (alc, name, len - 1);
@@ -440,11 +428,10 @@ _bfd_elf_link_record_dynamic_symbol (info, h)
    this in case some dynamic object refers to this symbol.  */
 
 bfd_boolean
-bfd_elf_record_link_assignment (output_bfd, info, name, provide)
-     bfd *output_bfd ATTRIBUTE_UNUSED;
-     struct bfd_link_info *info;
-     const char *name;
-     bfd_boolean provide;
+bfd_elf_record_link_assignment (bfd *output_bfd ATTRIBUTE_UNUSED,
+                               struct bfd_link_info *info,
+                               const char *name,
+                               bfd_boolean provide)
 {
   struct elf_link_hash_entry *h;
 
@@ -505,10 +492,9 @@ bfd_elf_record_link_assignment (output_bfd, info, name, provide)
    in a discarded section, eg. a discarded link-once section symbol.  */
 
 int
-elf_link_record_local_dynamic_symbol (info, input_bfd, input_indx)
-     struct bfd_link_info *info;
-     bfd *input_bfd;
-     long input_indx;
+elf_link_record_local_dynamic_symbol (struct bfd_link_info *info,
+                                     bfd *input_bfd,
+                                     long input_indx)
 {
   bfd_size_type amt;
   struct elf_link_local_dynamic_entry *entry;
@@ -528,14 +514,13 @@ elf_link_record_local_dynamic_symbol (info, input_bfd, input_indx)
       return 1;
 
   amt = sizeof (*entry);
-  entry = (struct elf_link_local_dynamic_entry *) bfd_alloc (input_bfd, amt);
+  entry = bfd_alloc (input_bfd, amt);
   if (entry == NULL)
     return 0;
 
   /* Go find the symbol, so that we can find it's name.  */
   if (!bfd_elf_get_elf_syms (input_bfd, &elf_tdata (input_bfd)->symtab_hdr,
-                            (size_t) 1, (size_t) input_indx,
-                            &entry->isym, esym, &eshndx))
+                            1, input_indx, &entry->isym, esym, &eshndx))
     {
       bfd_release (input_bfd, entry);
       return 0;
@@ -595,10 +580,9 @@ elf_link_record_local_dynamic_symbol (info, input_bfd, input_indx)
 /* Return the dynindex of a local dynamic symbol.  */
 
 long
-_bfd_elf_link_lookup_local_dynindx (info, input_bfd, input_indx)
-     struct bfd_link_info *info;
-     bfd *input_bfd;
-     long input_indx;
+_bfd_elf_link_lookup_local_dynindx (struct bfd_link_info *info,
+                                   bfd *input_bfd,
+                                   long input_indx)
 {
   struct elf_link_local_dynamic_entry *e;
 
@@ -612,15 +596,11 @@ _bfd_elf_link_lookup_local_dynindx (info, input_bfd, input_indx)
    them are removed because they are marked as local.  This is called
    via elf_link_hash_traverse.  */
 
-static bfd_boolean elf_link_renumber_hash_table_dynsyms
-  PARAMS ((struct elf_link_hash_entry *, PTR));
-
 static bfd_boolean
-elf_link_renumber_hash_table_dynsyms (h, data)
-     struct elf_link_hash_entry *h;
-     PTR data;
+elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry *h,
+                                     void *data)
 {
-  size_t *count = (size_t *) data;
+  size_t *count = data;
 
   if (h->root.type == bfd_link_hash_warning)
     h = (struct elf_link_hash_entry *) h->root.u.i.link;
@@ -637,9 +617,7 @@ elf_link_renumber_hash_table_dynsyms (h, data)
    the global symbols.  */
 
 unsigned long
-_bfd_elf_link_renumber_dynsyms (output_bfd, info)
-     bfd *output_bfd;
-     struct bfd_link_info *info;
+_bfd_elf_link_renumber_dynsyms (bfd *output_bfd, struct bfd_link_info *info)
 {
   unsigned long dynsymcount = 0;
 
@@ -684,20 +662,18 @@ _bfd_elf_link_renumber_dynsyms (output_bfd, info)
    a shared object.  */
 
 bfd_boolean
-_bfd_elf_merge_symbol (abfd, info, name, sym, psec, pvalue, sym_hash, skip,
-                      override, type_change_ok, size_change_ok, dt_needed)
-     bfd *abfd;
-     struct bfd_link_info *info;
-     const char *name;
-     Elf_Internal_Sym *sym;
-     asection **psec;
-     bfd_vma *pvalue;
-     struct elf_link_hash_entry **sym_hash;
-     bfd_boolean *skip;
-     bfd_boolean *override;
-     bfd_boolean *type_change_ok;
-     bfd_boolean *size_change_ok;
-     bfd_boolean dt_needed;
+_bfd_elf_merge_symbol (bfd *abfd,
+                      struct bfd_link_info *info,
+                      const char *name,
+                      Elf_Internal_Sym *sym,
+                      asection **psec,
+                      bfd_vma *pvalue,
+                      struct elf_link_hash_entry **sym_hash,
+                      bfd_boolean *skip,
+                      bfd_boolean *override,
+                      bfd_boolean *type_change_ok,
+                      bfd_boolean *size_change_ok,
+                      bfd_boolean dt_needed)
 {
   asection *sec;
   struct elf_link_hash_entry *h;
@@ -1254,18 +1230,16 @@ _bfd_elf_merge_symbol (abfd, info, name, sym, psec, pvalue, sym_hash, skip,
    indicates if it comes from a DT_NEEDED entry of a shared object.  */
 
 bfd_boolean
-_bfd_elf_add_default_symbol (abfd, info, h, name, sym, psec, value,
-                            dynsym, override, dt_needed)
-     bfd *abfd;
-     struct bfd_link_info *info;
-     struct elf_link_hash_entry *h;
-     const char *name;
-     Elf_Internal_Sym *sym;
-     asection **psec;
-     bfd_vma *value;
-     bfd_boolean *dynsym;
-     bfd_boolean override;
-     bfd_boolean dt_needed;
+_bfd_elf_add_default_symbol (bfd *abfd,
+                            struct bfd_link_info *info,
+                            struct elf_link_hash_entry *h,
+                            const char *name,
+                            Elf_Internal_Sym *sym,
+                            asection **psec,
+                            bfd_vma *value,
+                            bfd_boolean *dynsym,
+                            bfd_boolean override,
+                            bfd_boolean dt_needed)
 {
   bfd_boolean type_change_ok;
   bfd_boolean size_change_ok;
@@ -1337,7 +1311,7 @@ _bfd_elf_add_default_symbol (abfd, info, h, name, sym, psec, value,
       bh = &hi->root;
       if (! (_bfd_generic_link_add_one_symbol
             (info, abfd, shortname, BSF_INDIRECT, bfd_ind_section_ptr,
-             (bfd_vma) 0, name, FALSE, collect, &bh)))
+             0, name, FALSE, collect, &bh)))
        return FALSE;
       hi = (struct elf_link_hash_entry *) bh;
     }
@@ -1461,7 +1435,7 @@ nondefault:
       bh = &hi->root;
       if (! (_bfd_generic_link_add_one_symbol
             (info, abfd, shortname, BSF_INDIRECT,
-             bfd_ind_section_ptr, (bfd_vma) 0, name, FALSE, collect, &bh)))
+             bfd_ind_section_ptr, 0, name, FALSE, collect, &bh)))
        return FALSE;
       hi = (struct elf_link_hash_entry *) bh;
 
@@ -1507,11 +1481,9 @@ nondefault:
    symbol table.  It is called via elf_link_hash_traverse.  */
 
 bfd_boolean
-_bfd_elf_export_symbol (h, data)
-     struct elf_link_hash_entry *h;
-     PTR data;
+_bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data)
 {
-  struct elf_info_failed *eif = (struct elf_info_failed *) data;
+  struct elf_info_failed *eif = data;
 
   /* Ignore indirect symbols.  These are added by the versioning code.  */
   if (h->root.type == bfd_link_hash_indirect)
@@ -1568,11 +1540,10 @@ _bfd_elf_export_symbol (h, data)
    This function is called via elf_link_hash_traverse.  */
 
 bfd_boolean
-_bfd_elf_link_find_version_dependencies (h, data)
-     struct elf_link_hash_entry *h;
-     PTR data;
+_bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
+                                        void *data)
 {
-  struct elf_find_verdep_info *rinfo = (struct elf_find_verdep_info *) data;
+  struct elf_find_verdep_info *rinfo = data;
   Elf_Internal_Verneed *t;
   Elf_Internal_Vernaux *a;
   bfd_size_type amt;
@@ -1606,7 +1577,7 @@ _bfd_elf_link_find_version_dependencies (h, data)
   if (t == NULL)
     {
       amt = sizeof *t;
-      t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->output_bfd, amt);
+      t = bfd_zalloc (rinfo->output_bfd, amt);
       if (t == NULL)
        {
          rinfo->failed = TRUE;
@@ -1619,7 +1590,7 @@ _bfd_elf_link_find_version_dependencies (h, data)
     }
 
   amt = sizeof *a;
-  a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->output_bfd, amt);
+  a = bfd_zalloc (rinfo->output_bfd, amt);
 
   /* Note that we are copying a string pointer here, and testing it
      above.  If bfd_elf_string_from_elf_section is ever changed to
@@ -1646,9 +1617,7 @@ _bfd_elf_link_find_version_dependencies (h, data)
    local.  This function is called via elf_link_hash_traverse.  */
 
 bfd_boolean
-_bfd_elf_link_assign_sym_version (h, data)
-     struct elf_link_hash_entry *h;
-     PTR data;
+_bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
 {
   struct elf_assign_sym_version_info *sinfo;
   struct bfd_link_info *info;
@@ -1657,7 +1626,7 @@ _bfd_elf_link_assign_sym_version (h, data)
   char *p;
   bfd_size_type amt;
 
-  sinfo = (struct elf_assign_sym_version_info *) data;
+  sinfo = data;
   info = sinfo->info;
 
   if (h->root.type == bfd_link_hash_warning)
@@ -1714,7 +1683,7 @@ _bfd_elf_link_assign_sym_version (h, data)
              struct bfd_elf_version_expr *d;
 
              len = p - h->root.root.string;
-             alc = bfd_malloc ((bfd_size_type) len);
+             alc = bfd_malloc (len);
              if (alc == NULL)
                return FALSE;
              memcpy (alc, h->root.root.string, len - 1);
@@ -1771,8 +1740,7 @@ _bfd_elf_link_assign_sym_version (h, data)
            return TRUE;
 
          amt = sizeof *t;
-         t = ((struct bfd_elf_version_tree *)
-              bfd_alloc (sinfo->output_bfd, amt));
+         t = bfd_alloc (sinfo->output_bfd, amt);
          if (t == NULL)
            {
              sinfo->failed = TRUE;
@@ -1906,15 +1874,13 @@ _bfd_elf_link_assign_sym_version (h, data)
    Returns FALSE if something goes wrong.  */
 
 static bfd_boolean
-elf_link_read_relocs_from_section (abfd, shdr, external_relocs,
-                                  internal_relocs)
-     bfd *abfd;
-     Elf_Internal_Shdr *shdr;
-     PTR external_relocs;
-     Elf_Internal_Rela *internal_relocs;
+elf_link_read_relocs_from_section (bfd *abfd,
+                                  Elf_Internal_Shdr *shdr,
+                                  void *external_relocs,
+                                  Elf_Internal_Rela *internal_relocs)
 {
   struct elf_backend_data *bed;
-  void (*swap_in) PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rela *));
+  void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
   const bfd_byte *erela;
   const bfd_byte *erelaend;
   Elf_Internal_Rela *irela;
@@ -1968,16 +1934,14 @@ elf_link_read_relocs_from_section (abfd, shdr, external_relocs,
    REL_HDR2 relocations.  */
 
 Elf_Internal_Rela *
-_bfd_elf_link_read_relocs (abfd, o, external_relocs, internal_relocs,
-                          keep_memory)
-     bfd *abfd;
-     asection *o;
-     PTR external_relocs;
-     Elf_Internal_Rela *internal_relocs;
-     bfd_boolean keep_memory;
+_bfd_elf_link_read_relocs (bfd *abfd,
+                          asection *o,
+                          void *external_relocs,
+                          Elf_Internal_Rela *internal_relocs,
+                          bfd_boolean keep_memory)
 {
   Elf_Internal_Shdr *rel_hdr;
-  PTR alloc1 = NULL;
+  void *alloc1 = NULL;
   Elf_Internal_Rela *alloc2 = NULL;
   struct elf_backend_data *bed = get_elf_backend_data (abfd);
 
@@ -1996,9 +1960,9 @@ _bfd_elf_link_read_relocs (abfd, o, external_relocs, internal_relocs,
       size = o->reloc_count;
       size *= bed->s->int_rels_per_ext_rel * sizeof (Elf_Internal_Rela);
       if (keep_memory)
-       internal_relocs = (Elf_Internal_Rela *) bfd_alloc (abfd, size);
+       internal_relocs = bfd_alloc (abfd, size);
       else
-       internal_relocs = alloc2 = (Elf_Internal_Rela *) bfd_malloc (size);
+       internal_relocs = alloc2 = bfd_malloc (size);
       if (internal_relocs == NULL)
        goto error_return;
     }
@@ -2009,7 +1973,7 @@ _bfd_elf_link_read_relocs (abfd, o, external_relocs, internal_relocs,
 
       if (elf_section_data (o)->rel_hdr2)
        size += elf_section_data (o)->rel_hdr2->sh_size;
-      alloc1 = (PTR) bfd_malloc (size);
+      alloc1 = bfd_malloc (size);
       if (alloc1 == NULL)
        goto error_return;
       external_relocs = alloc1;
@@ -2051,10 +2015,9 @@ _bfd_elf_link_read_relocs (abfd, o, external_relocs, internal_relocs,
    section header for a section containing relocations for O.  */
 
 bfd_boolean
-_bfd_elf_link_size_reloc_section (abfd, rel_hdr, o)
-     bfd *abfd;
-     Elf_Internal_Shdr *rel_hdr;
-     asection *o;
+_bfd_elf_link_size_reloc_section (bfd *abfd,
+                                 Elf_Internal_Shdr *rel_hdr,
+                                 asection *o)
 {
   bfd_size_type reloc_count;
   bfd_size_type num_rel_hashes;
@@ -2076,7 +2039,7 @@ _bfd_elf_link_size_reloc_section (abfd, rel_hdr, o)
      allocate it with bfd_alloc rather than malloc.  Also since we
      cannot be sure that the contents will actually be filled in,
      we zero the allocated space.  */
-  rel_hdr->contents = (PTR) bfd_zalloc (abfd, rel_hdr->sh_size);
+  rel_hdr->contents = bfd_zalloc (abfd, rel_hdr->sh_size);
   if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
     return FALSE;
 
@@ -2087,9 +2050,7 @@ _bfd_elf_link_size_reloc_section (abfd, rel_hdr, o)
     {
       struct elf_link_hash_entry **p;
 
-      p = ((struct elf_link_hash_entry **)
-          bfd_zmalloc (num_rel_hashes
-                       * sizeof (struct elf_link_hash_entry *)));
+      p = bfd_zmalloc (num_rel_hashes * sizeof (struct elf_link_hash_entry *));
       if (p == NULL)
        return FALSE;
 
@@ -2104,12 +2065,10 @@ _bfd_elf_link_size_reloc_section (abfd, rel_hdr, o)
    OUTPUT_BFD.  */
 
 bfd_boolean
-_bfd_elf_link_output_relocs (output_bfd, input_section, input_rel_hdr,
-                            internal_relocs)
-     bfd *output_bfd;
-     asection *input_section;
-     Elf_Internal_Shdr *input_rel_hdr;
-     Elf_Internal_Rela *internal_relocs;
+_bfd_elf_link_output_relocs (bfd *output_bfd,
+                            asection *input_section,
+                            Elf_Internal_Shdr *input_rel_hdr,
+                            Elf_Internal_Rela *internal_relocs)
 {
   Elf_Internal_Rela *irela;
   Elf_Internal_Rela *irelaend;
@@ -2118,7 +2077,7 @@ _bfd_elf_link_output_relocs (output_bfd, input_section, input_rel_hdr,
   asection *output_section;
   unsigned int *rel_countp = NULL;
   struct elf_backend_data *bed;
-  void (*swap_out) PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *));
+  void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
 
   output_section = input_section->output_section;
   output_rel_hdr = NULL;
@@ -2181,9 +2140,8 @@ _bfd_elf_link_output_relocs (output_bfd, input_section, input_rel_hdr,
    the face of future changes.  */
 
 bfd_boolean
-_bfd_elf_fix_symbol_flags (h, eif)
-     struct elf_link_hash_entry *h;
-     struct elf_info_failed *eif;
+_bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
+                          struct elf_info_failed *eif)
 {
   /* If this symbol was mentioned in a non-ELF file, try to set
      DEF_REGULAR and REF_REGULAR correctly.  This is the only way to
@@ -2324,11 +2282,9 @@ _bfd_elf_fix_symbol_flags (h, eif)
    recursively.  */
 
 bfd_boolean
-_bfd_elf_adjust_dynamic_symbol (h, data)
-     struct elf_link_hash_entry *h;
-     PTR data;
+_bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
 {
-  struct elf_info_failed *eif = (struct elf_info_failed *) data;
+  struct elf_info_failed *eif = data;
   bfd *dynobj;
   struct elf_backend_data *bed;
 
@@ -2418,7 +2374,7 @@ _bfd_elf_adjust_dynamic_symbol (h, data)
         H->WEAKDEF before it finds H?  */
       h->weakdef->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
 
-      if (! _bfd_elf_adjust_dynamic_symbol (h->weakdef, (PTR) eif))
+      if (! _bfd_elf_adjust_dynamic_symbol (h->weakdef, eif))
        return FALSE;
     }
 
@@ -2449,9 +2405,7 @@ _bfd_elf_adjust_dynamic_symbol (h, data)
    to reflect the object merging within the sections.  */
 
 bfd_boolean
-_bfd_elf_link_sec_merge_syms (h, data)
-     struct elf_link_hash_entry *h;
-     PTR data;
+_bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry *h, void *data)
 {
   asection *sec;
 
@@ -2463,13 +2417,13 @@ _bfd_elf_link_sec_merge_syms (h, data)
       && ((sec = h->root.u.def.section)->flags & SEC_MERGE)
       && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
     {
-      bfd *output_bfd = (bfd *) data;
+      bfd *output_bfd = data;
 
       h->root.u.def.value =
        _bfd_merged_section_offset (output_bfd,
                                    &h->root.u.def.section,
                                    elf_section_data (sec)->sec_info,
-                                   h->root.u.def.value, (bfd_vma) 0);
+                                   h->root.u.def.value, 0);
     }
 
   return TRUE;
@@ -2480,10 +2434,9 @@ _bfd_elf_link_sec_merge_syms (h, data)
    considered to bind dynamically.  */
 
 bfd_boolean
-_bfd_elf_dynamic_symbol_p (h, info, ignore_protected)
-     struct elf_link_hash_entry *h;
-     struct bfd_link_info *info;
-     bfd_boolean ignore_protected;
+_bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
+                          struct bfd_link_info *info,
+                          bfd_boolean ignore_protected)
 {
   bfd_boolean binding_stays_local_p;
 
@@ -2537,10 +2490,9 @@ _bfd_elf_dynamic_symbol_p (h, info, ignore_protected)
    undefined symbols and weak symbols.  */
 
 bfd_boolean
-_bfd_elf_symbol_refs_local_p (h, info, local_protected)
-     struct elf_link_hash_entry *h;
-     struct bfd_link_info *info;
-     bfd_boolean local_protected;
+_bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
+                             struct bfd_link_info *info,
+                             bfd_boolean local_protected)
 {
   /* If it's a local sym, of course we resolve locally.  */
   if (h == NULL)
index 661b0236189b6a39d8c7ad2324be429e8c7102a4..a2520b1d8084dff70c5034e7e840c997cbff85d0 100644 (file)
 
 /* ELF linker code.  */
 
-static bfd_boolean is_global_data_symbol_definition
-  PARAMS ((bfd *, Elf_Internal_Sym *));
-static bfd_boolean elf_link_is_defined_archive_symbol
-  PARAMS ((bfd *, carsym *));
-static bfd_boolean elf_link_add_object_symbols
-  PARAMS ((bfd *, struct bfd_link_info *));
-static bfd_boolean elf_link_add_archive_symbols
-  PARAMS ((bfd *, struct bfd_link_info *));
-static bfd_boolean elf_finalize_dynstr
-  PARAMS ((bfd *, struct bfd_link_info *));
-static bfd_boolean elf_collect_hash_codes
-  PARAMS ((struct elf_link_hash_entry *, PTR));
-static size_t compute_bucket_count
-  PARAMS ((struct bfd_link_info *));
-static void elf_link_adjust_relocs
-  PARAMS ((bfd *, Elf_Internal_Shdr *, unsigned int,
-          struct elf_link_hash_entry **));
-static int elf_link_sort_cmp1
-  PARAMS ((const void *, const void *));
-static int elf_link_sort_cmp2
-  PARAMS ((const void *, const void *));
-static size_t elf_link_sort_relocs
-  PARAMS ((bfd *, struct bfd_link_info *, asection **));
-static bfd_boolean elf_section_ignore_discarded_relocs
-  PARAMS ((asection *));
+static bfd_boolean elf_link_add_object_symbols (bfd *, struct bfd_link_info *);
+static bfd_boolean elf_link_add_archive_symbols (bfd *,
+                                                struct bfd_link_info *);
+static bfd_boolean elf_finalize_dynstr (bfd *, struct bfd_link_info *);
+static bfd_boolean elf_collect_hash_codes (struct elf_link_hash_entry *,
+                                          void *);
+static bfd_boolean elf_section_ignore_discarded_relocs (asection *);
 
 /* Given an ELF BFD, add symbols to the global hash table as
    appropriate.  */
 
 bfd_boolean
-elf_bfd_link_add_symbols (abfd, info)
-     bfd *abfd;
-     struct bfd_link_info *info;
+elf_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
 {
   switch (bfd_get_format (abfd))
     {
@@ -68,9 +48,8 @@ elf_bfd_link_add_symbols (abfd, info)
 \f
 /* Return TRUE iff this is a non-common, definition of a non-function symbol.  */
 static bfd_boolean
-is_global_data_symbol_definition (abfd, sym)
-     bfd * abfd ATTRIBUTE_UNUSED;
-     Elf_Internal_Sym * sym;
+is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
+                                 Elf_Internal_Sym *sym)
 {
   /* Local symbols do not count, but target specific ones might.  */
   if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
@@ -109,9 +88,7 @@ is_global_data_symbol_definition (abfd, sym)
    whose archive map contains a mention of SYMDEF, and determine if
    the symbol is defined in this element.  */
 static bfd_boolean
-elf_link_is_defined_archive_symbol (abfd, symdef)
-     bfd * abfd;
-     carsym * symdef;
+elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
 {
   Elf_Internal_Shdr * hdr;
   bfd_size_type symcount;
@@ -123,7 +100,7 @@ elf_link_is_defined_archive_symbol (abfd, symdef)
   bfd_boolean result;
 
   abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
-  if (abfd == (bfd *) NULL)
+  if (abfd == NULL)
     return FALSE;
 
   if (! bfd_check_format (abfd, bfd_object))
@@ -174,7 +151,7 @@ elf_link_is_defined_archive_symbol (abfd, symdef)
 
       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
                                              isym->st_name);
-      if (name == (const char *) NULL)
+      if (name == NULL)
        break;
 
       if (strcmp (name, symdef->name) == 0)
@@ -215,9 +192,7 @@ elf_link_is_defined_archive_symbol (abfd, symdef)
    table until nothing further is resolved.  */
 
 static bfd_boolean
-elf_link_add_archive_symbols (abfd, info)
-     bfd *abfd;
-     struct bfd_link_info *info;
+elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
 {
   symindex c;
   bfd_boolean *defined = NULL;
@@ -229,7 +204,7 @@ elf_link_add_archive_symbols (abfd, info)
   if (! bfd_has_map (abfd))
     {
       /* An empty archive is a special case.  */
-      if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
+      if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
        return TRUE;
       bfd_set_error (bfd_error_no_armap);
       return FALSE;
@@ -243,9 +218,9 @@ elf_link_add_archive_symbols (abfd, info)
     return TRUE;
   amt = c;
   amt *= sizeof (bfd_boolean);
-  defined = (bfd_boolean *) bfd_zmalloc (amt);
-  included = (bfd_boolean *) bfd_zmalloc (amt);
-  if (defined == (bfd_boolean *) NULL || included == (bfd_boolean *) NULL)
+  defined = bfd_zmalloc (amt);
+  included = bfd_zmalloc (amt);
+  if (defined == NULL || included == NULL)
     goto error_return;
 
   symdefs = bfd_ardata (abfd)->symdefs;
@@ -297,7 +272,7 @@ elf_link_add_archive_symbols (abfd, info)
 
              /* First check with only one `@'.  */
              len = strlen (symdef->name);
-             copy = bfd_alloc (abfd, (bfd_size_type) len);
+             copy = bfd_alloc (abfd, len);
              if (copy == NULL)
                goto error_return;
              first = p - symdef->name + 1;
@@ -349,7 +324,7 @@ elf_link_add_archive_symbols (abfd, info)
 
          /* We need to include this archive member.  */
          element = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
-         if (element == (bfd *) NULL)
+         if (element == NULL)
            goto error_return;
 
          if (! bfd_check_format (element, bfd_object))
@@ -408,9 +383,9 @@ elf_link_add_archive_symbols (abfd, info)
   return TRUE;
 
  error_return:
-  if (defined != (bfd_boolean *) NULL)
+  if (defined != NULL)
     free (defined);
-  if (included != (bfd_boolean *) NULL)
+  if (included != NULL)
     free (included);
   return FALSE;
 }
@@ -418,16 +393,13 @@ elf_link_add_archive_symbols (abfd, info)
 /* Add symbols from an ELF object file to the linker hash table.  */
 
 static bfd_boolean
-elf_link_add_object_symbols (abfd, info)
-     bfd *abfd;
-     struct bfd_link_info *info;
+elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 {
   bfd_boolean (*add_symbol_hook)
-    PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
-            const char **, flagword *, asection **, bfd_vma *));
+    (bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
+     const char **, flagword *, asection **, bfd_vma *);
   bfd_boolean (*check_relocs)
-    PARAMS ((bfd *, struct bfd_link_info *, asection *,
-            const Elf_Internal_Rela *));
+    (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
   bfd_boolean collect;
   Elf_Internal_Shdr *hdr;
   bfd_size_type symcount;
@@ -520,18 +492,18 @@ elf_link_add_object_symbols (abfd, info)
                }
 
              sz = bfd_section_size (abfd, s);
-             msg = (char *) bfd_alloc (abfd, sz + 1);
+             msg = bfd_alloc (abfd, sz + 1);
              if (msg == NULL)
                goto error_return;
 
-             if (! bfd_get_section_contents (abfd, s, msg, (file_ptr) 0, sz))
+             if (! bfd_get_section_contents (abfd, s, msg, 0, sz))
                goto error_return;
 
              msg[sz] = '\0';
 
              if (! (_bfd_generic_link_add_one_symbol
-                    (info, abfd, name, BSF_WARNING, s, (bfd_vma) 0, msg,
-                     FALSE, collect, (struct bfd_link_hash_entry **) NULL)))
+                    (info, abfd, name, BSF_WARNING, s, 0, msg,
+                     FALSE, collect, NULL)))
                goto error_return;
 
              if (! info->relocatable)
@@ -608,12 +580,11 @@ elf_link_add_object_symbols (abfd, info)
          int elfsec;
          unsigned long shlink;
 
-         dynbuf = (Elf_External_Dyn *) bfd_malloc (s->_raw_size);
+         dynbuf = bfd_malloc (s->_raw_size);
          if (dynbuf == NULL)
            goto error_return;
 
-         if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf,
-                                         (file_ptr) 0, s->_raw_size))
+         if (! bfd_get_section_contents (abfd, s, dynbuf, 0, s->_raw_size))
            goto error_free_dyn;
 
          elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
@@ -642,7 +613,7 @@ elf_link_add_object_symbols (abfd, info)
                  unsigned int tagv = dyn.d_un.d_val;
 
                  amt = sizeof (struct bfd_link_needed_list);
-                 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
+                 n = bfd_alloc (abfd, amt);
                  fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
                  if (n == NULL || fnm == NULL)
                    goto error_free_dyn;
@@ -650,7 +621,7 @@ elf_link_add_object_symbols (abfd, info)
                  anm = bfd_alloc (abfd, amt);
                  if (anm == NULL)
                    goto error_free_dyn;
-                 memcpy (anm, fnm, (size_t) amt);
+                 memcpy (anm, fnm, amt);
                  n->name = anm;
                  n->by = abfd;
                  n->next = NULL;
@@ -667,7 +638,7 @@ elf_link_add_object_symbols (abfd, info)
                  unsigned int tagv = dyn.d_un.d_val;
 
                  amt = sizeof (struct bfd_link_needed_list);
-                 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
+                 n = bfd_alloc (abfd, amt);
                  fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
                  if (n == NULL || fnm == NULL)
                    goto error_free_dyn;
@@ -675,7 +646,7 @@ elf_link_add_object_symbols (abfd, info)
                  anm = bfd_alloc (abfd, amt);
                  if (anm == NULL)
                    goto error_free_dyn;
-                 memcpy (anm, fnm, (size_t) amt);
+                 memcpy (anm, fnm, amt);
                  n->name = anm;
                  n->by = abfd;
                  n->next = NULL;
@@ -693,7 +664,7 @@ elf_link_add_object_symbols (abfd, info)
                  unsigned int tagv = dyn.d_un.d_val;
 
                  amt = sizeof (struct bfd_link_needed_list);
-                 n = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
+                 n = bfd_alloc (abfd, amt);
                  fnm = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
                  if (n == NULL || fnm == NULL)
                    goto error_free_dyn;
@@ -705,7 +676,7 @@ elf_link_add_object_symbols (abfd, info)
                      free (dynbuf);
                      goto error_return;
                    }
-                 memcpy (anm, fnm, (size_t) amt);
+                 memcpy (anm, fnm, amt);
                  n->name = anm;
                  n->by = abfd;
                  n->next = NULL;
@@ -788,7 +759,7 @@ elf_link_add_object_symbols (abfd, info)
                }
            }
 
-         if (! elf_add_dynamic_entry (info, (bfd_vma) DT_NEEDED, strindex))
+         if (! elf_add_dynamic_entry (info, DT_NEEDED, strindex))
            goto error_return;
        }
 
@@ -836,7 +807,7 @@ elf_link_add_object_symbols (abfd, info)
       /* We store a pointer to the hash table entry for each external
         symbol.  */
       amt = extsymcount * sizeof (struct elf_link_hash_entry *);
-      sym_hash = (struct elf_link_hash_entry **) bfd_alloc (abfd, amt);
+      sym_hash = bfd_alloc (abfd, amt);
       if (sym_hash == NULL)
        goto error_free_sym;
       elf_sym_hashes (abfd) = sym_hash;
@@ -855,12 +826,12 @@ elf_link_add_object_symbols (abfd, info)
          Elf_Internal_Shdr *versymhdr;
 
          versymhdr = &elf_tdata (abfd)->dynversym_hdr;
-         extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
+         extversym = bfd_malloc (versymhdr->sh_size);
          if (extversym == NULL)
            goto error_free_sym;
          amt = versymhdr->sh_size;
          if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0
-             || bfd_bread ((PTR) extversym, amt, abfd) != amt)
+             || bfd_bread (extversym, amt, abfd) != amt)
            goto error_free_vers;
        }
     }
@@ -941,7 +912,7 @@ elf_link_add_object_symbols (abfd, info)
 
       name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
                                              isym->st_name);
-      if (name == (const char *) NULL)
+      if (name == NULL)
        goto error_free_vers;
 
       if (isym->st_shndx == SHN_COMMON
@@ -969,12 +940,12 @@ elf_link_add_object_symbols (abfd, info)
 
          /* The hook function sets the name to NULL if this symbol
             should be skipped for some reason.  */
-         if (name == (const char *) NULL)
+         if (name == NULL)
            continue;
        }
 
       /* Sanity check that all possibilities were handled.  */
-      if (sec == (asection *) NULL)
+      if (sec == NULL)
        {
          bfd_set_error (bfd_error_bad_value);
          goto error_free_vers;
@@ -1074,7 +1045,7 @@ elf_link_add_object_symbols (abfd, info)
                      && isym->st_shndx != SHN_UNDEF)
                    ++newlen;
 
-                 newname = (char *) bfd_alloc (abfd, (bfd_size_type) newlen);
+                 newname = bfd_alloc (abfd, newlen);
                  if (newname == NULL)
                    goto error_free_vers;
                  memcpy (newname, name, namelen);
@@ -1139,8 +1110,8 @@ elf_link_add_object_symbols (abfd, info)
        }
 
       if (! (_bfd_generic_link_add_one_symbol
-            (info, abfd, name, flags, sec, value, (const char *) NULL,
-             FALSE, collect, (struct bfd_link_hash_entry **) sym_hash)))
+            (info, abfd, name, flags, sec, value, NULL, FALSE, collect,
+             (struct bfd_link_hash_entry **) sym_hash)))
        goto error_free_vers;
 
       h = *sym_hash;
@@ -1435,7 +1406,7 @@ elf_link_add_object_symbols (abfd, info)
                    }
                }
 
-             if (! elf_add_dynamic_entry (info, (bfd_vma) DT_NEEDED, strindex))
+             if (! elf_add_dynamic_entry (info, DT_NEEDED, strindex))
                goto error_free_vers;
            }
        }
@@ -1608,10 +1579,8 @@ elf_link_add_object_symbols (abfd, info)
              || bfd_is_abs_section (o->output_section))
            continue;
 
-         internal_relocs
-           = _bfd_elf_link_read_relocs (abfd, o, (PTR) NULL,
-                                        (Elf_Internal_Rela *) NULL,
-                                        info->keep_memory);
+         internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
+                                                      info->keep_memory);
          if (internal_relocs == NULL)
            goto error_return;
 
@@ -1684,8 +1653,7 @@ elf_link_add_object_symbols (abfd, info)
       /* Add this bfd to the loaded list.  */
       struct elf_link_loaded_list *n;
 
-      n = ((struct elf_link_loaded_list *)
-          bfd_alloc (abfd, sizeof (struct elf_link_loaded_list)));
+      n = bfd_alloc (abfd, sizeof (struct elf_link_loaded_list));
       if (n == NULL)
        goto error_return;
       n->abfd = abfd;
@@ -1710,10 +1678,7 @@ elf_link_add_object_symbols (abfd, info)
 /* Add an entry to the .dynamic table.  */
 
 bfd_boolean
-elf_add_dynamic_entry (info, tag, val)
-     struct bfd_link_info *info;
-     bfd_vma tag;
-     bfd_vma val;
+elf_add_dynamic_entry (struct bfd_link_info *info, bfd_vma tag, bfd_vma val)
 {
   Elf_Internal_Dyn dyn;
   bfd *dynobj;
@@ -1730,7 +1695,7 @@ elf_add_dynamic_entry (info, tag, val)
   BFD_ASSERT (s != NULL);
 
   newsize = s->_raw_size + sizeof (Elf_External_Dyn);
-  newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
+  newcontents = bfd_realloc (s->contents, newsize);
   if (newcontents == NULL)
     return FALSE;
 
@@ -1766,8 +1731,7 @@ static const size_t elf_buckets[] =
    Therefore the result is always a good payoff between few collisions
    (= short chain lengths) and table size.  */
 static size_t
-compute_bucket_count (info)
-     struct bfd_link_info *info;
+compute_bucket_count (struct bfd_link_info *info)
 {
   size_t dynsymcount = elf_hash_table (info)->dynsymcount;
   size_t best_size = 0;
@@ -1781,7 +1745,7 @@ compute_bucket_count (info)
      optimizations.  */
   amt = dynsymcount;
   amt *= sizeof (unsigned long int);
-  hashcodes = (unsigned long int *) bfd_malloc (amt);
+  hashcodes = bfd_malloc (amt);
   if (hashcodes == NULL)
     return 0;
   hashcodesp = hashcodes;
@@ -1814,7 +1778,7 @@ compute_bucket_count (info)
         since the size could be large.  */
       amt = maxsize;
       amt *= sizeof (unsigned long int);
-      counts = (unsigned long int *) bfd_malloc (amt);
+      counts = bfd_malloc (amt);
       if (counts == NULL)
        {
          free (hashcodes);
@@ -1909,18 +1873,14 @@ compute_bucket_count (info)
    addresses of the various sections.  */
 
 bfd_boolean
-NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
-                                    filter_shlib,
-                                    auxiliary_filters, info, sinterpptr,
-                                    verdefs)
-     bfd *output_bfd;
-     const char *soname;
-     const char *rpath;
-     const char *filter_shlib;
-     const char * const *auxiliary_filters;
-     struct bfd_link_info *info;
-     asection **sinterpptr;
-     struct bfd_elf_version_tree *verdefs;
+NAME(bfd_elf,size_dynamic_sections) (bfd *output_bfd,
+                                    const char *soname,
+                                    const char *rpath,
+                                    const char *filter_shlib,
+                                    const char * const *auxiliary_filters,
+                                    struct bfd_link_info *info,
+                                    asection **sinterpptr,
+                                    struct bfd_elf_version_tree *verdefs)
 {
   bfd_size_type soname_indx;
   bfd *dynobj;
@@ -2012,15 +1972,13 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
          soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
                                             soname, TRUE);
          if (soname_indx == (bfd_size_type) -1
-             || ! elf_add_dynamic_entry (info, (bfd_vma) DT_SONAME,
-                                         soname_indx))
+             || ! elf_add_dynamic_entry (info, DT_SONAME, soname_indx))
            return FALSE;
        }
 
       if (info->symbolic)
        {
-         if (! elf_add_dynamic_entry (info, (bfd_vma) DT_SYMBOLIC,
-                                      (bfd_vma) 0))
+         if (! elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
            return FALSE;
          info->flags |= DF_SYMBOLIC;
        }
@@ -2034,10 +1992,9 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
          if (info->new_dtags)
            _bfd_elf_strtab_addref (elf_hash_table (info)->dynstr, indx);
          if (indx == (bfd_size_type) -1
-             || ! elf_add_dynamic_entry (info, (bfd_vma) DT_RPATH, indx)
+             || ! elf_add_dynamic_entry (info, DT_RPATH, indx)
              || (info->new_dtags
-                 && ! elf_add_dynamic_entry (info, (bfd_vma) DT_RUNPATH,
-                                             indx)))
+                 && ! elf_add_dynamic_entry (info, DT_RUNPATH, indx)))
            return FALSE;
        }
 
@@ -2048,7 +2005,7 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
          indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
                                      filter_shlib, TRUE);
          if (indx == (bfd_size_type) -1
-             || ! elf_add_dynamic_entry (info, (bfd_vma) DT_FILTER, indx))
+             || ! elf_add_dynamic_entry (info, DT_FILTER, indx))
            return FALSE;
        }
 
@@ -2063,8 +2020,7 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
              indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
                                          *p, TRUE);
              if (indx == (bfd_size_type) -1
-                 || ! elf_add_dynamic_entry (info, (bfd_vma) DT_AUXILIARY,
-                                             indx))
+                 || ! elf_add_dynamic_entry (info, DT_AUXILIARY, indx))
                return FALSE;
            }
        }
@@ -2079,7 +2035,7 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
        {
          elf_link_hash_traverse (elf_hash_table (info),
                                  _bfd_elf_export_symbol,
-                                 (PTR) &eif);
+                                 &eif);
          if (eif.failed)
            return FALSE;
        }
@@ -2100,7 +2056,7 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
              verlen = strlen (verstr);
              newlen = namelen + verlen + 3;
 
-             newname = (char *) bfd_malloc ((bfd_size_type) newlen);
+             newname = bfd_malloc (newlen);
              if (newname == NULL)
                return FALSE;
              memcpy (newname, name, namelen);
@@ -2143,7 +2099,7 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
 
       elf_link_hash_traverse (elf_hash_table (info),
                              _bfd_elf_link_assign_sym_version,
-                             (PTR) &asvinfo);
+                             &asvinfo);
       if (asvinfo.failed)
        return FALSE;
 
@@ -2173,7 +2129,7 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
         the backend pick a reasonable value for them.  */
       elf_link_hash_traverse (elf_hash_table (info),
                              _bfd_elf_adjust_dynamic_symbol,
-                             (PTR) &eif);
+                             &eif);
       if (eif.failed)
        return FALSE;
 
@@ -2192,7 +2148,7 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
          && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
                                        | ELF_LINK_HASH_DEF_REGULAR)) != 0)
        {
-         if (! elf_add_dynamic_entry (info, (bfd_vma) DT_INIT, (bfd_vma) 0))
+         if (! elf_add_dynamic_entry (info, DT_INIT, 0))
            return FALSE;
        }
       h = (info->fini_function
@@ -2204,7 +2160,7 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
          && (h->elf_link_hash_flags & (ELF_LINK_HASH_REF_REGULAR
                                        | ELF_LINK_HASH_DEF_REGULAR)) != 0)
        {
-         if (! elf_add_dynamic_entry (info, (bfd_vma) DT_FINI, (bfd_vma) 0))
+         if (! elf_add_dynamic_entry (info, DT_FINI, 0))
            return FALSE;
        }
 
@@ -2232,26 +2188,20 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
              return FALSE;
            }
 
-         if (!elf_add_dynamic_entry (info, (bfd_vma) DT_PREINIT_ARRAY,
-                                     (bfd_vma) 0)
-             || !elf_add_dynamic_entry (info, (bfd_vma) DT_PREINIT_ARRAYSZ,
-                                        (bfd_vma) 0))
+         if (!elf_add_dynamic_entry (info, DT_PREINIT_ARRAY, 0)
+             || !elf_add_dynamic_entry (info, DT_PREINIT_ARRAYSZ, 0))
            return FALSE;
        }
       if (bfd_get_section_by_name (output_bfd, ".init_array") != NULL)
        {
-         if (!elf_add_dynamic_entry (info, (bfd_vma) DT_INIT_ARRAY,
-                                     (bfd_vma) 0)
-             || !elf_add_dynamic_entry (info, (bfd_vma) DT_INIT_ARRAYSZ,
-                                        (bfd_vma) 0))
+         if (!elf_add_dynamic_entry (info, DT_INIT_ARRAY, 0)
+             || !elf_add_dynamic_entry (info, DT_INIT_ARRAYSZ, 0))
            return FALSE;
        }
       if (bfd_get_section_by_name (output_bfd, ".fini_array") != NULL)
        {
-         if (!elf_add_dynamic_entry (info, (bfd_vma) DT_FINI_ARRAY,
-                                     (bfd_vma) 0)
-             || !elf_add_dynamic_entry (info, (bfd_vma) DT_FINI_ARRAYSZ,
-                                        (bfd_vma) 0))
+         if (!elf_add_dynamic_entry (info, DT_FINI_ARRAY, 0)
+             || !elf_add_dynamic_entry (info, DT_FINI_ARRAYSZ, 0))
            return FALSE;
        }
 
@@ -2265,12 +2215,12 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
          bfd_size_type strsize;
 
          strsize = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
-         if (! elf_add_dynamic_entry (info, (bfd_vma) DT_HASH, (bfd_vma) 0)
-             || ! elf_add_dynamic_entry (info, (bfd_vma) DT_STRTAB, (bfd_vma) 0)
-             || ! elf_add_dynamic_entry (info, (bfd_vma) DT_SYMTAB, (bfd_vma) 0)
-             || ! elf_add_dynamic_entry (info, (bfd_vma) DT_STRSZ, strsize)
-             || ! elf_add_dynamic_entry (info, (bfd_vma) DT_SYMENT,
-                                         (bfd_vma) sizeof (Elf_External_Sym)))
+         if (! elf_add_dynamic_entry (info, DT_HASH, 0)
+             || ! elf_add_dynamic_entry (info, DT_STRTAB, 0)
+             || ! elf_add_dynamic_entry (info, DT_SYMTAB, 0)
+             || ! elf_add_dynamic_entry (info, DT_STRSZ, strsize)
+             || ! elf_add_dynamic_entry (info, DT_SYMENT,
+                                         sizeof (Elf_External_Sym)))
            return FALSE;
        }
     }
@@ -2333,7 +2283,7 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
            }
 
          s->_raw_size = size;
-         s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
+         s->contents = bfd_alloc (output_bfd, s->_raw_size);
          if (s->contents == NULL && s->_raw_size != 0)
            return FALSE;
 
@@ -2393,7 +2343,7 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
              bh = NULL;
              if (! (_bfd_generic_link_add_one_symbol
                     (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
-                     (bfd_vma) 0, (const char *) NULL, FALSE,
+                     0, NULL, FALSE,
                      get_elf_backend_data (dynobj)->collect, &bh)))
                return FALSE;
              h = (struct elf_link_hash_entry *) bh;
@@ -2461,9 +2411,8 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
                }
            }
 
-         if (! elf_add_dynamic_entry (info, (bfd_vma) DT_VERDEF, (bfd_vma) 0)
-             || ! elf_add_dynamic_entry (info, (bfd_vma) DT_VERDEFNUM,
-                                         (bfd_vma) cdefs))
+         if (! elf_add_dynamic_entry (info, DT_VERDEF, 0)
+             || ! elf_add_dynamic_entry (info, DT_VERDEFNUM, cdefs))
            return FALSE;
 
          elf_tdata (output_bfd)->cverdefs = cdefs;
@@ -2471,7 +2420,7 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
 
       if ((info->new_dtags && info->flags) || (info->flags & DF_STATIC_TLS))
        {
-         if (! elf_add_dynamic_entry (info, (bfd_vma) DT_FLAGS, info->flags))
+         if (! elf_add_dynamic_entry (info, DT_FLAGS, info->flags))
            return FALSE;
        }
 
@@ -2481,8 +2430,7 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
            info->flags_1 &= ~ (DF_1_INITFIRST
                                | DF_1_NODELETE
                                | DF_1_NOOPEN);
-         if (! elf_add_dynamic_entry (info, (bfd_vma) DT_FLAGS_1,
-                                      info->flags_1))
+         if (! elf_add_dynamic_entry (info, DT_FLAGS_1, info->flags_1))
            return FALSE;
        }
 
@@ -2502,7 +2450,7 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
 
        elf_link_hash_traverse (elf_hash_table (info),
                                _bfd_elf_link_find_version_dependencies,
-                               (PTR) &sinfo);
+                               &sinfo);
 
        if (elf_tdata (output_bfd)->verref == NULL)
          _bfd_strip_section_from_output (info, s);
@@ -2529,7 +2477,7 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
              }
 
            s->_raw_size = size;
-           s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
+           s->contents = bfd_alloc (output_bfd, s->_raw_size);
            if (s->contents == NULL)
              return FALSE;
 
@@ -2586,10 +2534,8 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
                  }
              }
 
-           if (! elf_add_dynamic_entry (info, (bfd_vma) DT_VERNEED,
-                                        (bfd_vma) 0)
-               || ! elf_add_dynamic_entry (info, (bfd_vma) DT_VERNEEDNUM,
-                                           (bfd_vma) crefs))
+           if (! elf_add_dynamic_entry (info, DT_VERNEED, 0)
+               || ! elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs))
              return FALSE;
 
            elf_tdata (output_bfd)->cverrefs = crefs;
@@ -2617,11 +2563,11 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
       else
        {
          s->_raw_size = dynsymcount * sizeof (Elf_External_Versym);
-         s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->_raw_size);
+         s->contents = bfd_zalloc (output_bfd, s->_raw_size);
          if (s->contents == NULL)
            return FALSE;
 
-         if (! elf_add_dynamic_entry (info, (bfd_vma) DT_VERSYM, (bfd_vma) 0))
+         if (! elf_add_dynamic_entry (info, DT_VERSYM, 0))
            return FALSE;
        }
 
@@ -2634,7 +2580,7 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
       s = bfd_get_section_by_name (dynobj, ".dynsym");
       BFD_ASSERT (s != NULL);
       s->_raw_size = dynsymcount * sizeof (Elf_External_Sym);
-      s->contents = (bfd_byte *) bfd_alloc (output_bfd, s->_raw_size);
+      s->contents = bfd_alloc (output_bfd, s->_raw_size);
       if (s->contents == NULL && s->_raw_size != 0)
        return FALSE;
 
@@ -2649,7 +2595,7 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
          isym.st_info = 0;
          isym.st_other = 0;
          isym.st_shndx = 0;
-         elf_swap_symbol_out (output_bfd, &isym, (PTR) s->contents, (PTR) 0);
+         elf_swap_symbol_out (output_bfd, &isym, s->contents, 0);
        }
 
       /* Compute the size of the hashing table.  As a side effect this
@@ -2660,13 +2606,12 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
       BFD_ASSERT (s != NULL);
       hash_entry_size = elf_section_data (s)->this_hdr.sh_entsize;
       s->_raw_size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
-      s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->_raw_size);
+      s->contents = bfd_zalloc (output_bfd, s->_raw_size);
       if (s->contents == NULL)
        return FALSE;
 
-      bfd_put (8 * hash_entry_size, output_bfd, (bfd_vma) bucketcount,
-              s->contents);
-      bfd_put (8 * hash_entry_size, output_bfd, (bfd_vma) dynsymcount,
+      bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
+      bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
               s->contents + hash_entry_size);
 
       elf_hash_table (info)->bucketcount = bucketcount;
@@ -2679,7 +2624,7 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
       s->_raw_size = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
 
       for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)
-       if (! elf_add_dynamic_entry (info, (bfd_vma) DT_NULL, (bfd_vma) 0))
+       if (! elf_add_dynamic_entry (info, DT_NULL, 0))
          return FALSE;
     }
 
@@ -2689,15 +2634,10 @@ NAME(bfd_elf,size_dynamic_sections) (output_bfd, soname, rpath,
 /* This function is used to adjust offsets into .dynstr for
    dynamic symbols.  This is called via elf_link_hash_traverse.  */
 
-static bfd_boolean elf_adjust_dynstr_offsets
-  PARAMS ((struct elf_link_hash_entry *, PTR));
-
 static bfd_boolean
-elf_adjust_dynstr_offsets (h, data)
-     struct elf_link_hash_entry *h;
-     PTR data;
+elf_adjust_dynstr_offsets (struct elf_link_hash_entry *h, void *data)
 {
-  struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) data;
+  struct elf_strtab_hash *dynstr = data;
 
   if (h->root.type == bfd_link_hash_warning)
     h = (struct elf_link_hash_entry *) h->root.u.i.link;
@@ -2711,9 +2651,7 @@ elf_adjust_dynstr_offsets (h, data)
    them.  */
 
 static bfd_boolean
-elf_finalize_dynstr (output_bfd, info)
-     bfd *output_bfd;
-     struct bfd_link_info *info;
+elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 {
   struct elf_link_local_dynamic_entry *entry;
   struct elf_strtab_hash *dynstr = elf_hash_table (info)->dynstr;
@@ -2856,7 +2794,7 @@ struct elf_final_link_info
   /* Buffer large enough to hold contents of any section.  */
   bfd_byte *contents;
   /* Buffer large enough to hold external relocs of any section.  */
-  PTR external_relocs;
+  void *external_relocs;
   /* Buffer large enough to hold internal relocs of any section.  */
   Elf_Internal_Rela *internal_relocs;
   /* Buffer large enough to hold external local symbols of any input
@@ -2886,19 +2824,15 @@ struct elf_final_link_info
 };
 
 static bfd_boolean elf_link_output_sym
-  PARAMS ((struct elf_final_link_info *, const char *,
-          Elf_Internal_Sym *, asection *));
+  (struct elf_final_link_info *, const char *, Elf_Internal_Sym *, asection *);
 static bfd_boolean elf_link_flush_output_syms
-  PARAMS ((struct elf_final_link_info *));
+  (struct elf_final_link_info *);
 static bfd_boolean elf_link_output_extsym
-  PARAMS ((struct elf_link_hash_entry *, PTR));
-static bfd_boolean elf_link_check_versioned_symbol
-  PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
+  (struct elf_link_hash_entry *, void *);
 static bfd_boolean elf_link_input_bfd
-  PARAMS ((struct elf_final_link_info *, bfd *));
+  (struct elf_final_link_info *, bfd *);
 static bfd_boolean elf_reloc_link_order
-  PARAMS ((bfd *, struct bfd_link_info *, asection *,
-          struct bfd_link_order *));
+  (bfd *, struct bfd_link_info *, asection *, struct bfd_link_order *);
 
 /* This struct is used to pass information to elf_link_output_extsym.  */
 
@@ -2915,17 +2849,16 @@ struct elf_outext_info
    REL_HDR (there are COUNT of them), using the data in REL_HASH.  */
 
 static void
-elf_link_adjust_relocs (abfd, rel_hdr, count, rel_hash)
-     bfd *abfd;
-     Elf_Internal_Shdr *rel_hdr;
-     unsigned int count;
-     struct elf_link_hash_entry **rel_hash;
+elf_link_adjust_relocs (bfd *abfd,
+                       Elf_Internal_Shdr *rel_hdr,
+                       unsigned int count,
+                       struct elf_link_hash_entry **rel_hash)
 {
   unsigned int i;
   struct elf_backend_data *bed = get_elf_backend_data (abfd);
   bfd_byte *erela;
-  void (*swap_in) PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rela *));
-  void (*swap_out) PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *));
+  void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
+  void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
 
   if (rel_hdr->sh_entsize == sizeof (Elf_External_Rel))
     {
@@ -2971,12 +2904,10 @@ struct elf_link_sort_rela
 };
 
 static int
-elf_link_sort_cmp1 (A, B)
-     const PTR A;
-     const PTR B;
+elf_link_sort_cmp1 (const void *A, const void *B)
 {
-  struct elf_link_sort_rela *a = (struct elf_link_sort_rela *) A;
-  struct elf_link_sort_rela *b = (struct elf_link_sort_rela *) B;
+  const struct elf_link_sort_rela *a = A;
+  const struct elf_link_sort_rela *b = B;
   int relativea, relativeb;
 
   relativea = a->type == reloc_class_relative;
@@ -2998,12 +2929,10 @@ elf_link_sort_cmp1 (A, B)
 }
 
 static int
-elf_link_sort_cmp2 (A, B)
-     const PTR A;
-     const PTR B;
+elf_link_sort_cmp2 (const void *A, const void *B)
 {
-  struct elf_link_sort_rela *a = (struct elf_link_sort_rela *) A;
-  struct elf_link_sort_rela *b = (struct elf_link_sort_rela *) B;
+  const struct elf_link_sort_rela *a = A;
+  const struct elf_link_sort_rela *b = B;
   int copya, copyb;
 
   if (a->offset < b->offset)
@@ -3024,10 +2953,7 @@ elf_link_sort_cmp2 (A, B)
 }
 
 static size_t
-elf_link_sort_relocs (abfd, info, psec)
-     bfd *abfd;
-     struct bfd_link_info *info;
-     asection **psec;
+elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
 {
   asection *reldyn;
   bfd_size_type count, size;
@@ -3036,8 +2962,8 @@ elf_link_sort_relocs (abfd, info, psec)
   struct elf_link_sort_rela *sq;
   struct elf_backend_data *bed = get_elf_backend_data (abfd);
   int i2e = bed->s->int_rels_per_ext_rel;
-  void (*swap_in) PARAMS ((bfd *, const bfd_byte *, Elf_Internal_Rela *));
-  void (*swap_out) PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *));
+  void (*swap_in) (bfd *, const bfd_byte *, Elf_Internal_Rela *);
+  void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
   struct bfd_link_order *lo;
 
   reldyn = bfd_get_section_by_name (abfd, ".rela.dyn");
@@ -3075,8 +3001,7 @@ elf_link_sort_relocs (abfd, info, psec)
   if (sort == NULL)
     {
       (*info->callbacks->warning)
-       (info, _("Not enough memory to sort relocations"), 0, abfd, 0,
-        (bfd_vma) 0);
+       (info, _("Not enough memory to sort relocations"), 0, abfd, 0, 0);
       return 0;
     }
 
@@ -3099,7 +3024,7 @@ elf_link_sort_relocs (abfd, info, psec)
          }
       }
 
-  qsort (sort, (size_t) count, sort_elt, elf_link_sort_cmp1);
+  qsort (sort, count, sort_elt, elf_link_sort_cmp1);
 
   for (i = 0, p = sort; i < count; i++, p += sort_elt)
     {
@@ -3119,7 +3044,7 @@ elf_link_sort_relocs (abfd, info, psec)
       sp->offset = sq->rela->r_offset;
     }
 
-  qsort (s_non_relative, (size_t) count - ret, sort_elt, elf_link_sort_cmp2);
+  qsort (s_non_relative, count - ret, sort_elt, elf_link_sort_cmp2);
 
   for (lo = reldyn->link_order_head; lo != NULL; lo = lo->next)
     if (lo->type == bfd_indirect_link_order)
@@ -3147,9 +3072,7 @@ elf_link_sort_relocs (abfd, info, psec)
 /* Do the final step of an ELF link.  */
 
 bfd_boolean
-elf_bfd_final_link (abfd, info)
-     bfd *abfd;
-     struct bfd_link_info *info;
+elf_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
 {
   bfd_boolean dynamic;
   bfd_boolean emit_relocs;
@@ -3223,7 +3146,7 @@ elf_bfd_final_link (abfd, info)
   finfo.symbuf_count = 0;
   finfo.shndxbuf_size = 0;
   finfo.first_tls_sec = NULL;
-  for (o = abfd->sections; o != (asection *) NULL; o = o->next)
+  for (o = abfd->sections; o != NULL; o = o->next)
     if ((o->flags & SEC_THREAD_LOCAL) != 0
        && (o->flags & SEC_LOAD) != 0)
       {
@@ -3240,7 +3163,7 @@ elf_bfd_final_link (abfd, info)
   max_sym_count = 0;
   max_sym_shndx_count = 0;
   merged = FALSE;
-  for (o = abfd->sections; o != (asection *) NULL; o = o->next)
+  for (o = abfd->sections; o != NULL; o = o->next)
     {
       struct bfd_elf_section_data *esdo = elf_section_data (o);
       o->reloc_count = 0;
@@ -3276,10 +3199,8 @@ elf_bfd_final_link (abfd, info)
                {
                  Elf_Internal_Rela * relocs;
 
-                 relocs
-                   = _bfd_elf_link_read_relocs (abfd, sec, (PTR) NULL,
-                                                (Elf_Internal_Rela *) NULL,
-                                                info->keep_memory);
+                 relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
+                                                     info->keep_memory);
 
                  reloc_count = (*bed->elf_backend_count_relocs) (sec, relocs);
 
@@ -3397,7 +3318,7 @@ elf_bfd_final_link (abfd, info)
 
   if (! info->relocatable && merged)
     elf_link_hash_traverse (elf_hash_table (info),
-                           _bfd_elf_link_sec_merge_syms, (PTR) abfd);
+                           _bfd_elf_link_sec_merge_syms, abfd);
 
   /* Figure out the file positions for everything but the symbol table
      and the relocs.  We set symcount to force assign_section_numbers
@@ -3461,7 +3382,7 @@ elf_bfd_final_link (abfd, info)
     finfo.symbuf_size = max_sym_count;
   amt = finfo.symbuf_size;
   amt *= sizeof (Elf_External_Sym);
-  finfo.symbuf = (Elf_External_Sym *) bfd_malloc (amt);
+  finfo.symbuf = bfd_malloc (amt);
   if (finfo.symbuf == NULL)
     goto error_return;
   if (elf_numsections (abfd) > SHN_LORESERVE)
@@ -3470,7 +3391,7 @@ elf_bfd_final_link (abfd, info)
       amt = 2 * max_sym_count + elf_numsections (abfd) + 1000;
       finfo.shndxbuf_size = amt;
       amt *= sizeof (Elf_External_Sym_Shndx);
-      finfo.symshndxbuf = (Elf_External_Sym_Shndx *) bfd_zmalloc (amt);
+      finfo.symshndxbuf = bfd_zmalloc (amt);
       if (finfo.symshndxbuf == NULL)
        goto error_return;
     }
@@ -3485,8 +3406,7 @@ elf_bfd_final_link (abfd, info)
       elfsym.st_info = 0;
       elfsym.st_other = 0;
       elfsym.st_shndx = SHN_UNDEF;
-      if (! elf_link_output_sym (&finfo, (const char *) NULL,
-                                &elfsym, bfd_und_section_ptr))
+      if (! elf_link_output_sym (&finfo, NULL, &elfsym, bfd_und_section_ptr))
        goto error_return;
     }
 
@@ -3527,8 +3447,7 @@ elf_bfd_final_link (abfd, info)
            elfsym.st_value = 0;
          else
            elfsym.st_value = o->vma;
-         if (! elf_link_output_sym (&finfo, (const char *) NULL,
-                                    &elfsym, o))
+         if (! elf_link_output_sym (&finfo, NULL, &elfsym, o))
            goto error_return;
          if (i == SHN_LORESERVE - 1)
            i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
@@ -3539,14 +3458,14 @@ elf_bfd_final_link (abfd, info)
      files.  */
   if (max_contents_size != 0)
     {
-      finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
+      finfo.contents = bfd_malloc (max_contents_size);
       if (finfo.contents == NULL)
        goto error_return;
     }
 
   if (max_external_reloc_size != 0)
     {
-      finfo.external_relocs = (PTR) bfd_malloc (max_external_reloc_size);
+      finfo.external_relocs = bfd_malloc (max_external_reloc_size);
       if (finfo.external_relocs == NULL)
        goto error_return;
     }
@@ -3555,7 +3474,7 @@ elf_bfd_final_link (abfd, info)
     {
       amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel;
       amt *= sizeof (Elf_Internal_Rela);
-      finfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
+      finfo.internal_relocs = bfd_malloc (amt);
       if (finfo.internal_relocs == NULL)
        goto error_return;
     }
@@ -3563,22 +3482,22 @@ elf_bfd_final_link (abfd, info)
   if (max_sym_count != 0)
     {
       amt = max_sym_count * sizeof (Elf_External_Sym);
-      finfo.external_syms = (Elf_External_Sym *) bfd_malloc (amt);
+      finfo.external_syms = bfd_malloc (amt);
       if (finfo.external_syms == NULL)
        goto error_return;
 
       amt = max_sym_count * sizeof (Elf_Internal_Sym);
-      finfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
+      finfo.internal_syms = bfd_malloc (amt);
       if (finfo.internal_syms == NULL)
        goto error_return;
 
       amt = max_sym_count * sizeof (long);
-      finfo.indices = (long *) bfd_malloc (amt);
+      finfo.indices = bfd_malloc (amt);
       if (finfo.indices == NULL)
        goto error_return;
 
       amt = max_sym_count * sizeof (asection *);
-      finfo.sections = (asection **) bfd_malloc (amt);
+      finfo.sections = bfd_malloc (amt);
       if (finfo.sections == NULL)
        goto error_return;
     }
@@ -3586,7 +3505,7 @@ elf_bfd_final_link (abfd, info)
   if (max_sym_shndx_count != 0)
     {
       amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx);
-      finfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
+      finfo.locsym_shndx = bfd_malloc (amt);
       if (finfo.locsym_shndx == NULL)
        goto error_return;
     }
@@ -3687,7 +3606,7 @@ elf_bfd_final_link (abfd, info)
   eoinfo.finfo = &finfo;
   eoinfo.localsyms = TRUE;
   elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
-                         (PTR) &eoinfo);
+                         &eoinfo);
   if (eoinfo.failed)
     return FALSE;
 
@@ -3727,7 +3646,7 @@ elf_bfd_final_link (abfd, info)
              sym.st_shndx = indx;
              sym.st_value = s->vma;
              dest = dynsym + elf_section_data (s)->dynindx;
-             elf_swap_symbol_out (abfd, &sym, (PTR) dest, (PTR) 0);
+             elf_swap_symbol_out (abfd, &sym, dest, 0);
            }
 
          last_local = bfd_count_sections (abfd);
@@ -3768,7 +3687,7 @@ elf_bfd_final_link (abfd, info)
                last_local = e->dynindx;
 
              dest = dynsym + e->dynindx;
-             elf_swap_symbol_out (abfd, &sym, (PTR) dest, (PTR) 0);
+             elf_swap_symbol_out (abfd, &sym, dest, 0);
            }
        }
 
@@ -3781,7 +3700,7 @@ elf_bfd_final_link (abfd, info)
   eoinfo.localsyms = FALSE;
   eoinfo.finfo = &finfo;
   elf_link_hash_traverse (elf_hash_table (info), elf_link_output_extsym,
-                         (PTR) &eoinfo);
+                         &eoinfo);
   if (eoinfo.failed)
     return FALSE;
 
@@ -3790,10 +3709,10 @@ elf_bfd_final_link (abfd, info)
   if (bed->elf_backend_output_arch_syms)
     {
       typedef bfd_boolean (*out_sym_func)
-       PARAMS ((PTR, const char *, Elf_Internal_Sym *, asection *));
+       (void *, const char *, Elf_Internal_Sym *, asection *);
 
       if (! ((*bed->elf_backend_output_arch_syms)
-            (abfd, info, (PTR) &finfo, (out_sym_func) elf_link_output_sym)))
+            (abfd, info, &finfo, (out_sym_func) elf_link_output_sym)))
        return FALSE;
     }
 
@@ -3817,7 +3736,7 @@ elf_bfd_final_link (abfd, info)
                                                       off, TRUE);
 
       if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
-         || (bfd_bwrite ((PTR) finfo.symshndxbuf, amt, abfd) != amt))
+         || (bfd_bwrite (finfo.symshndxbuf, amt, abfd) != amt))
        return FALSE;
     }
 
@@ -4171,17 +4090,16 @@ elf_bfd_final_link (abfd, info)
 /* Add a symbol to the output symbol table.  */
 
 static bfd_boolean
-elf_link_output_sym (finfo, name, elfsym, input_sec)
-     struct elf_final_link_info *finfo;
-     const char *name;
-     Elf_Internal_Sym *elfsym;
-     asection *input_sec;
+elf_link_output_sym (struct elf_final_link_info *finfo,
+                    const char *name,
+                    Elf_Internal_Sym *elfsym,
+                    asection *input_sec)
 {
   Elf_External_Sym *dest;
   Elf_External_Sym_Shndx *destshndx;
   bfd_boolean (*output_symbol_hook)
-    PARAMS ((bfd *, struct bfd_link_info *info, const char *,
-            Elf_Internal_Sym *, asection *));
+    (bfd *, struct bfd_link_info *info, const char *,
+     Elf_Internal_Sym *, asection *);
 
   output_symbol_hook = get_elf_backend_data (finfo->output_bfd)->
     elf_backend_link_output_symbol_hook;
@@ -4192,7 +4110,7 @@ elf_link_output_sym (finfo, name, elfsym, input_sec)
        return FALSE;
     }
 
-  if (name == (const char *) NULL || *name == '\0')
+  if (name == NULL || *name == '\0')
     elfsym->st_name = 0;
   else if (input_sec->flags & SEC_EXCLUDE)
     elfsym->st_name = 0;
@@ -4228,7 +4146,7 @@ elf_link_output_sym (finfo, name, elfsym, input_sec)
       destshndx += bfd_get_symcount (finfo->output_bfd);
     }
 
-  elf_swap_symbol_out (finfo->output_bfd, elfsym, (PTR) dest, (PTR) destshndx);
+  elf_swap_symbol_out (finfo->output_bfd, elfsym, dest, destshndx);
   finfo->symbuf_count += 1;
   bfd_get_symcount (finfo->output_bfd) += 1;
 
@@ -4238,8 +4156,7 @@ elf_link_output_sym (finfo, name, elfsym, input_sec)
 /* Flush the output symbols to the file.  */
 
 static bfd_boolean
-elf_link_flush_output_syms (finfo)
-     struct elf_final_link_info *finfo;
+elf_link_flush_output_syms (struct elf_final_link_info *finfo)
 {
   if (finfo->symbuf_count > 0)
     {
@@ -4251,7 +4168,7 @@ elf_link_flush_output_syms (finfo)
       pos = hdr->sh_offset + hdr->sh_size;
       amt = finfo->symbuf_count * sizeof (Elf_External_Sym);
       if (bfd_seek (finfo->output_bfd, pos, SEEK_SET) != 0
-         || bfd_bwrite ((PTR) finfo->symbuf, amt, finfo->output_bfd) != amt)
+         || bfd_bwrite (finfo->symbuf, amt, finfo->output_bfd) != amt)
        return FALSE;
 
       hdr->sh_size += amt;
@@ -4268,9 +4185,8 @@ elf_link_flush_output_syms (finfo)
    which may be satisfied by a versioned symbol in another DSO.  */
 
 static bfd_boolean
-elf_link_check_versioned_symbol (info, h)
-     struct bfd_link_info *info;
-     struct elf_link_hash_entry *h;
+elf_link_check_versioned_symbol (struct bfd_link_info *info,
+                                struct elf_link_hash_entry *h)
 {
   bfd *abfd;
   struct elf_link_loaded_list *loaded;
@@ -4350,12 +4266,12 @@ elf_link_check_versioned_symbol (info, h)
 
       /* Read in any version definitions.  */
       versymhdr = &elf_tdata (input)->dynversym_hdr;
-      extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size);
+      extversym = bfd_malloc (versymhdr->sh_size);
       if (extversym == NULL)
        goto error_ret;
 
       if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0
-         || (bfd_bread ((PTR) extversym, versymhdr->sh_size, input)
+         || (bfd_bread (extversym, versymhdr->sh_size, input)
              != versymhdr->sh_size))
        {
          free (extversym);
@@ -4416,11 +4332,9 @@ elf_link_check_versioned_symbol (info, h)
    global symbols.  */
 
 static bfd_boolean
-elf_link_output_extsym (h, data)
-     struct elf_link_hash_entry *h;
-     PTR data;
+elf_link_output_extsym (struct elf_link_hash_entry *h, void *data)
 {
-  struct elf_outext_info *eoinfo = (struct elf_outext_info *) data;
+  struct elf_outext_info *eoinfo = data;
   struct elf_final_link_info *finfo = eoinfo->finfo;
   bfd_boolean strip;
   Elf_Internal_Sym sym;
@@ -4462,7 +4376,7 @@ elf_link_output_extsym (h, data)
     {
       if (! ((*finfo->info->callbacks->undefined_symbol)
             (finfo->info, h->root.root.string, h->root.u.undef.abfd,
-             (asection *) NULL, (bfd_vma) 0, TRUE)))
+             NULL, 0, TRUE)))
        {
          eoinfo->failed = TRUE;
          return FALSE;
@@ -4689,7 +4603,7 @@ elf_link_output_extsym (h, data)
 
       sym.st_name = h->dynstr_index;
       esym = (Elf_External_Sym *) finfo->dynsym_sec->contents + h->dynindx;
-      elf_swap_symbol_out (finfo->output_bfd, &sym, (PTR) esym, (PTR) 0);
+      elf_swap_symbol_out (finfo->output_bfd, &sym, esym, 0);
 
       bucketcount = elf_hash_table (finfo->info)->bucketcount;
       bucket = h->elf_hash_value % bucketcount;
@@ -4698,8 +4612,7 @@ elf_link_output_extsym (h, data)
       bucketpos = ((bfd_byte *) finfo->hash_sec->contents
                   + (bucket + 2) * hash_entry_size);
       chain = bfd_get (8 * hash_entry_size, finfo->output_bfd, bucketpos);
-      bfd_put (8 * hash_entry_size, finfo->output_bfd, (bfd_vma) h->dynindx,
-              bucketpos);
+      bfd_put (8 * hash_entry_size, finfo->output_bfd, h->dynindx, bucketpos);
       bfd_put (8 * hash_entry_size, finfo->output_bfd, chain,
               ((bfd_byte *) finfo->hash_sec->contents
                + (bucketcount + 2 + h->dynindx) * hash_entry_size));
@@ -4755,13 +4668,11 @@ elf_link_output_extsym (h, data)
    don't have to keep them in memory.  */
 
 static bfd_boolean
-elf_link_input_bfd (finfo, input_bfd)
-     struct elf_final_link_info *finfo;
-     bfd *input_bfd;
+elf_link_input_bfd (struct elf_final_link_info *finfo, bfd *input_bfd)
 {
   bfd_boolean (*relocate_section)
-    PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
-            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
+    (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
+     Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
   bfd *output_bfd;
   Elf_Internal_Shdr *symtab_hdr;
   size_t locsymcount;
@@ -4849,7 +4760,7 @@ elf_link_input_bfd (finfo, input_bfd)
            isym->st_value =
              _bfd_merged_section_offset (output_bfd, &isec,
                                          elf_section_data (isec)->sec_info,
-                                         isym->st_value, (bfd_vma) 0);
+                                         isym->st_value, 0);
        }
       else if (isym->st_shndx == SHN_ABS)
        isec = bfd_abs_section_ptr;
@@ -4983,8 +4894,8 @@ elf_link_input_bfd (finfo, input_bfd)
       else
        {
          contents = finfo->contents;
-         if (! bfd_get_section_contents (input_bfd, o, contents,
-                                         (file_ptr) 0, o->_raw_size))
+         if (! bfd_get_section_contents (input_bfd, o, contents, 0,
+                                         o->_raw_size))
            return FALSE;
        }
 
@@ -5139,8 +5050,7 @@ elf_link_input_bfd (finfo, input_bfd)
              Elf_Internal_Shdr *input_rel_hdr, *input_rel_hdr2;
              unsigned int next_erel;
              bfd_boolean (*reloc_emitter)
-               PARAMS ((bfd *, asection *, Elf_Internal_Shdr *,
-                        Elf_Internal_Rela *));
+               (bfd *, asection *, Elf_Internal_Shdr *, Elf_Internal_Rela *);
              bfd_boolean rela_normal;
 
              input_rel_hdr = &elf_section_data (o)->rel_hdr;
@@ -5396,11 +5306,10 @@ elf_link_input_bfd (finfo, input_bfd)
    with -Ur.  */
 
 static bfd_boolean
-elf_reloc_link_order (output_bfd, info, output_section, link_order)
-     bfd *output_bfd;
-     struct bfd_link_info *info;
-     asection *output_section;
-     struct bfd_link_order *link_order;
+elf_reloc_link_order (bfd *output_bfd,
+                     struct bfd_link_info *info,
+                     asection *output_section,
+                     struct bfd_link_order *link_order)
 {
   reloc_howto_type *howto;
   long indx;
@@ -5467,8 +5376,7 @@ elf_reloc_link_order (output_bfd, info, output_section, link_order)
       else
        {
          if (! ((*info->callbacks->unattached_reloc)
-                (info, link_order->u.reloc.p->u.name, (bfd *) NULL,
-                 (asection *) NULL, (bfd_vma) 0)))
+                (info, link_order->u.reloc.p->u.name, NULL, NULL, 0)))
            return FALSE;
          indx = 0;
        }
@@ -5485,10 +5393,10 @@ elf_reloc_link_order (output_bfd, info, output_section, link_order)
       const char *sym_name;
 
       size = bfd_get_reloc_size (howto);
-      buf = (bfd_byte *) bfd_zmalloc (size);
-      if (buf == (bfd_byte *) NULL)
+      buf = bfd_zmalloc (size);
+      if (buf == NULL)
        return FALSE;
-      rstat = _bfd_relocate_contents (howto, output_bfd, (bfd_vma) addend, buf);
+      rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
       switch (rstat)
        {
        case bfd_reloc_ok:
@@ -5505,16 +5413,15 @@ elf_reloc_link_order (output_bfd, info, output_section, link_order)
          else
            sym_name = link_order->u.reloc.p->u.name;
          if (! ((*info->callbacks->reloc_overflow)
-                (info, sym_name, howto->name, addend,
-                 (bfd *) NULL, (asection *) NULL, (bfd_vma) 0)))
+                (info, sym_name, howto->name, addend, NULL, NULL, 0)))
            {
              free (buf);
              return FALSE;
            }
          break;
        }
-      ok = bfd_set_section_contents (output_bfd, output_section, (PTR) buf,
-                                    (file_ptr) link_order->offset, size);
+      ok = bfd_set_section_contents (output_bfd, output_section, buf,
+                                    link_order->offset, size);
       free (buf);
       if (! ok)
        return FALSE;
@@ -5558,42 +5465,24 @@ elf_reloc_link_order (output_bfd, info, output_section, link_order)
 \f
 /* Garbage collect unused sections.  */
 
-static bfd_boolean elf_gc_mark
-  PARAMS ((struct bfd_link_info *, asection *,
-          asection * (*) (asection *, struct bfd_link_info *,
-                          Elf_Internal_Rela *, struct elf_link_hash_entry *,
-                          Elf_Internal_Sym *)));
-
-static bfd_boolean elf_gc_sweep
-  PARAMS ((struct bfd_link_info *,
-          bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *,
-                           const Elf_Internal_Rela *)));
-
 static bfd_boolean elf_gc_sweep_symbol
-  PARAMS ((struct elf_link_hash_entry *, PTR));
+  (struct elf_link_hash_entry *, void *);
 
 static bfd_boolean elf_gc_allocate_got_offsets
-  PARAMS ((struct elf_link_hash_entry *, PTR));
-
-static bfd_boolean elf_gc_propagate_vtable_entries_used
-  PARAMS ((struct elf_link_hash_entry *, PTR));
-
-static bfd_boolean elf_gc_smash_unused_vtentry_relocs
-  PARAMS ((struct elf_link_hash_entry *, PTR));
+  (struct elf_link_hash_entry *, void *);
 
 /* The mark phase of garbage collection.  For a given section, mark
    it and any sections in this section's group, and all the sections
    which define symbols to which it refers.  */
 
 typedef asection * (*gc_mark_hook_fn)
-  PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
-          struct elf_link_hash_entry *, Elf_Internal_Sym *));
+  (asection *, struct bfd_link_info *, Elf_Internal_Rela *,
+   struct elf_link_hash_entry *, Elf_Internal_Sym *);
 
 static bfd_boolean
-elf_gc_mark (info, sec, gc_mark_hook)
-     struct bfd_link_info *info;
-     asection *sec;
-     gc_mark_hook_fn gc_mark_hook;
+elf_gc_mark (struct bfd_link_info *info,
+            asection *sec,
+            gc_mark_hook_fn gc_mark_hook)
 {
   bfd_boolean ret;
   asection *group_sec;
@@ -5641,8 +5530,7 @@ elf_gc_mark (info, sec, gc_mark_hook)
        }
 
       /* Read the relocations.  */
-      relstart = _bfd_elf_link_read_relocs (input_bfd, sec, NULL,
-                                           (Elf_Internal_Rela *) NULL,
+      relstart = _bfd_elf_link_read_relocs (input_bfd, sec, NULL, NULL,
                                            info->keep_memory);
       if (relstart == NULL)
        {
@@ -5703,13 +5591,10 @@ elf_gc_mark (info, sec, gc_mark_hook)
 /* The sweep phase of garbage collection.  Remove all garbage sections.  */
 
 typedef bfd_boolean (*gc_sweep_hook_fn)
-  PARAMS ((bfd *, struct bfd_link_info *, asection *,
-          const Elf_Internal_Rela *));
+  (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
 
 static bfd_boolean
-elf_gc_sweep (info, gc_sweep_hook)
-     struct bfd_link_info *info;
-     gc_sweep_hook_fn gc_sweep_hook;
+elf_gc_sweep (struct bfd_link_info *info, gc_sweep_hook_fn gc_sweep_hook)
 {
   bfd *sub;
 
@@ -5747,8 +5632,7 @@ elf_gc_sweep (info, gc_sweep_hook)
              bfd_boolean r;
 
              internal_relocs
-               = _bfd_elf_link_read_relocs (o->owner, o, NULL,
-                                            (Elf_Internal_Rela *) NULL,
+               = _bfd_elf_link_read_relocs (o->owner, o, NULL, NULL,
                                             info->keep_memory);
              if (internal_relocs == NULL)
                return FALSE;
@@ -5770,9 +5654,7 @@ elf_gc_sweep (info, gc_sweep_hook)
   {
     int i = 0;
 
-    elf_link_hash_traverse (elf_hash_table (info),
-                           elf_gc_sweep_symbol,
-                           (PTR) &i);
+    elf_link_hash_traverse (elf_hash_table (info), elf_gc_sweep_symbol, &i);
 
     elf_hash_table (info)->dynsymcount = i;
   }
@@ -5783,11 +5665,9 @@ elf_gc_sweep (info, gc_sweep_hook)
 /* Sweep symbols in swept sections.  Called via elf_link_hash_traverse.  */
 
 static bfd_boolean
-elf_gc_sweep_symbol (h, idxptr)
-     struct elf_link_hash_entry *h;
-     PTR idxptr;
+elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *idxptr)
 {
-  int *idx = (int *) idxptr;
+  int *idx = idxptr;
 
   if (h->root.type == bfd_link_hash_warning)
     h = (struct elf_link_hash_entry *) h->root.u.i.link;
@@ -5805,9 +5685,7 @@ elf_gc_sweep_symbol (h, idxptr)
    elf_link_hash_traverse.  */
 
 static bfd_boolean
-elf_gc_propagate_vtable_entries_used (h, okp)
-     struct elf_link_hash_entry *h;
-     PTR okp;
+elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp)
 {
   if (h->root.type == bfd_link_hash_warning)
     h = (struct elf_link_hash_entry *) h->root.u.i.link;
@@ -5864,9 +5742,7 @@ elf_gc_propagate_vtable_entries_used (h, okp)
 }
 
 static bfd_boolean
-elf_gc_smash_unused_vtentry_relocs (h, okp)
-     struct elf_link_hash_entry *h;
-     PTR okp;
+elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp)
 {
   asection *sec;
   bfd_vma hstart, hend;
@@ -5889,8 +5765,7 @@ elf_gc_smash_unused_vtentry_relocs (h, okp)
   hstart = h->root.u.def.value;
   hend = hstart + h->size;
 
-  relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL,
-                                       (Elf_Internal_Rela *) NULL, TRUE);
+  relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
   if (!relstart)
     return *(bfd_boolean *) okp = FALSE;
   bed = get_elf_backend_data (sec->owner);
@@ -5919,15 +5794,13 @@ elf_gc_smash_unused_vtentry_relocs (h, okp)
 /* Do mark and sweep of unused sections.  */
 
 bfd_boolean
-elf_gc_sections (abfd, info)
-     bfd *abfd;
-     struct bfd_link_info *info;
+elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
 {
   bfd_boolean ok = TRUE;
   bfd *sub;
   asection * (*gc_mark_hook)
-    PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
-            struct elf_link_hash_entry *h, Elf_Internal_Sym *));
+    (asection *, struct bfd_link_info *, Elf_Internal_Rela *,
+     struct elf_link_hash_entry *h, Elf_Internal_Sym *);
 
   if (!get_elf_backend_data (abfd)->can_gc_sections
       || info->relocatable || info->emitrelocations
@@ -5937,14 +5810,14 @@ elf_gc_sections (abfd, info)
   /* Apply transitive closure to the vtable entry usage info.  */
   elf_link_hash_traverse (elf_hash_table (info),
                          elf_gc_propagate_vtable_entries_used,
-                         (PTR) &ok);
+                         &ok);
   if (!ok)
     return FALSE;
 
   /* Kill the vtable relocations that were not used.  */
   elf_link_hash_traverse (elf_hash_table (info),
                          elf_gc_smash_unused_vtentry_relocs,
-                         (PTR) &ok);
+                         &ok);
   if (!ok)
     return FALSE;
 
@@ -5976,11 +5849,10 @@ elf_gc_sections (abfd, info)
 /* Called from check_relocs to record the existance of a VTINHERIT reloc.  */
 
 bfd_boolean
-elf_gc_record_vtinherit (abfd, sec, h, offset)
-     bfd *abfd;
-     asection *sec;
-     struct elf_link_hash_entry *h;
-     bfd_vma offset;
+elf_gc_record_vtinherit (bfd *abfd,
+                        asection *sec,
+                        struct elf_link_hash_entry *h,
+                        bfd_vma offset)
 {
   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
   struct elf_link_hash_entry **search, *child;
@@ -6033,11 +5905,10 @@ elf_gc_record_vtinherit (abfd, sec, h, offset)
 /* Called from check_relocs to record the existance of a VTENTRY reloc.  */
 
 bfd_boolean
-elf_gc_record_vtentry (abfd, sec, h, addend)
-     bfd *abfd ATTRIBUTE_UNUSED;
-     asection *sec ATTRIBUTE_UNUSED;
-     struct elf_link_hash_entry *h;
-     bfd_vma addend;
+elf_gc_record_vtentry (bfd *abfd ATTRIBUTE_UNUSED,
+                      asection *sec ATTRIBUTE_UNUSED,
+                      struct elf_link_hash_entry *h,
+                      bfd_vma addend)
 {
   struct elf_backend_data *bed = get_elf_backend_data (abfd);
   unsigned int log_file_align = bed->s->log_file_align;
@@ -6070,7 +5941,7 @@ elf_gc_record_vtentry (abfd, sec, h, addend)
 
       if (ptr)
        {
-         ptr = bfd_realloc (ptr - 1, (bfd_size_type) bytes);
+         ptr = bfd_realloc (ptr - 1, bytes);
 
          if (ptr != NULL)
            {
@@ -6082,7 +5953,7 @@ elf_gc_record_vtentry (abfd, sec, h, addend)
            }
        }
       else
-       ptr = bfd_zmalloc ((bfd_size_type) bytes);
+       ptr = bfd_zmalloc (bytes);
 
       if (ptr == NULL)
        return FALSE;
@@ -6101,9 +5972,8 @@ elf_gc_record_vtentry (abfd, sec, h, addend)
    we're done.  Should be called from final_link.  */
 
 bfd_boolean
-elf_gc_common_finalize_got_offsets (abfd, info)
-     bfd *abfd;
-     struct bfd_link_info *info;
+elf_gc_common_finalize_got_offsets (bfd *abfd,
+                                   struct bfd_link_info *info)
 {
   bfd *i;
   struct elf_backend_data *bed = get_elf_backend_data (abfd);
@@ -6152,7 +6022,7 @@ elf_gc_common_finalize_got_offsets (abfd, info)
      adjust_dynamic_symbol  */
   elf_link_hash_traverse (elf_hash_table (info),
                          elf_gc_allocate_got_offsets,
-                         (PTR) &gotoff);
+                         &gotoff);
   return TRUE;
 }
 
@@ -6160,11 +6030,9 @@ elf_gc_common_finalize_got_offsets (abfd, info)
    to real got offsets.  */
 
 static bfd_boolean
-elf_gc_allocate_got_offsets (h, offarg)
-     struct elf_link_hash_entry *h;
-     PTR offarg;
+elf_gc_allocate_got_offsets (struct elf_link_hash_entry *h, void *offarg)
 {
-  bfd_vma *off = (bfd_vma *) offarg;
+  bfd_vma *off = offarg;
 
   if (h->root.type == bfd_link_hash_warning)
     h = (struct elf_link_hash_entry *) h->root.u.i.link;
@@ -6184,9 +6052,7 @@ elf_gc_allocate_got_offsets (h, offarg)
    got entry reference counting is enabled.  */
 
 bfd_boolean
-elf_gc_common_final_link (abfd, info)
-     bfd *abfd;
-     struct bfd_link_info *info;
+elf_gc_common_final_link (bfd *abfd, struct bfd_link_info *info)
 {
   if (!elf_gc_common_finalize_got_offsets (abfd, info))
     return FALSE;
@@ -6199,11 +6065,9 @@ elf_gc_common_final_link (abfd, info)
    all hash value of the exported symbols in an array.  */
 
 static bfd_boolean
-elf_collect_hash_codes (h, data)
-     struct elf_link_hash_entry *h;
-     PTR data;
+elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
 {
-  unsigned long **valuep = (unsigned long **) data;
+  unsigned long **valuep = data;
   const char *name;
   char *p;
   unsigned long ha;
@@ -6220,8 +6084,8 @@ elf_collect_hash_codes (h, data)
   p = strchr (name, ELF_VER_CHR);
   if (p != NULL)
     {
-      alc = bfd_malloc ((bfd_size_type) (p - name + 1));
-      memcpy (alc, name, (size_t) (p - name));
+      alc = bfd_malloc (p - name + 1);
+      memcpy (alc, name, p - name);
       alc[p - name] = '\0';
       name = alc;
     }
@@ -6243,11 +6107,9 @@ elf_collect_hash_codes (h, data)
 }
 
 bfd_boolean
-elf_reloc_symbol_deleted_p (offset, cookie)
-     bfd_vma offset;
-     PTR cookie;
+elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie)
 {
-  struct elf_reloc_cookie *rcookie = (struct elf_reloc_cookie *) cookie;
+  struct elf_reloc_cookie *rcookie = cookie;
 
   if (rcookie->bad_symtab)
     rcookie->rel = rcookie->rels;
@@ -6312,9 +6174,7 @@ elf_reloc_symbol_deleted_p (offset, cookie)
    which is true for all known assemblers.  */
 
 bfd_boolean
-elf_bfd_discard_info (output_bfd, info)
-     bfd *output_bfd;
-     struct bfd_link_info *info;
+elf_bfd_discard_info (bfd *output_bfd, struct bfd_link_info *info)
 {
   struct elf_reloc_cookie cookie;
   asection *stab, *eh;
@@ -6388,10 +6248,8 @@ elf_bfd_discard_info (output_bfd, info)
          cookie.rels = NULL;
          count = stab->reloc_count;
          if (count != 0)
-           cookie.rels
-             = _bfd_elf_link_read_relocs (abfd, stab, (PTR) NULL,
-                                          (Elf_Internal_Rela *) NULL,
-                                          info->keep_memory);
+           cookie.rels = _bfd_elf_link_read_relocs (abfd, stab, NULL, NULL,
+                                                    info->keep_memory);
          if (cookie.rels != NULL)
            {
              cookie.rel = cookie.rels;
@@ -6412,10 +6270,8 @@ elf_bfd_discard_info (output_bfd, info)
          cookie.rels = NULL;
          count = eh->reloc_count;
          if (count != 0)
-           cookie.rels
-             = _bfd_elf_link_read_relocs (abfd, eh, (PTR) NULL,
-                                          (Elf_Internal_Rela *) NULL,
-                                          info->keep_memory);
+           cookie.rels = _bfd_elf_link_read_relocs (abfd, eh, NULL, NULL,
+                                                    info->keep_memory);
          cookie.rel = cookie.rels;
          cookie.relend = cookie.rels;
          if (cookie.rels != NULL)
@@ -6454,8 +6310,7 @@ elf_bfd_discard_info (output_bfd, info)
 }
 
 static bfd_boolean
-elf_section_ignore_discarded_relocs (sec)
-     asection *sec;
+elf_section_ignore_discarded_relocs (asection *sec)
 {
   struct elf_backend_data *bed;