Merge GDB 7.5.1

bfd/coff-or32.c

 /* BFD back-end for OpenRISC 1000 COFF binaries.
-   Copyright 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2011
+   Copyright 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2011, 2012
    Free Software Foundation, Inc.
    Contributed by Ivan Guzvinec  <ivang@opencores.org>
 
    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,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
    MA 02110-1301, USA.  */
 
 #define OR32 1
 
 #include "sysdep.h"
 #include "bfd.h"
 #include "libbfd.h"
 #include "coff/or32.h"
 #include "coff/internal.h"
 #include "libcoff.h"
 
-static long get_symbol_value
-  PARAMS ((asymbol *));
 static bfd_reloc_status_type or32_reloc
-  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
-static bfd_boolean coff_or32_relocate_section
-  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
-           struct internal_reloc *, struct internal_syment *, asection **));
-static bfd_boolean coff_or32_adjust_symndx
-  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
-           struct internal_reloc *, bfd_boolean *));
-static void reloc_processing
-  PARAMS ((arelent *, struct internal_reloc *, asymbol **, bfd *, asection *));
+  (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
 
 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
 
 #define INSERT_HWORD(WORD,HWORD)              \
     (((WORD) & 0xffff0000) | ((HWORD)& 0x0000ffff))
 #define EXTRACT_HWORD(WORD)                   \
     ((WORD) & 0x0000ffff)
 #define SIGN_EXTEND_HWORD(HWORD)              \
     ((HWORD) & 0x8000 ? (HWORD)|(~0xffffL) : (HWORD))
 
 #define INSERT_JUMPTARG(WORD,JT)              \
     (((WORD) & 0xfc000000) | ((JT)& 0x03ffffff))
 #define EXTRACT_JUMPTARG(WORD)                   \
     ((WORD) & 0x03ffffff)
 #define SIGN_EXTEND_JUMPTARG(JT)              \
     ((JT) & 0x04000000 ? (JT)|(~0x03ffffffL) : (JT))
 
 /* Provided the symbol, returns the value reffed.  */
 
 static long
-get_symbol_value (symbol)
-     asymbol *symbol;
+get_symbol_value (asymbol *symbol)
 {
   long relocation = 0;
 
   if (bfd_is_com_section (symbol->section))
     relocation = 0;
   else
     relocation = symbol->value +
       symbol->section->output_section->vma +
       symbol->section->output_offset;
 
   return relocation;
 }
 
 /* This function is in charge of performing all the or32 relocations.  */
 
 static bfd_reloc_status_type
-or32_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
-            error_message)
-     bfd *abfd;
-     arelent *reloc_entry;
-     asymbol *symbol_in;
-     PTR data;
-     asection *input_section;
-     bfd *output_bfd;
-     char **error_message;
+or32_reloc (bfd *abfd,
+            arelent *reloc_entry,
+            asymbol *symbol_in,
+            void * data,
+            asection *input_section,
+            bfd *output_bfd,
+            char **error_message)
 {
   /* The consth relocation comes in two parts, we have to remember
      the state between calls, in these variables.  */
   static bfd_boolean part1_consth_active = FALSE;
   static unsigned long part1_consth_value;
 
   unsigned long insn;
   unsigned long sym_value;
   unsigned long unsigned_value;
   unsigned short r_type;
@@ skipping 181 matching lines @@
   { R_HWORD,    0, 1, 16, FALSE,  0, complain_overflow_bitfield,  or32_reloc, "HWORD",   TRUE, 0x0000ffff,0x0000ffff, FALSE },
   { R_WORD,     0, 2, 32, FALSE,  0, complain_overflow_bitfield,  or32_reloc, "WORD",    TRUE, 0xffffffff,0xffffffff, FALSE },
 };
 
 #define BADMAG(x) OR32BADMAG (x)
 
 #define RELOC_PROCESSING(relent, reloc, symbols, abfd, section) \
   reloc_processing (relent, reloc, symbols, abfd, section)
 
 static void
-reloc_processing (relent,reloc, symbols, abfd, section)
-     arelent *relent;
-     struct internal_reloc *reloc;
-     asymbol **symbols;
-     bfd *abfd;
-     asection *section;
+reloc_processing (arelent *relent,
+                  struct internal_reloc *reloc,
+                  asymbol **symbols,
+                  bfd *abfd,
+                  asection *section)
 {
   static bfd_vma ihihalf_vaddr = (bfd_vma) -1;
 
   relent->address = reloc->r_vaddr;
   relent->howto = howto_table + reloc->r_type;
 
   if (reloc->r_type == R_IHCONST)
     {
       /* The address of an R_IHCONST should always be the address of
          the immediately preceding R_IHIHALF.  relocs generated by gas
@@ skipping 18 matching lines @@
       if (reloc->r_type == R_IHIHALF)
         ihihalf_vaddr = relent->address;
       else if (ihihalf_vaddr != (bfd_vma) -1)
         abort ();
     }
 }
 
 /* The reloc processing routine for the optimized COFF linker.  */
 
 static bfd_boolean
-coff_or32_relocate_section (output_bfd, info, input_bfd, input_section,
-                            contents, relocs, syms, sections)
-     bfd *output_bfd ATTRIBUTE_UNUSED;
-     struct bfd_link_info *info;
-     bfd *input_bfd;
-     asection *input_section;
-     bfd_byte *contents;
-     struct internal_reloc *relocs;
-     struct internal_syment *syms;
-     asection **sections;
+coff_or32_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
+                            struct bfd_link_info *info,
+                            bfd *input_bfd,
+                            asection *input_section,
+                            bfd_byte *contents,
+                            struct internal_reloc *relocs,
+                            struct internal_syment *syms,
+                            asection **sections)
 {
   struct internal_reloc *rel;
   struct internal_reloc *relend;
   bfd_boolean hihalf;
   bfd_vma hihalf_val;
 
   /* If we are performing a relocatable link, we don't need to do a
      thing.  The caller will take care of adjusting the reloc
      addresses and symbol indices.  */
   if (info->relocatable)
@@ skipping 191 matching lines @@
 
   return TRUE;
 }
 
 #define coff_relocate_section coff_or32_relocate_section
 
 /* We don't want to change the symndx of a R_IHCONST reloc, since it
    is actually an addend, not a symbol index at all.  */
 
 static bfd_boolean
-coff_or32_adjust_symndx (obfd, info, ibfd, sec, irel, adjustedp)
-     bfd *obfd ATTRIBUTE_UNUSED;
-     struct bfd_link_info *info ATTRIBUTE_UNUSED;
-     bfd *ibfd ATTRIBUTE_UNUSED;
-     asection *sec ATTRIBUTE_UNUSED;
-     struct internal_reloc *irel;
-     bfd_boolean *adjustedp;
+coff_or32_adjust_symndx (bfd *obfd ATTRIBUTE_UNUSED,
+                         struct bfd_link_info *info ATTRIBUTE_UNUSED,
+                         bfd *ibfd ATTRIBUTE_UNUSED,
+                         asection *sec ATTRIBUTE_UNUSED,
+                         struct internal_reloc *irel,
+                         bfd_boolean *adjustedp)
 {
   if (irel->r_type == R_IHCONST)
     *adjustedp = TRUE;
   else
     *adjustedp = FALSE;
   return TRUE;
 }
 
 #define coff_adjust_symndx coff_or32_adjust_symndx
 
@@ skipping 63 matching lines @@
 
  /* Alternative_target.  */
 #ifdef TARGET_LITTLE_SYM
   & TARGET_LITTLE_SYM,
 #else
   NULL,
 #endif
 
   COFF_SWAP_TABLE
 };