Changeset 618 for trunk/src/binutils/bfd/aoutx.h

Timestamp:

Aug 16, 2003, 11:33:53 PM (22 years ago)

Author:

bird

Message:

Joined the port of 2.11.2 with 2.14.

File:

• trunk/src/binutils/bfd/aoutx.h (modified) (257 diffs, 1 prop)

trunk/src/binutils/bfd/aoutx.h

@@ -1 +1 @@
 /* BFD semi-generic back-end for a.out binaries.
    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
-   2001
+   2001, 2002, 2003
    Free Software Foundation, Inc.
    Written by Cygnus Support.
 
-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 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.  */
+   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 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.  */
 
 /*
@@ -106 +106 @@
         to use the
         @file{@var{XXX}.mt} file (by setting "<<bfd_target=XXX>>") when your
-        configuration is selected.
-
-*/
+        configuration is selected.  */
 
 /* Some assumptions:
@@ -121 +119 @@
 #define KEEPIT udata.i
 
-#include <ctype.h>
 #include "bfd.h"
 #include "sysdep.h"
+#include "safe-ctype.h"
 #include "bfdlink.h"
 
@@ -132 +130 @@
 #include "aout/ar.h"
 
-static boolean aout_get_external_symbols PARAMS ((bfd *));
-static boolean translate_from_native_sym_flags
+static bfd_boolean aout_get_external_symbols
+  PARAMS ((bfd *));
+static bfd_boolean translate_from_native_sym_flags
   PARAMS ((bfd *, aout_symbol_type *));
-static boolean translate_to_native_sym_flags
+static bfd_boolean translate_to_native_sym_flags
   PARAMS ((bfd *, asymbol *, struct external_nlist *));
-static void adjust_o_magic PARAMS ((bfd *, struct internal_exec *));
-static void adjust_z_magic PARAMS ((bfd *, struct internal_exec *));
-static void adjust_n_magic PARAMS ((bfd *, struct internal_exec *));
+static void adjust_o_magic
+  PARAMS ((bfd *, struct internal_exec *));
+static void adjust_z_magic
+  PARAMS ((bfd *, struct internal_exec *));
+static void adjust_n_magic
+  PARAMS ((bfd *, struct internal_exec *));
+reloc_howto_type * NAME(aout,reloc_type_lookup)
+  PARAMS ((bfd *, bfd_reloc_code_real_type));
 
 /*
@@ -152 +156 @@
         address, a symbol index, and a type field. The extended records
         (used on 29ks and sparcs) also have a full integer for an
-        addend.
-
-*/
+        addend.  */
+
 #ifndef CTOR_TABLE_RELOC_HOWTO
 #define CTOR_TABLE_RELOC_IDX 2
-#define CTOR_TABLE_RELOC_HOWTO(BFD) ((obj_reloc_entry_size(BFD) == RELOC_EXT_SIZE \
-             ? howto_table_ext : howto_table_std) \
-            + CTOR_TABLE_RELOC_IDX)
+#define CTOR_TABLE_RELOC_HOWTO(BFD)                                     \
+  ((obj_reloc_entry_size (BFD) == RELOC_EXT_SIZE                        \
+    ? howto_table_ext : howto_table_std)                                \
+   + CTOR_TABLE_RELOC_IDX)
 #endif
 
@@ -191 +195 @@
 reloc_howto_type howto_table_ext[] =
 {
-  /* type           rs   size bsz  pcrel bitpos ovrf                  sf name          part_inpl readmask setmask pcdone */
-  HOWTO(RELOC_8,      0,  0,    8,  false, 0, complain_overflow_bitfield,0,"8",        false, 0,0x000000ff, false),
-  HOWTO(RELOC_16,     0,  1,    16, false, 0, complain_overflow_bitfield,0,"16",       false, 0,0x0000ffff, false),
-  HOWTO(RELOC_32,     0,  2,    32, false, 0, complain_overflow_bitfield,0,"32",       false, 0,0xffffffff, false),
-  HOWTO(RELOC_DISP8,  0,  0,    8,  true,  0, complain_overflow_signed,0,"DISP8",       false, 0,0x000000ff, false),
-  HOWTO(RELOC_DISP16, 0,  1,    16, true,  0, complain_overflow_signed,0,"DISP16",      false, 0,0x0000ffff, false),
-  HOWTO(RELOC_DISP32, 0,  2,    32, true,  0, complain_overflow_signed,0,"DISP32",      false, 0,0xffffffff, false),
-  HOWTO(RELOC_WDISP30,2,  2,    30, true,  0, complain_overflow_signed,0,"WDISP30",     false, 0,0x3fffffff, false),
-  HOWTO(RELOC_WDISP22,2,  2,    22, true,  0, complain_overflow_signed,0,"WDISP22",     false, 0,0x003fffff, false),
-  HOWTO(RELOC_HI22,   10, 2,    22, false, 0, complain_overflow_bitfield,0,"HI22",      false, 0,0x003fffff, false),
-  HOWTO(RELOC_22,     0,  2,    22, false, 0, complain_overflow_bitfield,0,"22",       false, 0,0x003fffff, false),
-  HOWTO(RELOC_13,     0,  2,    13, false, 0, complain_overflow_bitfield,0,"13",       false, 0,0x00001fff, false),
-  HOWTO(RELOC_LO10,   0,  2,    10, false, 0, complain_overflow_dont,0,"LO10",     false, 0,0x000003ff, false),
-  HOWTO(RELOC_SFA_BASE,0, 2,    32, false, 0, complain_overflow_bitfield,0,"SFA_BASE", false, 0,0xffffffff, false),
-  HOWTO(RELOC_SFA_OFF13,0,2,    32, false, 0, complain_overflow_bitfield,0,"SFA_OFF13",false, 0,0xffffffff, false),
-  HOWTO(RELOC_BASE10, 0,  2,    10, false, 0, complain_overflow_dont,0,"BASE10",   false, 0,0x000003ff, false),
-  HOWTO(RELOC_BASE13, 0,  2,    13, false, 0, complain_overflow_signed,0,"BASE13",   false, 0,0x00001fff, false),
-  HOWTO(RELOC_BASE22, 10, 2,    22, false, 0, complain_overflow_bitfield,0,"BASE22",   false, 0,0x003fffff, false),
-  HOWTO(RELOC_PC10,   0,  2,    10, true,  0, complain_overflow_dont,0,"PC10",  false, 0,0x000003ff, true),
-  HOWTO(RELOC_PC22,   10,  2,   22, true,  0, complain_overflow_signed,0,"PC22", false, 0,0x003fffff, true),
-  HOWTO(RELOC_JMP_TBL,2,  2,    30, true,  0, complain_overflow_signed,0,"JMP_TBL",     false, 0,0x3fffffff, false),
-  HOWTO(RELOC_SEGOFF16,0, 2,    0,  false, 0, complain_overflow_bitfield,0,"SEGOFF16",  false, 0,0x00000000, false),
-  HOWTO(RELOC_GLOB_DAT,0, 2,    0,  false, 0, complain_overflow_bitfield,0,"GLOB_DAT",  false, 0,0x00000000, false),
-  HOWTO(RELOC_JMP_SLOT,0, 2,    0,  false, 0, complain_overflow_bitfield,0,"JMP_SLOT",  false, 0,0x00000000, false),
-  HOWTO(RELOC_RELATIVE,0, 2,    0,  false, 0, complain_overflow_bitfield,0,"RELATIVE",  false, 0,0x00000000, false),
-  HOWTO(0,  0, 0,    0,  false, 0, complain_overflow_dont, 0, "R_SPARC_NONE",    false,0,0x00000000,true),
-  HOWTO(0,  0, 0,    0,  false, 0, complain_overflow_dont, 0, "R_SPARC_NONE",    false,0,0x00000000,true),
+  /* type           rs   size bsz  pcrel bitpos ovrf                  sf name          part_inpl readmask setmask pcdone.  */
+  HOWTO(RELOC_8,      0,  0,    8,  FALSE, 0, complain_overflow_bitfield,0,"8",        FALSE, 0,0x000000ff, FALSE),
+  HOWTO(RELOC_16,     0,  1,    16, FALSE, 0, complain_overflow_bitfield,0,"16",       FALSE, 0,0x0000ffff, FALSE),
+  HOWTO(RELOC_32,     0,  2,    32, FALSE, 0, complain_overflow_bitfield,0,"32",       FALSE, 0,0xffffffff, FALSE),
+  HOWTO(RELOC_DISP8,  0,  0,    8,  TRUE,  0, complain_overflow_signed,0,"DISP8",       FALSE, 0,0x000000ff, FALSE),
+  HOWTO(RELOC_DISP16, 0,  1,    16, TRUE,  0, complain_overflow_signed,0,"DISP16",      FALSE, 0,0x0000ffff, FALSE),
+  HOWTO(RELOC_DISP32, 0,  2,    32, TRUE,  0, complain_overflow_signed,0,"DISP32",      FALSE, 0,0xffffffff, FALSE),
+  HOWTO(RELOC_WDISP30,2,  2,    30, TRUE,  0, complain_overflow_signed,0,"WDISP30",     FALSE, 0,0x3fffffff, FALSE),
+  HOWTO(RELOC_WDISP22,2,  2,    22, TRUE,  0, complain_overflow_signed,0,"WDISP22",     FALSE, 0,0x003fffff, FALSE),
+  HOWTO(RELOC_HI22,   10, 2,    22, FALSE, 0, complain_overflow_bitfield,0,"HI22",      FALSE, 0,0x003fffff, FALSE),
+  HOWTO(RELOC_22,     0,  2,    22, FALSE, 0, complain_overflow_bitfield,0,"22",       FALSE, 0,0x003fffff, FALSE),
+  HOWTO(RELOC_13,     0,  2,    13, FALSE, 0, complain_overflow_bitfield,0,"13",       FALSE, 0,0x00001fff, FALSE),
+  HOWTO(RELOC_LO10,   0,  2,    10, FALSE, 0, complain_overflow_dont,0,"LO10",     FALSE, 0,0x000003ff, FALSE),
+  HOWTO(RELOC_SFA_BASE,0, 2,    32, FALSE, 0, complain_overflow_bitfield,0,"SFA_BASE", FALSE, 0,0xffffffff, FALSE),
+  HOWTO(RELOC_SFA_OFF13,0,2,    32, FALSE, 0, complain_overflow_bitfield,0,"SFA_OFF13",FALSE, 0,0xffffffff, FALSE),
+  HOWTO(RELOC_BASE10, 0,  2,    10, FALSE, 0, complain_overflow_dont,0,"BASE10",   FALSE, 0,0x000003ff, FALSE),
+  HOWTO(RELOC_BASE13, 0,  2,    13, FALSE, 0, complain_overflow_signed,0,"BASE13",   FALSE, 0,0x00001fff, FALSE),
+  HOWTO(RELOC_BASE22, 10, 2,    22, FALSE, 0, complain_overflow_bitfield,0,"BASE22",   FALSE, 0,0x003fffff, FALSE),
+  HOWTO(RELOC_PC10,   0,  2,    10, TRUE,  0, complain_overflow_dont,0,"PC10",  FALSE, 0,0x000003ff, TRUE),
+  HOWTO(RELOC_PC22,   10,  2,   22, TRUE,  0, complain_overflow_signed,0,"PC22", FALSE, 0,0x003fffff, TRUE),
+  HOWTO(RELOC_JMP_TBL,2,  2,    30, TRUE,  0, complain_overflow_signed,0,"JMP_TBL",     FALSE, 0,0x3fffffff, FALSE),
+  HOWTO(RELOC_SEGOFF16,0, 2,    0,  FALSE, 0, complain_overflow_bitfield,0,"SEGOFF16",  FALSE, 0,0x00000000, FALSE),
+  HOWTO(RELOC_GLOB_DAT,0, 2,    0,  FALSE, 0, complain_overflow_bitfield,0,"GLOB_DAT",  FALSE, 0,0x00000000, FALSE),
+  HOWTO(RELOC_JMP_SLOT,0, 2,    0,  FALSE, 0, complain_overflow_bitfield,0,"JMP_SLOT",  FALSE, 0,0x00000000, FALSE),
+  HOWTO(RELOC_RELATIVE,0, 2,    0,  FALSE, 0, complain_overflow_bitfield,0,"RELATIVE",  FALSE, 0,0x00000000, FALSE),
+  HOWTO(0,  0, 0,    0,  FALSE, 0, complain_overflow_dont, 0, "R_SPARC_NONE",    FALSE,0,0x00000000,TRUE),
+  HOWTO(0,  0, 0,    0,  FALSE, 0, complain_overflow_dont, 0, "R_SPARC_NONE",    FALSE,0,0x00000000,TRUE),
 #define RELOC_SPARC_REV32 RELOC_WDISP19
-  HOWTO(RELOC_SPARC_REV32,    0,  2,    32, false, 0, complain_overflow_dont,0,"R_SPARC_REV32",       false, 0,0xffffffff, false),
+  HOWTO(RELOC_SPARC_REV32,    0,  2,    32, FALSE, 0, complain_overflow_dont,0,"R_SPARC_REV32",       FALSE, 0,0xffffffff, FALSE),
 };
 
 /* Convert standard reloc records to "arelent" format (incl byte swap).  */
 
-reloc_howto_type howto_table_std[] = {
-  /* type              rs size bsz  pcrel bitpos ovrf                     sf name     part_inpl readmask  setmask    pcdone */
-HOWTO( 0,              0,  0,   8,  false, 0, complain_overflow_bitfield,0,"8",         true, 0x000000ff,0x000000ff, false),
-HOWTO( 1,              0,  1,   16, false, 0, complain_overflow_bitfield,0,"16",        true, 0x0000ffff,0x0000ffff, false),
-HOWTO( 2,              0,  2,   32, false, 0, complain_overflow_bitfield,0,"32",        true, 0xffffffff,0xffffffff, false),
-HOWTO( 3,              0,  4,   64, false, 0, complain_overflow_bitfield,0,"64",        true, 0xdeaddead,0xdeaddead, false),
-HOWTO( 4,              0,  0,   8,  true,  0, complain_overflow_signed,  0,"DISP8",     true, 0x000000ff,0x000000ff, false),
-HOWTO( 5,              0,  1,   16, true,  0, complain_overflow_signed,  0,"DISP16",    true, 0x0000ffff,0x0000ffff, false),
-HOWTO( 6,              0,  2,   32, true,  0, complain_overflow_signed,  0,"DISP32",    true, 0xffffffff,0xffffffff, false),
-HOWTO( 7,              0,  4,   64, true,  0, complain_overflow_signed,  0,"DISP64",    true, 0xfeedface,0xfeedface, false),
-HOWTO( 8,              0,  2,    0, false, 0, complain_overflow_bitfield,0,"GOT_REL",   false,         0,0x00000000, false),
-HOWTO( 9,              0,  1,   16, false, 0, complain_overflow_bitfield,0,"BASE16",    false,0xffffffff,0xffffffff, false),
-HOWTO(10,              0,  2,   32, false, 0, complain_overflow_bitfield,0,"BASE32",    false,0xffffffff,0xffffffff, false),
+reloc_howto_type howto_table_std[] =
+{
+  /* type              rs size bsz  pcrel bitpos ovrf                     sf name     part_inpl readmask  setmask    pcdone.  */
+HOWTO ( 0,             0,  0,   8,  FALSE, 0, complain_overflow_bitfield,0,"8",         TRUE, 0x000000ff,0x000000ff, FALSE),
+HOWTO ( 1,             0,  1,   16, FALSE, 0, complain_overflow_bitfield,0,"16",        TRUE, 0x0000ffff,0x0000ffff, FALSE),
+HOWTO ( 2,             0,  2,   32, FALSE, 0, complain_overflow_bitfield,0,"32",        TRUE, 0xffffffff,0xffffffff, FALSE),
+HOWTO ( 3,             0,  4,   64, FALSE, 0, complain_overflow_bitfield,0,"64",        TRUE, 0xdeaddead,0xdeaddead, FALSE),
+HOWTO ( 4,             0,  0,   8,  TRUE,  0, complain_overflow_signed,  0,"DISP8",     TRUE, 0x000000ff,0x000000ff, FALSE),
+HOWTO ( 5,             0,  1,   16, TRUE,  0, complain_overflow_signed,  0,"DISP16",    TRUE, 0x0000ffff,0x0000ffff, FALSE),
+HOWTO ( 6,             0,  2,   32, TRUE,  0, complain_overflow_signed,  0,"DISP32",    TRUE, 0xffffffff,0xffffffff, FALSE),
+HOWTO ( 7,             0,  4,   64, TRUE,  0, complain_overflow_signed,  0,"DISP64",    TRUE, 0xfeedface,0xfeedface, FALSE),
+HOWTO ( 8,             0,  2,    0, FALSE, 0, complain_overflow_bitfield,0,"GOT_REL",   FALSE,         0,0x00000000, FALSE),
+HOWTO ( 9,             0,  1,   16, FALSE, 0, complain_overflow_bitfield,0,"BASE16",    FALSE,0xffffffff,0xffffffff, FALSE),
+HOWTO (10,             0,  2,   32, FALSE, 0, complain_overflow_bitfield,0,"BASE32",    FALSE,0xffffffff,0xffffffff, FALSE),
 EMPTY_HOWTO (-1),
 EMPTY_HOWTO (-1),
@@ -242 +247 @@
 EMPTY_HOWTO (-1),
 EMPTY_HOWTO (-1),
-  HOWTO(16,            0,  2,    0, false, 0, complain_overflow_bitfield,0,"JMP_TABLE", false,         0,0x00000000, false),
+  HOWTO (16,           0,  2,    0, FALSE, 0, complain_overflow_bitfield,0,"JMP_TABLE", FALSE,         0,0x00000000, FALSE),
 EMPTY_HOWTO (-1),
 EMPTY_HOWTO (-1),
@@ -258 +263 @@
 EMPTY_HOWTO (-1),
 EMPTY_HOWTO (-1),
-  HOWTO(32,            0,  2,    0, false, 0, complain_overflow_bitfield,0,"RELATIVE",  false,         0,0x00000000, false),
+  HOWTO (32,           0,  2,    0, FALSE, 0, complain_overflow_bitfield,0,"RELATIVE",  FALSE,         0,0x00000000, FALSE),
 EMPTY_HOWTO (-1),
 EMPTY_HOWTO (-1),
@@ -266 +271 @@
 EMPTY_HOWTO (-1),
 EMPTY_HOWTO (-1),
-  HOWTO(40,            0,  2,    0, false, 0, complain_overflow_bitfield,0,"BASEREL",   false,         0,0x00000000, false),
+  HOWTO (40,           0,  2,    0, FALSE, 0, complain_overflow_bitfield,0,"BASEREL",   FALSE,         0,0x00000000, FALSE),
 };
 
-#define TABLE_SIZE(TABLE)       (sizeof (TABLE)/sizeof (TABLE[0]))
+#define TABLE_SIZE(TABLE)       (sizeof (TABLE) / sizeof (TABLE[0]))
 
 #ifndef IS_STAB
@@ -280 +285 @@
      bfd_reloc_code_real_type code;
 {
-#define EXT(i,j)        case i: return &howto_table_ext[j]
-#define STD(i,j)        case i: return &howto_table_std[j]
+#define EXT(i, j)       case i: return &howto_table_ext[j]
+#define STD(i, j)       case i: return &howto_table_std[j]
   int ext = obj_reloc_entry_size (abfd) == RELOC_EXT_SIZE;
+
   if (code == BFD_RELOC_CTOR)
     switch (bfd_get_arch_info (abfd)->bits_per_address)
@@ -293 +299 @@
         break;
       }
+
   if (ext)
     switch (code)
@@ -315 +322 @@
       }
   else
-    /* std relocs */
+    /* std relocs.  */
     switch (code)
       {
+        STD (BFD_RELOC_8, 0);
         STD (BFD_RELOC_16, 1);
         STD (BFD_RELOC_32, 2);
@@ -371 +379 @@
   memset ((PTR) execp, 0, sizeof (struct internal_exec));
   /* 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);
@@ -406 +414 @@
 
   /* 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);
@@ -418 +426 @@
 /* Make all the section for an a.out file.  */
 
-boolean
+bfd_boolean
 NAME(aout,make_sections) (abfd)
      bfd *abfd;
@@ -424 +432 @@
   if (obj_textsec (abfd) == (asection *) NULL
       && bfd_make_section (abfd, ".text") == (asection *) NULL)
-    return false;
+    return FALSE;
   if (obj_datasec (abfd) == (asection *) NULL
       && bfd_make_section (abfd, ".data") == (asection *) NULL)
-    return false;
+    return FALSE;
   if (obj_bsssec (abfd) == (asection *) NULL
       && bfd_make_section (abfd, ".bss") == (asection *) NULL)
-    return false;
-  return true;
+    return FALSE;
+  return TRUE;
 }
 
@@ -459 +467 @@
   struct aout_data_struct *rawptr, *oldrawptr;
   const bfd_target *result;
-
-  rawptr = (struct aout_data_struct  *) bfd_zalloc (abfd, sizeof (struct aout_data_struct ));
+  bfd_size_type amt = sizeof (struct aout_data_struct);
+
+  rawptr = (struct aout_data_struct  *) bfd_zalloc (abfd, amt);
   if (rawptr == NULL)
     return 0;
@@ -475 +484 @@
 
   abfd->tdata.aout_data->a.hdr = &rawptr->e;
-  *(abfd->tdata.aout_data->a.hdr) = *execp;     /* Copy in the internal_exec struct */
+  /* Copy in the internal_exec struct.  */
+  *(abfd->tdata.aout_data->a.hdr) = *execp;
   execp = abfd->tdata.aout_data->a.hdr;
 
-  /* Set the file flags */
+  /* Set the file flags.  */
   abfd->flags = BFD_NO_FLAGS;
   if (execp->a_drsize || execp->a_trsize)
     abfd->flags |= HAS_RELOC;
-  /* Setting of EXEC_P has been deferred to the bottom of this function */
+  /* Setting of EXEC_P has been deferred to the bottom of this function.  */
   if (execp->a_syms)
     abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
-  if (N_DYNAMIC(*execp))
+  if (N_DYNAMIC (*execp))
     abfd->flags |= DYNAMIC;
 
@@ -534 +544 @@
 
   if (! NAME(aout,make_sections) (abfd))
-    return NULL;
+    goto error_ret;
 
   obj_datasec (abfd)->_raw_size = execp->a_data;
@@ -562 +572 @@
   struct exec *execp = exec_hdr (abfd);
 
-  obj_textsec (abfd)->size = N_TXTSIZE(*execp);
-  obj_textsec (abfd)->raw_size = N_TXTSIZE(*execp);
-  /* data and bss are already filled in since they're so standard */
-
-  /* The virtual memory addresses of the sections */
-  obj_textsec (abfd)->vma = N_TXTADDR(*execp);
-  obj_datasec (abfd)->vma = N_DATADDR(*execp);
-  obj_bsssec  (abfd)->vma = N_BSSADDR(*execp);
-
-  /* The file offsets of the sections */
-  obj_textsec (abfd)->filepos = N_TXTOFF(*execp);
-  obj_datasec (abfd)->filepos = N_DATOFF(*execp);
-
-  /* The file offsets of the relocation info */
-  obj_textsec (abfd)->rel_filepos = N_TRELOFF(*execp);
-  obj_datasec (abfd)->rel_filepos = N_DRELOFF(*execp);
+  obj_textsec (abfd)->size = N_TXTSIZE (*execp);
+  obj_textsec (abfd)->raw_size = N_TXTSIZE (*execp);
+  /* Data and bss are already filled in since they're so standard.  */
+
+  /* The virtual memory addresses of the sections.  */
+  obj_textsec (abfd)->vma = N_TXTADDR (*execp);
+  obj_datasec (abfd)->vma = N_DATADDR (*execp);
+  obj_bsssec  (abfd)->vma = N_BSSADDR (*execp);
+
+  /* The file offsets of the sections.  */
+  obj_textsec (abfd)->filepos = N_TXTOFF (*execp);
+  obj_datasec (abfd)->filepos = N_DATOFF (*execp);
+
+  /* The file offsets of the relocation info.  */
+  obj_textsec (abfd)->rel_filepos = N_TRELOFF (*execp);
+  obj_datasec (abfd)->rel_filepos = N_DRELOFF (*execp);
 
   /* The file offsets of the string table and symbol table.  */
@@ -584 +594 @@
 
   /* Determine the architecture and machine type of the object file.  */
-  switch (N_MACHTYPE (*exec_hdr (abfd))) {
-  default:
-    abfd->obj_arch = bfd_arch_obscure;
-    break;
-  }
-
-  adata(abfd)->page_size = TARGET_PAGE_SIZE;
-  adata(abfd)->segment_size = SEGMENT_SIZE;
-  adata(abfd)->exec_bytes_size = EXEC_BYTES_SIZE;
+  switch (N_MACHTYPE (*exec_hdr (abfd)))
+    {
+    default:
+      abfd->obj_arch = bfd_arch_obscure;
+      break;
+    }
+
+  adata (abfd)->page_size = TARGET_PAGE_SIZE;
+  adata (abfd)->segment_size = SEGMENT_SIZE;
+  adata (abfd)->exec_bytes_size = EXEC_BYTES_SIZE;
 
   return abfd->xvec;
@@ -624 +635 @@
 
   if (execp->a_entry != 0
-      || (execp->a_entry >= obj_textsec(abfd)->vma
-          && execp->a_entry < obj_textsec(abfd)->vma + obj_textsec(abfd)->_raw_size))
+      || (execp->a_entry >= obj_textsec (abfd)->vma
+          && execp->a_entry < (obj_textsec (abfd)->vma
+                               + obj_textsec (abfd)->_raw_size)))
     abfd->flags |= EXEC_P;
 #ifdef STAT_FOR_EXEC
@@ -641 +653 @@
       if (abfd->iostream != NULL
           && (abfd->flags & BFD_IN_MEMORY) == 0
-          && (fstat(fileno((FILE *) (abfd->iostream)), &stat_buf) == 0)
+          && (fstat (fileno ((FILE *) (abfd->iostream)), &stat_buf) == 0)
           && ((stat_buf.st_mode & 0111) != 0))
         abfd->flags |= EXEC_P;
@@ -654 +666 @@
       obj_datasec (abfd)->next = obj_bsssec (abfd);
 #endif
-    }
-  else
-    {
-      free (rawptr);
-      abfd->tdata.aout_data = oldrawptr;
-    }
-  return result;
+      return result;
+    }
+
+ error_ret:
+  bfd_release (abfd, rawptr);
+  abfd->tdata.aout_data = oldrawptr;
+  return NULL;
 }
 
@@ -668 +680 @@
 
 SYNOPSIS
-        boolean aout_@var{size}_mkobject, (bfd *abfd);
+        bfd_boolean aout_@var{size}_mkobject, (bfd *abfd);
 
 DESCRIPTION
@@ -674 +686 @@
 */
 
-boolean
+bfd_boolean
 NAME(aout,mkobject) (abfd)
      bfd *abfd;
 {
-  struct aout_data_struct  *rawptr;
+  struct aout_data_struct *rawptr;
+  bfd_size_type amt = sizeof (struct aout_data_struct);
 
   bfd_set_error (bfd_error_system_call);
 
-  /* Use an intermediate variable for clarity */
-  rawptr = (struct aout_data_struct *)bfd_zalloc (abfd, sizeof (struct aout_data_struct ));
-
+  rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, amt);
   if (rawptr == NULL)
-    return false;
+    return FALSE;
 
   abfd->tdata.aout_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;
 }
 
@@ -721 +732 @@
      enum bfd_architecture arch;
      unsigned long machine;
-     boolean *unknown;
+     bfd_boolean *unknown;
 {
   enum machine_type arch_flags;
 
   arch_flags = M_UNKNOWN;
-  *unknown = true;
-
-  switch (arch) {
-  case bfd_arch_sparc:
-    if (machine == 0
-        || machine == bfd_mach_sparc
-        || machine == bfd_mach_sparc_sparclite
-        || machine == bfd_mach_sparc_sparclite_le
-        || machine == bfd_mach_sparc_v9)
-      arch_flags = M_SPARC;
-    else if (machine == bfd_mach_sparc_sparclet)
-      arch_flags = M_SPARCLET;
-    break;
-
-  case bfd_arch_m68k:
-    switch (machine) {
-    case 0:               arch_flags = M_68010; break;
-    case bfd_mach_m68000: arch_flags = M_UNKNOWN; *unknown = false; break;
-    case bfd_mach_m68010: arch_flags = M_68010; break;
-    case bfd_mach_m68020: arch_flags = M_68020; break;
-    default:              arch_flags = M_UNKNOWN; break;
-    }
-    break;
-
-  case bfd_arch_i386:
-    if (machine == 0)   arch_flags = M_386;
-    break;
-
-  case bfd_arch_a29k:
-    if (machine == 0)   arch_flags = M_29K;
-    break;
-
-  case bfd_arch_arm:
-    if (machine == 0)   arch_flags = M_ARM;
-    break;
-
-  case bfd_arch_mips:
-    switch (machine) {
-    case 0:
-    case bfd_mach_mips3000:
-    case bfd_mach_mips3900:
-      arch_flags = M_MIPS1;
+  *unknown = TRUE;
+
+  switch (arch)
+    {
+    case bfd_arch_sparc:
+      if (machine == 0
+          || machine == bfd_mach_sparc
+          || machine == bfd_mach_sparc_sparclite
+          || machine == bfd_mach_sparc_sparclite_le
+          || machine == bfd_mach_sparc_v9)
+        arch_flags = M_SPARC;
+      else if (machine == bfd_mach_sparc_sparclet)
+        arch_flags = M_SPARCLET;
       break;
-    case bfd_mach_mips6000:
-      arch_flags = M_MIPS2;
+
+    case bfd_arch_m68k:
+      switch (machine)
+        {
+        case 0:               arch_flags = M_68010; break;
+        case bfd_mach_m68000: arch_flags = M_UNKNOWN; *unknown = FALSE; break;
+        case bfd_mach_m68010: arch_flags = M_68010; break;
+        case bfd_mach_m68020: arch_flags = M_68020; break;
+        default:              arch_flags = M_UNKNOWN; break;
+        }
       break;
-    case bfd_mach_mips4000:
-    case bfd_mach_mips4010:
-    case bfd_mach_mips4100:
-    case bfd_mach_mips4300:
-    case bfd_mach_mips4400:
-    case bfd_mach_mips4600:
-    case bfd_mach_mips4650:
-    case bfd_mach_mips8000:
-    case bfd_mach_mips10000:
-    case bfd_mach_mips12000:
-    case bfd_mach_mips16:
-    case bfd_mach_mips32:
-    case bfd_mach_mips32_4k:
-    case bfd_mach_mips5:
-    case bfd_mach_mips64:
-    case bfd_mach_mips_sb1:
-      /* FIXME: These should be MIPS3, MIPS4, MIPS16, MIPS32, etc.  */
-      arch_flags = M_MIPS2;
+
+    case bfd_arch_i386:
+      if (machine == 0
+          || machine == bfd_mach_i386_i386
+          || machine == bfd_mach_i386_i386_intel_syntax)
+        arch_flags = M_386;
       break;
+
+    case bfd_arch_a29k:
+      if (machine == 0)
+        arch_flags = M_29K;
+      break;
+
+    case bfd_arch_arm:
+      if (machine == 0)
+        arch_flags = M_ARM;
+      break;
+
+    case bfd_arch_mips:
+      switch (machine)
+        {
+        case 0:
+        case bfd_mach_mips3000:
+        case bfd_mach_mips3900:
+          arch_flags = M_MIPS1;
+          break;
+        case bfd_mach_mips6000:
+          arch_flags = M_MIPS2;
+          break;
+        case bfd_mach_mips4000:
+        case bfd_mach_mips4010:
+        case bfd_mach_mips4100:
+        case bfd_mach_mips4300:
+        case bfd_mach_mips4400:
+        case bfd_mach_mips4600:
+        case bfd_mach_mips4650:
+        case bfd_mach_mips8000:
+        case bfd_mach_mips10000:
+        case bfd_mach_mips12000:
+        case bfd_mach_mips16:
+        case bfd_mach_mipsisa32:
+        case bfd_mach_mipsisa32r2:
+        case bfd_mach_mips5:
+        case bfd_mach_mipsisa64:
+        case bfd_mach_mips_sb1:
+          /* FIXME: These should be MIPS3, MIPS4, MIPS16, MIPS32, etc.  */
+          arch_flags = M_MIPS2;
+          break;
+        default:
+          arch_flags = M_UNKNOWN;
+          break;
+        }
+      break;
+
+    case bfd_arch_ns32k:
+      switch (machine)
+        {
+        case 0:         arch_flags = M_NS32532; break;
+        case 32032:     arch_flags = M_NS32032; break;
+        case 32532:     arch_flags = M_NS32532; break;
+        default:        arch_flags = M_UNKNOWN; break;
+        }
+      break;
+
+    case bfd_arch_vax:
+      *unknown = FALSE;
+      break;
+
+    case bfd_arch_cris:
+      if (machine == 0 || machine == 255)
+        arch_flags = M_CRIS;
+      break;
+
     default:
       arch_flags = M_UNKNOWN;
-      break;
-    }
-    break;
-
-  case bfd_arch_ns32k:
-    switch (machine) {
-    case 0:             arch_flags = M_NS32532; break;
-    case 32032:         arch_flags = M_NS32032; break;
-    case 32532:         arch_flags = M_NS32532; break;
-    default:            arch_flags = M_UNKNOWN; break;
-    }
-    break;
-
-  case bfd_arch_vax:
-    *unknown = false;
-    break;
-
-  case bfd_arch_cris:
-    if (machine == 0 || machine == 255) arch_flags = M_CRIS;
-    break;
-
-  default:
-    arch_flags = M_UNKNOWN;
-  }
+    }
 
   if (arch_flags != M_UNKNOWN)
-    *unknown = false;
+    *unknown = FALSE;
 
   return arch_flags;
@@ -829 +850 @@
 
 SYNOPSIS
-        boolean aout_@var{size}_set_arch_mach,
+        bfd_boolean aout_@var{size}_set_arch_mach,
          (bfd *,
           enum bfd_architecture arch,
@@ -840 +861 @@
 */
 
-boolean
+bfd_boolean
 NAME(aout,set_arch_mach) (abfd, arch, machine)
      bfd *abfd;
@@ -847 +868 @@
 {
   if (! bfd_default_set_arch_mach (abfd, arch, machine))
-    return false;
+    return FALSE;
 
   if (arch != bfd_arch_unknown)
     {
-      boolean unknown;
+      bfd_boolean unknown;
 
       NAME(aout,machine_type) (arch, machine, &unknown);
       if (unknown)
-        return false;
-    }
-
-  /* Determine the size of a relocation entry */
-  switch (arch) {
-  case bfd_arch_sparc:
-  case bfd_arch_a29k:
-  case bfd_arch_mips:
-    obj_reloc_entry_size (abfd) = RELOC_EXT_SIZE;
-    break;
-  default:
-    obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
-    break;
-  }
-
-  return (*aout_backend_info(abfd)->set_sizes) (abfd);
+        return FALSE;
+    }
+
+  /* Determine the size of a relocation entry.  */
+  switch (arch)
+    {
+    case bfd_arch_sparc:
+    case bfd_arch_a29k:
+    case bfd_arch_mips:
+      obj_reloc_entry_size (abfd) = RELOC_EXT_SIZE;
+      break;
+    default:
+      obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
+      break;
+    }
+
+  return (*aout_backend_info (abfd)->set_sizes) (abfd);
 }
 
@@ -883 +905 @@
 
   /* Text.  */
-  obj_textsec(abfd)->filepos = pos;
-  if (!obj_textsec(abfd)->user_set_vma)
-    obj_textsec(abfd)->vma = vma;
+  obj_textsec (abfd)->filepos = pos;
+  if (!obj_textsec (abfd)->user_set_vma)
+    obj_textsec (abfd)->vma = vma;
   else
-    vma = obj_textsec(abfd)->vma;
-
-  pos += obj_textsec(abfd)->_raw_size;
-  vma += obj_textsec(abfd)->_raw_size;
+    vma = obj_textsec (abfd)->vma;
+
+  pos += obj_textsec (abfd)->_raw_size;
+  vma += obj_textsec (abfd)->_raw_size;
 
   /* Data.  */
-  if (!obj_datasec(abfd)->user_set_vma)
-    {
-#if 0       /* ?? Does alignment in the file image really matter? */
-      pad = align_power (vma, obj_datasec(abfd)->alignment_power) - vma;
+  if (!obj_datasec (abfd)->user_set_vma)
+    {
+#if 0       /* ?? Does alignment in the file image really matter?  */
+      pad = align_power (vma, obj_datasec (abfd)->alignment_power) - vma;
 #endif
-      obj_textsec(abfd)->_raw_size += pad;
+      obj_textsec (abfd)->_raw_size += pad;
       pos += pad;
       vma += pad;
-      obj_datasec(abfd)->vma = vma;
+      obj_datasec (abfd)->vma = vma;
     }
   else
-    vma = obj_datasec(abfd)->vma;
-  obj_datasec(abfd)->filepos = pos;
-  pos += obj_datasec(abfd)->_raw_size;
-  vma += obj_datasec(abfd)->_raw_size;
+    vma = obj_datasec (abfd)->vma;
+  obj_datasec (abfd)->filepos = pos;
+  pos += obj_datasec (abfd)->_raw_size;
+  vma += obj_datasec (abfd)->_raw_size;
 
   /* BSS.  */
-  if (!obj_bsssec(abfd)->user_set_vma)
+  if (!obj_bsssec (abfd)->user_set_vma)
     {
 #if 0
-      pad = align_power (vma, obj_bsssec(abfd)->alignment_power) - vma;
+      pad = align_power (vma, obj_bsssec (abfd)->alignment_power) - vma;
 #endif
-      obj_datasec(abfd)->_raw_size += pad;
+      obj_datasec (abfd)->_raw_size += pad;
       pos += pad;
       vma += pad;
-      obj_bsssec(abfd)->vma = vma;
+      obj_bsssec (abfd)->vma = vma;
     }
   else
     {
-      /* The VMA of the .bss section is set by the the VMA of the
+      /* The VMA of the .bss section is set by the VMA of the
          .data section plus the size of the .data section.  We may
          need to add padding bytes to make this true.  */
@@ -932 +954 @@
         }
     }
-  obj_bsssec(abfd)->filepos = pos;
+  obj_bsssec (abfd)->filepos = pos;
 
   /* Fix up the exec header.  */
-  execp->a_text = obj_textsec(abfd)->_raw_size;
-  execp->a_data = obj_datasec(abfd)->_raw_size;
-  execp->a_bss = obj_bsssec(abfd)->_raw_size;
+  execp->a_text = obj_textsec (abfd)->_raw_size;
+  execp->a_data = obj_datasec (abfd)->_raw_size;
+  execp->a_bss = obj_bsssec (abfd)->_raw_size;
   N_SET_MAGIC (*execp, OMAGIC);
 }
@@ -948 +970 @@
   bfd_size_type data_pad, text_pad;
   file_ptr text_end;
-  CONST struct aout_backend_data *abdp;
+  const struct aout_backend_data *abdp;
   int ztih;                     /* Nonzero if text includes exec header.  */
 
@@ -957 +979 @@
           && (abdp->text_includes_header
               || obj_aout_subformat (abfd) == q_magic_format));
-  obj_textsec(abfd)->filepos = (ztih
-                                ? adata(abfd).exec_bytes_size
-                                : adata(abfd).zmagic_disk_block_size);
-  if (! obj_textsec(abfd)->user_set_vma)
+  obj_textsec (abfd)->filepos = (ztih
+                                 ? adata (abfd).exec_bytes_size
+                                 : adata (abfd).zmagic_disk_block_size);
+  if (! obj_textsec (abfd)->user_set_vma)
     {
       /* ?? Do we really need to check for relocs here?  */
-      obj_textsec(abfd)->vma = ((abfd->flags & HAS_RELOC)
-                                ? 0
-                                : (ztih
-                                   ? (abdp->default_text_vma
-                                      + adata(abfd).exec_bytes_size)
-                                   : abdp->default_text_vma));
+      obj_textsec (abfd)->vma = ((abfd->flags & HAS_RELOC)
+                                 ? 0
+                                 : (ztih
+                                    ? (abdp->default_text_vma
+                                       + adata (abfd).exec_bytes_size)
+                                    : abdp->default_text_vma));
       text_pad = 0;
     }
@@ -999 +1021 @@
       text_end += obj_textsec (abfd)->filepos;
     }
-  obj_textsec(abfd)->_raw_size += text_pad;
+  obj_textsec (abfd)->_raw_size += text_pad;
   text_end += text_pad;
 
   /* Data.  */
-  if (!obj_datasec(abfd)->user_set_vma)
+  if (!obj_datasec (abfd)->user_set_vma)
     {
       bfd_vma vma;
-      vma = obj_textsec(abfd)->vma + obj_textsec(abfd)->_raw_size;
-      obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size);
+      vma = obj_textsec (abfd)->vma + obj_textsec (abfd)->_raw_size;
+      obj_datasec (abfd)->vma = BFD_ALIGN (vma, adata (abfd).segment_size);
     }
   if (abdp && abdp->zmagic_mapped_contiguous)
     {
-      text_pad = (obj_datasec(abfd)->vma
-                  - obj_textsec(abfd)->vma
-                  - obj_textsec(abfd)->_raw_size);
-      obj_textsec(abfd)->_raw_size += text_pad;
-    }
-  obj_datasec(abfd)->filepos = (obj_textsec(abfd)->filepos
-                                + obj_textsec(abfd)->_raw_size);
+      asection * text = obj_textsec (abfd);
+      asection * data = obj_datasec (abfd);
+
+      text_pad = data->vma - (text->vma + text->_raw_size);
+      /* Only pad the text section if the data
+         section is going to be placed after it.  */
+      if (text_pad > 0)
+        text->_raw_size += text_pad;
+    }
+  obj_datasec (abfd)->filepos = (obj_textsec (abfd)->filepos
+                                 + obj_textsec (abfd)->_raw_size);
 
   /* Fix up exec header while we're at it.  */
-  execp->a_text = obj_textsec(abfd)->_raw_size;
+  execp->a_text = obj_textsec (abfd)->_raw_size;
   if (ztih && (!abdp || (abdp && !abdp->exec_header_not_counted)))
-    execp->a_text += adata(abfd).exec_bytes_size;
+    execp->a_text += adata (abfd).exec_bytes_size;
   if (obj_aout_subformat (abfd) == q_magic_format)
     N_SET_MAGIC (*execp, QMAGIC);
@@ -1029 +1055 @@
 
   /* Spec says data section should be rounded up to page boundary.  */
-  obj_datasec(abfd)->_raw_size
-    = align_power (obj_datasec(abfd)->_raw_size,
-                   obj_bsssec(abfd)->alignment_power);
-  execp->a_data = BFD_ALIGN (obj_datasec(abfd)->_raw_size,
-                             adata(abfd).page_size);
-  data_pad = execp->a_data - obj_datasec(abfd)->_raw_size;
+  obj_datasec (abfd)->_raw_size
+    = align_power (obj_datasec (abfd)->_raw_size,
+                   obj_bsssec (abfd)->alignment_power);
+  execp->a_data = BFD_ALIGN (obj_datasec (abfd)->_raw_size,
+                             adata (abfd).page_size);
+  data_pad = execp->a_data - obj_datasec (abfd)->_raw_size;
 
   /* BSS.  */
-  if (!obj_bsssec(abfd)->user_set_vma)
-    obj_bsssec(abfd)->vma = (obj_datasec(abfd)->vma
-                             + obj_datasec(abfd)->_raw_size);
+  if (!obj_bsssec (abfd)->user_set_vma)
+    obj_bsssec (abfd)->vma = (obj_datasec (abfd)->vma
+                              + obj_datasec (abfd)->_raw_size);
   /* If the BSS immediately follows the data section and extra space
      in the page is left after the data section, fudge data
@@ -1047 +1073 @@
      could have explicitly set the BSS vma to immediately follow
      the data section.)  */
-  if (align_power (obj_bsssec(abfd)->vma, obj_bsssec(abfd)->alignment_power)
-      == obj_datasec(abfd)->vma + obj_datasec(abfd)->_raw_size)
-    execp->a_bss = (data_pad > obj_bsssec(abfd)->_raw_size) ? 0 :
-      obj_bsssec(abfd)->_raw_size - data_pad;
+  if (align_power (obj_bsssec (abfd)->vma, obj_bsssec (abfd)->alignment_power)
+      == obj_datasec (abfd)->vma + obj_datasec (abfd)->_raw_size)
+    execp->a_bss = (data_pad > obj_bsssec (abfd)->_raw_size
+                    ? 0 : obj_bsssec (abfd)->_raw_size - data_pad);
   else
-    execp->a_bss = obj_bsssec(abfd)->_raw_size;
+    execp->a_bss = obj_bsssec (abfd)->_raw_size;
 }
 
@@ -1060 +1086 @@
      struct internal_exec *execp;
 {
-  file_ptr pos = adata(abfd).exec_bytes_size;
+  file_ptr pos = adata (abfd).exec_bytes_size;
   bfd_vma vma = 0;
   int pad;
 
   /* Text.  */
-  obj_textsec(abfd)->filepos = pos;
-  if (!obj_textsec(abfd)->user_set_vma)
-    obj_textsec(abfd)->vma = vma;
+  obj_textsec (abfd)->filepos = pos;
+  if (!obj_textsec (abfd)->user_set_vma)
+    obj_textsec (abfd)->vma = vma;
   else
-    vma = obj_textsec(abfd)->vma;
-  pos += obj_textsec(abfd)->_raw_size;
-  vma += obj_textsec(abfd)->_raw_size;
+    vma = obj_textsec (abfd)->vma;
+  pos += obj_textsec (abfd)->_raw_size;
+  vma += obj_textsec (abfd)->_raw_size;
 
   /* Data.  */
-  obj_datasec(abfd)->filepos = pos;
-  if (!obj_datasec(abfd)->user_set_vma)
-    obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size);
-  vma = obj_datasec(abfd)->vma;
+  obj_datasec (abfd)->filepos = pos;
+  if (!obj_datasec (abfd)->user_set_vma)
+    obj_datasec (abfd)->vma = BFD_ALIGN (vma, adata (abfd).segment_size);
+  vma = obj_datasec (abfd)->vma;
 
   /* Since BSS follows data immediately, see if it needs alignment.  */
-  vma += obj_datasec(abfd)->_raw_size;
-  pad = align_power (vma, obj_bsssec(abfd)->alignment_power) - vma;
-  obj_datasec(abfd)->_raw_size += pad;
-  pos += obj_datasec(abfd)->_raw_size;
+  vma += obj_datasec (abfd)->_raw_size;
+  pad = align_power (vma, obj_bsssec (abfd)->alignment_power) - vma;
+  obj_datasec (abfd)->_raw_size += pad;
+  pos += obj_datasec (abfd)->_raw_size;
 
   /* BSS.  */
-  if (!obj_bsssec(abfd)->user_set_vma)
-    obj_bsssec(abfd)->vma = vma;
+  if (!obj_bsssec (abfd)->user_set_vma)
+    obj_bsssec (abfd)->vma = vma;
   else
-    vma = obj_bsssec(abfd)->vma;
+    vma = obj_bsssec (abfd)->vma;
 
   /* Fix up exec header.  */
-  execp->a_text = obj_textsec(abfd)->_raw_size;
-  execp->a_data = obj_datasec(abfd)->_raw_size;
-  execp->a_bss = obj_bsssec(abfd)->_raw_size;
+  execp->a_text = obj_textsec (abfd)->_raw_size;
+  execp->a_data = obj_datasec (abfd)->_raw_size;
+  execp->a_bss = obj_bsssec (abfd)->_raw_size;
   N_SET_MAGIC (*execp, NMAGIC);
 }
 
-boolean
+bfd_boolean
 NAME(aout,adjust_sizes_and_vmas) (abfd, text_size, text_end)
      bfd *abfd;
@@ -1107 +1133 @@
 
   if (! NAME(aout,make_sections) (abfd))
-    return false;
-
-  if (adata(abfd).magic != undecided_magic)
-    return true;
-
-  obj_textsec(abfd)->_raw_size =
-    align_power(obj_textsec(abfd)->_raw_size,
-                obj_textsec(abfd)->alignment_power);
+    return FALSE;
+
+  if (adata (abfd).magic != undecided_magic)
+    return TRUE;
+
+  obj_textsec (abfd)->_raw_size =
+    align_power (obj_textsec (abfd)->_raw_size,
+                 obj_textsec (abfd)->alignment_power);
 
   *text_size = obj_textsec (abfd)->_raw_size;
@@ -1135 +1161 @@
   if (abfd->flags & D_PAGED)
     /* Whether or not WP_TEXT is set -- let D_PAGED override.  */
-    adata(abfd).magic = z_magic;
+    adata (abfd).magic = z_magic;
   else if (abfd->flags & WP_TEXT)
-    adata(abfd).magic = n_magic;
+    adata (abfd).magic = n_magic;
   else
-    adata(abfd).magic = o_magic;
+    adata (abfd).magic = o_magic;
 
 #ifdef BFD_AOUT_DEBUG /* requires gcc2 */
@@ -1145 +1171 @@
   fprintf (stderr, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
            ({ char *str;
-              switch (adata(abfd).magic) {
-              case n_magic: str = "NMAGIC"; break;
-              case o_magic: str = "OMAGIC"; break;
-              case z_magic: str = "ZMAGIC"; break;
-              default: abort ();
-              }
+              switch (adata (abfd).magic)
+                {
+                case n_magic: str = "NMAGIC"; break;
+                case o_magic: str = "OMAGIC"; break;
+                case z_magic: str = "ZMAGIC"; break;
+                default: abort ();
+                }
               str;
             }),
-           obj_textsec(abfd)->vma, obj_textsec(abfd)->_raw_size,
-                obj_textsec(abfd)->alignment_power,
-           obj_datasec(abfd)->vma, obj_datasec(abfd)->_raw_size,
-                obj_datasec(abfd)->alignment_power,
-           obj_bsssec(abfd)->vma, obj_bsssec(abfd)->_raw_size,
-                obj_bsssec(abfd)->alignment_power);
+           obj_textsec (abfd)->vma, obj_textsec (abfd)->_raw_size,
+                obj_textsec (abfd)->alignment_power,
+           obj_datasec (abfd)->vma, obj_datasec (abfd)->_raw_size,
+                obj_datasec (abfd)->alignment_power,
+           obj_bsssec (abfd)->vma, obj_bsssec (abfd)->_raw_size,
+                obj_bsssec (abfd)->alignment_power);
 #endif
 #endif
 
-  switch (adata(abfd).magic)
+  switch (adata (abfd).magic)
     {
     case o_magic:
@@ -1179 +1206 @@
 #ifdef BFD_AOUT_DEBUG
   fprintf (stderr, "       text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
-           obj_textsec(abfd)->vma, obj_textsec(abfd)->_raw_size,
-                obj_textsec(abfd)->filepos,
-           obj_datasec(abfd)->vma, obj_datasec(abfd)->_raw_size,
-                obj_datasec(abfd)->filepos,
-           obj_bsssec(abfd)->vma, obj_bsssec(abfd)->_raw_size);
+           obj_textsec (abfd)->vma, obj_textsec (abfd)->_raw_size,
+                obj_textsec (abfd)->filepos,
+           obj_datasec (abfd)->vma, obj_datasec (abfd)->_raw_size,
+                obj_datasec (abfd)->filepos,
+           obj_bsssec (abfd)->vma, obj_bsssec (abfd)->_raw_size);
 #endif
 
-  return true;
+  return TRUE;
 }
 
@@ -1194 +1221 @@
 
 SYNOPSIS
-        boolean aout_@var{size}_new_section_hook,
+        bfd_boolean aout_@var{size}_new_section_hook,
            (bfd *abfd,
             asection *newsect));
@@ -1202 +1229 @@
         request.
 */
-boolean
+bfd_boolean
 NAME(aout,new_section_hook) (abfd, newsect)
      bfd *abfd;
      asection *newsect;
 {
-  /* align to double at least */
-  newsect->alignment_power = bfd_get_arch_info(abfd)->section_align_power;
+  /* Align to double at least.  */
+  newsect->alignment_power = bfd_get_arch_info (abfd)->section_align_power;
 
   if (bfd_get_format (abfd) == bfd_object)
-  {
-    if (obj_textsec(abfd) == NULL && !strcmp(newsect->name, ".text")) {
-        obj_textsec(abfd)= newsect;
-        newsect->target_index = N_TEXT;
-        return true;
-      }
-
-    if (obj_datasec(abfd) == NULL && !strcmp(newsect->name, ".data")) {
-        obj_datasec(abfd) = newsect;
-        newsect->target_index = N_DATA;
-        return true;
-      }
-
-    if (obj_bsssec(abfd) == NULL && !strcmp(newsect->name, ".bss")) {
-        obj_bsssec(abfd) = newsect;
-        newsect->target_index = N_BSS;
-        return true;
-      }
-
-  }
-
-  /* We allow more than three sections internally */
-  return true;
-}
-
-boolean
+    {
+      if (obj_textsec (abfd) == NULL && !strcmp (newsect->name, ".text"))
+        {
+          obj_textsec (abfd)= newsect;
+          newsect->target_index = N_TEXT;
+          return TRUE;
+        }
+
+      if (obj_datasec (abfd) == NULL && !strcmp (newsect->name, ".data"))
+        {
+          obj_datasec (abfd) = newsect;
+          newsect->target_index = N_DATA;
+          return TRUE;
+        }
+
+      if (obj_bsssec (abfd) == NULL && !strcmp (newsect->name, ".bss"))
+        {
+          obj_bsssec (abfd) = newsect;
+          newsect->target_index = N_BSS;
+          return TRUE;
+        }
+    }
+
+  /* We allow more than three sections internally.  */
+  return TRUE;
+}
+
+bfd_boolean
 NAME(aout,set_section_contents) (abfd, section, location, offset, count)
      bfd *abfd;
@@ -1250 +1279 @@
     {
       if (! NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
-        return false;
+        return FALSE;
     }
 
@@ -1256 +1285 @@
     {
       bfd_set_error (bfd_error_no_contents);
-      return false;
+      return FALSE;
     }
 
@@ -1262 +1291 @@
       && section != obj_datasec (abfd))
     {
-      (*_bfd_error_handler)
-        (_("%s: can not represent section `%s' in a.out object file format"),
-         bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
-      bfd_set_error (bfd_error_nonrepresentable_section);
-      return false;
+      if (aout_section_merge_with_text_p (abfd, section))
+        section->filepos = obj_textsec (abfd)->filepos +
+                           (section->vma - obj_textsec (abfd)->vma);
+      else
+        {
+          (*_bfd_error_handler)
+           (_("%s: can not represent section `%s' in a.out object file format"),
+             bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
+          bfd_set_error (bfd_error_nonrepresentable_section);
+          return FALSE;
+        }
     }
 
@@ -1272 +1307 @@
     {
       if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
-          || bfd_write (location, 1, count, abfd) != count)
-        return false;
-    }
-
-  return true;
+          || bfd_bwrite (location, count, abfd) != count)
+        return FALSE;
+    }
+
+  return TRUE;
 }
 
@@ -1282 +1317 @@
 /* Read the external symbols from an a.out file.  */
 
-static boolean
+static bfd_boolean
 aout_get_external_symbols (abfd)
      bfd *abfd;
@@ -1290 +1325 @@
       bfd_size_type count;
       struct external_nlist *syms;
+      bfd_size_type amt;
 
       count = exec_hdr (abfd)->a_syms / EXTERNAL_NLIST_SIZE;
 
 #ifdef USE_MMAP
-      if (bfd_get_file_window (abfd,
-                               obj_sym_filepos (abfd), exec_hdr (abfd)->a_syms,
-                               &obj_aout_sym_window (abfd), true) == false)
-        return false;
+      if (! bfd_get_file_window (abfd, obj_sym_filepos (abfd),
+                                 exec_hdr (abfd)->a_syms,
+                                 &obj_aout_sym_window (abfd), TRUE))
+        return FALSE;
       syms = (struct external_nlist *) obj_aout_sym_window (abfd).data;
 #else
@@ -1304 +1340 @@
          possible to free them.  */
       syms = ((struct external_nlist *)
-              bfd_malloc ((size_t) count * EXTERNAL_NLIST_SIZE));
+              bfd_malloc (count * EXTERNAL_NLIST_SIZE));
       if (syms == (struct external_nlist *) NULL && count != 0)
-        return false;
-
+        return FALSE;
+
+      amt = exec_hdr (abfd)->a_syms;
       if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
-          || (bfd_read (syms, 1, exec_hdr (abfd)->a_syms, abfd)
-              != exec_hdr (abfd)->a_syms))
+          || bfd_bread (syms, amt, abfd) != amt)
         {
           free (syms);
-          return false;
+          return FALSE;
         }
 #endif
@@ -1327 +1363 @@
       bfd_size_type stringsize;
       char *strings;
+      bfd_size_type amt = BYTES_IN_WORD;
 
       /* Get the size of the strings.  */
       if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
-          || (bfd_read ((PTR) string_chars, BYTES_IN_WORD, 1, abfd)
-              != BYTES_IN_WORD))
-        return false;
+          || bfd_bread ((PTR) string_chars, amt, abfd) != amt)
+        return FALSE;
       stringsize = GET_WORD (abfd, string_chars);
 
 #ifdef USE_MMAP
-      if (bfd_get_file_window (abfd, obj_str_filepos (abfd), stringsize,
-                               &obj_aout_string_window (abfd), true) == false)
-        return false;
+      if (! bfd_get_file_window (abfd, obj_str_filepos (abfd), stringsize,
+                                 &obj_aout_string_window (abfd), TRUE))
+        return FALSE;
       strings = (char *) obj_aout_string_window (abfd).data;
 #else
-      strings = (char *) bfd_malloc ((size_t) stringsize + 1);
+      strings = (char *) bfd_malloc (stringsize + 1);
       if (strings == NULL)
-        return false;
+        return FALSE;
 
       /* Skip space for the string count in the buffer for convenience
          when using indexes.  */
-      if (bfd_read (strings + BYTES_IN_WORD, 1, stringsize - BYTES_IN_WORD,
-                    abfd)
-          != stringsize - BYTES_IN_WORD)
+      amt = stringsize - BYTES_IN_WORD;
+      if (bfd_bread (strings + BYTES_IN_WORD, amt, abfd) != amt)
         {
           free (strings);
-          return false;
+          return FALSE;
         }
 #endif
@@ -1365 +1400 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -1373 +1408 @@
    symbol->flags and symbol->section, and adjusting symbol->value.  */
 
-static boolean
+static bfd_boolean
 translate_from_native_sym_flags (abfd, cache_ptr)
      bfd *abfd;
@@ -1386 +1421 @@
 
       /* This is a debugging symbol.  */
-
       cache_ptr->symbol.flags = BSF_DEBUGGING;
 
@@ -1411 +1445 @@
       cache_ptr->symbol.value -= sec->vma;
 
-      return true;
+      return TRUE;
     }
 
@@ -1480 +1514 @@
         arelent_chain *reloc;
         asection *into_section;
+        bfd_size_type amt;
 
         /* This is a set symbol.  The name of the symbol is the name
@@ -1496 +1531 @@
             char *copy;
 
-            copy = bfd_alloc (abfd, strlen (cache_ptr->symbol.name) + 1);
+            amt = strlen (cache_ptr->symbol.name) + 1;
+            copy = bfd_alloc (abfd, amt);
             if (copy == NULL)
-              return false;
+              return FALSE;
 
             strcpy (copy, cache_ptr->symbol.name);
             section = bfd_make_section (abfd, copy);
             if (section == NULL)
-              return false;
+              return FALSE;
           }
 
-        reloc = (arelent_chain *) bfd_alloc (abfd, sizeof (arelent_chain));
+        amt = sizeof (arelent_chain);
+        reloc = (arelent_chain *) bfd_alloc (abfd, amt);
         if (reloc == NULL)
-          return false;
+          return FALSE;
 
         /* Build a relocation entry for the constructor.  */
@@ -1551 +1588 @@
         section->_raw_size += BYTES_IN_WORD;
 
-        reloc->relent.howto = CTOR_TABLE_RELOC_HOWTO(abfd);
+        reloc->relent.howto = CTOR_TABLE_RELOC_HOWTO (abfd);
 
 #endif /* 0 */
@@ -1633 +1670 @@
     }
 
-  return true;
+  return TRUE;
 }
 
 /* Set the fields of SYM_POINTER according to CACHE_PTR.  */
 
-static boolean
+static bfd_boolean
 translate_to_native_sym_flags (abfd, cache_ptr, sym_pointer)
      bfd *abfd;
@@ -1664 +1701 @@
          cache_ptr->name != NULL ? cache_ptr->name : _("*unknown*"));
       bfd_set_error (bfd_error_nonrepresentable_section);
-      return false;
+      return FALSE;
     }
 
@@ -1689 +1726 @@
   else
     {
-      (*_bfd_error_handler)
-        (_("%s: can not represent section `%s' in a.out object file format"),
-         bfd_get_filename (abfd), bfd_get_section_name (abfd, sec));
-      bfd_set_error (bfd_error_nonrepresentable_section);
-      return false;
-    }
-
-  /* Turn the symbol from section relative to absolute again */
+      if (aout_section_merge_with_text_p (abfd, sec))
+        sym_pointer->e_type[0] |= N_TEXT;
+      else
+        {
+          (*_bfd_error_handler)
+           (_("%s: can not represent section `%s' in a.out object file format"),
+             bfd_get_filename (abfd), bfd_get_section_name (abfd, sec));
+          bfd_set_error (bfd_error_nonrepresentable_section);
+          return FALSE;
+        }
+    }
+
+  /* Turn the symbol from section relative to absolute again.  */
   value += sec->vma + off;
 
@@ -1712 +1754 @@
     {
       int type = ((aout_symbol_type *) cache_ptr)->type;
+
       switch (type)
         {
@@ -1738 +1781 @@
     }
 
-  PUT_WORD(abfd, value, sym_pointer->e_value);
-
-  return true;
+  PUT_WORD (abfd, value, sym_pointer->e_value);
+
+  return TRUE;
 }
 
@@ -1750 +1793 @@
      bfd *abfd;
 {
-  aout_symbol_type  *new =
-    (aout_symbol_type *)bfd_zalloc (abfd, sizeof (aout_symbol_type));
+  bfd_size_type amt = sizeof (aout_symbol_type);
+  aout_symbol_type *new = (aout_symbol_type *) bfd_zalloc (abfd, amt);
   if (!new)
     return NULL;
@@ -1761 +1804 @@
 /* Translate a set of internal symbols into external symbols.  */
 
-boolean
+bfd_boolean
 NAME(aout,translate_symbol_table) (abfd, in, ext, count, str, strsize, dynamic)
      bfd *abfd;
@@ -1769 +1812 @@
      char *str;
      bfd_size_type strsize;
-     boolean dynamic;
+     bfd_boolean dynamic;
 {
   struct external_nlist *ext_end;
@@ -1791 +1834 @@
         in->symbol.name = str + x;
       else
-        return false;
+        return FALSE;
 
       in->symbol.value = GET_SWORD (abfd,  ext->e_value);
-      in->desc = bfd_h_get_16 (abfd, ext->e_desc);
-      in->other = bfd_h_get_8 (abfd, ext->e_other);
-      in->type = bfd_h_get_8 (abfd,  ext->e_type);
+      in->desc = H_GET_16 (abfd, ext->e_desc);
+      in->other = H_GET_8 (abfd, ext->e_other);
+      in->type = H_GET_8 (abfd,  ext->e_type);
       in->symbol.udata.p = NULL;
 
       if (! translate_from_native_sym_flags (abfd, in))
-        return false;
+        return FALSE;
 
       if (dynamic)
@@ -1806 +1849 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -1813 +1856 @@
    hold them all plus all the cached symbol entries.  */
 
-boolean
+bfd_boolean
 NAME(aout,slurp_symbol_table) (abfd)
      bfd *abfd;
@@ -1819 +1862 @@
   struct external_nlist *old_external_syms;
   aout_symbol_type *cached;
-  size_t cached_size;
-
-  /* If there's no work to be done, don't do any */
+  bfd_size_type cached_size;
+
+  /* If there's no work to be done, don't do any.  */
   if (obj_aout_symbols (abfd) != (aout_symbol_type *) NULL)
-    return true;
+    return TRUE;
 
   old_external_syms = obj_aout_external_syms (abfd);
 
   if (! aout_get_external_symbols (abfd))
-    return false;
-
-  cached_size = (obj_aout_external_sym_count (abfd)
-                 * sizeof (aout_symbol_type));
-  cached = (aout_symbol_type *) bfd_malloc (cached_size);
+    return FALSE;
+
+  cached_size = obj_aout_external_sym_count (abfd);
+  cached_size *= sizeof (aout_symbol_type);
+  cached = (aout_symbol_type *) bfd_zmalloc (cached_size);
   if (cached == NULL && cached_size != 0)
-    return false;
-  if (cached_size != 0)
-    memset (cached, 0, cached_size);
+    return FALSE;
 
   /* Convert from external symbol information to internal.  */
@@ -1845 +1886 @@
           obj_aout_external_strings (abfd),
           obj_aout_external_string_size (abfd),
-          false)))
+          FALSE)))
     {
       free (cached);
-      return false;
+      return FALSE;
     }
 
@@ -1870 +1911 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -1884 +1925 @@
 
 static bfd_size_type add_to_stringtab
-  PARAMS ((bfd *, struct bfd_strtab_hash *, const char *, boolean));
-static boolean emit_stringtab PARAMS ((bfd *, struct bfd_strtab_hash *));
+  PARAMS ((bfd *, struct bfd_strtab_hash *, const char *, bfd_boolean));
+static bfd_boolean emit_stringtab
+  PARAMS ((bfd *, struct bfd_strtab_hash *));
 
 /* Get the index of a string in a strtab, adding it if it is not
@@ -1895 +1937 @@
      struct bfd_strtab_hash *tab;
      const char *str;
-     boolean copy;
-{
-  boolean hash;
+     bfd_boolean copy;
+{
+  bfd_boolean hash;
   bfd_size_type index;
 
@@ -1906 +1948 @@
   /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
      doesn't understand a hashed string table.  */
-  hash = true;
+  hash = TRUE;
   if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
-    hash = false;
+    hash = FALSE;
 
   index = _bfd_stringtab_add (tab, str, hash, copy);
@@ -1925 +1967 @@
    file.  */
 
-static boolean
+static bfd_boolean
 emit_stringtab (abfd, tab)
      register bfd *abfd;
@@ -1931 +1973 @@
 {
   bfd_byte buffer[BYTES_IN_WORD];
+  bfd_size_type amt = BYTES_IN_WORD;
 
   /* The string table starts with the size.  */
   PUT_WORD (abfd, _bfd_stringtab_size (tab) + BYTES_IN_WORD, buffer);
-  if (bfd_write ((PTR) buffer, 1, BYTES_IN_WORD, abfd) != BYTES_IN_WORD)
-    return false;
+  if (bfd_bwrite ((PTR) buffer, amt, abfd) != amt)
+    return FALSE;
 
   return _bfd_stringtab_emit (abfd, tab);
@@ -1941 +1984 @@
 
 
-boolean
+bfd_boolean
 NAME(aout,write_syms) (abfd)
      bfd *abfd;
@@ -1951 +1994 @@
   strtab = _bfd_stringtab_init ();
   if (strtab == NULL)
-    return false;
+    return FALSE;
 
   for (count = 0; count < bfd_get_symcount (abfd); count++)
@@ -1958 +2001 @@
       bfd_size_type indx;
       struct external_nlist nsp;
-
-      indx = add_to_stringtab (abfd, strtab, g->name, false);
+      bfd_size_type amt;
+
+      indx = add_to_stringtab (abfd, strtab, g->name, FALSE);
       if (indx == (bfd_size_type) -1)
         goto error_return;
       PUT_WORD (abfd, indx, (bfd_byte *) nsp.e_strx);
 
-      if (bfd_asymbol_flavour(g) == abfd->xvec->flavour)
+      if (bfd_asymbol_flavour (g) == abfd->xvec->flavour)
         {
-          bfd_h_put_16(abfd, aout_symbol(g)->desc,  nsp.e_desc);
-          bfd_h_put_8(abfd, aout_symbol(g)->other,  nsp.e_other);
-          bfd_h_put_8(abfd, aout_symbol(g)->type,  nsp.e_type);
+          H_PUT_16 (abfd, aout_symbol (g)->desc,  nsp.e_desc);
+          H_PUT_8  (abfd, aout_symbol (g)->other, nsp.e_other);
+          H_PUT_8  (abfd, aout_symbol (g)->type,  nsp.e_type);
         }
       else
         {
-          bfd_h_put_16(abfd,0, nsp.e_desc);
-          bfd_h_put_8(abfd, 0, nsp.e_other);
-          bfd_h_put_8(abfd, 0, nsp.e_type);
+          H_PUT_16 (abfd, 0, nsp.e_desc);
+          H_PUT_8  (abfd, 0, nsp.e_other);
+          H_PUT_8  (abfd, 0, nsp.e_type);
         }
 
@@ -1980 +2024 @@
         goto error_return;
 
-      if (bfd_write((PTR)&nsp,1,EXTERNAL_NLIST_SIZE, abfd)
-          != EXTERNAL_NLIST_SIZE)
+      amt = EXTERNAL_NLIST_SIZE;
+      if (bfd_bwrite ((PTR) &nsp, amt, abfd) != amt)
         goto error_return;
 
@@ -1994 +2038 @@
   _bfd_stringtab_free (strtab);
 
-  return true;
+  return TRUE;
 
 error_return:
   _bfd_stringtab_free (strtab);
-  return false;
+  return FALSE;
 }
 
@@ -2013 +2057 @@
       return -1;
 
-    for (symbase = obj_aout_symbols(abfd); counter++ < bfd_get_symcount (abfd);)
-      *(location++) = (asymbol *) ( symbase++);
+    for (symbase = obj_aout_symbols (abfd);
+         counter++ < bfd_get_symcount (abfd);
+         )
+      *(location++) = (asymbol *) (symbase++);
     *location++ =0;
     return bfd_get_symcount (abfd);
@@ -2020 +2066 @@
 
 
-/* Standard reloc stuff */
+/* Standard reloc stuff.  */
 /* Output standard relocation information to a file in target byte order.  */
 
@@ -2040 +2086 @@
   asection *output_section = sym->section->output_section;
 
-  PUT_WORD(abfd, g->address, natptr->r_address);
-
-  r_length = g->howto->size ;   /* Size as a power of two */
-  r_pcrel  = (int) g->howto->pc_relative; /* Relative to PC? */
+  PUT_WORD (abfd, g->address, natptr->r_address);
+
+  r_length = g->howto->size ;   /* Size as a power of two.  */
+  r_pcrel  = (int) g->howto->pc_relative; /* Relative to PC?  */
   /* XXX This relies on relocs coming from a.out files.  */
   r_baserel = (g->howto->type & 8) != 0;
@@ -2054 +2100 @@
 #endif
 
-  /* name was clobbered by aout_write_syms to be symbol index */
+  /* Name was clobbered by aout_write_syms to be symbol index.  */
 
   /* If this relocation is relative to a symbol then set the
@@ -2061 +2107 @@
      Absolute symbols can come in in two ways, either as an offset
      from the abs section, or as a symbol which has an abs value.
-     check for that here
-     */
+     check for that here.  */
 
   if (bfd_is_com_section (output_section)
@@ -2069 +2114 @@
     {
       if (bfd_abs_section_ptr->symbol == sym)
-      {
-        /* Whoops, looked like an abs symbol, but is really an offset
-           from the abs section */
-        r_index = N_ABS;
-        r_extern = 0;
-       }
+        {
+          /* Whoops, looked like an abs symbol, but is
+             really an offset from the abs section.  */
+          r_index = N_ABS;
+          r_extern = 0;
+        }
       else
-      {
-        /* Fill in symbol */
-        r_extern = 1;
-        r_index = (*(g->sym_ptr_ptr))->KEEPIT;
-
-      }
+        {
+          /* Fill in symbol.  */
+          r_extern = 1;
+          r_index = (*(g->sym_ptr_ptr))->KEEPIT;
+        }
     }
   else
     {
-      /* Just an ordinary section */
+      /* Just an ordinary section.  */
       r_extern = 0;
       r_index  = output_section->target_index;
     }
 
-  /* now the fun stuff */
-  if (bfd_header_big_endian (abfd)) {
+  /* Now the fun stuff.  */
+  if (bfd_header_big_endian (abfd))
+    {
       natptr->r_index[0] = r_index >> 16;
       natptr->r_index[1] = r_index >> 8;
       natptr->r_index[2] = r_index;
-      natptr->r_type[0] =
-       (r_extern?    RELOC_STD_BITS_EXTERN_BIG: 0)
-        | (r_pcrel?     RELOC_STD_BITS_PCREL_BIG: 0)
-         | (r_baserel?   RELOC_STD_BITS_BASEREL_BIG: 0)
-          | (r_jmptable?  RELOC_STD_BITS_JMPTABLE_BIG: 0)
-           | (r_relative?  RELOC_STD_BITS_RELATIVE_BIG: 0)
-            | (r_length <<  RELOC_STD_BITS_LENGTH_SH_BIG);
-    } else {
-        natptr->r_index[2] = r_index >> 16;
-        natptr->r_index[1] = r_index >> 8;
-        natptr->r_index[0] = r_index;
-        natptr->r_type[0] =
-         (r_extern?    RELOC_STD_BITS_EXTERN_LITTLE: 0)
-          | (r_pcrel?     RELOC_STD_BITS_PCREL_LITTLE: 0)
-           | (r_baserel?   RELOC_STD_BITS_BASEREL_LITTLE: 0)
-            | (r_jmptable?  RELOC_STD_BITS_JMPTABLE_LITTLE: 0)
-             | (r_relative?  RELOC_STD_BITS_RELATIVE_LITTLE: 0)
-              | (r_length <<  RELOC_STD_BITS_LENGTH_SH_LITTLE);
-      }
-}
-
-/* Extended stuff */
+      natptr->r_type[0] = ((r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
+                           | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
+                           | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
+                           | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
+                           | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
+                           | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG));
+    }
+  else
+    {
+      natptr->r_index[2] = r_index >> 16;
+      natptr->r_index[1] = r_index >> 8;
+      natptr->r_index[0] = r_index;
+      natptr->r_type[0] = ((r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
+                           | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
+                           | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
+                           | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
+                           | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
+                           | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE));
+    }
+}
+
+/* Extended stuff.  */
 /* Output extended relocation information to a file in target byte order.  */
 
@@ -2131 +2176 @@
   int r_extern;
   unsigned int r_type;
-  unsigned int r_addend;
+  bfd_vma r_addend;
   asymbol *sym = *(g->sym_ptr_ptr);
   asection *output_section = sym->section->output_section;
@@ -2149 +2194 @@
      from the abs section, or as a symbol which has an abs value.
      check for that here.  */
-
   if (bfd_is_abs_section (bfd_get_section (sym)))
     {
@@ -2166 +2210 @@
   else
     {
-      /* Just an ordinary section */
+      /* Just an ordinary section.  */
       r_extern = 0;
       r_index = output_section->target_index;
     }
 
-  /* now the fun stuff */
-  if (bfd_header_big_endian (abfd)) {
-    natptr->r_index[0] = r_index >> 16;
-    natptr->r_index[1] = r_index >> 8;
-    natptr->r_index[2] = r_index;
-    natptr->r_type[0] =
-      ((r_extern? RELOC_EXT_BITS_EXTERN_BIG: 0)
-       | (r_type << RELOC_EXT_BITS_TYPE_SH_BIG));
-  } else {
-    natptr->r_index[2] = r_index >> 16;
-    natptr->r_index[1] = r_index >> 8;
-    natptr->r_index[0] = r_index;
-    natptr->r_type[0] =
-     (r_extern? RELOC_EXT_BITS_EXTERN_LITTLE: 0)
-      | (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
-  }
+  /* Now the fun stuff.  */
+  if (bfd_header_big_endian (abfd))
+    {
+      natptr->r_index[0] = r_index >> 16;
+      natptr->r_index[1] = r_index >> 8;
+      natptr->r_index[2] = r_index;
+      natptr->r_type[0] = ((r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
+                           | (r_type << RELOC_EXT_BITS_TYPE_SH_BIG));
+    }
+  else
+    {
+      natptr->r_index[2] = r_index >> 16;
+      natptr->r_index[1] = r_index >> 8;
+      natptr->r_index[0] = r_index;
+      natptr->r_type[0] = ((r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
+                           | (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE));
+    }
 
   PUT_WORD (abfd, r_addend, natptr->r_addend);
@@ -2197 +2242 @@
    Aout keeps all it's symbols based from zero, so the symbol would
    contain 60. This macro subs the base of each section from the value
-   to give the true offset from the section */
-
-#define MOVE_ADDRESS(ad)                                                \
-  if (r_extern) {                                                       \
-   /* undefined symbol */                                               \
-     cache_ptr->sym_ptr_ptr = symbols + r_index;                        \
-     cache_ptr->addend = ad;                                            \
-     } else {                                                           \
-    /* defined, section relative. replace symbol with pointer to        \
-       symbol which points to section  */                               \
-    switch (r_index) {                                                  \
-    case N_TEXT:                                                        \
-    case N_TEXT | N_EXT:                                                \
-      cache_ptr->sym_ptr_ptr  = obj_textsec(abfd)->symbol_ptr_ptr;      \
-      cache_ptr->addend = ad  - su->textsec->vma;                       \
-      break;                                                            \
-    case N_DATA:                                                        \
-    case N_DATA | N_EXT:                                                \
-      cache_ptr->sym_ptr_ptr  = obj_datasec(abfd)->symbol_ptr_ptr;      \
-      cache_ptr->addend = ad - su->datasec->vma;                        \
-      break;                                                            \
-    case N_BSS:                                                         \
-    case N_BSS | N_EXT:                                                 \
-      cache_ptr->sym_ptr_ptr  = obj_bsssec(abfd)->symbol_ptr_ptr;       \
-      cache_ptr->addend = ad - su->bsssec->vma;                         \
-      break;                                                            \
-    default:                                                            \
-    case N_ABS:                                                         \
-    case N_ABS | N_EXT:                                                 \
-     cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;      \
+   to give the true offset from the section.  */
+
+#define MOVE_ADDRESS(ad)                                                \
+  if (r_extern)                                                         \
+    {                                                                   \
+      /* Undefined symbol.  */                                          \
+      cache_ptr->sym_ptr_ptr = symbols + r_index;                       \
       cache_ptr->addend = ad;                                           \
-      break;                                                            \
     }                                                                   \
-  }                                                                     \
+   else                                                                 \
+    {                                                                   \
+      /* Defined, section relative.  Replace symbol with pointer to     \
+         symbol which points to section.  */                            \
+      switch (r_index)                                                  \
+        {                                                               \
+        case N_TEXT:                                                    \
+        case N_TEXT | N_EXT:                                            \
+          cache_ptr->sym_ptr_ptr = obj_textsec (abfd)->symbol_ptr_ptr;  \
+          cache_ptr->addend = ad - su->textsec->vma;                    \
+          break;                                                        \
+        case N_DATA:                                                    \
+        case N_DATA | N_EXT:                                            \
+          cache_ptr->sym_ptr_ptr = obj_datasec (abfd)->symbol_ptr_ptr;  \
+          cache_ptr->addend = ad - su->datasec->vma;                    \
+          break;                                                        \
+        case N_BSS:                                                     \
+        case N_BSS | N_EXT:                                             \
+          cache_ptr->sym_ptr_ptr = obj_bsssec (abfd)->symbol_ptr_ptr;   \
+          cache_ptr->addend = ad - su->bsssec->vma;                     \
+          break;                                                        \
+        default:                                                        \
+        case N_ABS:                                                     \
+        case N_ABS | N_EXT:                                             \
+          cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
+          cache_ptr->addend = ad;                                       \
+          break;                                                        \
+        }                                                               \
+    }
 
 void
@@ -2247 +2296 @@
   cache_ptr->address = (GET_SWORD (abfd, bytes->r_address));
 
-  /* now the fun stuff */
-  if (bfd_header_big_endian (abfd)) {
-    r_index =  (bytes->r_index[0] << 16)
-             | (bytes->r_index[1] << 8)
-             |  bytes->r_index[2];
-    r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
-    r_type   =       (bytes->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
-                                      >> RELOC_EXT_BITS_TYPE_SH_BIG;
-  } else {
-    r_index =  (bytes->r_index[2] << 16)
-             | (bytes->r_index[1] << 8)
-             |  bytes->r_index[0];
-    r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
-    r_type   =       (bytes->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
-                                      >> RELOC_EXT_BITS_TYPE_SH_LITTLE;
-  }
+  /* Now the fun stuff.  */
+  if (bfd_header_big_endian (abfd))
+    {
+      r_index = (((unsigned int) bytes->r_index[0] << 16)
+                 | ((unsigned int) bytes->r_index[1] << 8)
+                 | bytes->r_index[2]);
+      r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
+      r_type = ((bytes->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
+                >> RELOC_EXT_BITS_TYPE_SH_BIG);
+    }
+  else
+    {
+      r_index =  (((unsigned int) bytes->r_index[2] << 16)
+                  | ((unsigned int) bytes->r_index[1] << 8)
+                  | bytes->r_index[0]);
+      r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
+      r_type = ((bytes->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
+                >> RELOC_EXT_BITS_TYPE_SH_LITTLE);
+    }
 
   cache_ptr->howto =  howto_table_ext + r_type;
@@ -2269 +2321 @@
      regardless of the setting of r_extern.  r_extern just reflects
      whether the symbol the reloc is against is local or global.  */
-  if (r_type == RELOC_BASE10
-      || r_type == RELOC_BASE13
-      || r_type == RELOC_BASE22)
+  if (r_type == (unsigned int) RELOC_BASE10
+      || r_type == (unsigned int) RELOC_BASE13
+      || r_type == (unsigned int) RELOC_BASE22)
     r_extern = 1;
 
@@ -2282 +2334 @@
     }
 
-  MOVE_ADDRESS(GET_SWORD(abfd, bytes->r_addend));
+  MOVE_ADDRESS (GET_SWORD (abfd, bytes->r_addend));
 }
 
@@ -2301 +2353 @@
   unsigned int howto_idx;
 
-  cache_ptr->address = bfd_h_get_32 (abfd, bytes->r_address);
-
-  /* now the fun stuff */
-  if (bfd_header_big_endian (abfd)) {
-    r_index =  (bytes->r_index[0] << 16)
-      | (bytes->r_index[1] << 8)
-        |  bytes->r_index[2];
-    r_extern  = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
-    r_pcrel   = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
-    r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
-    r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
-    r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
-    r_length  =       (bytes->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
-                        >> RELOC_STD_BITS_LENGTH_SH_BIG;
-  } else {
-    r_index =  (bytes->r_index[2] << 16)
-      | (bytes->r_index[1] << 8)
-        |  bytes->r_index[0];
-    r_extern  = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
-    r_pcrel   = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
-    r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_LITTLE));
-    r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_LITTLE));
-    r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_LITTLE));
-    r_length  =       (bytes->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
-                        >> RELOC_STD_BITS_LENGTH_SH_LITTLE;
-  }
-
-  howto_idx = r_length + 4 * r_pcrel + 8 * r_baserel
-              + 16 * r_jmptable + 32 * r_relative;
+  cache_ptr->address = H_GET_32 (abfd, bytes->r_address);
+
+  /* Now the fun stuff.  */
+  if (bfd_header_big_endian (abfd))
+    {
+      r_index = (((unsigned int) bytes->r_index[0] << 16)
+                 | ((unsigned int) bytes->r_index[1] << 8)
+                 | bytes->r_index[2]);
+      r_extern  = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
+      r_pcrel   = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
+      r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_BIG));
+      r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_BIG));
+      r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_BIG));
+      r_length  = ((bytes->r_type[0] & RELOC_STD_BITS_LENGTH_BIG)
+                   >> RELOC_STD_BITS_LENGTH_SH_BIG);
+    }
+  else
+    {
+      r_index = (((unsigned int) bytes->r_index[2] << 16)
+                 | ((unsigned int) bytes->r_index[1] << 8)
+                 | bytes->r_index[0]);
+      r_extern  = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
+      r_pcrel   = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
+      r_baserel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_BASEREL_LITTLE));
+      r_jmptable= (0 != (bytes->r_type[0] & RELOC_STD_BITS_JMPTABLE_LITTLE));
+      r_relative= (0 != (bytes->r_type[0] & RELOC_STD_BITS_RELATIVE_LITTLE));
+      r_length  = ((bytes->r_type[0] & RELOC_STD_BITS_LENGTH_LITTLE)
+                   >> RELOC_STD_BITS_LENGTH_SH_LITTLE);
+    }
+
+  howto_idx = (r_length + 4 * r_pcrel + 8 * r_baserel
+               + 16 * r_jmptable + 32 * r_relative);
   BFD_ASSERT (howto_idx < TABLE_SIZE (howto_table_std));
   cache_ptr->howto =  howto_table_std + howto_idx;
@@ -2348 +2403 @@
     }
 
-  MOVE_ADDRESS(0);
+  MOVE_ADDRESS (0);
 }
 
 /* Read and swap the relocs for a section.  */
 
-boolean
+bfd_boolean
 NAME(aout,slurp_reloc_table) (abfd, asect, symbols)
      bfd *abfd;
@@ -2359 +2414 @@
      asymbol **symbols;
 {
-  unsigned int count;
+  bfd_size_type count;
   bfd_size_type reloc_size;
   PTR relocs;
@@ -2366 +2421 @@
   unsigned int counter = 0;
   arelent *cache_ptr;
+  bfd_size_type amt;
 
   if (asect->relocation)
-    return true;
+    return TRUE;
 
   if (asect->flags & SEC_CONSTRUCTOR)
-    return true;
+    return TRUE;
 
   if (asect == obj_datasec (abfd))
-    reloc_size = exec_hdr(abfd)->a_drsize;
+    reloc_size = exec_hdr (abfd)->a_drsize;
   else if (asect == obj_textsec (abfd))
-    reloc_size = exec_hdr(abfd)->a_trsize;
+    reloc_size = exec_hdr (abfd)->a_trsize;
   else if (asect == obj_bsssec (abfd))
     reloc_size = 0;
@@ -2382 +2438 @@
     {
       bfd_set_error (bfd_error_invalid_operation);
-      return false;
+      return FALSE;
     }
 
   if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
-    return false;
+    return FALSE;
 
   each_size = obj_reloc_entry_size (abfd);
@@ -2392 +2448 @@
   count = reloc_size / each_size;
 
-  reloc_cache = (arelent *) bfd_malloc ((size_t) (count * sizeof (arelent)));
+  amt = count * sizeof (arelent);
+  reloc_cache = (arelent *) bfd_zmalloc (amt);
   if (reloc_cache == NULL && count != 0)
-    return false;
-  memset (reloc_cache, 0, count * sizeof (arelent));
-
-  relocs = bfd_malloc ((size_t) reloc_size);
+    return FALSE;
+
+  relocs = bfd_malloc (reloc_size);
   if (relocs == NULL && reloc_size != 0)
     {
       free (reloc_cache);
-      return false;
-    }
-
-  if (bfd_read (relocs, 1, reloc_size, abfd) != reloc_size)
+      return FALSE;
+    }
+
+  if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
     {
       free (relocs);
       free (reloc_cache);
-      return false;
+      return FALSE;
     }
 
@@ -2414 +2470 @@
   if (each_size == RELOC_EXT_SIZE)
     {
-      register struct reloc_ext_external *rptr =
-        (struct reloc_ext_external *) relocs;
+      struct reloc_ext_external *rptr = (struct reloc_ext_external *) relocs;
 
       for (; counter < count; counter++, rptr++, cache_ptr++)
         MY_swap_ext_reloc_in (abfd, rptr, cache_ptr, symbols,
-                              bfd_get_symcount (abfd));
+                              (bfd_size_type) bfd_get_symcount (abfd));
     }
   else
     {
-      register struct reloc_std_external *rptr =
-        (struct reloc_std_external *) relocs;
+      struct reloc_std_external *rptr = (struct reloc_std_external *) relocs;
 
       for (; counter < count; counter++, rptr++, cache_ptr++)
         MY_swap_std_reloc_in (abfd, rptr, cache_ptr, symbols,
-                              bfd_get_symcount (abfd));
+                              (bfd_size_type) bfd_get_symcount (abfd));
     }
 
@@ -2436 +2490 @@
   asect->reloc_count = cache_ptr - reloc_cache;
 
-  return true;
+  return TRUE;
 }
 
 /* Write out a relocation section into an object file.  */
 
-boolean
+bfd_boolean
 NAME(aout,squirt_out_relocs) (abfd, section)
      bfd *abfd;
@@ -2451 +2505 @@
 
   unsigned int count = section->reloc_count;
-  size_t natsize;
+  bfd_size_type natsize;
 
   if (count == 0 || section->orelocation == NULL)
-    return true;
+    return TRUE;
 
   each_size = obj_reloc_entry_size (abfd);
-  natsize = each_size * count;
+  natsize = (bfd_size_type) each_size * count;
   native = (unsigned char *) bfd_zalloc (abfd, natsize);
   if (!native)
-    return false;
+    return FALSE;
 
   generic = section->orelocation;
@@ -2477 +2531 @@
            count != 0;
            --count, natptr += each_size, ++generic)
-        MY_swap_std_reloc_out(abfd, *generic, (struct reloc_std_external *)natptr);
-    }
-
-  if ( bfd_write ((PTR) native, 1, natsize, abfd) != natsize) {
-    bfd_release(abfd, native);
-    return false;
-  }
+        MY_swap_std_reloc_out (abfd, *generic,
+                               (struct reloc_std_external *) natptr);
+    }
+
+  if (bfd_bwrite ((PTR) native, natsize, abfd) != natsize)
+    {
+      bfd_release (abfd, native);
+      return FALSE;
+    }
   bfd_release (abfd, 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.  */
+
 long
 NAME(aout,canonicalize_reloc) (abfd, section, relptr, symbols)
@@ -2509 +2566 @@
     return -1;
 
-  if (section->flags & SEC_CONSTRUCTOR) {
-    arelent_chain *chain = section->constructor_chain;
-    for (count = 0; count < section->reloc_count; count ++) {
-      *relptr ++ = &chain->relent;
-      chain = chain->next;
-    }
-  }
-  else {
-    tblptr = section->relocation;
-
-    for (count = 0; count++ < section->reloc_count;)
-      {
-        *relptr++ = tblptr++;
-      }
-  }
+  if (section->flags & SEC_CONSTRUCTOR)
+    {
+      arelent_chain *chain = section->constructor_chain;
+      for (count = 0; count < section->reloc_count; count ++)
+        {
+          *relptr ++ = &chain->relent;
+          chain = chain->next;
+        }
+    }
+  else
+    {
+      tblptr = section->relocation;
+
+      for (count = 0; count++ < section->reloc_count; )
+        {
+          *relptr++ = tblptr++;
+        }
+    }
   *relptr = 0;
 
@@ -2534 +2594 @@
      sec_ptr asect;
 {
-  if (bfd_get_format (abfd) != bfd_object) {
-    bfd_set_error (bfd_error_invalid_operation);
-    return -1;
-  }
-  if (asect->flags & SEC_CONSTRUCTOR) {
+  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));
-  }
 
   if (asect == obj_datasec (abfd))
     return (sizeof (arelent *)
-            * ((exec_hdr(abfd)->a_drsize / obj_reloc_entry_size (abfd))
+            * ((exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd))
                + 1));
 
   if (asect == obj_textsec (abfd))
     return (sizeof (arelent *)
-            * ((exec_hdr(abfd)->a_trsize / obj_reloc_entry_size (abfd))
+            * ((exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd))
                + 1));
 
@@ -2573 +2634 @@
 }
 
- alent *
+alent *
 NAME(aout,get_lineno) (ignore_abfd, ignore_symbol)
      bfd *ignore_abfd ATTRIBUTE_UNUSED;
@@ -2591 +2652 @@
   if (ret->type == '?')
     {
-      int type_code = aout_symbol(symbol)->type & 0xff;
+      int type_code = aout_symbol (symbol)->type & 0xff;
       const char *stab_name = bfd_get_stab_name (type_code);
       static char buf[10];
@@ -2602 +2663 @@
       ret->type = '-';
       ret->stab_type = type_code;
-      ret->stab_other = (unsigned) (aout_symbol(symbol)->other & 0xff);
-      ret->stab_desc = (unsigned) (aout_symbol(symbol)->desc & 0xffff);
+      ret->stab_other = (unsigned) (aout_symbol (symbol)->other & 0xff);
+      ret->stab_desc = (unsigned) (aout_symbol (symbol)->desc & 0xffff);
       ret->stab_name = stab_name;
     }
@@ -2609 +2670 @@
 
 void
-NAME(aout,print_symbol) (ignore_abfd, afile, symbol, how)
-     bfd *ignore_abfd ATTRIBUTE_UNUSED;
+NAME(aout,print_symbol) (abfd, afile, symbol, how)
+     bfd *abfd;
      PTR afile;
      asymbol *symbol;
@@ -2617 +2678 @@
   FILE *file = (FILE *)afile;
 
-  switch (how) {
-  case bfd_print_symbol_name:
-    if (symbol->name)
-      fprintf (file,"%s", symbol->name);
-    break;
-  case bfd_print_symbol_more:
-    fprintf (file,"%4x %2x %2x",(unsigned) (aout_symbol(symbol)->desc & 0xffff),
-            (unsigned) (aout_symbol(symbol)->other & 0xff),
-            (unsigned) (aout_symbol(symbol)->type));
-    break;
-  case bfd_print_symbol_all:
-    {
-   CONST char *section_name = symbol->section->name;
-
-      bfd_print_symbol_vandf((PTR)file,symbol);
-
-      fprintf (file," %-5s %04x %02x %02x",
-              section_name,
-              (unsigned) (aout_symbol(symbol)->desc & 0xffff),
-              (unsigned) (aout_symbol(symbol)->other & 0xff),
-              (unsigned) (aout_symbol(symbol)->type  & 0xff));
+  switch (how)
+    {
+    case bfd_print_symbol_name:
       if (symbol->name)
-        fprintf (file," %s", symbol->name);
-    }
-    break;
-  }
+        fprintf (file,"%s", symbol->name);
+      break;
+    case bfd_print_symbol_more:
+      fprintf (file,"%4x %2x %2x",
+               (unsigned) (aout_symbol (symbol)->desc & 0xffff),
+               (unsigned) (aout_symbol (symbol)->other & 0xff),
+               (unsigned) (aout_symbol (symbol)->type));
+      break;
+    case bfd_print_symbol_all:
+      {
+        const char *section_name = symbol->section->name;
+
+        bfd_print_symbol_vandf (abfd, (PTR)file, symbol);
+
+        fprintf (file," %-5s %04x %02x %02x",
+                 section_name,
+                 (unsigned) (aout_symbol (symbol)->desc & 0xffff),
+                 (unsigned) (aout_symbol (symbol)->other & 0xff),
+                 (unsigned) (aout_symbol (symbol)->type & 0xff));
+        if (symbol->name)
+          fprintf (file," %s", symbol->name);
+      }
+      break;
+    }
 }
 
@@ -2657 +2720 @@
 NAME(aout,read_minisymbols) (abfd, dynamic, minisymsp, sizep)
      bfd *abfd;
-     boolean dynamic;
+     bfd_boolean dynamic;
      PTR *minisymsp;
      unsigned int *sizep;
@@ -2693 +2756 @@
 NAME(aout,minisymbol_to_symbol) (abfd, dynamic, minisym, sym)
      bfd *abfd;
-     boolean dynamic;
+     bfd_boolean dynamic;
      const PTR minisym;
      asymbol *sym;
@@ -2711 +2774 @@
           obj_aout_external_strings (abfd),
           obj_aout_external_string_size (abfd),
-          false)))
+          FALSE)))
     return NULL;
 
@@ -2717 +2780 @@
 }
 
-/*
- provided a BFD, a section and an offset into the section, calculate
- and return the name of the source file and the line nearest to the
- wanted location.
-*/
-
-boolean
+/* Provided a BFD, a section and an offset into the section, calculate
+   and return the name of the source file and the line nearest to the
+   wanted location.  */
+
+bfd_boolean
 NAME(aout,find_nearest_line)
      (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
@@ -2730 +2791 @@
      asymbol **symbols;
      bfd_vma offset;
-     CONST char **filename_ptr;
-     CONST char **functionname_ptr;
+     const char **filename_ptr;
+     const char **functionname_ptr;
      unsigned int *line_ptr;
 {
-  /* Run down the file looking for the filename, function and linenumber */
+  /* Run down the file looking for the filename, function and linenumber.  */
   asymbol **p;
-  CONST char *directory_name = NULL;
-  CONST char *main_file_name = NULL;
-  CONST char *current_file_name = NULL;
-  CONST char *line_file_name = NULL; /* Value of current_file_name at line number.  */
-  CONST char *line_directory_name = NULL; /* Value of directory_name at line number.  */
+  const char *directory_name = NULL;
+  const char *main_file_name = NULL;
+  const char *current_file_name = NULL;
+  const char *line_file_name = NULL; /* Value of current_file_name at line number.  */
+  const char *line_directory_name = NULL; /* Value of directory_name at line number.  */
   bfd_vma low_line_vma = 0;
   bfd_vma low_func_vma = 0;
   asymbol *func = 0;
-  size_t filelen, funclen;
+  bfd_size_type filelen, funclen;
   char *buf;
 
@@ -2750 +2811 @@
   *functionname_ptr = 0;
   *line_ptr = 0;
-  if (symbols != (asymbol **)NULL) {
-    for (p = symbols; *p; p++) {
-      aout_symbol_type  *q = (aout_symbol_type *) (*p);
-    next:
-      switch (q->type){
-      case N_TEXT:
-        /* If this looks like a file name symbol, and it comes after
-           the line number we have found so far, but before the
-           offset, then we have probably not found the right line
-           number.  */
-        if (q->symbol.value <= offset
-            && ((q->symbol.value > low_line_vma
-                 && (line_file_name != NULL
-                     || *line_ptr != 0))
-                || (q->symbol.value > low_func_vma
-                    && func != NULL)))
-          {
-            const char *symname;
-
-            symname = q->symbol.name;
-            if (strcmp (symname + strlen (symname) - 2, ".o") == 0)
+
+  if (symbols != (asymbol **)NULL)
+    {
+      for (p = symbols; *p; p++)
+        {
+          aout_symbol_type  *q = (aout_symbol_type *) (*p);
+        next:
+          switch (q->type)
+            {
+            case N_TEXT:
+              /* If this looks like a file name symbol, and it comes after
+                 the line number we have found so far, but before the
+                 offset, then we have probably not found the right line
+                 number.  */
+              if (q->symbol.value <= offset
+                  && ((q->symbol.value > low_line_vma
+                       && (line_file_name != NULL
+                           || *line_ptr != 0))
+                      || (q->symbol.value > low_func_vma
+                          && func != NULL)))
+                {
+                  const char *symname;
+
+                  symname = q->symbol.name;
+                  if (strcmp (symname + strlen (symname) - 2, ".o") == 0)
+                    {
+                      if (q->symbol.value > low_line_vma)
+                        {
+                          *line_ptr = 0;
+                          line_file_name = NULL;
+                        }
+                      if (q->symbol.value > low_func_vma)
+                        func = NULL;
+                    }
+                }
+              break;
+
+            case N_SO:
+              /* If this symbol is less than the offset, but greater than
+                 the line number we have found so far, then we have not
+                 found the right line number.  */
+              if (q->symbol.value <= offset)
+                {
+                  if (q->symbol.value > low_line_vma)
+                    {
+                      *line_ptr = 0;
+                      line_file_name = NULL;
+                    }
+                  if (q->symbol.value > low_func_vma)
+                    func = NULL;
+                }
+
+              main_file_name = current_file_name = q->symbol.name;
+              /* Look ahead to next symbol to check if that too is an N_SO.  */
+              p++;
+              if (*p == NULL)
+                break;
+              q = (aout_symbol_type *) (*p);
+              if (q->type != (int)N_SO)
+                goto next;
+
+              /* Found a second N_SO  First is directory; second is filename.  */
+              directory_name = current_file_name;
+              main_file_name = current_file_name = q->symbol.name;
+              if (obj_textsec (abfd) != section)
+                goto done;
+              break;
+            case N_SOL:
+              current_file_name = q->symbol.name;
+              break;
+
+            case N_SLINE:
+
+            case N_DSLINE:
+            case N_BSLINE:
+              /* We'll keep this if it resolves nearer than the one we have
+                 already.  */
+              if (q->symbol.value >= low_line_vma
+                  && q->symbol.value <= offset)
+                {
+                  *line_ptr = q->desc;
+                  low_line_vma = q->symbol.value;
+                  line_file_name = current_file_name;
+                  line_directory_name = directory_name;
+                }
+              break;
+            case N_FUN:
               {
-                if (q->symbol.value > low_line_vma)
+                /* We'll keep this if it is nearer than the one we have already.  */
+                if (q->symbol.value >= low_func_vma &&
+                    q->symbol.value <= offset)
                   {
-                    *line_ptr = 0;
-                    line_file_name = NULL;
+                    low_func_vma = q->symbol.value;
+                    func = (asymbol *)q;
                   }
-                if (q->symbol.value > low_func_vma)
-                  func = NULL;
+                else if (q->symbol.value > offset)
+                  goto done;
               }
-          }
-        break;
-
-      case N_SO:
-        /* If this symbol is less than the offset, but greater than
-           the line number we have found so far, then we have not
-           found the right line number.  */
-        if (q->symbol.value <= offset)
-          {
-            if (q->symbol.value > low_line_vma)
-              {
-                *line_ptr = 0;
-                line_file_name = NULL;
-              }
-            if (q->symbol.value > low_func_vma)
-              func = NULL;
-          }
-
-        main_file_name = current_file_name = q->symbol.name;
-        /* Look ahead to next symbol to check if that too is an N_SO.  */
-        p++;
-        if (*p == NULL)
-          break;
-        q = (aout_symbol_type *) (*p);
-        if (q->type != (int)N_SO)
-          goto next;
-
-        /* Found a second N_SO  First is directory; second is filename.  */
-        directory_name = current_file_name;
-        main_file_name = current_file_name = q->symbol.name;
-        if (obj_textsec(abfd) != section)
-          goto done;
-        break;
-      case N_SOL:
-        current_file_name = q->symbol.name;
-        break;
-
-      case N_SLINE:
-
-      case N_DSLINE:
-      case N_BSLINE:
-        /* We'll keep this if it resolves nearer than the one we have
-           already.  */
-        if (q->symbol.value >= low_line_vma
-            && q->symbol.value <= offset)
-          {
-            *line_ptr = q->desc;
-            low_line_vma = q->symbol.value;
-            line_file_name = current_file_name;
-            line_directory_name = directory_name;
-          }
-        break;
-      case N_FUN:
-        {
-          /* We'll keep this if it is nearer than the one we have already */
-          if (q->symbol.value >= low_func_vma &&
-              q->symbol.value <= offset) {
-            low_func_vma = q->symbol.value;
-            func = (asymbol *)q;
-          }
-          else if (q->symbol.value > offset)
-            goto done;
+              break;
+            }
         }
-        break;
-      }
-    }
-  }
+    }
 
  done:
@@ -2861 +2927 @@
   else
     filelen = strlen (directory_name) + strlen (main_file_name);
+
   if (func == NULL)
     funclen = 0;
@@ -2868 +2935 @@
   if (adata (abfd).line_buf != NULL)
     free (adata (abfd).line_buf);
+
   if (filelen + funclen == 0)
     adata (abfd).line_buf = buf = NULL;
@@ -2875 +2943 @@
       adata (abfd).line_buf = buf;
       if (buf == NULL)
-        return false;
+        return FALSE;
     }
 
@@ -2893 +2961 @@
     {
       const char *function = func->name;
-      char *p;
+      char *colon;
 
       /* The caller expects a symbol name.  We actually have a
@@ -2905 +2973 @@
           strcpy (buf + 1, function);
         }
-      /* Have to remove : stuff */
-      p = strchr (buf, ':');
-      if (p != NULL)
-        *p = '\0';
+      /* Have to remove : stuff.  */
+      colon = strchr (buf, ':');
+      if (colon != NULL)
+        *colon = '\0';
       *functionname_ptr = buf;
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -2918 +2986 @@
 NAME(aout,sizeof_headers) (abfd, execable)
      bfd *abfd;
-     boolean execable ATTRIBUTE_UNUSED;
-{
-  return adata(abfd).exec_bytes_size;
+     bfd_boolean execable ATTRIBUTE_UNUSED;
+{
+  return adata (abfd).exec_bytes_size;
 }
 
@@ -2926 +2994 @@
    read it again later if we need it.  */
 
-boolean
+bfd_boolean
 NAME(aout,bfd_free_cached_info) (abfd)
      bfd *abfd;
@@ -2934 +3002 @@
   if (bfd_get_format (abfd) != bfd_object
       || abfd->tdata.aout_data == NULL)
-    return true;
+    return TRUE;
 
 #define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
@@ -2951 +3019 @@
 #undef BFCI_FREE
 
-  return true;
+  return TRUE;
 }
 
@@ -2957 +3025 @@
 /* a.out link code.  */
 
-static boolean aout_link_add_object_symbols
+static bfd_boolean aout_link_add_object_symbols
   PARAMS ((bfd *, struct bfd_link_info *));
-static boolean aout_link_check_archive_element
-  PARAMS ((bfd *, struct bfd_link_info *, boolean *));
-static boolean aout_link_free_symbols PARAMS ((bfd *));
-static boolean aout_link_check_ar_symbols
-  PARAMS ((bfd *, struct bfd_link_info *, boolean *pneeded));
-static boolean aout_link_add_symbols
+static bfd_boolean aout_link_check_archive_element
+  PARAMS ((bfd *, struct bfd_link_info *, bfd_boolean *));
+static bfd_boolean aout_link_free_symbols
+  PARAMS ((bfd *));
+static bfd_boolean aout_link_check_ar_symbols
+  PARAMS ((bfd *, struct bfd_link_info *, bfd_boolean *pneeded));
+static bfd_boolean aout_link_add_symbols
   PARAMS ((bfd *, struct bfd_link_info *));
 
@@ -2992 +3061 @@
     {
       /* Set local fields.  */
-      ret->written = false;
+      ret->written = FALSE;
       ret->indx = -1;
     }
@@ -3001 +3070 @@
 /* Initialize an a.out link hash table.  */
 
-boolean
+bfd_boolean
 NAME(aout,link_hash_table_init) (table, abfd, newfunc)
      struct aout_link_hash_table *table;
      bfd *abfd;
-     struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
-                                                struct bfd_hash_table *,
-                                                const char *));
+     struct bfd_hash_entry *(*newfunc)
+       PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
+                const char *));
 {
   return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
@@ -3019 +3088 @@
 {
   struct aout_link_hash_table *ret;
-
-  ret = ((struct aout_link_hash_table *)
-         bfd_alloc (abfd, sizeof (struct aout_link_hash_table)));
+  bfd_size_type amt = sizeof (struct aout_link_hash_table);
+
+  ret = (struct aout_link_hash_table *) bfd_malloc (amt);
   if (ret == NULL)
     return (struct bfd_link_hash_table *) NULL;
+
   if (! NAME(aout,link_hash_table_init) (ret, abfd,
                                          NAME(aout,link_hash_newfunc)))
@@ -3036 +3106 @@
    appropriate.  */
 
-boolean
+bfd_boolean
 NAME(aout,link_add_symbols) (abfd, info)
      bfd *abfd;
@@ -3050 +3120 @@
     default:
       bfd_set_error (bfd_error_wrong_format);
-      return false;
+      return FALSE;
     }
 }
@@ -3056 +3126 @@
 /* Add symbols from an a.out object file.  */
 
-static boolean
+static bfd_boolean
 aout_link_add_object_symbols (abfd, info)
      bfd *abfd;
@@ -3062 +3132 @@
 {
   if (! aout_get_external_symbols (abfd))
-    return false;
+    return FALSE;
   if (! aout_link_add_symbols (abfd, info))
-    return false;
+    return FALSE;
   if (! info->keep_memory)
     {
       if (! aout_link_free_symbols (abfd))
-        return false;
-    }
-  return true;
+        return FALSE;
+    }
+  return TRUE;
 }
 
@@ -3078 +3148 @@
    _bfd_generic_link_add_archive_symbols.  */
 
-static boolean
+static bfd_boolean
 aout_link_check_archive_element (abfd, info, pneeded)
      bfd *abfd;
      struct bfd_link_info *info;
-     boolean *pneeded;
+     bfd_boolean *pneeded;
 {
   if (! aout_get_external_symbols (abfd))
-    return false;
+    return FALSE;
 
   if (! aout_link_check_ar_symbols (abfd, info, pneeded))
-    return false;
+    return FALSE;
 
   if (*pneeded)
     {
       if (! aout_link_add_symbols (abfd, info))
-        return false;
+        return FALSE;
     }
 
@@ -3099 +3169 @@
     {
       if (! aout_link_free_symbols (abfd))
-        return false;
-    }
-
-  return true;
+        return FALSE;
+    }
+
+  return TRUE;
 }
 
 /* Free up the internal symbols read from an a.out file.  */
 
-static boolean
+static bfd_boolean
 aout_link_free_symbols (abfd)
      bfd *abfd;
@@ -3129 +3199 @@
       obj_aout_external_strings (abfd) = (char *) NULL;
     }
-  return true;
+  return TRUE;
 }
 
@@ -3139 +3209 @@
    (unless there is some other reason to include it).  */
 
-static boolean
+static bfd_boolean
 aout_link_check_ar_symbols (abfd, info, pneeded)
      bfd *abfd;
      struct bfd_link_info *info;
-     boolean *pneeded;
+     bfd_boolean *pneeded;
 {
   register struct external_nlist *p;
@@ -3149 +3219 @@
   char *strings;
 
-  *pneeded = false;
+  *pneeded = FALSE;
 
   /* Look through all the symbols.  */
@@ -3157 +3227 @@
   for (; p < pend; p++)
     {
-      int type = bfd_h_get_8 (abfd, p->e_type);
+      int type = H_GET_8 (abfd, p->e_type);
       const char *name;
       struct bfd_link_hash_entry *h;
@@ -3179 +3249 @@
 
       name = strings + GET_WORD (abfd, p->e_strx);
-      h = bfd_link_hash_lookup (info->hash, name, false, false, true);
+      h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
 
       /* We are only interested in symbols that are currently
@@ -3204 +3274 @@
           /* This object file defines this symbol.  We must link it
              in.  This is true regardless of whether the current
-             definition of the symbol is undefined or common.  If the
-             current definition is common, we have a case in which we
-             have already seen an object file including
+             definition of the symbol is undefined or common.
+
+             If the current definition is common, we have a case in
+             which we have already seen an object file including:
                  int a;
-             and this object file from the archive includes
+             and this object file from the archive includes:
                  int a = 5;
-             In such a case we must include this object file.
+             In such a case, whether to include this object is target
+             dependant for backward compatability.
 
              FIXME: The SunOS 4.1.3 linker will pull in the archive
              element if the symbol is defined in the .data section,
              but not if it is defined in the .text section.  That
-             seems a bit crazy to me, and I haven't implemented it.
-             However, it might be correct.  */
+             seems a bit crazy to me, and it has not been implemented
+             yet.  However, it might be correct.  */
+          if (h->type == bfd_link_hash_common)
+            {
+              int skip = 0;
+
+              switch (info->common_skip_ar_aymbols)
+                {
+                case bfd_link_common_skip_text:
+                  skip = (type == (N_TEXT | N_EXT));
+                  break;
+                case bfd_link_common_skip_data:
+                  skip = (type == (N_DATA | N_EXT));
+                  break;
+                default:
+                case bfd_link_common_skip_all:
+                  skip = 1;
+                  break;
+                }
+
+              if (skip)
+                continue;
+            }
+
           if (! (*info->callbacks->add_archive_element) (info, abfd, name))
-            return false;
-          *pneeded = true;
-          return true;
+            return FALSE;
+          *pneeded = TRUE;
+          return TRUE;
         }
 
@@ -3247 +3341 @@
                                                                      abfd,
                                                                      name))
-                        return false;
-                      *pneeded = true;
-                      return true;
+                        return FALSE;
+                      *pneeded = TRUE;
+                      return TRUE;
                     }
                   /* Turn the current link symbol into a common
@@ -3258 +3352 @@
                                   sizeof (struct bfd_link_hash_common_entry)));
                   if (h->u.c.p == NULL)
-                    return false;
+                    return FALSE;
 
                   h->u.c.size = value;
@@ -3295 +3389 @@
             {
               if (! (*info->callbacks->add_archive_element) (info, abfd, name))
-                return false;
-              *pneeded = true;
-              return true;
+                return FALSE;
+              *pneeded = TRUE;
+              return TRUE;
             }
         }
@@ -3303 +3397 @@
 
   /* We do not need this object file.  */
-  return true;
+  return TRUE;
 }
 
 /* Add all symbols from an object file to the hash table.  */
 
-static boolean
+static bfd_boolean
 aout_link_add_symbols (abfd, info)
      bfd *abfd;
      struct bfd_link_info *info;
 {
-  boolean (*add_one_symbol) PARAMS ((struct bfd_link_info *, bfd *,
-                                     const char *, flagword, asection *,
-                                     bfd_vma, const char *, boolean,
-                                     boolean,
-                                     struct bfd_link_hash_entry **));
+  bfd_boolean (*add_one_symbol)
+    PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword, asection *,
+             bfd_vma, const char *, bfd_boolean, bfd_boolean,
+             struct bfd_link_hash_entry **));
   struct external_nlist *syms;
   bfd_size_type sym_count;
   char *strings;
-  boolean copy;
+  bfd_boolean copy;
   struct aout_link_hash_entry **sym_hash;
   register struct external_nlist *p;
   struct external_nlist *pend;
+  bfd_size_type amt;
 
   syms = obj_aout_external_syms (abfd);
@@ -3330 +3424 @@
   strings = obj_aout_external_strings (abfd);
   if (info->keep_memory)
-    copy = false;
+    copy = FALSE;
   else
-    copy = true;
+    copy = TRUE;
 
   if (aout_backend_info (abfd)->add_dynamic_symbols != NULL)
@@ -3338 +3432 @@
       if (! ((*aout_backend_info (abfd)->add_dynamic_symbols)
              (abfd, info, &syms, &sym_count, &strings)))
-        return false;
+        return FALSE;
     }
 
@@ -3345 +3439 @@
      table, but keeping the list is more efficient.  Perhaps this
      should be conditional on info->keep_memory.  */
-  sym_hash = ((struct aout_link_hash_entry **)
-              bfd_alloc (abfd,
-                         ((size_t) sym_count
-                          * sizeof (struct aout_link_hash_entry *))));
+  amt = sym_count * sizeof (struct aout_link_hash_entry *);
+  sym_hash = (struct aout_link_hash_entry **) bfd_alloc (abfd, amt);
   if (sym_hash == NULL && sym_count != 0)
-    return false;
+    return FALSE;
   obj_aout_sym_hashes (abfd) = sym_hash;
 
@@ -3370 +3462 @@
       *sym_hash = NULL;
 
-      type = bfd_h_get_8 (abfd, p->e_type);
+      type = H_GET_8 (abfd, p->e_type);
 
       /* Ignore debugging symbols.  */
@@ -3507 +3599 @@
 
       if (! ((*add_one_symbol)
-             (info, abfd, name, flags, section, value, string, copy, false,
+             (info, abfd, name, flags, section, value, string, copy, FALSE,
               (struct bfd_link_hash_entry **) sym_hash)))
-        return false;
+        return FALSE;
 
       /* Restrict the maximum alignment of a common symbol based on
@@ -3535 +3627 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -3566 +3658 @@
 /* Look up an entry in an the header file hash table.  */
 
-#define aout_link_includes_lookup(table, string, create, copy) \
-  ((struct aout_link_includes_entry *) \
+#define aout_link_includes_lookup(table, string, create, copy)          \
+  ((struct aout_link_includes_entry *)                                  \
    bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
 
@@ -3599 +3691 @@
 static struct bfd_hash_entry *aout_link_includes_newfunc
   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
-static boolean aout_link_input_bfd
+static bfd_boolean aout_link_input_bfd
   PARAMS ((struct aout_final_link_info *, bfd *input_bfd));
-static boolean aout_link_write_symbols
+static bfd_boolean aout_link_write_symbols
   PARAMS ((struct aout_final_link_info *, bfd *input_bfd));
-static boolean aout_link_write_other_symbol
+static bfd_boolean aout_link_write_other_symbol
   PARAMS ((struct aout_link_hash_entry *, PTR));
-static boolean aout_link_input_section
+static bfd_boolean aout_link_input_section
   PARAMS ((struct aout_final_link_info *, bfd *input_bfd,
            asection *input_section, file_ptr *reloff_ptr,
            bfd_size_type rel_size));
-static boolean aout_link_input_section_std
+static bfd_boolean aout_link_input_section_std
   PARAMS ((struct aout_final_link_info *, bfd *input_bfd,
            asection *input_section, struct reloc_std_external *,
            bfd_size_type rel_size, bfd_byte *contents));
-static boolean aout_link_input_section_ext
+static bfd_boolean aout_link_input_section_ext
   PARAMS ((struct aout_final_link_info *, bfd *input_bfd,
            asection *input_section, struct reloc_ext_external *,
@@ -3619 +3711 @@
 static INLINE asection *aout_reloc_index_to_section
   PARAMS ((bfd *, int));
-static boolean aout_link_reloc_link_order
+static bfd_boolean aout_link_reloc_link_order
   PARAMS ((struct aout_final_link_info *, asection *,
            struct bfd_link_order *));
@@ -3662 +3754 @@
    the output section.  */
 
-boolean
+bfd_boolean
 NAME(aout,final_link) (abfd, info, callback)
      bfd *abfd;
@@ -3669 +3761 @@
 {
   struct aout_final_link_info aout_info;
-  boolean includes_hash_initialized = false;
+  bfd_boolean includes_hash_initialized = FALSE;
   register bfd *sub;
   bfd_size_type trsize, drsize;
-  size_t max_contents_size;
-  size_t max_relocs_size;
-  size_t max_sym_count;
+  bfd_size_type max_contents_size;
+  bfd_size_type max_relocs_size;
+  bfd_size_type max_sym_count;
   bfd_size_type text_size;
   file_ptr text_end;
   register struct bfd_link_order *p;
   asection *o;
-  boolean have_link_order_relocs;
+  bfd_boolean have_link_order_relocs;
 
   if (info->shared)
@@ -3695 +3787 @@
                                251))
     goto error_return;
-  includes_hash_initialized = true;
+  includes_hash_initialized = TRUE;
 
   /* Figure out the largest section size.  Also, if generating
@@ -3706 +3798 @@
   for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
     {
-      size_t sz;
+      bfd_size_type sz;
 
       if (info->relocateable)
@@ -3818 +3910 @@
 
     h = aout_link_hash_lookup (aout_hash_table (info), "__DYNAMIC",
-                               false, false, false);
+                               FALSE, FALSE, FALSE);
     if (h != NULL)
       aout_link_write_other_symbol (h, &aout_info);
@@ -3845 +3937 @@
      whether we have already handled it.  */
   for (sub = info->input_bfds; sub != (bfd *) NULL; sub = sub->link_next)
-    sub->output_has_begun = false;
+    sub->output_has_begun = FALSE;
 
   /* Mark all sections which are to be included in the link.  This
@@ -3854 +3946 @@
     {
       for (p = o->link_order_head; p != NULL; p = p->next)
-        {
-          if (p->type == bfd_indirect_link_order)
-            p->u.indirect.section->linker_mark = true;
-        }
-    }
-
-  have_link_order_relocs = false;
+        if (p->type == bfd_indirect_link_order)
+          p->u.indirect.section->linker_mark = TRUE;
+    }
+
+  have_link_order_relocs = FALSE;
   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
     {
@@ -3878 +3968 @@
                   if (! aout_link_input_bfd (&aout_info, input_bfd))
                     goto error_return;
-                  input_bfd->output_has_begun = true;
+                  input_bfd->output_has_begun = TRUE;
                 }
             }
@@ -3885 +3975 @@
             {
               /* These are handled below.  */
-              have_link_order_relocs = true;
+              have_link_order_relocs = TRUE;
             }
           else
@@ -3945 +4035 @@
     {
       bfd_hash_table_free (&aout_info.includes.root);
-      includes_hash_initialized = false;
+      includes_hash_initialized = FALSE;
     }
 
@@ -3975 +4065 @@
     {
       bfd_byte b;
+      file_ptr pos;
 
       b = 0;
-      if (bfd_seek (abfd,
-                    (obj_datasec (abfd)->filepos
-                     + exec_hdr (abfd)->a_data
-                     - 1),
-                    SEEK_SET) != 0
-          || bfd_write (&b, 1, 1, abfd) != 1)
+      pos = obj_datasec (abfd)->filepos + exec_hdr (abfd)->a_data - 1;
+      if (bfd_seek (abfd, pos, SEEK_SET) != 0
+          || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
         goto error_return;
     }
 
-  return true;
+  return TRUE;
 
  error_return:
@@ -3999 +4087 @@
   if (includes_hash_initialized)
     bfd_hash_table_free (&aout_info.includes.root);
-  return false;
+  return FALSE;
 }
 
 /* Link an a.out input BFD into the output file.  */
 
-static boolean
+static bfd_boolean
 aout_link_input_bfd (finfo, input_bfd)
      struct aout_final_link_info *finfo;
@@ -4022 +4110 @@
 
   /* Get the symbols.  We probably have them already, unless
-     finfo->info->keep_memory is false.  */
+     finfo->info->keep_memory is FALSE.  */
   if (! aout_get_external_symbols (input_bfd))
-    return false;
+    return FALSE;
 
   sym_count = obj_aout_external_sym_count (input_bfd);
@@ -4031 +4119 @@
      is placed into finfo->symbol_map.  */
   if (! aout_link_write_symbols (finfo, input_bfd))
-    return false;
+    return FALSE;
 
   /* Relocate and write out the sections.  These functions use the
@@ -4043 +4131 @@
                                      &finfo->treloff,
                                      exec_hdr (input_bfd)->a_trsize))
-        return false;
+        return FALSE;
     }
   if (obj_datasec (input_bfd)->linker_mark)
@@ -4051 +4139 @@
                                      &finfo->dreloff,
                                      exec_hdr (input_bfd)->a_drsize))
-        return false;
+        return FALSE;
     }
 
@@ -4060 +4148 @@
     {
       if (! aout_link_free_symbols (input_bfd))
-        return false;
-    }
-
-  return true;
+        return FALSE;
+    }
+
+  return TRUE;
 }
 
@@ -4069 +4157 @@
    symbol indices into a symbol_map.  */
 
-static boolean
+static bfd_boolean
 aout_link_write_symbols (finfo, input_bfd)
      struct aout_final_link_info *finfo;
@@ -4085 +4173 @@
   struct aout_link_hash_entry **sym_hash;
   int *symbol_map;
-  boolean pass;
-  boolean skip_next;
+  bfd_boolean pass;
+  bfd_boolean skip_next;
 
   output_bfd = finfo->output_bfd;
@@ -4100 +4188 @@
       && (strip != strip_some
           || bfd_hash_lookup (finfo->info->keep_hash, input_bfd->filename,
-                              false, false) != NULL)
+                              FALSE, FALSE) != NULL)
       && discard != discard_all)
     {
-      bfd_h_put_8 (output_bfd, N_TEXT, outsym->e_type);
-      bfd_h_put_8 (output_bfd, 0, outsym->e_other);
-      bfd_h_put_16 (output_bfd, (bfd_vma) 0, outsym->e_desc);
+      H_PUT_8 (output_bfd, N_TEXT, outsym->e_type);
+      H_PUT_8 (output_bfd, 0, outsym->e_other);
+      H_PUT_16 (output_bfd, 0, outsym->e_desc);
       strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
-                                       input_bfd->filename, false);
+                                       input_bfd->filename, FALSE);
       if (strtab_index == (bfd_size_type) -1)
-        return false;
+        return FALSE;
       PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
       PUT_WORD (output_bfd,
@@ -4120 +4208 @@
     }
 
-  pass = false;
-  skip_next = false;
+  pass = FALSE;
+  skip_next = FALSE;
   sym = obj_aout_external_syms (input_bfd);
   sym_end = sym + sym_count;
   sym_hash = obj_aout_sym_hashes (input_bfd);
   symbol_map = finfo->symbol_map;
-  memset (symbol_map, 0, sym_count * sizeof *symbol_map);
+  memset (symbol_map, 0, (size_t) sym_count * sizeof *symbol_map);
   for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
     {
@@ -4132 +4220 @@
       int type;
       struct aout_link_hash_entry *h;
-      boolean skip;
+      bfd_boolean skip;
       asection *symsec;
       bfd_vma val = 0;
-      boolean copy;
+      bfd_boolean copy;
 
       /* We set *symbol_map to 0 above for all symbols.  If it has
@@ -4149 +4237 @@
       *symbol_map = -1;
 
-      type = bfd_h_get_8 (input_bfd, sym->e_type);
+      type = H_GET_8 (input_bfd, sym->e_type);
       name = strings + GET_WORD (input_bfd, sym->e_strx);
 
@@ -4159 +4247 @@
              indirect or warning symbol.  */
           val = GET_WORD (input_bfd, sym->e_value);
-          pass = false;
+          pass = FALSE;
         }
       else if (skip_next)
@@ -4166 +4254 @@
              symbol that we have changed to no longer be an indirect
              symbol.  */
-          skip_next = false;
+          skip_next = FALSE;
           continue;
         }
@@ -4181 +4269 @@
           /* Use the name from the hash table, in case the symbol was
              wrapped.  */
-          if (h != NULL)
+          if (h != NULL
+              && h->root.type != bfd_link_hash_warning)
             name = h->root.root.string;
 
@@ -4203 +4292 @@
           /* If the symbol has already been written out, skip it.  */
           if (h != (struct aout_link_hash_entry *) NULL
-              && h->root.type != bfd_link_hash_warning
               && h->written)
             {
               if ((type & N_TYPE) == N_INDR
                   || type == N_WARNING)
-                skip_next = true;
+                skip_next = TRUE;
               *symbol_map = h->indx;
               continue;
@@ -4214 +4302 @@
 
           /* See if we are stripping this symbol.  */
-          skip = false;
+          skip = FALSE;
           switch (strip)
             {
@@ -4221 +4309 @@
             case strip_debugger:
               if (IS_STAB(type))
-                skip = true;
+                skip = TRUE;
               break;
             case strip_some:
-              if (bfd_hash_lookup (finfo->info->keep_hash, name, false, false)
+              if (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
                   == NULL)
-                skip = true;
+                skip = TRUE;
               break;
             case strip_all:
-              skip = true;
+              skip = TRUE;
               break;
             }
@@ -4235 +4323 @@
             {
               if (h != (struct aout_link_hash_entry *) NULL)
-                h->written = true;
+                h->written = TRUE;
               continue;
             }
@@ -4264 +4352 @@
                  the correct definition so the debugger will
                  understand it.  */
-              pass = true;
+              pass = TRUE;
               val = GET_WORD (input_bfd, sym->e_value);
               symsec = NULL;
@@ -4285 +4373 @@
                  which is the target of the indirection.  */
               if ((type & N_TYPE) == N_INDR)
-                skip_next = true;
+                skip_next = TRUE;
 
               symsec = NULL;
@@ -4377 +4465 @@
           if (h != (struct aout_link_hash_entry *) NULL)
             {
-              h->written = true;
+              h->written = TRUE;
               h->indx = obj_aout_external_sym_count (output_bfd);
             }
@@ -4388 +4476 @@
                 {
                 case discard_none:
+                case discard_sec_merge:
                   break;
                 case discard_l:
                   if (!IS_STAB(type)
                       && bfd_is_local_label_name (input_bfd, name))
-                    skip = true;
+                    skip = TRUE;
                   break;
                 case discard_all:
-                  skip = true;
+                  skip = TRUE;
                   break;
                 }
               if (skip)
                 {
-                  pass = false;
+                  pass = FALSE;
                   continue;
                 }
@@ -4411 +4500 @@
              numbers in types (the first number after an open
              parenthesis).  */
-          if (type == N_BINCL)
+          if (type == (int) N_BINCL)
             {
               struct external_nlist *incl_sym;
@@ -4424 +4513 @@
                   int incl_type;
 
-                  incl_type = bfd_h_get_8 (input_bfd, incl_sym->e_type);
-                  if (incl_type == N_EINCL)
+                  incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
+                  if (incl_type == (int) N_EINCL)
                     {
                       if (nest == 0)
@@ -4431 +4520 @@
                       --nest;
                     }
-                  else if (incl_type == N_BINCL)
+                  else if (incl_type == (int) N_BINCL)
                     ++nest;
                   else if (nest == 0)
@@ -4445 +4534 @@
                               /* Skip the file number.  */
                               ++s;
-                              while (isdigit ((unsigned char) *s))
+                              while (ISDIGIT (*s))
                                 ++s;
                               --s;
@@ -4456 +4545 @@
                  same value, then replace this one with an N_EXCL
                  symbol.  */
-              copy = ! finfo->info->keep_memory;
+              copy = (bfd_boolean) (! finfo->info->keep_memory);
               incl_entry = aout_link_includes_lookup (&finfo->includes,
-                                                      name, true, copy);
+                                                      name, TRUE, copy);
               if (incl_entry == NULL)
-                return false;
+                return FALSE;
               for (t = incl_entry->totals; t != NULL; t = t->next)
                 if (t->total == val)
@@ -4472 +4561 @@
                                           sizeof *t));
                   if (t == NULL)
-                    return false;
+                    return FALSE;
                   t->total = val;
                   t->next = incl_entry->totals;
@@ -4484 +4573 @@
                      it to be an N_EXCL entry, and mark all the
                      included symbols to prevent outputting them.  */
-                  type = N_EXCL;
+                  type = (int) N_EXCL;
 
                   nest = 0;
@@ -4493 +4582 @@
                       int incl_type;
 
-                      incl_type = bfd_h_get_8 (input_bfd, incl_sym->e_type);
-                      if (incl_type == N_EINCL)
+                      incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
+                      if (incl_type == (int) N_EINCL)
                         {
                           if (nest == 0)
@@ -4503 +4592 @@
                           --nest;
                         }
-                      else if (incl_type == N_BINCL)
+                      else if (incl_type == (int) N_BINCL)
                         ++nest;
                       else if (nest == 0)
@@ -4514 +4603 @@
       /* Copy this symbol into the list of symbols we are going to
          write out.  */
-      bfd_h_put_8 (output_bfd, type, outsym->e_type);
-      bfd_h_put_8 (output_bfd, bfd_h_get_8 (input_bfd, sym->e_other),
-                   outsym->e_other);
-      bfd_h_put_16 (output_bfd, bfd_h_get_16 (input_bfd, sym->e_desc),
-                    outsym->e_desc);
-      copy = false;
+      H_PUT_8 (output_bfd, type, outsym->e_type);
+      H_PUT_8 (output_bfd, H_GET_8 (input_bfd, sym->e_other), outsym->e_other);
+      H_PUT_16 (output_bfd, H_GET_16 (input_bfd, sym->e_desc), outsym->e_desc);
+      copy = FALSE;
       if (! finfo->info->keep_memory)
         {
@@ -4528 +4615 @@
             name = h->root.root.string;
           else
-            copy = true;
+            copy = TRUE;
         }
       strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
                                        name, copy);
       if (strtab_index == (bfd_size_type) -1)
-        return false;
+        return FALSE;
       PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
       PUT_WORD (output_bfd, val, outsym->e_value);
@@ -4544 +4631 @@
   if (outsym > finfo->output_syms)
     {
-      bfd_size_type outsym_count;
+      bfd_size_type outsym_size;
 
       if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0)
-        return false;
-      outsym_count = outsym - finfo->output_syms;
-      if (bfd_write ((PTR) finfo->output_syms,
-                     (bfd_size_type) EXTERNAL_NLIST_SIZE,
-                     (bfd_size_type) outsym_count, output_bfd)
-          != outsym_count * EXTERNAL_NLIST_SIZE)
-        return false;
-      finfo->symoff += outsym_count * EXTERNAL_NLIST_SIZE;
-    }
-
-  return true;
+        return FALSE;
+      outsym_size = outsym - finfo->output_syms;
+      outsym_size *= EXTERNAL_NLIST_SIZE;
+      if (bfd_bwrite ((PTR) finfo->output_syms, outsym_size, output_bfd)
+          != outsym_size)
+        return FALSE;
+      finfo->symoff += outsym_size;
+    }
+
+  return TRUE;
 }
 
@@ -4563 +4649 @@
    object.  */
 
-static boolean
+static bfd_boolean
 aout_link_write_other_symbol (h, data)
      struct aout_link_hash_entry *h;
@@ -4574 +4660 @@
   struct external_nlist outsym;
   bfd_size_type indx;
+  bfd_size_type amt;
+
+  if (h->root.type == bfd_link_hash_warning)
+    {
+      h = (struct aout_link_hash_entry *) h->root.u.i.link;
+      if (h->root.type == bfd_link_hash_new)
+        return TRUE;
+    }
 
   output_bfd = finfo->output_bfd;
@@ -4588 +4682 @@
 
   if (h->written)
-    return true;
-
-  h->written = true;
+    return TRUE;
+
+  h->written = TRUE;
 
   /* An indx of -2 means the symbol must be written.  */
@@ -4597 +4691 @@
           || (finfo->info->strip == strip_some
               && bfd_hash_lookup (finfo->info->keep_hash, h->root.root.string,
-                                  false, false) == NULL)))
-    return true;
+                                  FALSE, FALSE) == NULL)))
+    return TRUE;
 
   switch (h->root.type)
     {
     default:
+    case bfd_link_hash_warning:
       abort ();
       /* Avoid variable not initialized warnings.  */
-      return true;
+      return TRUE;
     case bfd_link_hash_new:
       /* This can happen for set symbols when sets are not being
          built.  */
-      return true;
+      return TRUE;
     case bfd_link_hash_undefined:
       type = N_UNDF | N_EXT;
@@ -4644 +4739 @@
       val = 0;
     case bfd_link_hash_indirect:
-    case bfd_link_hash_warning:
-      /* FIXME: Ignore these for now.  The circumstances under which
-         they should be written out are not clear to me.  */
-      return true;
-    }
-
-  bfd_h_put_8 (output_bfd, type, outsym.e_type);
-  bfd_h_put_8 (output_bfd, 0, outsym.e_other);
-  bfd_h_put_16 (output_bfd, 0, outsym.e_desc);
+      /* We ignore these symbols, since the indirected symbol is
+         already in the hash table.  */
+      return TRUE;
+    }
+
+  H_PUT_8 (output_bfd, type, outsym.e_type);
+  H_PUT_8 (output_bfd, 0, outsym.e_other);
+  H_PUT_16 (output_bfd, 0, outsym.e_desc);
   indx = add_to_stringtab (output_bfd, finfo->strtab, h->root.root.string,
-                           false);
-  if (indx == (bfd_size_type) -1)
+                           FALSE);
+  if (indx == - (bfd_size_type) 1)
     {
       /* FIXME: No way to handle errors.  */
@@ -4663 +4757 @@
   PUT_WORD (output_bfd, val, outsym.e_value);
 
+  amt = EXTERNAL_NLIST_SIZE;
   if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0
-      || bfd_write ((PTR) &outsym, (bfd_size_type) EXTERNAL_NLIST_SIZE,
-                    (bfd_size_type) 1, output_bfd) != EXTERNAL_NLIST_SIZE)
+      || bfd_bwrite ((PTR) &outsym, amt, output_bfd) != amt)
     {
       /* FIXME: No way to handle errors.  */
@@ -4675 +4769 @@
   ++obj_aout_external_sym_count (output_bfd);
 
-  return true;
+  return TRUE;
 }
 
 /* Link an a.out section into the output file.  */
 
-static boolean
+static bfd_boolean
 aout_link_input_section (finfo, input_bfd, input_section, reloff_ptr,
                          rel_size)
@@ -4697 +4791 @@
                                   (PTR) finfo->contents,
                                   (file_ptr) 0, input_size))
-    return false;
+    return FALSE;
 
   /* Read in the relocs if we haven't already done it.  */
@@ -4709 +4803 @@
         {
           if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
-              || bfd_read (relocs, 1, rel_size, input_bfd) != rel_size)
-            return false;
+              || bfd_bread (relocs, rel_size, input_bfd) != rel_size)
+            return FALSE;
         }
     }
@@ -4720 +4814 @@
                                          (struct reloc_std_external *) relocs,
                                          rel_size, finfo->contents))
-        return false;
+        return FALSE;
     }
   else
@@ -4727 +4821 @@
                                          (struct reloc_ext_external *) relocs,
                                          rel_size, finfo->contents))
-        return false;
+        return FALSE;
     }
 
@@ -4734 +4828 @@
                                   input_section->output_section,
                                   (PTR) finfo->contents,
-                                  input_section->output_offset,
+                                  (file_ptr) input_section->output_offset,
                                   input_size))
-    return false;
+    return FALSE;
 
   /* If we are producing relocateable output, the relocs were
@@ -4743 +4837 @@
     {
       if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
-        return false;
-      if (bfd_write (relocs, (bfd_size_type) 1, rel_size, finfo->output_bfd)
-          != rel_size)
-        return false;
+        return FALSE;
+      if (bfd_bwrite (relocs, rel_size, finfo->output_bfd) != rel_size)
+        return FALSE;
       *reloff_ptr += rel_size;
 
@@ -4758 +4851 @@
     }
 
-  return true;
+  return TRUE;
 }
 
@@ -4788 +4881 @@
 /* Relocate an a.out section using standard a.out relocs.  */
 
-static boolean
+static bfd_boolean
 aout_link_input_section_std (finfo, input_bfd, input_section, relocs,
                              rel_size, contents)
@@ -4798 +4891 @@
      bfd_byte *contents;
 {
-  boolean (*check_dynamic_reloc) PARAMS ((struct bfd_link_info *,
-                                          bfd *, asection *,
-                                          struct aout_link_hash_entry *,
-                                          PTR, bfd_byte *, boolean *,
-                                          bfd_vma *));
+  bfd_boolean (*check_dynamic_reloc)
+    PARAMS ((struct bfd_link_info *, bfd *, asection *,
+             struct aout_link_hash_entry *, PTR, bfd_byte *, bfd_boolean *,
+             bfd_vma *));
   bfd *output_bfd;
-  boolean relocateable;
+  bfd_boolean relocateable;
   struct external_nlist *syms;
   char *strings;
@@ -4844 +4936 @@
 
 #ifdef MY_reloc_howto
-      howto = MY_reloc_howto(input_bfd, rel, r_index, r_extern, r_pcrel);
+      howto = MY_reloc_howto (input_bfd, rel, r_index, r_extern, r_pcrel);
 #else
       {
@@ -4854 +4946 @@
         if (bfd_header_big_endian (input_bfd))
           {
-            r_index   =  ((rel->r_index[0] << 16)
-                          | (rel->r_index[1] << 8)
+            r_index   =  (((unsigned int) rel->r_index[0] << 16)
+                          | ((unsigned int) rel->r_index[1] << 8)
                           | rel->r_index[2]);
             r_extern  = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
@@ -4867 +4959 @@
         else
           {
-            r_index   = ((rel->r_index[2] << 16)
-                         | (rel->r_index[1] << 8)
+            r_index   = (((unsigned int) rel->r_index[2] << 16)
+                         | ((unsigned int) rel->r_index[1] << 8)
                          | rel->r_index[0]);
             r_extern  = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
@@ -4951 +5043 @@
                             {
                               h->indx = -2;
-                              h->written = false;
+                              h->written = FALSE;
                               if (! aout_link_write_other_symbol (h,
                                                                   (PTR) finfo))
-                                return false;
+                                return FALSE;
                             }
                           r_index = h->indx;
@@ -4967 +5059 @@
                                  (finfo->info, name, input_bfd, input_section,
                                   r_addr)))
-                            return false;
+                            return FALSE;
                           r_index = 0;
                         }
@@ -5027 +5119 @@
       else
         {
-          boolean hundef;
+          bfd_boolean hundef;
 
           /* We are generating an executable, and must do a full
              relocation.  */
-          hundef = false;
+          hundef = FALSE;
 
           if (r_extern)
@@ -5050 +5142 @@
               else
                 {
-                  hundef = true;
+                  hundef = TRUE;
                   relocation = 0;
                 }
@@ -5068 +5160 @@
           if (check_dynamic_reloc != NULL)
             {
-              boolean skip;
+              bfd_boolean skip;
 
               if (! ((*check_dynamic_reloc)
                      (finfo->info, input_bfd, input_section, h,
                       (PTR) rel, contents, &skip, &relocation)))
-                return false;
+                return FALSE;
               if (skip)
                 continue;
@@ -5091 +5183 @@
               if (! ((*finfo->info->callbacks->undefined_symbol)
                      (finfo->info, name, input_bfd, input_section,
-                     r_addr, true)))
-                return false;
+                     r_addr, TRUE)))
+                return FALSE;
             }
 
@@ -5127 +5219 @@
                        (finfo->info, name, howto->name,
                         (bfd_vma) 0, input_bfd, input_section, r_addr)))
-                  return false;
+                  return FALSE;
               }
               break;
@@ -5134 +5226 @@
     }
 
-  return true;
+  return TRUE;
 }
 
 /* Relocate an a.out section using extended a.out relocs.  */
 
-static boolean
+static bfd_boolean
 aout_link_input_section_ext (finfo, input_bfd, input_section, relocs,
                              rel_size, contents)
@@ -5149 +5241 @@
      bfd_byte *contents;
 {
-  boolean (*check_dynamic_reloc) PARAMS ((struct bfd_link_info *,
-                                          bfd *, asection *,
-                                          struct aout_link_hash_entry *,
-                                          PTR, bfd_byte *, boolean *,
-                                          bfd_vma *));
+  bfd_boolean (*check_dynamic_reloc)
+    PARAMS ((struct bfd_link_info *, bfd *, asection *,
+             struct aout_link_hash_entry *, PTR, bfd_byte *, bfd_boolean *,
+             bfd_vma *));
   bfd *output_bfd;
-  boolean relocateable;
+  bfd_boolean relocateable;
   struct external_nlist *syms;
   char *strings;
@@ -5195 +5286 @@
       if (bfd_header_big_endian (input_bfd))
         {
-          r_index  = ((rel->r_index[0] << 16)
-                      | (rel->r_index[1] << 8)
+          r_index  = (((unsigned int) rel->r_index[0] << 16)
+                      | ((unsigned int) rel->r_index[1] << 8)
                       | rel->r_index[2]);
           r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
@@ -5204 +5295 @@
       else
         {
-          r_index  = ((rel->r_index[2] << 16)
-                      | (rel->r_index[1] << 8)
+          r_index  = (((unsigned int) rel->r_index[2] << 16)
+                      | ((unsigned int) rel->r_index[1] << 8)
                       | rel->r_index[0]);
           r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
@@ -5221 +5312 @@
              modify the reloc accordingly.  */
           if (r_extern
-              || r_type == RELOC_BASE10
-              || r_type == RELOC_BASE13
-              || r_type == RELOC_BASE22)
+              || r_type == (unsigned int) RELOC_BASE10
+              || r_type == (unsigned int) RELOC_BASE13
+              || r_type == (unsigned int) RELOC_BASE22)
             {
               /* If we know the symbol this relocation is against,
                  convert it into a relocation against a section.  This
                  is what the native linker does.  */
-              if (r_type == RELOC_BASE10
-                  || r_type == RELOC_BASE13
-                  || r_type == RELOC_BASE22)
+              if (r_type == (unsigned int) RELOC_BASE10
+                  || r_type == (unsigned int) RELOC_BASE13
+                  || r_type == (unsigned int) RELOC_BASE22)
                 h = NULL;
               else
@@ -5289 +5380 @@
                             {
                               h->indx = -2;
-                              h->written = false;
+                              h->written = FALSE;
                               if (! aout_link_write_other_symbol (h,
                                                                   (PTR) finfo))
-                                return false;
+                                return FALSE;
                             }
                           r_index = h->indx;
@@ -5305 +5396 @@
                                  (finfo->info, name, input_bfd, input_section,
                                   r_addr)))
-                            return false;
+                            return FALSE;
                           r_index = 0;
                         }
@@ -5370 +5461 @@
       else
         {
-          boolean hundef;
+          bfd_boolean hundef;
           bfd_reloc_status_type r;
 
           /* We are generating an executable, and must do a full
              relocation.  */
-          hundef = false;
+          hundef = FALSE;
 
           if (r_extern)
@@ -5394 +5485 @@
               else
                 {
-                  hundef = true;
+                  hundef = TRUE;
                   relocation = 0;
                 }
             }
-          else if (r_type == RELOC_BASE10
-                   || r_type == RELOC_BASE13
-                   || r_type == RELOC_BASE22)
+          else if (r_type == (unsigned int) RELOC_BASE10
+                   || r_type == (unsigned int) RELOC_BASE13
+                   || r_type == (unsigned int) RELOC_BASE22)
             {
               struct external_nlist *sym;
@@ -5408 +5499 @@
                  into the symbol table, even if r_extern is 0.  */
               sym = syms + r_index;
-              type = bfd_h_get_8 (input_bfd, sym->e_type);
+              type = H_GET_8 (input_bfd, sym->e_type);
               if ((type & N_TYPE) == N_TEXT
                   || type == N_WEAKT)
@@ -5467 +5558 @@
           if (check_dynamic_reloc != NULL)
             {
-              boolean skip;
+              bfd_boolean skip;
 
               if (! ((*check_dynamic_reloc)
                      (finfo->info, input_bfd, input_section, h,
                       (PTR) rel, contents, &skip, &relocation)))
-                return false;
+                return FALSE;
               if (skip)
                 continue;
@@ -5482 +5573 @@
           if (hundef
               && ! finfo->info->shared
-              && r_type != RELOC_BASE10
-              && r_type != RELOC_BASE13
-              && r_type != RELOC_BASE22)
+              && r_type != (unsigned int) RELOC_BASE10
+              && r_type != (unsigned int) RELOC_BASE13
+              && r_type != (unsigned int) RELOC_BASE22)
             {
               const char *name;
@@ -5494 +5585 @@
               if (! ((*finfo->info->callbacks->undefined_symbol)
                      (finfo->info, name, input_bfd, input_section,
-                     r_addr, true)))
-                return false;
+                     r_addr, TRUE)))
+                return FALSE;
             }
 
-          if (r_type != RELOC_SPARC_REV32)
+          if (r_type != (unsigned int) RELOC_SPARC_REV32)
             r = MY_final_link_relocate (howto_table_ext + r_type,
                                         input_bfd, input_section,
@@ -5527 +5618 @@
                       name = h->root.root.string;
                     else if (r_extern
-                             || r_type == RELOC_BASE10
-                             || r_type == RELOC_BASE13
-                             || r_type == RELOC_BASE22)
+                             || r_type == (unsigned int) RELOC_BASE10
+                             || r_type == (unsigned int) RELOC_BASE13
+                             || r_type == (unsigned int) RELOC_BASE22)
                       name = strings + GET_WORD (input_bfd,
                                                  syms[r_index].e_strx);
@@ -5542 +5633 @@
                            (finfo->info, name, howto_table_ext[r_type].name,
                             r_addend, input_bfd, input_section, r_addr)))
-                      return false;
+                      return FALSE;
                   }
                   break;
@@ -5550 +5641 @@
     }
 
-  return true;
+  return TRUE;
 }
 
 /* Handle a link order which is supposed to generate a reloc.  */
 
-static boolean
+static bfd_boolean
 aout_link_reloc_link_order (finfo, o, p)
      struct aout_final_link_info *finfo;
@@ -5569 +5660 @@
   struct reloc_ext_external erel;
   PTR rel_ptr;
+  bfd_size_type amt;
 
   pr = p->u.reloc.p;
@@ -5591 +5683 @@
       h = ((struct aout_link_hash_entry *)
            bfd_wrapped_link_hash_lookup (finfo->output_bfd, finfo->info,
-                                         pr->u.name, false, false, true));
+                                         pr->u.name, FALSE, FALSE, TRUE));
       if (h != (struct aout_link_hash_entry *) NULL
           && h->indx >= 0)
@@ -5602 +5694 @@
              symbol.  */
           h->indx = -2;
-          h->written = false;
+          h->written = FALSE;
           if (! aout_link_write_other_symbol (h, (PTR) finfo))
-            return false;
+            return FALSE;
           r_index = h->indx;
         }
@@ -5612 +5704 @@
                  (finfo->info, pr->u.name, (bfd *) NULL,
                   (asection *) NULL, (bfd_vma) 0)))
-            return false;
+            return FALSE;
           r_index = 0;
         }
@@ -5621 +5713 @@
     {
       bfd_set_error (bfd_error_bad_value);
-      return false;
+      return FALSE;
     }
 
@@ -5634 +5726 @@
     {
 #ifdef MY_put_reloc
-      MY_put_reloc(finfo->output_bfd, r_extern, r_index, p->offset, howto,
-                   &srel);
+      MY_put_reloc (finfo->output_bfd, r_extern, r_index, p->offset, howto,
+                    &srel);
 #else
       {
@@ -5644 +5736 @@
         int r_length;
 
-        r_pcrel = howto->pc_relative;
+        r_pcrel = (int) howto->pc_relative;
         r_baserel = (howto->type & 8) != 0;
         r_jmptable = (howto->type & 16) != 0;
@@ -5691 +5783 @@
           bfd_reloc_status_type r;
           bfd_byte *buf;
-          boolean ok;
+          bfd_boolean ok;
 
           size = bfd_get_reloc_size (howto);
           buf = (bfd_byte *) bfd_zmalloc (size);
           if (buf == (bfd_byte *) NULL)
-            return false;
+            return FALSE;
           r = MY_relocate_contents (howto, finfo->output_bfd,
-                                      pr->addend, buf);
+                                    (bfd_vma) pr->addend, buf);
           switch (r)
             {
@@ -5717 +5809 @@
                 {
                   free (buf);
-                  return false;
+                  return FALSE;
                 }
               break;
             }
-          ok = bfd_set_section_contents (finfo->output_bfd, o,
-                                         (PTR) buf,
-                                         (file_ptr) p->offset,
-                                         size);
+          ok = bfd_set_section_contents (finfo->output_bfd, o, (PTR) buf,
+                                         (file_ptr) p->offset, size);
           free (buf);
           if (! ok)
-            return false;
+            return FALSE;
         }
     }
@@ -5757 +5847 @@
         }
 
-      PUT_WORD (finfo->output_bfd, pr->addend, erel.r_addend);
+      PUT_WORD (finfo->output_bfd, (bfd_vma) pr->addend, erel.r_addend);
 #endif /* MY_put_ext_reloc */
 
@@ -5763 +5853 @@
     }
 
+  amt = obj_reloc_entry_size (finfo->output_bfd);
   if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
-      || (bfd_write (rel_ptr, (bfd_size_type) 1,
-                     obj_reloc_entry_size (finfo->output_bfd),
-                     finfo->output_bfd)
-          != obj_reloc_entry_size (finfo->output_bfd)))
-    return false;
+      || bfd_bwrite (rel_ptr, amt, finfo->output_bfd) != amt)
+    return FALSE;
 
   *reloff_ptr += obj_reloc_entry_size (finfo->output_bfd);
@@ -5779 +5867 @@
                       <= obj_datasec (finfo->output_bfd)->rel_filepos)));
 
-  return true;
-}
+  return TRUE;
+}