Merge GDB 7.5.1

bfd/hp300hpux.c

 /* BFD backend for hp-ux 9000/300
    Copyright 1990, 1991, 1993, 1994, 1995, 1997, 1999, 2000, 2001, 2002,
-   2003, 2004, 2005, 2007, 2010 Free Software Foundation, Inc.
+   2003, 2004, 2005, 2007, 2010, 2012 Free Software Foundation, Inc.
    Written by Glenn Engel.
 
    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 174 matching lines @@
 
 #define NAME(x,y) CONCAT3 (hp300hpux,_32_,y)
 #define ARCH_SIZE 32
 
 /* aoutx.h requires definitions for BMAGIC and QMAGIC.  */
 #define BMAGIC HPUX_DOT_O_MAGIC
 #define QMAGIC 0314
 
 #include "aoutx.h"
 
-static const bfd_target * MY (callback)
-  PARAMS ((bfd *));
-static bfd_boolean MY (write_object_contents)
-  PARAMS ((bfd *));
+static const bfd_target * MY (callback) (bfd *);
+static bfd_boolean MY (write_object_contents) (bfd *);
 static void convert_sym_type
-  PARAMS ((struct external_nlist *, aout_symbol_type *, bfd *));
+  (struct external_nlist *, aout_symbol_type *, bfd *);
 
-bfd_boolean MY (slurp_symbol_table)
-  PARAMS ((bfd *));
+bfd_boolean MY (slurp_symbol_table) (bfd *);
 void MY (swap_std_reloc_in)
-  PARAMS ((bfd *, struct hp300hpux_reloc *, arelent *, asymbol **,
-           bfd_size_type));
+  (bfd *, struct hp300hpux_reloc *, arelent *, asymbol **, bfd_size_type);
 bfd_boolean MY (slurp_reloc_table)
-  PARAMS ((bfd *, sec_ptr, asymbol **));
-long MY (canonicalize_symtab)
-  PARAMS ((bfd *, asymbol **));
-long MY (get_symtab_upper_bound)
-  PARAMS ((bfd *));
-long MY (canonicalize_reloc)
-  PARAMS ((bfd *, sec_ptr, arelent **, asymbol **));
+  (bfd *, sec_ptr, asymbol **);
+long MY (canonicalize_symtab)  (bfd *, asymbol **);
+long MY (get_symtab_upper_bound)  (bfd *);
+long MY (canonicalize_reloc)  (bfd *, sec_ptr, arelent **, asymbol **);
 
 /* Since the hpux symbol table has nlist elements interspersed with
    strings and we need to insert som strings for secondary symbols, we
    give ourselves a little extra padding up front to account for
    this.  Note that for each non-secondary symbol we process, we gain
    9 bytes of space for the discarded nlist element (one byte used for
    null).  SYM_EXTRA_BYTES is the extra space.  */
 #define SYM_EXTRA_BYTES   1024
 
 /* Set parameters about this a.out file that are machine-dependent.
    This routine is called from some_aout_object_p just before it returns.  */
 static const bfd_target *
-MY (callback) (abfd)
-     bfd *abfd;
+MY (callback) (bfd *abfd)
 {
   struct internal_exec *execp = exec_hdr (abfd);
 
   /* Calculate the file positions of the parts of a newly read aout header */
   obj_textsec (abfd)->size = N_TXTSIZE (*execp);
 
   /* The virtual memory addresses of the sections */
   obj_textsec (abfd)->vma = N_TXTADDR (*execp);
   obj_datasec (abfd)->vma = N_DATADDR (*execp);
   obj_bsssec (abfd)->vma = N_BSSADDR (*execp);
@@ skipping 33 matching lines @@
 
       abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
       bfd_get_symcount (abfd) = execp->a_syms / 12;
       obj_symbol_entry_size (abfd) = 12;
       obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
     }
 
   return abfd->xvec;
 }
 
-extern bfd_boolean aout_32_write_syms
-  PARAMS ((bfd * abfd));
+extern bfd_boolean aout_32_write_syms (bfd *);
 
 static bfd_boolean
-MY (write_object_contents) (abfd)
-     bfd *abfd;
+MY (write_object_contents) (bfd * abfd)
 {
   struct external_exec exec_bytes;
   struct internal_exec *execp = exec_hdr (abfd);
   bfd_size_type text_size;      /* dummy vars */
   file_ptr text_end;
 
   memset (&exec_bytes, 0, sizeof (exec_bytes));
 
   obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
 
@@ skipping 12 matching lines @@
   N_SET_FLAGS (*execp, aout_backend_info (abfd)->exec_hdr_flags);
 
   NAME (aout,swap_exec_header_out) (abfd, execp, &exec_bytes);
 
   /* update fields not covered by default swap_exec_header_out */
 
   /* this is really the sym table size but we store it in drelocs */
   H_PUT_32 (abfd, (bfd_get_symcount (abfd) * 12), exec_bytes.e_drelocs);
 
   if (bfd_seek (abfd, (file_ptr) 0, FALSE) != 0
-      || (bfd_bwrite ((PTR) &exec_bytes, (bfd_size_type) EXEC_BYTES_SIZE, abfd)
+      || (bfd_bwrite (&exec_bytes, (bfd_size_type) EXEC_BYTES_SIZE, abfd)
           != EXEC_BYTES_SIZE))
     return FALSE;
 
   /* Write out the symbols, and then the relocs.  We must write out
        the symbols first so that we know the symbol indices.  */
 
   if (bfd_get_symcount (abfd) != 0)
     {
       /* Skip the relocs to where we want to put the symbols.  */
       if (bfd_seek (abfd, (file_ptr) (N_DRELOFF (*execp) + execp->a_drsize),
@@ skipping 12 matching lines @@
         return FALSE;
       if (bfd_seek (abfd, (file_ptr) N_DRELOFF (*execp), SEEK_CUR) != 0)
         return FALSE;
       if (!NAME (aout,squirt_out_relocs) (abfd, obj_datasec (abfd)))
         return FALSE;
     }
 
   return TRUE;
 }
 
-/* convert the hp symbol type to be the same as aout64.h usage so we */
-/* can piggyback routines in aoutx.h.                                */
+/* Convert the hp symbol type to be the same as aout64.h usage so we
+   can piggyback routines in aoutx.h.  */
 
 static void
-convert_sym_type (sym_pointer, cache_ptr, abfd)
-     struct external_nlist *sym_pointer ATTRIBUTE_UNUSED;
-     aout_symbol_type *cache_ptr;
-     bfd *abfd ATTRIBUTE_UNUSED;
+convert_sym_type (struct external_nlist *sym_pointer ATTRIBUTE_UNUSED,
+                  aout_symbol_type *cache_ptr,
+                  bfd *abfd ATTRIBUTE_UNUSED)
 {
   int name_type;
   int new_type;
 
   name_type = (cache_ptr->type);
   new_type = 0;
 
   if ((name_type & HP_SYMTYPE_ALIGN) != 0)
     {
       /* iou_error ("aligned symbol encountered: %s", name);*/
@@ skipping 71 matching lines @@
 }
 
 /*
 DESCRIPTION
         Swaps the information in an executable header taken from a raw
         byte stream memory image, into the internal exec_header
         structure.
 */
 
 void
-NAME (aout,swap_exec_header_in) (abfd, raw_bytes, execp)
-     bfd *abfd;
-     struct external_exec *raw_bytes;
-     struct internal_exec *execp;
+NAME (aout,swap_exec_header_in) (bfd *abfd,
+                                 struct external_exec *raw_bytes,
+                                 struct internal_exec *execp)
 {
   struct external_exec *bytes = (struct external_exec *) raw_bytes;
 
   /* The internal_exec structure has some fields that are unused in this
      configuration (IE for i960), so ensure that all such uninitialized
      fields are zero'd out.  There are places where two of these structs
      are memcmp'd, and thus the contents do matter. */
   memset (execp, 0, sizeof (struct internal_exec));
   /* Now fill in fields in the execp, from the bytes in the raw data.  */
   execp->a_info = H_GET_32 (abfd, bytes->e_info);
@@ skipping 60 matching lines @@
    terminate them, using storage from the already allocated symbol table:
 
    string1
    null
    string2
    null
    ...
 */
 
 bfd_boolean
-MY (slurp_symbol_table) (abfd)
-     bfd *abfd;
+MY (slurp_symbol_table) (bfd *abfd)
 {
   bfd_size_type symbol_bytes;
   struct external_nlist *syms;
   struct external_nlist *sym_pointer;
   struct external_nlist *sym_end;
   char *strings;
   aout_symbol_type *cached;
   unsigned num_syms = 0;
   bfd_size_type amt;
 
   /* If there's no work to be done, don't do any */
   if (obj_aout_symbols (abfd) != (aout_symbol_type *) NULL)
     return TRUE;
   symbol_bytes = exec_hdr (abfd)->a_syms;
 
   amt = symbol_bytes + SYM_EXTRA_BYTES;
   strings = (char *) bfd_alloc (abfd, amt);
   if (!strings)
     return FALSE;
   syms = (struct external_nlist *) (strings + SYM_EXTRA_BYTES);
   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
-      || bfd_bread ((PTR) syms, symbol_bytes, abfd) != symbol_bytes)
+      || bfd_bread (syms, symbol_bytes, abfd) != symbol_bytes)
     {
       bfd_release (abfd, syms);
       return FALSE;
     }
 
   sym_end = (struct external_nlist *) (((char *) syms) + symbol_bytes);
 
   /* first, march thru the table and figure out how many symbols there are */
   for (sym_pointer = syms; sym_pointer < sym_end; sym_pointer++, num_syms++)
     {
@@ skipping 60 matching lines @@
                                                  length);
       }
   }
 
   obj_aout_symbols (abfd) = cached;
 
   return TRUE;
 }
 
 void
-MY (swap_std_reloc_in) (abfd, bytes, cache_ptr, symbols, symcount)
-     bfd *abfd;
-     struct hp300hpux_reloc *bytes;
-     arelent *cache_ptr;
-     asymbol **symbols;
-     bfd_size_type symcount ATTRIBUTE_UNUSED;
+MY (swap_std_reloc_in) (bfd *abfd,
+                        struct hp300hpux_reloc *bytes,
+                        arelent *cache_ptr,
+                        asymbol **symbols,
+                        bfd_size_type symcount ATTRIBUTE_UNUSED)
 {
   int r_index;
   int r_extern = 0;
   unsigned int r_length;
   int r_pcrel = 0;
   struct aoutdata *su = &(abfd->tdata.aout_data->a);
 
   cache_ptr->address = H_GET_32 (abfd, bytes->r_address);
   r_index = H_GET_16 (abfd, bytes->r_index);
 
@@ skipping 53 matching lines @@
       /* adds this in later.  Add it in now...                       */
       MOVE_ADDRESS (-cache_ptr->address);
     }
   else
     {
       MOVE_ADDRESS (0);
     }
 }
 
 bfd_boolean
-MY (slurp_reloc_table) (abfd, asect, symbols)
-     bfd *abfd;
-     sec_ptr asect;
-     asymbol **symbols;
+MY (slurp_reloc_table) (bfd *abfd, sec_ptr asect, asymbol **symbols)
 {
   bfd_size_type count;
   bfd_size_type reloc_size;
-  PTR relocs;
+  void * relocs;
   arelent *reloc_cache;
   size_t each_size;
   struct hp300hpux_reloc *rptr;
   unsigned int counter;
   arelent *cache_ptr;
 
   if (asect->relocation)
     return TRUE;
 
   if (asect->flags & SEC_CONSTRUCTOR)
@@ skipping 18 matching lines @@
   if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
     return FALSE;
   each_size = obj_reloc_entry_size (abfd);
 
   count = reloc_size / each_size;
 
   reloc_cache = (arelent *) bfd_zalloc (abfd, count * sizeof (arelent));
   if (!reloc_cache && count != 0)
     return FALSE;
 
-  relocs = (PTR) bfd_alloc (abfd, reloc_size);
+  relocs = bfd_alloc (abfd, reloc_size);
   if (!relocs && reloc_size != 0)
     {
       bfd_release (abfd, reloc_cache);
       return FALSE;
     }
 
   if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
     {
       bfd_release (abfd, relocs);
       bfd_release (abfd, reloc_cache);
@@ skipping 15 matching lines @@
   asect->reloc_count = count;
   return TRUE;
 }
 
 /************************************************************************/
 /* The following functions are identical to functions in aoutx.h except */
 /* they refer to MY(func) rather than NAME(aout,func) and they also     */
 /* call aout_32 versions if the input file was generated by gcc         */
 /************************************************************************/
 
-long aout_32_canonicalize_symtab
-  PARAMS ((bfd * abfd, asymbol ** location));
-long aout_32_get_symtab_upper_bound
-  PARAMS ((bfd * abfd));
-long aout_32_canonicalize_reloc
-  PARAMS ((bfd * abfd, sec_ptr section, arelent ** relptr,
-           asymbol ** symbols));
+long aout_32_canonicalize_symtab  (bfd *, asymbol **);
+long aout_32_get_symtab_upper_bound  (bfd *);
+long aout_32_canonicalize_reloc  (bfd *, sec_ptr, arelent **, asymbol **);
 
 long
-MY (canonicalize_symtab) (abfd, location)
-     bfd *abfd;
-     asymbol **location;
+MY (canonicalize_symtab) (bfd *abfd, asymbol **location)
 {
   unsigned int counter = 0;
   aout_symbol_type *symbase;
 
   if (obj_aout_subformat (abfd) == gnu_encap_format)
     return aout_32_canonicalize_symtab (abfd, location);
 
   if (!MY (slurp_symbol_table) (abfd))
     return -1;
 
   for (symbase = obj_aout_symbols (abfd); counter++ < bfd_get_symcount (abfd);)
     *(location++) = (asymbol *) (symbase++);
   *location++ = 0;
   return bfd_get_symcount (abfd);
 }
 
 long
-MY (get_symtab_upper_bound) (abfd)
-     bfd *abfd;
+MY (get_symtab_upper_bound) (bfd *abfd)
 {
   if (obj_aout_subformat (abfd) == gnu_encap_format)
     return aout_32_get_symtab_upper_bound (abfd);
   if (!MY (slurp_symbol_table) (abfd))
     return -1;
 
   return (bfd_get_symcount (abfd) + 1) * (sizeof (aout_symbol_type *));
 }
 
 long
-MY (canonicalize_reloc) (abfd, section, relptr, symbols)
-     bfd *abfd;
-     sec_ptr section;
-     arelent **relptr;
-     asymbol **symbols;
+MY (canonicalize_reloc) (bfd *abfd,
+                         sec_ptr section,
+                         arelent **relptr,
+                         asymbol **symbols)
 {
   arelent *tblptr = section->relocation;
   unsigned int count;
+
   if (obj_aout_subformat (abfd) == gnu_encap_format)
     return aout_32_canonicalize_reloc (abfd, section, relptr, symbols);
 
   if (!(tblptr || MY (slurp_reloc_table) (abfd, section, symbols)))
     return -1;
 
   if (section->flags & SEC_CONSTRUCTOR)
     {
       arelent_chain *chain = section->constructor_chain;
       for (count = 0; count < section->reloc_count; count++)
@@ skipping 10 matching lines @@
         {
           *relptr++ = tblptr++;
         }
     }
   *relptr = 0;
 
   return section->reloc_count;
 }
 
 #include "aout-target.h"