Add missing prototypes for bout.c

1 files changed, 413 insertions, 403 deletions

diff --git a/bfd/bout.c b/bfd/bout.c
index 165dd24e5f..fb6b4751d3 100644
--- a/bfd/bout.c
+++ b/bfd/bout.c
@@ -1,6 +1,6 @@
 /* BFD back-end for Intel 960 b.out binaries.
    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-   2000
+   2000, 2001
    Free Software Foundation, Inc.
    Written by Cygnus Support.
 
@@ -28,30 +28,32 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "bout.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 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 *, 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 boolean b_out_bfd_relax_section PARAMS ((bfd *, asection *,
-						struct bfd_link_info *,
-						boolean *));
-static bfd_byte *b_out_bfd_get_relocated_section_contents
-  PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
-	   bfd_byte *, boolean, asymbol **));
+#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 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 *, 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 boolean               b_out_bfd_relax_section PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
+static bfd_byte *            b_out_bfd_get_relocated_section_contents  PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *, boolean, asymbol **));
+static int                   b_out_sizeof_headers PARAMS ((bfd *, boolean));
+static boolean               b_out_set_arch_mach PARAMS ((bfd *, enum bfd_architecture, unsigned long));
+static boolean               b_out_set_section_contents PARAMS ((bfd *, asection *, 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 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 boolean               b_out_write_object_contents PARAMS ((bfd *));
+static int                   b_out_symbol_cmp PARAMS ((const void *, const void *));
+static 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 *));
 
 /* Swaps the information in an executable header taken from a raw byte
    stream memory image, into the internal exec_header structure.  */
@@ -84,10 +86,6 @@ bout_swap_exec_header_in (abfd, raw_bytes, execp)
 /* Swaps the information in an internal exec header structure into the
    supplied buffer ready for writing to disk.  */
 
-PROTO(void, bout_swap_exec_header_out,
-	  (bfd *abfd,
-	   struct internal_exec *execp,
-	   struct external_exec *raw_bytes));
 void
 bout_swap_exec_header_out (abfd, execp, raw_bytes)
      bfd *abfd;
@@ -121,18 +119,20 @@ b_out_object_p (abfd)
   struct external_exec exec_bytes;
 
   if (bfd_read ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd)
-      != EXEC_BYTES_SIZE) {
-    if (bfd_get_error () != bfd_error_system_call)
-      bfd_set_error (bfd_error_wrong_format);
-    return 0;
-  }
+      != EXEC_BYTES_SIZE)
+    {
+      if (bfd_get_error () != bfd_error_system_call)
+	bfd_set_error (bfd_error_wrong_format);
+      return 0;
+    }
 
   anexec.a_info = bfd_h_get_32 (abfd, exec_bytes.e_info);
 
-  if (N_BADMAG (anexec)) {
-    bfd_set_error (bfd_error_wrong_format);
-    return 0;
-  }
+  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);
@@ -148,7 +148,7 @@ b_out_callback (abfd)
   struct internal_exec *execp = exec_hdr (abfd);
   unsigned long bss_start;
 
-  /* Architecture and machine type */
+  /* Architecture and machine type.  */
   bfd_set_arch_mach(abfd,
 		    bfd_arch_i960, /* B.out only used on i960 */
 		    bfd_mach_i960_core /* Default */
@@ -158,7 +158,7 @@ b_out_callback (abfd)
   obj_str_filepos (abfd) = N_STROFF (*execp);
   obj_sym_filepos (abfd) = N_SYMOFF (*execp);
 
-  /* The alignments of the sections */
+  /* The alignments of the sections.  */
   obj_textsec (abfd)->alignment_power = execp->a_talign;
   obj_datasec (abfd)->alignment_power = execp->a_dalign;
   obj_bsssec  (abfd)->alignment_power = execp->a_balign;
@@ -170,7 +170,7 @@ b_out_callback (abfd)
   obj_textsec (abfd)->lma = obj_textsec (abfd)->vma;
   obj_datasec (abfd)->lma = obj_datasec (abfd)->vma;
 
-  /* And reload the sizes, since the aout module zaps them */
+  /* And reload the sizes, since the aout module zaps them.  */
   obj_textsec (abfd)->_raw_size = execp->a_text;
 
   bss_start = execp->a_dload + execp->a_data; /* BSS = end of data section */
@@ -178,11 +178,11 @@ b_out_callback (abfd)
 
   obj_bsssec (abfd)->lma = obj_bsssec (abfd)->vma;
 
-  /* The file positions of the sections */
+  /* The file positions of the sections.  */
   obj_textsec (abfd)->filepos = N_TXTOFF(*execp);
   obj_datasec (abfd)->filepos = N_DATOFF(*execp);
 
-  /* The file positions of the relocation info */
+  /* The file positions of the relocation info.  */
   obj_textsec (abfd)->rel_filepos = N_TROFF(*execp);
   obj_datasec (abfd)->rel_filepos =  N_DROFF(*execp);
 
@@ -195,10 +195,11 @@ b_out_callback (abfd)
   return abfd->xvec;
 }
 
-struct bout_data_struct {
+struct bout_data_struct
+  {
     struct aoutdata a;
     struct internal_exec e;
-};
+  };
 
 static boolean
 b_out_mkobject (abfd)
@@ -221,13 +222,16 @@ b_out_mkobject (abfd)
 }
 
 static int
-b_out_symbol_cmp (a, b)
-     struct aout_symbol **a, **b;
+b_out_symbol_cmp (a_ptr, b_ptr)
+     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;
   asection *sec;
   bfd_vma av, bv;
 
-  /* Primary key is address */
+  /* Primary key is address.  */
   sec = bfd_get_section (&(*a)->symbol);
   av = sec->output_section->vma + sec->output_offset + (*a)->symbol.value;
   sec = bfd_get_section (&(*b)->symbol);
@@ -310,7 +314,6 @@ b_out_write_object_contents (abfd)
 	qsort (outsyms, q - outsyms, sizeof (asymbol*), b_out_symbol_cmp);
 
       /* Back to your regularly scheduled program.  */
-
       if (bfd_seek (abfd, (file_ptr) (N_SYMOFF(*exec_hdr(abfd))), SEEK_SET)
 	  != 0)
 	return false;
@@ -331,10 +334,10 @@ b_out_write_object_contents (abfd)
   return true;
 }
 
-/** Some reloc hackery */
+/* Some reloc hackery.  */
 
 #define CALLS	  0x66003800	/* Template for 'calls' instruction	*/
-#define BAL	  0x0b000000	/* Template for 'bal' instruction */
+#define BAL	  0x0b000000	/* Template for 'bal' instruction 	*/
 #define BAL_MASK  0x00ffffff
 #define BALX	  0x85f00000	/* Template for 'balx' instruction	*/
 #define BALX_MASK 0x0007ffff
@@ -343,7 +346,8 @@ b_out_write_object_contents (abfd)
 
 #define output_addr(sec) ((sec)->output_offset+(sec)->output_section->vma)
 
-/* Magic to turn callx into calljx */
+/* Magic to turn callx into calljx.  */
+
 static bfd_reloc_status_type
 calljx_callback (abfd, link_info, reloc_entry, src, dst, input_section)
      bfd *abfd;
@@ -364,7 +368,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 */
+      /* The next symbol should be an N_BALNAME.  */
       BFD_ASSERT (IS_BALNAME (balsym->other));
       inst &= BALX_MASK;
       inst |= BALX;
@@ -380,7 +384,8 @@ calljx_callback (abfd, link_info, reloc_entry, src, dst, input_section)
   return bfd_reloc_ok;
 }
 
-/* Magic to turn call into callj */
+/* Magic to turn call into callj.  */
+
 static bfd_reloc_status_type
 callj_callback (abfd, link_info, reloc_entry,  data, srcidx, dstidx,
 		input_section, shrinking)
@@ -506,7 +511,7 @@ b_out_bfd_reloc_type_lookup (abfd, code)
     }
 }
 
-/* Allocate enough room for all the reloc entries, plus pointers to them all */
+/* Allocate enough room for all the reloc entries, plus pointers to them all.  */
 
 static boolean
 b_out_slurp_reloc_table (abfd, asect, symbols)
@@ -528,23 +533,27 @@ b_out_slurp_reloc_table (abfd, asect, symbols)
 
   if (asect->relocation)
     return true;
+
   if (!aout_32_slurp_symbol_table (abfd))
     return false;
 
-  if (asect == obj_datasec (abfd)) {
-    reloc_size = exec_hdr(abfd)->a_drsize;
-    goto doit;
-  }
+  if (asect == obj_datasec (abfd))
+    {
+      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_textsec (abfd))
+    {
+      reloc_size = exec_hdr(abfd)->a_trsize;
+      goto doit;
+    }
 
-  if (asect == obj_bsssec (abfd)) {
-    reloc_size = 0;
-    goto doit;
-  }
+  if (asect == obj_bsssec (abfd))
+    {
+      reloc_size = 0;
+      goto doit;
+    }
 
   bfd_set_error (bfd_error_invalid_operation);
   return false;
@@ -557,37 +566,43 @@ b_out_slurp_reloc_table (abfd, asect, symbols)
   relocs = (struct relocation_info *) bfd_malloc (reloc_size);
   if (!relocs && reloc_size != 0)
     return false;
+
   reloc_cache = (arelent *) bfd_malloc ((count+1) * sizeof (arelent));
-  if (!reloc_cache) {
-    if (relocs != NULL)
-      free ((char*)relocs);
-    return false;
-  }
+  if (!reloc_cache)
+    {
+      if (relocs != NULL)
+	free ((char*)relocs);
+      return false;
+    }
 
-  if (bfd_read ((PTR) relocs, 1, reloc_size, abfd) != reloc_size) {
-    free (reloc_cache);
-    if (relocs != NULL)
-      free (relocs);
-    return false;
-  }
+  if (bfd_read ((PTR) relocs, 1, reloc_size, abfd) != reloc_size)
+    {
+      free (reloc_cache);
+      if (relocs != NULL)
+	free (relocs);
+      return false;
+    }
 
-  if (bfd_header_big_endian (abfd)) {
-    /* big-endian bit field allocation order */
-    pcrel_mask  = 0x80;
-    extern_mask = 0x10;
-    incode_mask = 0x08;
-    callj_mask  = 0x02;
-    size_mask =   0x20;
-    length_shift = 5;
-  } else {
-    /* little-endian bit field allocation order */
-    pcrel_mask  = 0x01;
-    extern_mask = 0x08;
-    incode_mask = 0x10;
-    callj_mask  = 0x40;
-    size_mask   = 0x02;
-    length_shift = 1;
-  }
+  if (bfd_header_big_endian (abfd))
+    {
+      /* Big-endian bit field allocation order.  */
+      pcrel_mask  = 0x80;
+      extern_mask = 0x10;
+      incode_mask = 0x08;
+      callj_mask  = 0x02;
+      size_mask =   0x20;
+      length_shift = 5;
+    }
+  else
+    {
+      /* Little-endian bit field allocation order.  */
+      pcrel_mask  = 0x01;
+      extern_mask = 0x08;
+      incode_mask = 0x10;
+      callj_mask  = 0x40;
+      size_mask   = 0x02;
+      length_shift = 1;
+    }
 
   for (rptr = relocs, cache_ptr = reloc_cache, counter = 0;
        counter < count;
@@ -595,129 +610,124 @@ b_out_slurp_reloc_table (abfd, asect, symbols)
   {
     unsigned char *raw = (unsigned char *)rptr;
     unsigned int symnum;
+
     cache_ptr->address = bfd_h_get_32 (abfd, raw + 0);
     cache_ptr->howto = 0;
+
     if (bfd_header_big_endian (abfd))
-    {
       symnum = (raw[4] << 16) | (raw[5] << 8) | raw[6];
-    }
     else
-    {
       symnum = (raw[6] << 16) | (raw[5] << 8) | raw[4];
-    }
 
     if (raw[7] & extern_mask)
-    {
-      /* if this is set then the r_index is a index into the symbol table;
-       * if the bit is not set then r_index contains a section map.
-       * we either fill in the sym entry with a pointer to the symbol,
-       * or point to the correct section
-       */
+      {
+	/* If this is set then the r_index is a index into the symbol table;
+	   if the bit is not set then r_index contains a section map.
+	   We either fill in the sym entry with a pointer to the symbol,
+	   or point to the correct section.  */
       cache_ptr->sym_ptr_ptr = symbols + symnum;
       cache_ptr->addend = 0;
-    } else
-    {
-      /* in a.out symbols are relative to the beginning of the
-       * file rather than sections ?
-       * (look in translate_from_native_sym_flags)
-       * the reloc entry addend has added to it the offset into the
-       * file of the data, so subtract the base to make the reloc
-       * section relative */
-      int s;
+      }
+    else
       {
-	/* sign-extend symnum from 24 bits to whatever host uses */
+	/* In a.out symbols are relative to the beginning of the
+	   file rather than sections ?
+	   (look in translate_from_native_sym_flags)
+	   The reloc entry addend has added to it the offset into the
+	   file of the data, so subtract the base to make the reloc
+	   section relative.  */
+	int s;
+
+	/* Sign-extend symnum from 24 bits to whatever host uses.  */
 	s = symnum;
 	if (s & (1 << 23))
 	  s |= (~0) << 24;
-      }
-      cache_ptr->sym_ptr_ptr = (asymbol **)NULL;
-      switch (s)
-      {
-       case N_TEXT:
-       case N_TEXT | N_EXT:
-	cache_ptr->sym_ptr_ptr = obj_textsec(abfd)->symbol_ptr_ptr;
-	cache_ptr->addend = - obj_textsec(abfd)->vma;
-	break;
-       case N_DATA:
-       case N_DATA | N_EXT:
-	cache_ptr->sym_ptr_ptr = obj_datasec(abfd)->symbol_ptr_ptr;
-	cache_ptr->addend = - obj_datasec(abfd)->vma;
-	break;
-       case N_BSS:
-       case N_BSS | N_EXT:
-	cache_ptr->sym_ptr_ptr = obj_bsssec(abfd)->symbol_ptr_ptr;
-	cache_ptr->addend =  - obj_bsssec(abfd)->vma;
-	break;
-       case N_ABS:
-       case N_ABS | N_EXT:
-	cache_ptr->sym_ptr_ptr = obj_bsssec(abfd)->symbol_ptr_ptr;
-	cache_ptr->addend = 0;
-	break;
-      case -2: /* .align */
-	if (raw[7] & pcrel_mask)
-	  {
-	    cache_ptr->howto = &howto_align_table[(raw[7] >> length_shift) & 3];
-	    cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
-	  }
-	else
+
+	cache_ptr->sym_ptr_ptr = (asymbol **)NULL;
+	switch (s)
 	  {
-	    /* .org? */
-	    abort ();
+	  case N_TEXT:
+	  case N_TEXT | N_EXT:
+	    cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr;
+	    cache_ptr->addend = - obj_textsec (abfd)->vma;
+	    break;
+	  case N_DATA:
+	  case N_DATA | N_EXT:
+	    cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr;
+	    cache_ptr->addend = - obj_datasec (abfd)->vma;
+	    break;
+	  case N_BSS:
+	  case N_BSS | N_EXT:
+	    cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr;
+	    cache_ptr->addend =  - obj_bsssec (abfd)->vma;
+	    break;
+	  case N_ABS:
+	  case N_ABS | N_EXT:
+	    cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr;
+	    cache_ptr->addend = 0;
+	    break;
+	  case -2: /* .align */
+	    if (raw[7] & pcrel_mask)
+	      {
+		cache_ptr->howto = &howto_align_table[(raw[7] >> length_shift) & 3];
+		cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
+	      }
+	    else
+	      {
+		/* .org? */
+		abort ();
+	      }
+	    cache_ptr->addend = 0;
+	    break;
+	  default:
+	    BFD_ASSERT(0);
+	    break;
 	  }
-	cache_ptr->addend = 0;
-	break;
-       default:
-	BFD_ASSERT(0);
-	break;
       }
 
-    }
-
-    /* the i960 only has a few relocation types:
+    /* The i960 only has a few relocation types:
        abs 32-bit and pcrel 24bit.   except for callj's!  */
     if (cache_ptr->howto != 0)
       ;
     else if (raw[7] & callj_mask)
-    {
-      cache_ptr->howto = &howto_reloc_callj;
-    }
+      {
+	cache_ptr->howto = &howto_reloc_callj;
+      }
     else if ( raw[7] & pcrel_mask)
-    {
-      if (raw[7] & size_mask)
-       cache_ptr->howto = &howto_reloc_pcrel13;
-      else
-       cache_ptr->howto = &howto_reloc_pcrel24;
-    }
-    else
-    {
-      if (raw[7] & incode_mask)
       {
-	cache_ptr->howto = &howto_reloc_abs32code;
+	if (raw[7] & size_mask)
+	  cache_ptr->howto = &howto_reloc_pcrel13;
+	else
+	  cache_ptr->howto = &howto_reloc_pcrel24;
       }
-      else
+    else
       {
-	cache_ptr->howto = &howto_reloc_abs32;
+	if (raw[7] & incode_mask)
+	  cache_ptr->howto = &howto_reloc_abs32code;
+	else
+	  cache_ptr->howto = &howto_reloc_abs32;
       }
-    }
+
     if (cache_ptr->address < prev_addr)
-    {
-      /* Ouch! this reloc is out of order, insert into the right place
-       */
-      arelent tmp;
-      arelent *cursor = cache_ptr-1;
-      bfd_vma stop = cache_ptr->address;
-      tmp  = *cache_ptr;
-      while (cursor->address > stop && cursor >= reloc_cache)
       {
-	cursor[1] = cursor[0];
-	cursor--;
+	/* Ouch! this reloc is out of order, insert into the right place.  */
+	arelent tmp;
+	arelent *cursor = cache_ptr-1;
+	bfd_vma stop = cache_ptr->address;
+
+	tmp  = *cache_ptr;
+	while (cursor->address > stop && cursor >= reloc_cache)
+	  {
+	    cursor[1] = cursor[0];
+	    cursor--;
+	  }
+
+	cursor[1] = tmp;
       }
-      cursor[1] = tmp;
-    }
     else
-    {
-      prev_addr = cache_ptr->address;
-    }
+      {
+	prev_addr = cache_ptr->address;
+      }
   }
 
   if (relocs != NULL)
@@ -742,131 +752,128 @@ b_out_squirt_out_relocs (abfd, section)
   struct relocation_info *native, *natptr;
   size_t natsize = count * sizeof (struct relocation_info);
   int extern_mask, pcrel_mask,  len_2, callj_mask;
-  if (count == 0) return true;
+
+  if (count == 0)
+    return true;
+
   generic   = section->orelocation;
   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;
-
-    bfd_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;
+      /* 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 if (g->howto == &howto_reloc_abs32code)
+  else
     {
-      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;
+      /* Little-endian bit field allocation order.  */
+      pcrel_mask  = 0x01;
+      extern_mask = 0x08;
+      len_2       = 0x04;
+      len_1       = 0x02;
+      callj_mask  = 0x40;
+      incode_mask = 0x10;
     }
 
-    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))
+  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;
+
+      bfd_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 (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;
-       }
+      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
-      {
-	/* Fill in symbol */
+	{
+	  /* Just an ordinary section.  */
+	  r_extern = 0;
+	  r_idx  = output_section->target_index;
+	}
 
-	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_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 (bfd_write ((PTR) native, 1, natsize, abfd) != natsize)
+    {
+      free ((PTR)native);
+      return false;
     }
-    if (r_extern)
-     raw[7] |= extern_mask;
-  }
 
-  if (bfd_write ((PTR) native, 1, natsize, abfd) != natsize) {
-    free((PTR)native);
-    return false;
-  }
   free ((PTR)native);
 
   return true;
 }
 
-/* This is stupid.  This function should be a boolean predicate */
+/* This is stupid.  This function should be a boolean predicate.  */
+
 static long
 b_out_canonicalize_reloc (abfd, section, relptr, symbols)
      bfd *abfd;
@@ -880,6 +887,7 @@ b_out_canonicalize_reloc (abfd, section, relptr, symbols)
   if ((section->flags & SEC_CONSTRUCTOR) != 0)
     {
       arelent_chain *chain = section->constructor_chain;
+
       for (count = 0; count < section->reloc_count; count++)
 	{
 	  *relptr++ = &chain->relent;
@@ -907,10 +915,11 @@ b_out_get_reloc_upper_bound (abfd, asect)
      bfd *abfd;
      sec_ptr asect;
 {
-  if (bfd_get_format (abfd) != bfd_object) {
-    bfd_set_error (bfd_error_invalid_operation);
-    return -1;
-  }
+  if (bfd_get_format (abfd) != bfd_object)
+    {
+      bfd_set_error (bfd_error_invalid_operation);
+      return -1;
+    }
 
   if (asect->flags & SEC_CONSTRUCTOR)
     return sizeof (arelent *) * (asect->reloc_count + 1);
@@ -931,6 +940,7 @@ b_out_get_reloc_upper_bound (abfd, asect)
   bfd_set_error (bfd_error_invalid_operation);
   return -1;
 }
+
 
 static boolean
 b_out_set_section_contents (abfd, section, location, offset, count)
@@ -940,23 +950,24 @@ b_out_set_section_contents (abfd, section, location, offset, count)
      file_ptr offset;
      bfd_size_type count;
 {
+  if (abfd->output_has_begun == false)
+    {
+      /* Set by bfd.c handler.  */
+      if (! aout_32_make_sections (abfd))
+	return false;
 
-  if (abfd->output_has_begun == false) { /* set by bfd.c handler */
-    if (! aout_32_make_sections (abfd))
-      return false;
-
-    obj_textsec (abfd)->filepos = sizeof (struct internal_exec);
-    obj_datasec(abfd)->filepos = obj_textsec(abfd)->filepos
-                                 +  obj_textsec (abfd)->_raw_size;
+      obj_textsec (abfd)->filepos = sizeof (struct internal_exec);
+      obj_datasec(abfd)->filepos = obj_textsec(abfd)->filepos
+	+  obj_textsec (abfd)->_raw_size;
+    }
 
-  }
-  /* regardless, once we know what we're doing, we might as well get going */
+  /* Regardless, once we know what we're doing, we might as well get going.  */
   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
     return false;
 
-  if (count != 0) {
-    return (bfd_write ((PTR)location, 1, count, abfd) == count) ?true:false;
-  }
+  if (count != 0)
+    return (bfd_write ((PTR)location, 1, count, abfd) == count) ? true : false;
+
   return true;
 }
 
@@ -968,23 +979,25 @@ b_out_set_arch_mach (abfd, arch, machine)
 {
   bfd_default_set_arch_mach(abfd, arch, machine);
 
-  if (arch == bfd_arch_unknown)	/* Unknown machine arch is OK */
+  if (arch == bfd_arch_unknown)	/* Unknown machine arch is OK.  */
     return true;
-  if (arch == bfd_arch_i960)	/* i960 default is OK */
-    switch (machine) {
-    case bfd_mach_i960_core:
-    case bfd_mach_i960_kb_sb:
-    case bfd_mach_i960_mc:
-    case bfd_mach_i960_xa:
-    case bfd_mach_i960_ca:
-    case bfd_mach_i960_ka_sa:
-    case bfd_mach_i960_jx:
-    case bfd_mach_i960_hx:
-    case 0:
-      return true;
-    default:
-      return false;
-    }
+
+  if (arch == bfd_arch_i960)	/* i960 default is OK.  */
+    switch (machine)
+      {
+      case bfd_mach_i960_core:
+      case bfd_mach_i960_kb_sb:
+      case bfd_mach_i960_mc:
+      case bfd_mach_i960_xa:
+      case bfd_mach_i960_ca:
+      case bfd_mach_i960_ka_sa:
+      case bfd_mach_i960_jx:
+      case bfd_mach_i960_hx:
+      case 0:
+	return true;
+      default:
+	return false;
+      }
 
   return false;
 }
@@ -996,8 +1009,8 @@ b_out_sizeof_headers (ignore_abfd, ignore)
 {
   return sizeof (struct internal_exec);
 }
+
 
-/************************************************************************/
 static bfd_vma
 get_value (reloc, link_info, input_section)
      arelent *reloc;
@@ -1009,8 +1022,7 @@ get_value (reloc, link_info, input_section)
 
   /* 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 */
-
+     live in the output and add that in.  */
   if (bfd_is_und_section (symbol->section))
     {
       struct bfd_link_hash_entry *h;
@@ -1045,7 +1057,7 @@ get_value (reloc, link_info, input_section)
       value = symbol->value + output_addr (symbol->section);
     }
 
-  /* Add the value contained in the relocation */
+  /* Add the value contained in the relocation.  */
   value += reloc->addend;
 
   return value;
@@ -1064,35 +1076,36 @@ perform_slip (abfd, slip, input_section, value)
   BFD_ASSERT (s != (asymbol **) NULL);
 
   /* Find all symbols past this point, and make them know
-     what's happened */
+     what's happened.  */
   while (*s)
-  {
-    asymbol *p = *s;
-    if (p->section == input_section)
     {
-      /* This was pointing into this section, so mangle it */
-      if (p->value > value)
-      {
-	p->value -=slip;
-	if (p->udata.p != NULL)
-	  {
-	    struct generic_link_hash_entry *h;
+      asymbol *p = *s;
 
-	    h = (struct generic_link_hash_entry *) p->udata.p;
-	    BFD_ASSERT (h->root.type == bfd_link_hash_defined);
-	    h->root.u.def.value -= slip;
-	    BFD_ASSERT (h->root.u.def.value == p->value);
-	  }
-      }
-    }
-    s++;
+      if (p->section == input_section)
+	{
+	  /* This was pointing into this section, so mangle it.  */
+	  if (p->value > value)
+	    {
+	      p->value -=slip;
 
-  }
+	      if (p->udata.p != NULL)
+		{
+		  struct generic_link_hash_entry *h;
+
+		  h = (struct generic_link_hash_entry *) p->udata.p;
+		  BFD_ASSERT (h->root.type == bfd_link_hash_defined);
+		  h->root.u.def.value -= slip;
+		  BFD_ASSERT (h->root.u.def.value == p->value);
+		}
+	    }
+	}
+      s++;
+    }
 }
 
 /* This routine works out if the thing we want to get to can be
    reached with a 24bit offset instead of a 32 bit one.
-   If it can, then it changes the amode */
+   If it can, then it changes the amode.  */
 
 static int
 abs32code (abfd, input_section, r, shrink, link_info)
@@ -1108,23 +1121,22 @@ abs32code (abfd, input_section, r, shrink, link_info)
 
   /* See if the address we're looking at within 2^23 bytes of where
      we are, if so then we can use a small branch rather than the
-     jump we were going to */
-
+     jump we were going to.  */
   gap = value - (dot - shrink);
 
-  if (-1<<23 < (long)gap && (long)gap < 1<<23 )
-  {
-    /* Change the reloc type from 32bitcode possible 24, to 24bit
-       possible 32 */
-
-    r->howto = &howto_reloc_abs32codeshrunk;
-    /* The place to relc moves back by four bytes */
-    r->address -=4;
+  if (-1 << 23 < (long)gap && (long)gap < 1 << 23)
+    {
+      /* Change the reloc type from 32bitcode possible 24, to 24bit
+	 possible 32.  */
+      r->howto = &howto_reloc_abs32codeshrunk;
+      /* The place to relc moves back by four bytes.  */
+      r->address -=4;
+
+      /* This will be four bytes smaller in the long run.  */
+      shrink += 4 ;
+      perform_slip (abfd, 4, input_section, r->address-shrink + 4);
+    }
 
-    /* This will be four bytes smaller in the long run */
-    shrink += 4 ;
-    perform_slip (abfd, 4, input_section, r->address-shrink + 4);
-  }
   return shrink;
 }
 
@@ -1146,30 +1158,31 @@ aligncode (abfd, input_section, r, shrink)
      smaller  - the current size is already the same size as or bigger
      than the alignment required.  */
 
-  /* calculate the first byte following the padding before we optimize */
+  /* Calculate the first byte following the padding before we optimize.  */
   old_end = ((dot + size ) & ~size) + size+1;
-  /* work out where the new end will be - remember that we're smaller
-     than we used to be */
+  /* Work out where the new end will be - remember that we're smaller
+     than we used to be.  */
   new_end = ((dot - shrink + size) & ~size);
 
-  /* This is the new end */
+  /* This is the new end.  */
   gap = old_end - ((dot + size) & ~size);
 
   shrink_delta = (old_end - new_end) - shrink;
 
   if (shrink_delta)
-  {
-    /* Change the reloc so that it knows how far to align to */
-    r->howto = howto_done_align_table + (r->howto - howto_align_table);
+    {
+      /* Change the reloc so that it knows how far to align to.  */
+      r->howto = howto_done_align_table + (r->howto - howto_align_table);
 
-    /* Encode the stuff into the addend - for future use we need to
-       know how big the reloc used to be */
-    r->addend = old_end - dot + r->address;
+      /* Encode the stuff into the addend - for future use we need to
+	 know how big the reloc used to be.  */
+      r->addend = old_end - dot + r->address;
+
+      /* This will be N bytes smaller in the long run, adjust all the symbols.  */
+      perform_slip (abfd, shrink_delta, input_section, r->address - shrink);
+      shrink += shrink_delta;
+    }
 
-    /* This will be N bytes smaller in the long run, adjust all the symbols */
-    perform_slip (abfd, shrink_delta, input_section, r->address - shrink);
-    shrink += shrink_delta;
-  }
   return shrink;
 }
 
@@ -1180,7 +1193,7 @@ b_out_bfd_relax_section (abfd, i, link_info, again)
      struct bfd_link_info *link_info;
      boolean *again;
 {
-  /* Get enough memory to hold the stuff */
+  /* Get enough memory to hold the stuff.  */
   bfd *input_bfd = i->owner;
   asection *input_section = i;
   int shrink = 0 ;
@@ -1203,7 +1216,7 @@ b_out_bfd_relax_section (abfd, i, link_info, again)
       if (reloc_vector == NULL && reloc_size != 0)
 	goto error_return;
 
-      /* Get the relocs and think about them */
+      /* Get the relocs and think about them.  */
       reloc_count =
 	bfd_canonicalize_reloc (input_bfd, input_section, reloc_vector,
 				_bfd_generic_link_get_symbols (input_bfd));
@@ -1212,17 +1225,19 @@ b_out_bfd_relax_section (abfd, i, link_info, again)
       if (reloc_count > 0)
 	{
 	  arelent **parent;
+
 	  for (parent = reloc_vector; *parent; parent++)
 	    {
 	      arelent *r = *parent;
+
 	      switch (r->howto->type)
 		{
 		case ALIGNER:
-		  /* An alignment reloc */
+		  /* An alignment reloc.  */
 		  shrink = aligncode (abfd, input_section, r, shrink);
 		  break;
 		case ABS32CODE:
-		  /* A 32bit reloc in an addressing mode */
+		  /* A 32bit reloc in an addressing mode.  */
 		  shrink = abs32code (input_bfd, input_section, r, shrink,
 				      link_info);
 		  break;
@@ -1254,7 +1269,7 @@ b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order,
      boolean relocateable;
      asymbol **symbols;
 {
-  /* Get enough memory to hold the stuff */
+  /* 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,
@@ -1278,7 +1293,7 @@ b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order,
 
   input_section->reloc_done = 1;
 
-  /* read in the section */
+  /* Read in the section.  */
   BFD_ASSERT (true == bfd_get_section_contents (input_bfd,
 						input_section,
 						data,
@@ -1295,13 +1310,12 @@ b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order,
     {
       arelent **parent = reloc_vector;
       arelent *reloc ;
-
       unsigned int dst_address = 0;
       unsigned int src_address = 0;
       unsigned int run;
       unsigned int idx;
 
-      /* Find how long a run we can do */
+      /* Find how long a run we can do.  */
       while (dst_address < link_order->size)
 	{
 	  reloc = *parent;
@@ -1309,7 +1323,7 @@ b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order,
 	    {
 	      /* Note that the relaxing didn't tie up the addresses in the
 		 relocation, so we use the original address to work out the
-		 run of non-relocated data */
+		 run of non-relocated data.  */
 	      BFD_ASSERT (reloc->address >= src_address);
 	      run = reloc->address - src_address;
 	      parent++;
@@ -1318,14 +1332,12 @@ b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order,
 	    {
 	      run = link_order->size - dst_address;
 	    }
-	  /* Copy the bytes */
-	  for (idx = 0; idx < run; idx++)
-	    {
-	      data[dst_address++] = data[src_address++];
-	    }
 
-	  /* Now do the relocation */
+	  /* Copy the bytes.  */
+	  for (idx = 0; idx < run; idx++)
+	    data[dst_address++] = data[src_address++];
 
+	  /* Now do the relocation.  */
 	  if (reloc)
 	    {
 	      switch (reloc->howto->type)
@@ -1334,23 +1346,23 @@ b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order,
 		  calljx_callback (input_bfd, link_info, reloc,
 				   src_address + data, dst_address + data,
 				   input_section);
-		  src_address+=4;
-		  dst_address+=4;
+		  src_address += 4;
+		  dst_address += 4;
 		  break;
 		case ABS32:
 		  bfd_put_32 (input_bfd,
 			      (bfd_get_32 (input_bfd, data + src_address)
 			       + get_value (reloc, link_info, input_section)),
 			      data + dst_address);
-		  src_address+=4;
-		  dst_address+=4;
+		  src_address += 4;
+		  dst_address += 4;
 		  break;
 		case CALLJ:
 		  callj_callback (input_bfd, link_info, reloc, data,
 				  src_address, dst_address, input_section,
 				  false);
-		  src_address+=4;
-		  dst_address+=4;
+		  src_address += 4;
+		  dst_address += 4;
 		  break;
 		case ALIGNDONE:
 		  BFD_ASSERT (reloc->addend >= src_address);
@@ -1365,8 +1377,8 @@ b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order,
 		  callj_callback (input_bfd, link_info, reloc, data,
 				  src_address + 4, dst_address, input_section,
 				  true);
-		  dst_address+=4;
-		  src_address+=8;
+		  dst_address += 4;
+		  src_address += 8;
 		  break;
 		case PCREL24:
 		  {
@@ -1383,12 +1395,11 @@ b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order,
 			       & BAL_MASK));
 
 		    bfd_put_32 (input_bfd, word, data + dst_address);
-		    dst_address+=4;
-		    src_address+=4;
+		    dst_address += 4;
+		    src_address += 4;
 
 		  }
 		  break;
-
 		case PCREL13:
 		  {
 		    long int word = bfd_get_32 (input_bfd,
@@ -1404,9 +1415,8 @@ b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order,
 			       & PCREL13_MASK));
 
 		    bfd_put_32 (input_bfd, word, data + dst_address);
-		    dst_address+=4;
-		    src_address+=4;
-
+		    dst_address += 4;
+		    src_address += 4;
 		  }
 		  break;
 
@@ -1424,7 +1434,7 @@ b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order,
     free (reloc_vector);
   return NULL;
 }
-/***********************************************************************/
+
 
 /* Build the transfer vectors for Big and Little-Endian B.OUT files.  */