Changeset 609 for branches/GNU/src/binutils/bfd/bout.c

Timestamp:

Aug 16, 2003, 6:59:22 PM (22 years ago)

Author:

bird

Message:

binutils v2.14 - offical sources.

File:

• branches/GNU/src/binutils/bfd/bout.c (modified) (59 diffs, 1 prop)

branches/GNU/src/binutils/bfd/bout.c

@@ -1 +1 @@
 /* BFD back-end for Intel 960 b.out binaries.
    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-   2000
+   2000, 2001, 2002
    Free Software Foundation, Inc.
    Written by Cygnus Support.
@@ -29 +29 @@
 
 #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 *));
+#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,
@@ -42 +46 @@
 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 *));
+           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 *, boolean, asymbol **));
+  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 *, 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 *));
 
 /* Swaps the information in an executable header taken from a raw byte
@@ -66 +97 @@
 
   /* Now fill in fields in the execp, from the bytes in the raw data.  */
-  execp->a_info   = bfd_h_get_32 (abfd, bytes->e_info);
+  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);
@@ -85 +116 @@
    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)
@@ -98 +125 @@
 
   /* Now fill in fields in the raw data, from the fields in the exec struct.  */
-  bfd_h_put_32 (abfd, execp->a_info  , bytes->e_info);
+  H_PUT_32 (abfd, execp->a_info  , bytes->e_info);
   PUT_WORD (abfd, execp->a_text  , bytes->e_text);
   PUT_WORD (abfd, execp->a_data  , bytes->e_data);
@@ -120 +147 @@
   struct internal_exec anexec;
   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_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;
-  }
-
-  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;
-  }
+      return 0;
+    }
 
   bout_swap_exec_header_in (abfd, &exec_bytes, &anexec);
@@ -149 +178 @@
   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 */
@@ -159 +188 @@
   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;
@@ -171 +200 @@
   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;
 
@@ -179 +208 @@
   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);
@@ -196 +225 @@
 }
 
-struct bout_data_struct {
+struct bout_data_struct
+  {
     struct aoutdata a;
     struct internal_exec e;
-};
-
-static boolean
+  };
+
+static bfd_boolean
 b_out_mkobject (abfd)
      bfd *abfd;
 {
   struct bout_data_struct *rawptr;
-
-  rawptr = (struct bout_data_struct *) bfd_zalloc (abfd, sizeof (struct bout_data_struct));
+  bfd_size_type amt = sizeof (struct bout_data_struct);
+
+  rawptr = (struct bout_data_struct *) bfd_zalloc (abfd, amt);
   if (rawptr == NULL)
-    return false;
+    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;
-
-  return true;
+  obj_textsec (abfd) = (asection *) NULL;
+  obj_datasec (abfd) = (asection *) NULL;
+  obj_bsssec (abfd) = (asection *) NULL;
+
+  return TRUE;
 }
 
 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;
@@ -249 +283 @@
 }
 
-static boolean
+static bfd_boolean
 b_out_write_object_contents (abfd)
      bfd *abfd;
 {
   struct external_exec swapped_hdr;
+  bfd_size_type amt;
 
   if (! aout_32_make_sections (abfd))
-    return false;
+    return FALSE;
 
   exec_hdr (abfd)->a_info = BMAGIC;
@@ -279 +314 @@
   bout_swap_exec_header_out (abfd, exec_hdr (abfd), &swapped_hdr);
 
+  amt = EXEC_BYTES_SIZE;
   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
-      || (bfd_write ((PTR) &swapped_hdr, 1, EXEC_BYTES_SIZE, abfd)
-          != EXEC_BYTES_SIZE))
-    return false;
+      || bfd_bwrite ((PTR) &swapped_hdr, amt, abfd) != amt)
+    return FALSE;
 
   /* Now write out reloc info, followed by syms and strings */
@@ -308 +343 @@
 
       if (q > outsyms)
-        qsort (outsyms, q - outsyms, sizeof (asymbol*), b_out_symbol_cmp);
+        qsort (outsyms, (size_t) (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;
+        return FALSE;
 
       if (! aout_32_write_syms (abfd))
-        return false;
-
-      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;
+        return FALSE;
+
+      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)
           != 0)
-        return false;
-
-      if (!b_out_squirt_out_relocs (abfd, obj_datasec (abfd))) return false;
-    }
-  return true;
-}
-
-
-/** Some reloc hackery */
+        return FALSE;
+
+      if (!b_out_squirt_out_relocs (abfd, obj_datasec (abfd)))
+        return FALSE;
+    }
+  return TRUE;
+}
+
+
+/* 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      */
@@ -345 +383 @@
 #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)
@@ -366 +405 @@
       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;
-      bfd_put_32 (abfd, inst, (bfd_byte *) dst-4);
+      bfd_put_32 (abfd, (bfd_vma) inst, (bfd_byte *) dst-4);
       symbol = balsym;
       value = (symbol->symbol.value
@@ -378 +417 @@
   word += value + reloc_entry->addend;
 
-  bfd_put_32 (abfd, word, dst);
+  bfd_put_32 (abfd, (bfd_vma) word, dst);
   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,
@@ -393 +433 @@
      unsigned int dstidx;
      asection *input_section;
-     boolean shrinking;
+     bfd_boolean shrinking;
 {
   int word = bfd_get_32 (abfd, (bfd_byte *) data + srcidx);
@@ -442 +482 @@
                      & BAL_MASK);
     }
-  bfd_put_32 (abfd, word, (bfd_byte *) data + dstidx);
+  bfd_put_32 (abfd, (bfd_vma) word, (bfd_byte *) data + dstidx);
   return bfd_reloc_ok;
 }
@@ -460 +500 @@
 #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);
+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);
+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);
+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);
+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);
+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);
+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),
+  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),
+  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),
 };
 
@@ -508 +548 @@
 }
 
-/* Allocate enough room for all the reloc entries, plus pointers to them all */
-
-static boolean
+/* 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;
@@ -517 +557 @@
 {
   register struct relocation_info *rptr;
-  unsigned int counter ;
-  arelent *cache_ptr ;
+  unsigned int counter;
+  arelent *cache_ptr;
   int extern_mask, pcrel_mask, callj_mask, length_shift;
   int incode_mask;
@@ -524 +564 @@
   bfd_vma prev_addr = 0;
   unsigned int count;
-  size_t  reloc_size;
+  bfd_size_type reloc_size, amt;
   struct relocation_info *relocs;
   arelent *reloc_cache;
 
   if (asect->relocation)
-    return true;
+    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_textsec (abfd)) {
-    reloc_size = exec_hdr(abfd)->a_trsize;
-    goto doit;
-  }
-
-  if (asect == obj_bsssec (abfd)) {
-    reloc_size = 0;
-    goto doit;
-  }
+    return FALSE;
+
+  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_bsssec (abfd))
+    {
+      reloc_size = 0;
+      goto doit;
+    }
 
   bfd_set_error (bfd_error_invalid_operation);
-  return false;
+  return FALSE;
 
  doit:
-  if (bfd_seek (abfd, (file_ptr) (asect->rel_filepos),  SEEK_SET) != 0)
-    return false;
+  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);
   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 (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;
-  }
+    return FALSE;
+
+  amt = ((bfd_size_type) count + 1) * sizeof (arelent);
+  reloc_cache = (arelent *) bfd_malloc (amt);
+  if (!reloc_cache)
+    {
+      if (relocs != NULL)
+        free (relocs);
+      return FALSE;
+    }
+
+  if (bfd_bread ((PTR) relocs, 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;
+    }
 
   for (rptr = relocs, cache_ptr = reloc_cache, counter = 0;
@@ -597 +648 @@
     unsigned char *raw = (unsigned char *)rptr;
     unsigned int symnum;
-    cache_ptr->address = bfd_h_get_32 (abfd, raw + 0);
+
+    cache_ptr->address = 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 an 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
+              {
+                /* .org? */
+                abort ();
+              }
+            cache_ptr->addend = 0;
+            break;
+          default:
+            BFD_ASSERT(0);
+            break;
+          }
       }
-      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
-          {
-            /* .org? */
-            abort ();
-          }
-        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;
-    }
+      {
+        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] & incode_mask)
+          cache_ptr->howto = &howto_reloc_abs32code;
+        else
+          cache_ptr->howto = &howto_reloc_abs32;
       }
-      else
+
+    if (cache_ptr->address < prev_addr)
       {
-        cache_ptr->howto = &howto_reloc_abs32;
+        /* 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;
       }
-    }
-    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)
+    else
       {
-        cursor[1] = cursor[0];
-        cursor--;
+        prev_addr = cache_ptr->address;
       }
-      cursor[1] = tmp;
-    }
-    else
-    {
-      prev_addr = cache_ptr->address;
-    }
   }
 
@@ -727 +773 @@
   asect->reloc_count = count;
 
-  return true;
-}
-
-static boolean
+  return TRUE;
+}
+
+static bfd_boolean
 b_out_squirt_out_relocs (abfd, section)
      bfd *abfd;
@@ -742 +788 @@
   unsigned int count = section->reloc_count;
   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;
-  generic   = section->orelocation;
+  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;
+    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;
-  }
+    {
+      /* 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;
-  }
+    {
+      /* 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;
-    }
-    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;
-       }
+    {
+      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
-      {
-        /* 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_write ((PTR) native, 1, natsize, abfd) != natsize) {
-    free((PTR)native);
-    return false;
-  }
+        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 */
+  return TRUE;
+}
+
+/* This is stupid.  This function should be a boolean predicate.  */
+
 static long
 b_out_canonicalize_reloc (abfd, section, relptr, symbols)
@@ -882 +926 @@
     {
       arelent_chain *chain = section->constructor_chain;
+
       for (count = 0; count < section->reloc_count; count++)
         {
@@ -909 +954 @@
      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)
@@ -935 +981 @@
 
 
-static boolean
+
+static bfd_boolean
 b_out_set_section_contents (abfd, section, location, offset, count)
      bfd *abfd;
@@ -943 +990 @@
      bfd_size_type count;
 {
-
-  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;
-
-  }
-  /* regardless, once we know what we're doing, we might as well get going */
+  if (! abfd->output_has_begun)
+    {
+      /* 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;
+    }
+
+  /* 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;
-  }
-  return true;
-}
-
-static boolean
+    return FALSE;
+
+  if (count == 0)
+    return TRUE;
+
+  return bfd_bwrite ((PTR) location, count, abfd) == count;
+}
+
+static bfd_boolean
 b_out_set_arch_mach (abfd, arch, machine)
      bfd *abfd;
@@ -971 +1019 @@
   bfd_default_set_arch_mach(abfd, arch, machine);
 
-  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;
-    }
-
-  return false;
+  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;
+      }
+
+  return FALSE;
 }
 
@@ -995 +1045 @@
 b_out_sizeof_headers (ignore_abfd, ignore)
      bfd *ignore_abfd ATTRIBUTE_UNUSED;
-     boolean ignore ATTRIBUTE_UNUSED;
+     bfd_boolean ignore ATTRIBUTE_UNUSED;
 {
   return sizeof (struct internal_exec);
 }
 
-/************************************************************************/
+
+
 static bfd_vma
 get_value (reloc, link_info, input_section)
@@ -1012 +1063 @@
   /* 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))
     {
@@ -1025 +1075 @@
       h = bfd_wrapped_link_hash_lookup (input_section->owner, link_info,
                                         bfd_asymbol_name (symbol),
-                                        false, false, true);
+                                        FALSE, FALSE, TRUE);
       if (h != (struct bfd_link_hash_entry *) NULL
           && (h->type == bfd_link_hash_defined
@@ -1038 +1088 @@
                  (link_info, bfd_asymbol_name (symbol),
                   input_section->owner, input_section, reloc->address,
-                  true)))
+                  TRUE)))
             abort ();
           value = 0;
@@ -1048 +1098 @@
     }
 
-  /* Add the value contained in the relocation */
+  /* Add the value contained in the relocation.  */
   value += reloc->addend;
 
@@ -1067 +1117 @@
 
   /* 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;
-
-            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++;
-
-  }
+    {
+      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;
+
+                  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
@@ -1111 +1162 @@
   /* 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;
-
-    /* This will be four bytes smaller in the long run */
-    shrink += 4 ;
-    perform_slip (abfd, 4, input_section, r->address-shrink + 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);
+    }
+
   return shrink;
 }
@@ -1142 +1192 @@
   bfd_vma old_end;
   bfd_vma new_end;
-  int shrink_delta;
+  unsigned int shrink_delta;
   int size = r->howto->size;
 
@@ -1149 +1199 @@
      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);
 
@@ -1161 +1211 @@
 
   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);
-
-    /* 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;
-  }
+    {
+      /* 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;
+
+      /* 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;
 }
 
-static boolean
+static bfd_boolean
 b_out_bfd_relax_section (abfd, i, link_info, again)
      bfd *abfd;
      asection *i;
      struct bfd_link_info *link_info;
-     boolean *again;
-{
-  /* Get enough memory to hold the stuff */
+     bfd_boolean *again;
+{
+  /* Get enough memory to hold the stuff.  */
   bfd *input_bfd = i->owner;
   asection *input_section = i;
-  int shrink = 0 ;
+  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;
+    return FALSE;
 
   /* We only run this relaxation once.  It might work to run it
      multiple times, but it hasn't been tested.  */
-  *again = false;
+  *again = FALSE;
 
   if (reloc_size)
@@ -1202 +1253 @@
       long reloc_count;
 
-      reloc_vector = (arelent **) bfd_malloc (reloc_size);
+      reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
       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,
@@ -1215 +1266 @@
         {
           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;
                 case ABS32CODE_SHRUNK:
-                  shrink+=4;
+                  shrink += 4;
                   break;
                 }
@@ -1240 +1293 @@
   if (reloc_vector != NULL)
     free (reloc_vector);
-  return true;
+  return TRUE;
  error_return:
   if (reloc_vector != NULL)
     free (reloc_vector);
-  return false;
+  return FALSE;
 }
 
@@ -1254 +1307 @@
      struct bfd_link_order *link_order;
      bfd_byte *data;
-     boolean relocateable;
+     bfd_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;
@@ -1275 +1328 @@
                                                        symbols);
 
-  reloc_vector = (arelent **) bfd_malloc (reloc_size);
+  reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
   if (reloc_vector == NULL && reloc_size != 0)
     goto error_return;
@@ -1281 +1334 @@
   input_section->reloc_done = 1;
 
-  /* read in the section */
-  BFD_ASSERT (true == bfd_get_section_contents (input_bfd,
-                                                input_section,
-                                                data,
-                                                0,
-                                                input_section->_raw_size));
+  /* Read in the section.  */
+  BFD_ASSERT (bfd_get_section_contents (input_bfd,
+                                        input_section,
+                                        data,
+                                        (bfd_vma) 0,
+                                        input_section->_raw_size));
 
   reloc_count = bfd_canonicalize_reloc (input_bfd,
@@ -1298 +1351 @@
       arelent **parent = reloc_vector;
       arelent *reloc ;
-
       unsigned int dst_address = 0;
       unsigned int src_address = 0;
@@ -1304 +1356 @@
       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)
         {
@@ -1312 +1364 @@
               /* 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;
@@ -1321 +1373 @@
               run = link_order->size - dst_address;
             }
-          /* Copy the bytes */
+
+          /* Copy the bytes.  */
           for (idx = 0; idx < run; idx++)
-            {
-              data[dst_address++] = data[src_address++];
-            }
-
-          /* Now do the relocation */
-
+            data[dst_address++] = data[src_address++];
+
+          /* Now do the relocation.  */
           if (reloc)
             {
@@ -1337 +1387 @@
                                    src_address + data, dst_address + data,
                                    input_section);
-                  src_address+=4;
-                  dst_address+=4;
+                  src_address += 4;
+                  dst_address += 4;
                   break;
                 case ABS32:
@@ -1345 +1395 @@
                                + 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;
+                                  FALSE);
+                  src_address += 4;
+                  dst_address += 4;
                   break;
                 case ALIGNDONE:
                   BFD_ASSERT (reloc->addend >= src_address);
-                  BFD_ASSERT (reloc->addend <= input_section->_raw_size);
+                  BFD_ASSERT ((bfd_vma) reloc->addend
+                              <= input_section->_raw_size);
                   src_address = reloc->addend;
                   dst_address = ((dst_address + reloc->howto->size)
@@ -1367 +1418 @@
                   callj_callback (input_bfd, link_info, reloc, data,
                                   src_address + 4, dst_address, input_section,
-                                  true);
-                  dst_address+=4;
-                  src_address+=8;
+                                  TRUE);
+                  dst_address += 4;
+                  src_address += 8;
                   break;
                 case PCREL24:
@@ -1385 +1436 @@
                                & BAL_MASK));
 
-                    bfd_put_32 (input_bfd, word, data + dst_address);
-                    dst_address+=4;
-                    src_address+=4;
+                    bfd_put_32 (input_bfd, (bfd_vma) word, data + dst_address);
+                    dst_address += 4;
+                    src_address += 4;
 
                   }
                   break;
-
                 case PCREL13:
                   {
@@ -1406 +1456 @@
                                & PCREL13_MASK));
 
-                    bfd_put_32 (input_bfd, word, data + dst_address);
-                    dst_address+=4;
-                    src_address+=4;
-
+                    bfd_put_32 (input_bfd, (bfd_vma) word, data + dst_address);
+                    dst_address += 4;
+                    src_address += 4;
                   }
                   break;
@@ -1427 +1476 @@
   return NULL;
 }
-/***********************************************************************/
+
+
 
 /* Build the transfer vectors for Big and Little-Endian B.OUT files.  */
@@ -1435 +1485 @@
 
 #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_discard_group bfd_generic_discard_group
 
 #define aout_32_get_section_contents_in_window \