Merge GDB 7.5.1

bfd/sparclinux.c

 /* BFD back-end for linux flavored sparc a.out binaries.
    Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002,
-   2003, 2004, 2005, 2006, 2007, 2008, 2009, 2011
+   2003, 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012
    Free Software Foundation, Inc.
 
    This file is part of BFD, the Binary File Descriptor library.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ skipping 28 matching lines @@
 #define MY(OP) CONCAT2 (sparclinux_,OP)
 #define TARGETNAME "a.out-sparc-linux"
 
 extern const bfd_target MY(vec);
 
 /* We always generate QMAGIC files in preference to ZMAGIC files.  It
    would be possible to make this a linker option, if that ever
    becomes important.  */
 
 static void MY_final_link_callback
-  PARAMS ((bfd *, file_ptr *, file_ptr *, file_ptr *));
-
-static bfd_boolean sparclinux_bfd_final_link
-  PARAMS ((bfd *abfd, struct bfd_link_info *info));
+  (bfd *, file_ptr *, file_ptr *, file_ptr *);
 
 static bfd_boolean
-sparclinux_bfd_final_link (abfd, info)
-     bfd *abfd;
-     struct bfd_link_info *info;
+sparclinux_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
 {
   obj_aout_subformat (abfd) = q_magic_format;
   return NAME(aout,final_link) (abfd, info, MY_final_link_callback);
 }
 
 #define MY_bfd_final_link sparclinux_bfd_final_link
 
 /* Set the machine type correctly.  */
 
-static bfd_boolean sparclinux_write_object_contents PARAMS ((bfd *abfd));
-
 static bfd_boolean
-sparclinux_write_object_contents (abfd)
-     bfd *abfd;
+sparclinux_write_object_contents (bfd *abfd)
 {
   struct external_exec exec_bytes;
   struct internal_exec *execp = exec_hdr (abfd);
 
   N_SET_MACHTYPE (*execp, M_SPARC);
 
   obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
 
   WRITE_HEADERS(abfd, execp);
 
@@ skipping 78 matching lines @@
   /* Number of fixups.  */
   size_t fixup_count;
 
   /* Number of builtin fixups.  */
   size_t local_builtins;
 
   /* List of fixups.  */
   struct fixup *fixup_list;
 };
 
-static struct bfd_hash_entry *linux_link_hash_newfunc
-  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
-static struct bfd_link_hash_table *linux_link_hash_table_create
-  PARAMS ((bfd *));
-static struct fixup *new_fixup
-  PARAMS ((struct bfd_link_info *, struct linux_link_hash_entry *,
-          bfd_vma, int));
-static bfd_boolean linux_link_create_dynamic_sections
-  PARAMS ((bfd *, struct bfd_link_info *));
-static bfd_boolean linux_add_one_symbol
-  PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword, asection *,
-          bfd_vma, const char *, bfd_boolean, bfd_boolean,
-          struct bfd_link_hash_entry **));
-static bfd_boolean linux_tally_symbols
-  PARAMS ((struct linux_link_hash_entry *, PTR));
-static bfd_boolean linux_finish_dynamic_link
-  PARAMS ((bfd *, struct bfd_link_info *));
 
 /* Routine to create an entry in an Linux link hash table.  */
 
 static struct bfd_hash_entry *
-linux_link_hash_newfunc (entry, table, string)
-     struct bfd_hash_entry *entry;
-     struct bfd_hash_table *table;
-     const char *string;
+linux_link_hash_newfunc (struct bfd_hash_entry *entry,
+                         struct bfd_hash_table *table,
+                         const char *string)
 {
   struct linux_link_hash_entry *ret = (struct linux_link_hash_entry *) entry;
 
   /* Allocate the structure if it has not already been allocated by a
      subclass.  */
   if (ret == (struct linux_link_hash_entry *) NULL)
     ret = ((struct linux_link_hash_entry *)
            bfd_hash_allocate (table, sizeof (struct linux_link_hash_entry)));
   if (ret == NULL)
     return (struct bfd_hash_entry *) ret;
 
   /* Call the allocation method of the superclass.  */
   ret = ((struct linux_link_hash_entry *)
          NAME(aout,link_hash_newfunc) ((struct bfd_hash_entry *) ret,
                                        table, string));
   if (ret != NULL)
     {
       /* Set local fields; there aren't any.  */
     }
 
   return (struct bfd_hash_entry *) ret;
 }
 
 /* Create a Linux link hash table.  */
 
 static struct bfd_link_hash_table *
-linux_link_hash_table_create (abfd)
-     bfd *abfd;
+linux_link_hash_table_create (bfd *abfd)
 {
   struct linux_link_hash_table *ret;
   bfd_size_type amt = sizeof (struct linux_link_hash_table);
 
   ret = (struct linux_link_hash_table *) bfd_malloc (amt);
   if (ret == (struct linux_link_hash_table *) NULL)
     return (struct bfd_link_hash_table *) NULL;
   if (!NAME(aout,link_hash_table_init) (&ret->root, abfd,
                                         linux_link_hash_newfunc,
                                         sizeof (struct linux_link_hash_entry)))
@@ skipping 15 matching lines @@
 #define linux_link_hash_lookup(table, string, create, copy, follow) \
   ((struct linux_link_hash_entry *) \
    aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\
                           (follow)))
 
 /* Traverse a Linux link hash table.  */
 
 #define linux_link_hash_traverse(table, func, info)                    \
   (aout_link_hash_traverse                                             \
    (&(table)->root,                                                    \
-    (bfd_boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func), \
+    (bfd_boolean (*) (struct aout_link_hash_entry *, void *)) (func),  \
     (info)))
 
 /* Get the Linux link hash table from the info structure.  This is
    just a cast.  */
 
 #define linux_hash_table(p) ((struct linux_link_hash_table *) ((p)->hash))
 
 /* Store the information for a new fixup.  */
 
 static struct fixup *
-new_fixup (info, h, value, builtin)
-     struct bfd_link_info *info;
-     struct linux_link_hash_entry *h;
-     bfd_vma value;
-     int builtin;
+new_fixup (struct bfd_link_info *info,
+           struct linux_link_hash_entry *h,
+           bfd_vma value,
+           int builtin)
 {
   struct fixup *f;
 
   f = (struct fixup *) bfd_hash_allocate (&info->hash->table,
                                           sizeof (struct fixup));
   if (f == NULL)
     return f;
   f->next = linux_hash_table (info)->fixup_list;
   linux_hash_table (info)->fixup_list = f;
   f->h = h;
   f->value = value;
   f->builtin = builtin;
   f->jump = 0;
   ++linux_hash_table (info)->fixup_count;
   return f;
 }
 
 /* We come here once we realize that we are going to link to a shared
    library.  We need to create a special section that contains the
    fixup table, and we ultimately need to add a pointer to this into
    the set vector for SHARABLE_CONFLICTS.  At this point we do not
    know the size of the section, but that's OK - we just need to
    create it for now.  */
 
 static bfd_boolean
-linux_link_create_dynamic_sections (abfd, info)
-     bfd *abfd;
-     struct bfd_link_info *info ATTRIBUTE_UNUSED;
+linux_link_create_dynamic_sections (bfd *abfd,
+                                    struct bfd_link_info *info ATTRIBUTE_UNUSED)
 {
   flagword flags;
-  register asection *s;
+  asection *s;
 
   /* Note that we set the SEC_IN_MEMORY flag.  */
   flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
 
   /* We choose to use the name ".linux-dynamic" for the fixup table.
      Why not?  */
   s = bfd_make_section_with_flags (abfd, ".linux-dynamic", flags);
   if (s == NULL
       || ! bfd_set_section_alignment (abfd, s, 2))
     return FALSE;
   s->size = 0;
   s->contents = 0;
 
   return TRUE;
 }
 
 /* Function to add a single symbol to the linker hash table.  This is
    a wrapper around _bfd_generic_link_add_one_symbol which handles the
    tweaking needed for dynamic linking support.  */
 
 static bfd_boolean
-linux_add_one_symbol (info, abfd, name, flags, section, value, string,
-                      copy, collect, hashp)
-     struct bfd_link_info *info;
-     bfd *abfd;
-     const char *name;
-     flagword flags;
-     asection *section;
-     bfd_vma value;
-     const char *string;
-     bfd_boolean copy;
-     bfd_boolean collect;
-     struct bfd_link_hash_entry **hashp;
+linux_add_one_symbol (struct bfd_link_info *info,
+                      bfd *abfd,
+                      const char *name,
+                      flagword flags,
+                      asection *section,
+                      bfd_vma value,
+                      const char *string,
+                      bfd_boolean copy,
+                      bfd_boolean collect,
+                      struct bfd_link_hash_entry **hashp)
 {
   struct linux_link_hash_entry *h;
   bfd_boolean insert;
 
   /* Look up and see if we already have this symbol in the hash table.
      If we do, and the defining entry is from a shared library, we
      need to create the dynamic sections.
 
      FIXME: What if abfd->xvec != info->output_bfd->xvec?  We may
      want to be able to link Linux a.out and ELF objects together,
@@ skipping 190 matching lines @@
   return TRUE;
 }
 
 /* This is called to set the size of the .linux-dynamic section is.
    It is called by the Linux linker emulation before_allocation
    routine.  We have finished reading all of the input files, and now
    we just scan the hash tables to find out how many additional fixups
    are required.  */
 
 bfd_boolean
-bfd_sparclinux_size_dynamic_sections (output_bfd, info)
-     bfd *output_bfd;
-     struct bfd_link_info *info;
+bfd_sparclinux_size_dynamic_sections (bfd *output_bfd,
+                                      struct bfd_link_info *info)
 {
   struct fixup *f;
   asection *s;
 
   if (output_bfd->xvec != &MY(vec))
     return TRUE;
 
   /* First find the fixups...  */
   linux_link_hash_traverse (linux_hash_table (info),
                             linux_tally_symbols,
-                            (PTR) info);
+                            info);
 
   /* If there are builtin fixups, leave room for a marker.  This is
      used by the dynamic linker so that it knows that all that follow
      are builtin fixups instead of regular fixups.  */
   for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
     {
       if (f->builtin)
         {
           ++linux_hash_table (info)->fixup_count;
           ++linux_hash_table (info)->local_builtins;
@@ skipping 21 matching lines @@
     }
 
   return TRUE;
 }
 
 /* We come here once we are ready to actually write the fixup table to
    the output file.  Scan the fixup tables and so forth and generate
    the stuff we need.  */
 
 static bfd_boolean
-linux_finish_dynamic_link (output_bfd, info)
-     bfd *output_bfd;
-     struct bfd_link_info *info;
+linux_finish_dynamic_link (bfd *output_bfd, struct bfd_link_info *info)
 {
   asection *s, *os, *is;
   bfd_byte *fixup_table;
   struct linux_link_hash_entry *h;
   struct fixup *f;
   unsigned int new_addr;
   int section_offset;
   unsigned int fixups_written;
 
   if (linux_hash_table (info)->dynobj == NULL)
@@ skipping 129 matching lines @@
 
       bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
     }
   else
     bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
 
   if (bfd_seek (output_bfd, (file_ptr) (os->filepos + s->output_offset),
                 SEEK_SET) != 0)
     return FALSE;
 
-  if (bfd_bwrite ((PTR) s->contents, s->size, output_bfd) != s->size)
+  if (bfd_bwrite (s->contents, s->size, output_bfd) != s->size)
     return FALSE;
 
   return TRUE;
 }
 
 #define MY_bfd_link_hash_table_create linux_link_hash_table_create
 #define MY_add_one_symbol linux_add_one_symbol
 #define MY_finish_dynamic_link linux_finish_dynamic_link
 
 #define MY_zmagic_contiguous 1
 
 #include "aout-target.h"