Convert to ISO C90 formatting

1 files changed, 443 insertions, 560 deletions

diff --git a/bfd/bout.c b/bfd/bout.c
index 5268c62..b696003 100644
--- a/bfd/bout.c
+++ b/bfd/bout.c
@@ -4,21 +4,21 @@
    Free Software Foundation, Inc.
    Written by Cygnus Support.
 
-This file is part of BFD, the Binary File Descriptor library.
+   This file is part of BFD, the Binary File Descriptor library.
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "bfd.h"
 #include "sysdep.h"
@@ -26,103 +26,85 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "bfdlink.h"
 #include "genlink.h"
 #include "bout.h"
+#include "libiberty.h"
 
 #include "aout/stab_gnu.h"
 #include "libaout.h"		/* BFD a.out internal data structures.  */
 
-static int aligncode
-  PARAMS ((bfd *abfd, asection *input_section, arelent *r,
-	   unsigned int shrink));
-static void perform_slip
-  PARAMS ((bfd *abfd, unsigned int slip, asection *input_section,
-	   bfd_vma value));
-static bfd_boolean b_out_squirt_out_relocs
-  PARAMS ((bfd *abfd, asection *section));
-static const bfd_target *b_out_callback
-  PARAMS ((bfd *));
-static bfd_reloc_status_type calljx_callback
-  PARAMS ((bfd *, struct bfd_link_info *, arelent *, PTR src, PTR dst,
-	   asection *));
-static bfd_reloc_status_type callj_callback
-  PARAMS ((bfd *, struct bfd_link_info *, arelent *, PTR data,
-	   unsigned int srcidx, unsigned int dstidx, asection *, bfd_boolean));
-static bfd_vma get_value
-  PARAMS ((arelent *, struct bfd_link_info *, asection *));
-static int abs32code
-  PARAMS ((bfd *, asection *, arelent *, unsigned int,
-	   struct bfd_link_info *));
-static bfd_boolean b_out_bfd_relax_section
-  PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
-static bfd_byte *b_out_bfd_get_relocated_section_contents
-  PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,
-	   bfd_boolean, asymbol **));
-static int b_out_sizeof_headers
-  PARAMS ((bfd *, bfd_boolean));
-static bfd_boolean b_out_set_arch_mach
-  PARAMS ((bfd *, enum bfd_architecture, unsigned long));
-static bfd_boolean b_out_set_section_contents
-  PARAMS ((bfd *, asection *, const PTR, file_ptr, bfd_size_type));
-static long b_out_get_reloc_upper_bound
-  PARAMS ((bfd *, sec_ptr));
-static long b_out_canonicalize_reloc
-  PARAMS ((bfd *, sec_ptr, arelent **, asymbol **));
-static bfd_boolean b_out_slurp_reloc_table
-  PARAMS ((bfd *, sec_ptr, asymbol **));
-static reloc_howto_type *b_out_bfd_reloc_type_lookup
-  PARAMS ((bfd *, bfd_reloc_code_real_type));
-static bfd_boolean b_out_write_object_contents
-  PARAMS ((bfd *));
-static int b_out_symbol_cmp
-  PARAMS ((const void *, const void *));
-static bfd_boolean b_out_mkobject
-  PARAMS ((bfd *));
-static const bfd_target *b_out_object_p
-  PARAMS ((bfd *));
-
-void bout_swap_exec_header_in
-  PARAMS ((bfd *, struct external_exec *, struct internal_exec *));
-void bout_swap_exec_header_out
-  PARAMS ((bfd *, struct internal_exec *, struct external_exec *));
+#define ABS32CODE 0
+#define ABS32CODE_SHRUNK 1
+#define PCREL24 2
+#define CALLJ 3
+#define ABS32 4
+#define PCREL13 5
+#define ABS32_MAYBE_RELAXABLE 1
+#define ABS32_WAS_RELAXABLE 2
+
+#define ALIGNER 10
+#define ALIGNDONE 11
+
+static reloc_howto_type howto_reloc_callj =
+  HOWTO (CALLJ, 0, 2, 24, TRUE, 0, complain_overflow_signed, 0,"callj", TRUE, 0x00ffffff, 0x00ffffff,FALSE);
+static  reloc_howto_type howto_reloc_abs32 =
+  HOWTO (ABS32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"abs32", TRUE, 0xffffffff,0xffffffff,FALSE);
+static reloc_howto_type howto_reloc_pcrel24 =
+  HOWTO (PCREL24, 0, 2, 24, TRUE, 0, complain_overflow_signed,0,"pcrel24", TRUE, 0x00ffffff,0x00ffffff,FALSE);
+static reloc_howto_type howto_reloc_pcrel13 =
+  HOWTO (PCREL13, 0, 2, 13, TRUE, 0, complain_overflow_signed,0,"pcrel13", TRUE, 0x00001fff,0x00001fff,FALSE);
+static reloc_howto_type howto_reloc_abs32codeshrunk =
+  HOWTO (ABS32CODE_SHRUNK, 0, 2, 24, TRUE, 0, complain_overflow_signed, 0,"callx->callj", TRUE, 0x00ffffff, 0x00ffffff,FALSE);
+static  reloc_howto_type howto_reloc_abs32code =
+  HOWTO (ABS32CODE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"callx", TRUE, 0xffffffff,0xffffffff,FALSE);
+
+static reloc_howto_type howto_align_table[] =
+{
+  HOWTO (ALIGNER, 0, 0x1, 0, FALSE, 0, complain_overflow_dont, 0, "align16", FALSE, 0, 0, FALSE),
+  HOWTO (ALIGNER, 0, 0x3, 0, FALSE, 0, complain_overflow_dont, 0, "align32", FALSE, 0, 0, FALSE),
+  HOWTO (ALIGNER, 0, 0x7, 0, FALSE, 0, complain_overflow_dont, 0, "align64", FALSE, 0, 0, FALSE),
+  HOWTO (ALIGNER, 0, 0xf, 0, FALSE, 0, complain_overflow_dont, 0, "align128", FALSE, 0, 0, FALSE),
+};
+
+static reloc_howto_type howto_done_align_table[] =
+{
+  HOWTO (ALIGNDONE, 0x1, 0x1, 0, FALSE, 0, complain_overflow_dont, 0, "donealign16", FALSE, 0, 0, FALSE),
+  HOWTO (ALIGNDONE, 0x3, 0x3, 0, FALSE, 0, complain_overflow_dont, 0, "donealign32", FALSE, 0, 0, FALSE),
+  HOWTO (ALIGNDONE, 0x7, 0x7, 0, FALSE, 0, complain_overflow_dont, 0, "donealign64", FALSE, 0, 0, FALSE),
+  HOWTO (ALIGNDONE, 0xf, 0xf, 0, FALSE, 0, complain_overflow_dont, 0, "donealign128", FALSE, 0, 0, FALSE),
+};
 
 /* Swaps the information in an executable header taken from a raw byte
    stream memory image, into the internal exec_header structure.  */
 
-void
-bout_swap_exec_header_in (abfd, raw_bytes, execp)
-     bfd *abfd;
-     struct external_exec *raw_bytes;
-     struct internal_exec *execp;
+static void
+bout_swap_exec_header_in (bfd *abfd,
+			  struct external_exec *bytes,
+			  struct internal_exec *execp)
 {
-  struct external_exec *bytes = (struct external_exec *)raw_bytes;
-
   /* Now fill in fields in the execp, from the bytes in the raw data.  */
-  execp->a_info   = H_GET_32 (abfd, bytes->e_info);
-  execp->a_text   = GET_WORD (abfd, bytes->e_text);
-  execp->a_data   = GET_WORD (abfd, bytes->e_data);
-  execp->a_bss    = GET_WORD (abfd, bytes->e_bss);
-  execp->a_syms   = GET_WORD (abfd, bytes->e_syms);
-  execp->a_entry  = GET_WORD (abfd, bytes->e_entry);
-  execp->a_trsize = GET_WORD (abfd, bytes->e_trsize);
-  execp->a_drsize = GET_WORD (abfd, bytes->e_drsize);
-  execp->a_tload  = GET_WORD (abfd, bytes->e_tload);
-  execp->a_dload  = GET_WORD (abfd, bytes->e_dload);
-  execp->a_talign = bytes->e_talign[0];
-  execp->a_dalign = bytes->e_dalign[0];
-  execp->a_balign = bytes->e_balign[0];
+  execp->a_info      = H_GET_32 (abfd, bytes->e_info);
+  execp->a_text      = GET_WORD (abfd, bytes->e_text);
+  execp->a_data      = GET_WORD (abfd, bytes->e_data);
+  execp->a_bss       = GET_WORD (abfd, bytes->e_bss);
+  execp->a_syms      = GET_WORD (abfd, bytes->e_syms);
+  execp->a_entry     = GET_WORD (abfd, bytes->e_entry);
+  execp->a_trsize    = GET_WORD (abfd, bytes->e_trsize);
+  execp->a_drsize    = GET_WORD (abfd, bytes->e_drsize);
+  execp->a_tload     = GET_WORD (abfd, bytes->e_tload);
+  execp->a_dload     = GET_WORD (abfd, bytes->e_dload);
+  execp->a_talign    = bytes->e_talign[0];
+  execp->a_dalign    = bytes->e_dalign[0];
+  execp->a_balign    = bytes->e_balign[0];
   execp->a_relaxable = bytes->e_relaxable[0];
 }
 
 /* Swaps the information in an internal exec header structure into the
    supplied buffer ready for writing to disk.  */
 
-void
-bout_swap_exec_header_out (abfd, execp, raw_bytes)
-     bfd *abfd;
-     struct internal_exec *execp;
-     struct external_exec *raw_bytes;
+static void
+bout_swap_exec_header_out (bfd *abfd,
+			   struct internal_exec *execp,
+			   struct external_exec *bytes)
 {
-  struct external_exec *bytes = (struct external_exec *)raw_bytes;
-
   /* Now fill in fields in the raw data, from the fields in the exec struct.  */
   H_PUT_32 (abfd, execp->a_info  , bytes->e_info);
   PUT_WORD (abfd, execp->a_text  , bytes->e_text);
@@ -134,54 +116,26 @@ bout_swap_exec_header_out (abfd, execp, raw_bytes)
   PUT_WORD (abfd, execp->a_drsize, bytes->e_drsize);
   PUT_WORD (abfd, execp->a_tload , bytes->e_tload);
   PUT_WORD (abfd, execp->a_dload , bytes->e_dload);
-  bytes->e_talign[0] = execp->a_talign;
-  bytes->e_dalign[0] = execp->a_dalign;
-  bytes->e_balign[0] = execp->a_balign;
+  bytes->e_talign[0]    = execp->a_talign;
+  bytes->e_dalign[0]    = execp->a_dalign;
+  bytes->e_balign[0]    = execp->a_balign;
   bytes->e_relaxable[0] = execp->a_relaxable;
 }
 
-static const bfd_target *
-b_out_object_p (abfd)
-     bfd *abfd;
-{
-  struct internal_exec anexec;
-  struct external_exec exec_bytes;
-  bfd_size_type amt = EXEC_BYTES_SIZE;
-
-  if (bfd_bread ((PTR) &exec_bytes, amt, abfd) != amt)
-    {
-      if (bfd_get_error () != bfd_error_system_call)
-	bfd_set_error (bfd_error_wrong_format);
-      return 0;
-    }
-
-  anexec.a_info = H_GET_32 (abfd, exec_bytes.e_info);
-
-  if (N_BADMAG (anexec))
-    {
-      bfd_set_error (bfd_error_wrong_format);
-      return 0;
-    }
-
-  bout_swap_exec_header_in (abfd, &exec_bytes, &anexec);
-  return aout_32_some_aout_object_p (abfd, &anexec, b_out_callback);
-}
-
 /* Finish up the opening of a b.out file for reading.  Fill in all the
    fields that are not handled by common code.  */
 
 static const bfd_target *
-b_out_callback (abfd)
-     bfd *abfd;
+b_out_callback (bfd *abfd)
 {
   struct internal_exec *execp = exec_hdr (abfd);
   unsigned long bss_start;
 
   /* Architecture and machine type.  */
-  bfd_set_arch_mach(abfd,
-		    bfd_arch_i960, /* B.out only used on i960 */
-		    bfd_mach_i960_core /* Default */
-		    );
+  bfd_set_arch_mach (abfd,
+		     bfd_arch_i960,     /* B.out only used on i960.  */
+		     bfd_mach_i960_core /* Default.  */
+		     );
 
   /* The positions of the string table and symbol table.  */
   obj_str_filepos (abfd) = N_STROFF (*execp);
@@ -202,28 +156,54 @@ b_out_callback (abfd)
   /* And reload the sizes, since the aout module zaps them.  */
   obj_textsec (abfd)->size = execp->a_text;
 
-  bss_start = execp->a_dload + execp->a_data; /* BSS = end of data section */
+  bss_start = execp->a_dload + execp->a_data; /* BSS = end of data section.  */
   obj_bsssec (abfd)->vma = align_power (bss_start, execp->a_balign);
 
   obj_bsssec (abfd)->lma = obj_bsssec (abfd)->vma;
 
   /* The file positions of the sections.  */
-  obj_textsec (abfd)->filepos = N_TXTOFF(*execp);
-  obj_datasec (abfd)->filepos = N_DATOFF(*execp);
+  obj_textsec (abfd)->filepos = N_TXTOFF (*execp);
+  obj_datasec (abfd)->filepos = N_DATOFF (*execp);
 
   /* The file positions of the relocation info.  */
-  obj_textsec (abfd)->rel_filepos = N_TROFF(*execp);
-  obj_datasec (abfd)->rel_filepos =  N_DROFF(*execp);
+  obj_textsec (abfd)->rel_filepos = N_TROFF (*execp);
+  obj_datasec (abfd)->rel_filepos =  N_DROFF (*execp);
 
-  adata(abfd).page_size = 1;	/* Not applicable.  */
-  adata(abfd).segment_size = 1; /* Not applicable.  */
-  adata(abfd).exec_bytes_size = EXEC_BYTES_SIZE;
+  adata (abfd).page_size = 1;	/* Not applicable.  */
+  adata (abfd).segment_size = 1; /* Not applicable.  */
+  adata (abfd).exec_bytes_size = EXEC_BYTES_SIZE;
 
   if (execp->a_relaxable)
    abfd->flags |= BFD_IS_RELAXABLE;
   return abfd->xvec;
 }
 
+static const bfd_target *
+b_out_object_p (bfd *abfd)
+{
+  struct internal_exec anexec;
+  struct external_exec exec_bytes;
+  bfd_size_type amt = EXEC_BYTES_SIZE;
+
+  if (bfd_bread ((void *) &exec_bytes, amt, abfd) != amt)
+    {
+      if (bfd_get_error () != bfd_error_system_call)
+	bfd_set_error (bfd_error_wrong_format);
+      return 0;
+    }
+
+  anexec.a_info = H_GET_32 (abfd, exec_bytes.e_info);
+
+  if (N_BADMAG (anexec))
+    {
+      bfd_set_error (bfd_error_wrong_format);
+      return 0;
+    }
+
+  bout_swap_exec_header_in (abfd, &exec_bytes, &anexec);
+  return aout_32_some_aout_object_p (abfd, &anexec, b_out_callback);
+}
+
 struct bout_data_struct
   {
     struct aoutdata a;
@@ -231,30 +211,27 @@ struct bout_data_struct
   };
 
 static bfd_boolean
-b_out_mkobject (abfd)
-     bfd *abfd;
+b_out_mkobject (bfd *abfd)
 {
   struct bout_data_struct *rawptr;
   bfd_size_type amt = sizeof (struct bout_data_struct);
 
-  rawptr = (struct bout_data_struct *) bfd_zalloc (abfd, amt);
+  rawptr = bfd_zalloc (abfd, amt);
   if (rawptr == NULL)
     return FALSE;
 
   abfd->tdata.bout_data = rawptr;
   exec_hdr (abfd) = &rawptr->e;
 
-  obj_textsec (abfd) = (asection *) NULL;
-  obj_datasec (abfd) = (asection *) NULL;
-  obj_bsssec (abfd) = (asection *) NULL;
+  obj_textsec (abfd) = NULL;
+  obj_datasec (abfd) = NULL;
+  obj_bsssec (abfd)  = NULL;
 
   return TRUE;
 }
 
 static int
-b_out_symbol_cmp (a_ptr, b_ptr)
-     const void * a_ptr;
-     const void * b_ptr;
+b_out_symbol_cmp (const void * a_ptr, const void * b_ptr)
 {
   struct aout_symbol ** a = (struct aout_symbol **) a_ptr;
   struct aout_symbol ** b = (struct aout_symbol **) b_ptr;
@@ -272,8 +249,8 @@ b_out_symbol_cmp (a_ptr, b_ptr)
   if (av > bv)
     return 1;
 
-  /* Secondary key puts CALLNAME syms last and BALNAME syms first, so
-     that they have the best chance of being contiguous.  */
+  /* Secondary key puts CALLNAME syms last and BALNAME syms first,
+     so that they have the best chance of being contiguous.  */
   if (IS_BALNAME ((*a)->other) || IS_CALLNAME ((*b)->other))
     return -1;
   if (IS_CALLNAME ((*a)->other) || IS_BALNAME ((*b)->other))
@@ -283,8 +260,138 @@ b_out_symbol_cmp (a_ptr, b_ptr)
 }
 
 static bfd_boolean
-b_out_write_object_contents (abfd)
-     bfd *abfd;
+b_out_squirt_out_relocs (bfd *abfd, asection *section)
+{
+  arelent **generic;
+  int r_extern = 0;
+  int r_idx;
+  int incode_mask;
+  int len_1;
+  unsigned int count = section->reloc_count;
+  struct relocation_info *native, *natptr;
+  bfd_size_type natsize;
+  int extern_mask, pcrel_mask, len_2, callj_mask;
+
+  if (count == 0)
+    return TRUE;
+
+  generic = section->orelocation;
+  natsize = (bfd_size_type) count * sizeof (struct relocation_info);
+  native = bfd_malloc (natsize);
+  if (!native && natsize != 0)
+    return FALSE;
+
+  if (bfd_header_big_endian (abfd))
+    {
+      /* Big-endian bit field allocation order.  */
+      pcrel_mask  = 0x80;
+      extern_mask = 0x10;
+      len_2       = 0x40;
+      len_1       = 0x20;
+      callj_mask  = 0x02;
+      incode_mask = 0x08;
+    }
+  else
+    {
+      /* Little-endian bit field allocation order.  */
+      pcrel_mask  = 0x01;
+      extern_mask = 0x08;
+      len_2       = 0x04;
+      len_1       = 0x02;
+      callj_mask  = 0x40;
+      incode_mask = 0x10;
+    }
+
+  for (natptr = native; count > 0; --count, ++natptr, ++generic)
+    {
+      arelent *g = *generic;
+      unsigned char *raw = (unsigned char *) natptr;
+      asymbol *sym = *(g->sym_ptr_ptr);
+      asection *output_section = sym->section->output_section;
+
+      H_PUT_32 (abfd, g->address, raw);
+      /* Find a type in the output format which matches the input howto -
+	 at the moment we assume input format == output format FIXME!!  */
+      r_idx = 0;
+      /* FIXME:  Need callj stuff here, and to check the howto entries to
+	 be sure they are real for this architecture.  */
+      if (g->howto== &howto_reloc_callj)
+	raw[7] = callj_mask + pcrel_mask + len_2;
+      else if (g->howto == &howto_reloc_pcrel24)
+	raw[7] = pcrel_mask + len_2;
+      else if (g->howto == &howto_reloc_pcrel13)
+	raw[7] = pcrel_mask + len_1;
+      else if (g->howto == &howto_reloc_abs32code)
+	raw[7] = len_2 + incode_mask;
+      else if (g->howto >= howto_align_table
+	       && g->howto <= (howto_align_table + ARRAY_SIZE (howto_align_table) - 1))
+	{
+	  /* symnum == -2; extern_mask not set, pcrel_mask set.  */
+	  r_idx = -2;
+	  r_extern = 0;
+	  raw[7] = (pcrel_mask
+		    | ((g->howto - howto_align_table) << 1));
+	}
+      else
+	raw[7] = len_2;
+
+      if (r_idx != 0)
+	/* Already mucked with r_extern, r_idx.  */;
+      else if (bfd_is_com_section (output_section)
+	       || bfd_is_abs_section (output_section)
+	       || bfd_is_und_section (output_section))
+	{
+	  if (bfd_abs_section_ptr->symbol == sym)
+	    {
+	      /* Whoops, looked like an abs symbol, but is really an offset
+		 from the abs section.  */
+	      r_idx = 0;
+	      r_extern = 0;
+	    }
+	  else
+	    {
+	      /* Fill in symbol.  */
+	      r_extern = 1;
+	      r_idx = (*g->sym_ptr_ptr)->udata.i;
+	    }
+	}
+      else
+	{
+	  /* Just an ordinary section.  */
+	  r_extern = 0;
+	  r_idx  = output_section->target_index;
+	}
+
+      if (bfd_header_big_endian (abfd))
+	{
+	  raw[4] = (unsigned char) (r_idx >> 16);
+	  raw[5] = (unsigned char) (r_idx >>  8);
+	  raw[6] = (unsigned char) (r_idx      );
+	}
+      else
+	{
+	  raw[6] = (unsigned char) (r_idx >> 16);
+	  raw[5] = (unsigned char) (r_idx>>   8);
+	  raw[4] = (unsigned char) (r_idx      );
+	}
+
+      if (r_extern)
+	raw[7] |= extern_mask;
+    }
+
+  if (bfd_bwrite ((void *) native, natsize, abfd) != natsize)
+    {
+      free (native);
+      return FALSE;
+    }
+
+  free (native);
+
+  return TRUE;
+}
+
+static bfd_boolean
+b_out_write_object_contents (bfd *abfd)
 {
   struct external_exec swapped_hdr;
   bfd_size_type amt;
@@ -313,7 +420,7 @@ b_out_write_object_contents (abfd)
 
   amt = EXEC_BYTES_SIZE;
   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
-      || bfd_bwrite ((PTR) &swapped_hdr, amt, abfd) != amt)
+      || bfd_bwrite ((void *) &swapped_hdr, amt, abfd) != amt)
     return FALSE;
 
   /* Now write out reloc info, followed by syms and strings */
@@ -344,20 +451,20 @@ b_out_write_object_contents (abfd)
 	       b_out_symbol_cmp);
 
       /* Back to your regularly scheduled program.  */
-      if (bfd_seek (abfd, (file_ptr) (N_SYMOFF(*exec_hdr(abfd))), SEEK_SET)
+      if (bfd_seek (abfd, (file_ptr) (N_SYMOFF (*exec_hdr (abfd))), SEEK_SET)
 	  != 0)
 	return FALSE;
 
       if (! aout_32_write_syms (abfd))
 	return FALSE;
 
-      if (bfd_seek (abfd, (file_ptr) (N_TROFF(*exec_hdr(abfd))), SEEK_SET)
+      if (bfd_seek (abfd, (file_ptr) (N_TROFF (*exec_hdr (abfd))), SEEK_SET)
 	  != 0)
 	return FALSE;
 
       if (!b_out_squirt_out_relocs (abfd, obj_textsec (abfd)))
 	return FALSE;
-      if (bfd_seek (abfd, (file_ptr) (N_DROFF(*exec_hdr(abfd))), SEEK_SET)
+      if (bfd_seek (abfd, (file_ptr) (N_DROFF (*exec_hdr (abfd))), SEEK_SET)
 	  != 0)
 	return FALSE;
 
@@ -379,16 +486,64 @@ b_out_write_object_contents (abfd)
 
 #define output_addr(sec) ((sec)->output_offset+(sec)->output_section->vma)
 
+static bfd_vma
+get_value (arelent *reloc,
+	   struct bfd_link_info *link_info,
+	   asection *input_section)
+{
+  bfd_vma value;
+  asymbol *symbol = *(reloc->sym_ptr_ptr);
+
+  /* A symbol holds a pointer to a section, and an offset from the
+     base of the section.  To relocate, we find where the section will
+     live in the output and add that in.  */
+  if (bfd_is_und_section (symbol->section))
+    {
+      struct bfd_link_hash_entry *h;
+
+      /* The symbol is undefined in this BFD.  Look it up in the
+	 global linker hash table.  FIXME: This should be changed when
+	 we convert b.out to use a specific final_link function and
+	 change the interface to bfd_relax_section to not require the
+	 generic symbols.  */
+      h = bfd_wrapped_link_hash_lookup (input_section->owner, link_info,
+					bfd_asymbol_name (symbol),
+					FALSE, FALSE, TRUE);
+      if (h != (struct bfd_link_hash_entry *) NULL
+	  && (h->type == bfd_link_hash_defined
+	      || h->type == bfd_link_hash_defweak))
+	value = h->u.def.value + output_addr (h->u.def.section);
+      else if (h != (struct bfd_link_hash_entry *) NULL
+	       && h->type == bfd_link_hash_common)
+	value = h->u.c.size;
+      else
+	{
+	  if (! ((*link_info->callbacks->undefined_symbol)
+		 (link_info, bfd_asymbol_name (symbol),
+		  input_section->owner, input_section, reloc->address,
+		  TRUE)))
+	    abort ();
+	  value = 0;
+	}
+    }
+  else
+    value = symbol->value + output_addr (symbol->section);
+
+  /* Add the value contained in the relocation.  */
+  value += reloc->addend;
+
+  return value;
+}
+
 /* Magic to turn callx into calljx.  */
 
 static bfd_reloc_status_type
-calljx_callback (abfd, link_info, reloc_entry, src, dst, input_section)
-     bfd *abfd;
-     struct bfd_link_info *link_info;
-     arelent *reloc_entry;
-     PTR src;
-     PTR dst;
-     asection *input_section;
+calljx_callback (bfd *abfd,
+		 struct bfd_link_info *link_info,
+		 arelent *reloc_entry,
+		 void * src,
+		 void * dst,
+		 asection *input_section)
 {
   int word = bfd_get_32 (abfd, src);
   asymbol *symbol_in = *(reloc_entry->sym_ptr_ptr);
@@ -401,6 +556,7 @@ calljx_callback (abfd, link_info, reloc_entry, src, dst, input_section)
     {
       aout_symbol_type *balsym = symbol+1;
       int inst = bfd_get_32 (abfd, (bfd_byte *) src-4);
+
       /* The next symbol should be an N_BALNAME.  */
       BFD_ASSERT (IS_BALNAME (balsym->other));
       inst &= BALX_MASK;
@@ -420,16 +576,14 @@ calljx_callback (abfd, link_info, reloc_entry, src, dst, input_section)
 /* Magic to turn call into callj.  */
 
 static bfd_reloc_status_type
-callj_callback (abfd, link_info, reloc_entry,  data, srcidx, dstidx,
-		input_section, shrinking)
-     bfd *abfd;
-     struct bfd_link_info *link_info;
-     arelent *reloc_entry;
-     PTR data;
-     unsigned int srcidx;
-     unsigned int dstidx;
-     asection *input_section;
-     bfd_boolean shrinking;
+callj_callback (bfd *abfd,
+		struct bfd_link_info *link_info,
+		arelent *reloc_entry,
+		void * data,
+		unsigned int srcidx,
+		unsigned int dstidx,
+		asection *input_section,
+		bfd_boolean shrinking)
 {
   int word = bfd_get_32 (abfd, (bfd_byte *) data + srcidx);
   asymbol *symbol_in = *(reloc_entry->sym_ptr_ptr);
@@ -438,18 +592,17 @@ callj_callback (abfd, link_info, reloc_entry,  data, srcidx, dstidx,
 
   value = get_value (reloc_entry, link_info, input_section);
 
-  if (IS_OTHER(symbol->other))
-    {
-      /* Call to a system procedure - replace code with system
-	 procedure number.  */
-      word = CALLS | (symbol->other - 1);
-    }
-  else if (IS_CALLNAME(symbol->other))
+  if (IS_OTHER (symbol->other))
+    /* Call to a system procedure - replace code with system
+       procedure number.  */
+    word = CALLS | (symbol->other - 1);
+
+  else if (IS_CALLNAME (symbol->other))
     {
       aout_symbol_type *balsym = symbol+1;
 
       /* The next symbol should be an N_BALNAME.  */
-      BFD_ASSERT(IS_BALNAME(balsym->other));
+      BFD_ASSERT (IS_BALNAME (balsym->other));
 
       /* We are calling a leaf, so replace the call instruction with a
 	 bal.  */
@@ -470,65 +623,19 @@ callj_callback (abfd, link_info, reloc_entry,  data, srcidx, dstidx,
       BFD_ASSERT (symbol->symbol.section == input_section);
     }
   else
-    {
-      word = CALL | (((word & BAL_MASK)
-		      + value
-		      + reloc_entry->addend
-		      - (shrinking ? dstidx : 0)
-		      - output_addr (input_section))
-		     & BAL_MASK);
-    }
+    word = CALL | (((word & BAL_MASK)
+		    + value
+		    + reloc_entry->addend
+		    - (shrinking ? dstidx : 0)
+		    - output_addr (input_section))
+		   & BAL_MASK);
+
   bfd_put_32 (abfd, (bfd_vma) word, (bfd_byte *) data + dstidx);
   return bfd_reloc_ok;
 }
 
-/* type rshift size  bitsize  	pcrel	bitpos  absolute overflow check*/
-
-#define ABS32CODE 0
-#define ABS32CODE_SHRUNK 1
-#define PCREL24 2
-#define CALLJ 3
-#define ABS32 4
-#define PCREL13 5
-#define ABS32_MAYBE_RELAXABLE 1
-#define ABS32_WAS_RELAXABLE 2
-
-#define ALIGNER 10
-#define ALIGNDONE 11
-static reloc_howto_type howto_reloc_callj =
-HOWTO(CALLJ, 0, 2, 24, TRUE, 0, complain_overflow_signed, 0,"callj", TRUE, 0x00ffffff, 0x00ffffff,FALSE);
-static  reloc_howto_type howto_reloc_abs32 =
-HOWTO(ABS32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"abs32", TRUE, 0xffffffff,0xffffffff,FALSE);
-static reloc_howto_type howto_reloc_pcrel24 =
-HOWTO(PCREL24, 0, 2, 24, TRUE, 0, complain_overflow_signed,0,"pcrel24", TRUE, 0x00ffffff,0x00ffffff,FALSE);
-
-static reloc_howto_type howto_reloc_pcrel13 =
-HOWTO(PCREL13, 0, 2, 13, TRUE, 0, complain_overflow_signed,0,"pcrel13", TRUE, 0x00001fff,0x00001fff,FALSE);
-
-static reloc_howto_type howto_reloc_abs32codeshrunk =
-HOWTO(ABS32CODE_SHRUNK, 0, 2, 24, TRUE, 0, complain_overflow_signed, 0,"callx->callj", TRUE, 0x00ffffff, 0x00ffffff,FALSE);
-
-static  reloc_howto_type howto_reloc_abs32code =
-HOWTO(ABS32CODE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"callx", TRUE, 0xffffffff,0xffffffff,FALSE);
-
-static reloc_howto_type howto_align_table[] = {
-  HOWTO (ALIGNER, 0, 0x1, 0, FALSE, 0, complain_overflow_dont, 0, "align16", FALSE, 0, 0, FALSE),
-  HOWTO (ALIGNER, 0, 0x3, 0, FALSE, 0, complain_overflow_dont, 0, "align32", FALSE, 0, 0, FALSE),
-  HOWTO (ALIGNER, 0, 0x7, 0, FALSE, 0, complain_overflow_dont, 0, "align64", FALSE, 0, 0, FALSE),
-  HOWTO (ALIGNER, 0, 0xf, 0, FALSE, 0, complain_overflow_dont, 0, "align128", FALSE, 0, 0, FALSE),
-};
-
-static reloc_howto_type howto_done_align_table[] = {
-  HOWTO (ALIGNDONE, 0x1, 0x1, 0, FALSE, 0, complain_overflow_dont, 0, "donealign16", FALSE, 0, 0, FALSE),
-  HOWTO (ALIGNDONE, 0x3, 0x3, 0, FALSE, 0, complain_overflow_dont, 0, "donealign32", FALSE, 0, 0, FALSE),
-  HOWTO (ALIGNDONE, 0x7, 0x7, 0, FALSE, 0, complain_overflow_dont, 0, "donealign64", FALSE, 0, 0, FALSE),
-  HOWTO (ALIGNDONE, 0xf, 0xf, 0, FALSE, 0, complain_overflow_dont, 0, "donealign128", FALSE, 0, 0, FALSE),
-};
-
 static reloc_howto_type *
-b_out_bfd_reloc_type_lookup (abfd, code)
-     bfd *abfd ATTRIBUTE_UNUSED;
-     bfd_reloc_code_real_type code;
+b_out_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code)
 {
   switch (code)
     {
@@ -547,12 +654,9 @@ b_out_bfd_reloc_type_lookup (abfd, code)
 /* Allocate enough room for all the reloc entries, plus pointers to them all.  */
 
 static bfd_boolean
-b_out_slurp_reloc_table (abfd, asect, symbols)
-     bfd *abfd;
-     sec_ptr asect;
-     asymbol **symbols;
+b_out_slurp_reloc_table (bfd *abfd, sec_ptr asect, asymbol **symbols)
 {
-  register struct relocation_info *rptr;
+  struct relocation_info *rptr;
   unsigned int counter;
   arelent *cache_ptr;
   int extern_mask, pcrel_mask, callj_mask, length_shift;
@@ -571,37 +675,27 @@ b_out_slurp_reloc_table (abfd, asect, symbols)
     return FALSE;
 
   if (asect == obj_datasec (abfd))
+    reloc_size = exec_hdr (abfd)->a_drsize;
+  else if (asect == obj_textsec (abfd))
+    reloc_size = exec_hdr (abfd)->a_trsize;
+  else if (asect == obj_bsssec (abfd))
+    reloc_size = 0;
+  else
     {
-      reloc_size = exec_hdr(abfd)->a_drsize;
-      goto doit;
-    }
-
-  if (asect == obj_textsec (abfd))
-    {
-      reloc_size = exec_hdr(abfd)->a_trsize;
-      goto doit;
-    }
-
-  if (asect == obj_bsssec (abfd))
-    {
-      reloc_size = 0;
-      goto doit;
+      bfd_set_error (bfd_error_invalid_operation);
+      return FALSE;
     }
 
-  bfd_set_error (bfd_error_invalid_operation);
-  return FALSE;
-
- doit:
   if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
     return FALSE;
   count = reloc_size / sizeof (struct relocation_info);
 
-  relocs = (struct relocation_info *) bfd_malloc (reloc_size);
+  relocs = bfd_malloc (reloc_size);
   if (!relocs && reloc_size != 0)
     return FALSE;
 
   amt = ((bfd_size_type) count + 1) * sizeof (arelent);
-  reloc_cache = (arelent *) bfd_malloc (amt);
+  reloc_cache = bfd_malloc (amt);
   if (!reloc_cache)
     {
       if (relocs != NULL)
@@ -609,7 +703,7 @@ b_out_slurp_reloc_table (abfd, asect, symbols)
       return FALSE;
     }
 
-  if (bfd_bread ((PTR) relocs, reloc_size, abfd) != reloc_size)
+  if (bfd_bread ((void *) relocs, reloc_size, abfd) != reloc_size)
     {
       free (reloc_cache);
       if (relocs != NULL)
@@ -714,7 +808,7 @@ b_out_slurp_reloc_table (abfd, asect, symbols)
 	    cache_ptr->addend = 0;
 	    break;
 	  default:
-	    BFD_ASSERT(0);
+	    BFD_ASSERT (FALSE);
 	    break;
 	  }
       }
@@ -759,9 +853,7 @@ b_out_slurp_reloc_table (abfd, asect, symbols)
 	cursor[1] = tmp;
       }
     else
-      {
-	prev_addr = cache_ptr->address;
-      }
+      prev_addr = cache_ptr->address;
   }
 
   if (relocs != NULL)
@@ -772,149 +864,13 @@ b_out_slurp_reloc_table (abfd, asect, symbols)
   return TRUE;
 }
 
-static bfd_boolean
-b_out_squirt_out_relocs (abfd, section)
-     bfd *abfd;
-     asection *section;
-{
-  arelent **generic;
-  int r_extern = 0;
-  int r_idx;
-  int incode_mask;
-  int len_1;
-  unsigned int count = section->reloc_count;
-  struct relocation_info *native, *natptr;
-  bfd_size_type natsize;
-  int extern_mask, pcrel_mask, len_2, callj_mask;
-
-  if (count == 0)
-    return TRUE;
-
-  generic = section->orelocation;
-  natsize = (bfd_size_type) count * sizeof (struct relocation_info);
-  native = ((struct relocation_info *) bfd_malloc (natsize));
-  if (!native && natsize != 0)
-    return FALSE;
-
-  if (bfd_header_big_endian (abfd))
-    {
-      /* Big-endian bit field allocation order.  */
-      pcrel_mask  = 0x80;
-      extern_mask = 0x10;
-      len_2       = 0x40;
-      len_1       = 0x20;
-      callj_mask  = 0x02;
-      incode_mask = 0x08;
-    }
-  else
-    {
-      /* Little-endian bit field allocation order.  */
-      pcrel_mask  = 0x01;
-      extern_mask = 0x08;
-      len_2       = 0x04;
-      len_1       = 0x02;
-      callj_mask  = 0x40;
-      incode_mask = 0x10;
-    }
-
-  for (natptr = native; count > 0; --count, ++natptr, ++generic)
-    {
-      arelent *g = *generic;
-      unsigned char *raw = (unsigned char *)natptr;
-      asymbol *sym = *(g->sym_ptr_ptr);
-      asection *output_section = sym->section->output_section;
-
-      H_PUT_32 (abfd, g->address, raw);
-      /* Find a type in the output format which matches the input howto -
-	 at the moment we assume input format == output format FIXME!!  */
-      r_idx = 0;
-      /* FIXME:  Need callj stuff here, and to check the howto entries to
-	 be sure they are real for this architecture.  */
-      if (g->howto== &howto_reloc_callj)
-	raw[7] = callj_mask + pcrel_mask + len_2;
-      else if (g->howto == &howto_reloc_pcrel24)
-	raw[7] = pcrel_mask + len_2;
-      else if (g->howto == &howto_reloc_pcrel13)
-	raw[7] = pcrel_mask + len_1;
-      else if (g->howto == &howto_reloc_abs32code)
-	raw[7] = len_2 + incode_mask;
-      else if (g->howto >= howto_align_table
-	       && g->howto <= (howto_align_table
-			       + sizeof (howto_align_table) / sizeof (howto_align_table[0])
-			       - 1))
-	{
-	  /* symnum == -2; extern_mask not set, pcrel_mask set.  */
-	  r_idx = -2;
-	  r_extern = 0;
-	  raw[7] = (pcrel_mask
-		    | ((g->howto - howto_align_table) << 1));
-	}
-      else
-	raw[7] = len_2;
-
-      if (r_idx != 0)
-	/* Already mucked with r_extern, r_idx.  */;
-      else if (bfd_is_com_section (output_section)
-	       || bfd_is_abs_section (output_section)
-	       || bfd_is_und_section (output_section))
-	{
-	  if (bfd_abs_section_ptr->symbol == sym)
-	    {
-	      /* Whoops, looked like an abs symbol, but is really an offset
-		 from the abs section.  */
-	      r_idx = 0;
-	      r_extern = 0;
-	    }
-	  else
-	    {
-	      /* Fill in symbol.  */
-	      r_extern = 1;
-	      r_idx = (*g->sym_ptr_ptr)->udata.i;
-	    }
-	}
-      else
-	{
-	  /* Just an ordinary section.  */
-	  r_extern = 0;
-	  r_idx  = output_section->target_index;
-	}
-
-      if (bfd_header_big_endian (abfd))
-	{
-	  raw[4] = (unsigned char) (r_idx >> 16);
-	  raw[5] = (unsigned char) (r_idx >>  8);
-	  raw[6] = (unsigned char) (r_idx      );
-	}
-      else
-	{
-	  raw[6] = (unsigned char) (r_idx >> 16);
-	  raw[5] = (unsigned char) (r_idx>>   8);
-	  raw[4] = (unsigned char) (r_idx      );
-	}
-
-      if (r_extern)
-	raw[7] |= extern_mask;
-    }
-
-  if (bfd_bwrite ((PTR) native, natsize, abfd) != natsize)
-    {
-      free ((PTR)native);
-      return FALSE;
-    }
-
-  free ((PTR)native);
-
-  return TRUE;
-}
-
 /* This is stupid.  This function should be a boolean predicate.  */
 
 static long
-b_out_canonicalize_reloc (abfd, section, relptr, symbols)
-     bfd *abfd;
-     sec_ptr section;
-     arelent **relptr;
-     asymbol **symbols;
+b_out_canonicalize_reloc (bfd *abfd,
+			  sec_ptr section,
+			  arelent **relptr,
+			  asymbol **symbols)
 {
   arelent *tblptr;
   unsigned int count;
@@ -946,9 +902,7 @@ b_out_canonicalize_reloc (abfd, section, relptr, symbols)
 }
 
 static long
-b_out_get_reloc_upper_bound (abfd, asect)
-     bfd *abfd;
-     sec_ptr asect;
+b_out_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
 {
   if (bfd_get_format (abfd) != bfd_object)
     {
@@ -961,13 +915,13 @@ b_out_get_reloc_upper_bound (abfd, asect)
 
   if (asect == obj_datasec (abfd))
     return (sizeof (arelent *) *
-	    ((exec_hdr(abfd)->a_drsize / sizeof (struct relocation_info))
-	     +1));
+	    ((exec_hdr (abfd)->a_drsize / sizeof (struct relocation_info))
+	     + 1));
 
   if (asect == obj_textsec (abfd))
     return (sizeof (arelent *) *
-	    ((exec_hdr(abfd)->a_trsize / sizeof (struct relocation_info))
-	     +1));
+	    ((exec_hdr (abfd)->a_trsize / sizeof (struct relocation_info))
+	     + 1));
 
   if (asect == obj_bsssec (abfd))
     return 0;
@@ -978,12 +932,11 @@ b_out_get_reloc_upper_bound (abfd, asect)
 
 
 static bfd_boolean
-b_out_set_section_contents (abfd, section, location, offset, count)
-     bfd *abfd;
-     asection *section;
-     const PTR location;
-     file_ptr offset;
-     bfd_size_type count;
+b_out_set_section_contents (bfd *abfd,
+			    asection *section,
+			    const void * location,
+			    file_ptr offset,
+			    bfd_size_type count)
 {
   if (! abfd->output_has_begun)
     {
@@ -992,7 +945,7 @@ b_out_set_section_contents (abfd, section, location, offset, count)
 	return FALSE;
 
       obj_textsec (abfd)->filepos = sizeof (struct external_exec);
-      obj_datasec(abfd)->filepos = obj_textsec(abfd)->filepos
+      obj_datasec (abfd)->filepos = obj_textsec (abfd)->filepos
 	+  obj_textsec (abfd)->size;
     }
 
@@ -1003,16 +956,15 @@ b_out_set_section_contents (abfd, section, location, offset, count)
   if (count == 0)
     return TRUE;
 
-  return bfd_bwrite ((PTR) location, count, abfd) == count;
+  return bfd_bwrite ((void *) location, count, abfd) == count;
 }
 
 static bfd_boolean
-b_out_set_arch_mach (abfd, arch, machine)
-     bfd *abfd;
-     enum bfd_architecture arch;
-     unsigned long machine;
+b_out_set_arch_mach (bfd *abfd,
+		     enum bfd_architecture arch,
+		     unsigned long machine)
 {
-  bfd_default_set_arch_mach(abfd, arch, machine);
+  bfd_default_set_arch_mach (abfd, arch, machine);
 
   if (arch == bfd_arch_unknown)	/* Unknown machine arch is OK.  */
     return TRUE;
@@ -1038,72 +990,16 @@ b_out_set_arch_mach (abfd, arch, machine)
 }
 
 static int
-b_out_sizeof_headers (ignore_abfd, ignore)
-     bfd *ignore_abfd ATTRIBUTE_UNUSED;
-     bfd_boolean ignore ATTRIBUTE_UNUSED;
+b_out_sizeof_headers (bfd *ignore_abfd ATTRIBUTE_UNUSED, bfd_boolean ignore ATTRIBUTE_UNUSED)
 {
   return sizeof (struct external_exec);
 }
 
-
-static bfd_vma
-get_value (reloc, link_info, input_section)
-     arelent *reloc;
-     struct bfd_link_info *link_info;
-     asection *input_section;
-{
-  bfd_vma value;
-  asymbol *symbol = *(reloc->sym_ptr_ptr);
-
-  /* A symbol holds a pointer to a section, and an offset from the
-     base of the section.  To relocate, we find where the section will
-     live in the output and add that in.  */
-  if (bfd_is_und_section (symbol->section))
-    {
-      struct bfd_link_hash_entry *h;
-
-      /* The symbol is undefined in this BFD.  Look it up in the
-	 global linker hash table.  FIXME: This should be changed when
-	 we convert b.out to use a specific final_link function and
-	 change the interface to bfd_relax_section to not require the
-	 generic symbols.  */
-      h = bfd_wrapped_link_hash_lookup (input_section->owner, link_info,
-					bfd_asymbol_name (symbol),
-					FALSE, FALSE, TRUE);
-      if (h != (struct bfd_link_hash_entry *) NULL
-	  && (h->type == bfd_link_hash_defined
-	      || h->type == bfd_link_hash_defweak))
-	value = h->u.def.value + output_addr (h->u.def.section);
-      else if (h != (struct bfd_link_hash_entry *) NULL
-	       && h->type == bfd_link_hash_common)
-	value = h->u.c.size;
-      else
-	{
-	  if (! ((*link_info->callbacks->undefined_symbol)
-		 (link_info, bfd_asymbol_name (symbol),
-		  input_section->owner, input_section, reloc->address,
-		  TRUE)))
-	    abort ();
-	  value = 0;
-	}
-    }
-  else
-    {
-      value = symbol->value + output_addr (symbol->section);
-    }
-
-  /* Add the value contained in the relocation.  */
-  value += reloc->addend;
-
-  return value;
-}
-
 static void
-perform_slip (abfd, slip, input_section, value)
-     bfd *abfd;
-     unsigned int slip;
-     asection *input_section;
-     bfd_vma value;
+perform_slip (bfd *abfd,
+	      unsigned int slip,
+	      asection *input_section,
+	      bfd_vma value)
 {
   asymbol **s;
 
@@ -1143,12 +1039,11 @@ perform_slip (abfd, slip, input_section, value)
    If it can, then it changes the amode.  */
 
 static int
-abs32code (abfd, input_section, r, shrink, link_info)
-     bfd *abfd;
-     asection *input_section;
-     arelent *r;
-     unsigned int shrink;
-     struct bfd_link_info *link_info;
+abs32code (bfd *abfd,
+	   asection *input_section,
+	   arelent *r,
+	   unsigned int shrink,
+	   struct bfd_link_info *link_info)
 {
   bfd_vma value = get_value (r, link_info, input_section);
   bfd_vma dot = output_addr (input_section) + r->address;
@@ -1176,11 +1071,10 @@ abs32code (abfd, input_section, r, shrink, link_info)
 }
 
 static int
-aligncode (abfd, input_section, r, shrink)
-     bfd *abfd;
-     asection *input_section;
-     arelent *r;
-     unsigned int shrink;
+aligncode (bfd *abfd,
+	   asection *input_section,
+	   arelent *r,
+	   unsigned int shrink)
 {
   bfd_vma dot = output_addr (input_section) + r->address;
   bfd_vma gap;
@@ -1222,19 +1116,17 @@ aligncode (abfd, input_section, r, shrink)
 }
 
 static bfd_boolean
-b_out_bfd_relax_section (abfd, i, link_info, again)
-     bfd *abfd;
-     asection *i;
-     struct bfd_link_info *link_info;
-     bfd_boolean *again;
+b_out_bfd_relax_section (bfd *abfd,
+			 asection *i,
+			 struct bfd_link_info *link_info,
+			 bfd_boolean *again)
 {
   /* Get enough memory to hold the stuff.  */
   bfd *input_bfd = i->owner;
   asection *input_section = i;
   unsigned int shrink = 0 ;
   arelent **reloc_vector = NULL;
-  long reloc_size = bfd_get_reloc_upper_bound (input_bfd,
-					       input_section);
+  long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
 
   if (reloc_size < 0)
     return FALSE;
@@ -1247,7 +1139,7 @@ b_out_bfd_relax_section (abfd, i, link_info, again)
     {
       long reloc_count;
 
-      reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
+      reloc_vector = bfd_malloc ((bfd_size_type) reloc_size);
       if (reloc_vector == NULL && reloc_size != 0)
 	goto error_return;
 
@@ -1295,20 +1187,17 @@ b_out_bfd_relax_section (abfd, i, link_info, again)
 }
 
 static bfd_byte *
-b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order,
-					  data, relocatable, symbols)
-     bfd *output_bfd;
-     struct bfd_link_info *link_info;
-     struct bfd_link_order *link_order;
-     bfd_byte *data;
-     bfd_boolean relocatable;
-     asymbol **symbols;
+b_out_bfd_get_relocated_section_contents (bfd *output_bfd,
+					  struct bfd_link_info *link_info,
+					  struct bfd_link_order *link_order,
+					  bfd_byte *data,
+					  bfd_boolean relocatable,
+					  asymbol **symbols)
 {
   /* Get enough memory to hold the stuff.  */
   bfd *input_bfd = link_order->u.indirect.section->owner;
   asection *input_section = link_order->u.indirect.section;
-  long reloc_size = bfd_get_reloc_upper_bound (input_bfd,
-					       input_section);
+  long reloc_size = bfd_get_reloc_upper_bound (input_bfd, input_section);
   arelent **reloc_vector = NULL;
   long reloc_count;
 
@@ -1322,7 +1211,7 @@ b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order,
 						       data, relocatable,
 						       symbols);
 
-  reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
+  reloc_vector = bfd_malloc ((bfd_size_type) reloc_size);
   if (reloc_vector == NULL && reloc_size != 0)
     goto error_return;
 
@@ -1362,9 +1251,7 @@ b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order,
 	      parent++;
 	    }
 	  else
-	    {
-	      run = link_order->size - dst_address;
-	    }
+	    run = link_order->size - dst_address;
 
 	  /* Copy the bytes.  */
 	  for (idx = 0; idx < run; idx++)
@@ -1472,52 +1359,48 @@ b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order,
 
 /* Build the transfer vectors for Big and Little-Endian B.OUT files.  */
 
-#define aout_32_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
-#define aout_32_close_and_cleanup aout_32_bfd_free_cached_info
-
-#define b_out_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
-#define b_out_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
-#define b_out_bfd_link_add_symbols _bfd_generic_link_add_symbols
-#define b_out_bfd_link_just_syms _bfd_generic_link_just_syms
-#define b_out_bfd_final_link _bfd_generic_final_link
-#define b_out_bfd_link_split_section  _bfd_generic_link_split_section
-#define b_out_bfd_gc_sections  bfd_generic_gc_sections
-#define b_out_bfd_merge_sections  bfd_generic_merge_sections
-#define b_out_bfd_is_group_section bfd_generic_is_group_section
-#define b_out_bfd_discard_group bfd_generic_discard_group
-#define b_out_section_already_linked \
-  _bfd_generic_section_already_linked
-
-#define aout_32_get_section_contents_in_window \
-  _bfd_generic_get_section_contents_in_window
+#define aout_32_bfd_make_debug_symbol          _bfd_nosymbols_bfd_make_debug_symbol
+#define aout_32_close_and_cleanup              aout_32_bfd_free_cached_info
+#define b_out_bfd_link_hash_table_create       _bfd_generic_link_hash_table_create
+#define b_out_bfd_link_hash_table_free         _bfd_generic_link_hash_table_free
+#define b_out_bfd_link_add_symbols             _bfd_generic_link_add_symbols
+#define b_out_bfd_link_just_syms               _bfd_generic_link_just_syms
+#define b_out_bfd_final_link                   _bfd_generic_final_link
+#define b_out_bfd_link_split_section           _bfd_generic_link_split_section
+#define b_out_bfd_gc_sections                  bfd_generic_gc_sections
+#define b_out_bfd_merge_sections               bfd_generic_merge_sections
+#define b_out_bfd_is_group_section             bfd_generic_is_group_section
+#define b_out_bfd_discard_group                bfd_generic_discard_group
+#define b_out_section_already_linked           _bfd_generic_section_already_linked
+#define aout_32_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
 
 extern const bfd_target b_out_vec_little_host;
 
 const bfd_target b_out_vec_big_host =
 {
-  "b.out.big",			/* name */
+  "b.out.big",			/* Name.  */
   bfd_target_aout_flavour,
-  BFD_ENDIAN_LITTLE,		/* data byte order is little */
-  BFD_ENDIAN_BIG,		/* hdr byte order is big */
-  (HAS_RELOC | EXEC_P |		/* object flags */
+  BFD_ENDIAN_LITTLE,		/* Data byte order.  */
+  BFD_ENDIAN_BIG,		/* Header byte order.  */
+  (HAS_RELOC | EXEC_P |		/* Object flags.  */
    HAS_LINENO | HAS_DEBUG |
    HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE ),
   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
-  '_',				/* symbol leading char */
-  ' ',				/* ar_pad_char */
-  16,				/* ar_max_namelen */
+  '_',				/* Symbol leading char.  */
+  ' ',				/* AR_pad_char.  */
+  16,				/* AR_max_namelen.  */
 
   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
-     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
+     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data.  */
   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
      bfd_getb32, bfd_getb_signed_32, bfd_putb32,
-     bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
- {_bfd_dummy_target, b_out_object_p, /* bfd_check_format */
+     bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* Headers.  */
+ {_bfd_dummy_target, b_out_object_p, /* bfd_check_format.  */
    bfd_generic_archive_p, _bfd_dummy_target},
- {bfd_false, b_out_mkobject,	/* bfd_set_format */
+ {bfd_false, b_out_mkobject,	/* bfd_set_format.  */
    _bfd_generic_mkarchive, bfd_false},
- {bfd_false, b_out_write_object_contents, /* bfd_write_contents */
+ {bfd_false, b_out_write_object_contents, /* bfd_write_contents.  */
    _bfd_write_archive_contents, bfd_false},
 
      BFD_JUMP_TABLE_GENERIC (aout_32),
@@ -1532,34 +1415,34 @@ const bfd_target b_out_vec_big_host =
 
   & b_out_vec_little_host,
 
-  (PTR) 0,
+  NULL
 };
 
 const bfd_target b_out_vec_little_host =
 {
-  "b.out.little",		/* name */
+  "b.out.little",		/* Name.  */
   bfd_target_aout_flavour,
-  BFD_ENDIAN_LITTLE,		/* data byte order is little */
-  BFD_ENDIAN_LITTLE,		/* header byte order is little */
-  (HAS_RELOC | EXEC_P |		/* object flags */
+  BFD_ENDIAN_LITTLE,		/* Data byte order.  */
+  BFD_ENDIAN_LITTLE,		/* Header byte order.  */
+  (HAS_RELOC | EXEC_P |		/* Object flags.  */
    HAS_LINENO | HAS_DEBUG |
    HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE ),
   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
-  '_',				/* symbol leading char */
-  ' ',				/* ar_pad_char */
-  16,				/* ar_max_namelen */
+  '_',				/* Symbol leading char.  */
+  ' ',				/* AR_pad_char.  */
+  16,				/* AR_max_namelen.  */
   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
     bfd_getl32, bfd_getl_signed_32, bfd_putl32,
-     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
+     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data.  */
   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
-     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
+     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Headers.  */
 
-  {_bfd_dummy_target, b_out_object_p, /* bfd_check_format */
+  {_bfd_dummy_target, b_out_object_p, /* bfd_check_format.  */
      bfd_generic_archive_p, _bfd_dummy_target},
-  {bfd_false, b_out_mkobject,	/* bfd_set_format */
+  {bfd_false, b_out_mkobject,	/* bfd_set_format.  */
      _bfd_generic_mkarchive, bfd_false},
-  {bfd_false, b_out_write_object_contents, /* bfd_write_contents */
+  {bfd_false, b_out_write_object_contents, /* bfd_write_contents.  */
      _bfd_write_archive_contents, bfd_false},
 
      BFD_JUMP_TABLE_GENERIC (aout_32),
@@ -1574,5 +1457,5 @@ const bfd_target b_out_vec_little_host =
 
   & b_out_vec_big_host,
 
-  (PTR) 0
+  NULL
 };