/* BFD back-end for PDP-11 a.out binaries.

   Copyright (C) 2001-2025 Free Software Foundation, Inc.

   This file is part of BFD, the Binary File Descriptor library.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA. */

/* BFD backend for PDP-11, running 2.11BSD in particular.

   This file was hacked up by looking hard at the existing vaxnetbsd

   back end and the header files in 2.11BSD.  The symbol table format

   of 2.11BSD has been extended to accommodate .stab symbols.  See

   struct pdp11_external_nlist below for details.

   TODO

   * support for V7 file formats

   * support for overlay object files (see 2.11 a.out(5))

   * support for old and very old archives

   (see 2.11 ar(5), historical section)

   Search for TODO to find other areas needing more work.  */

#define BYTES_IN_WORD 2

#define BYTES_IN_LONG 4

#define ARCH_SIZE 16

#undef TARGET_IS_BIG_ENDIAN_P

#define TARGET_PAGE_SIZE  8192

#define SEGMENT__SIZE TARGET_PAGE_SIZE

#define DEFAULT_ARCH  bfd_arch_pdp11

#define DEFAULT_MID M_PDP11

/* Do not "beautify" the CONCAT* macro args.  Traditional C will not

   remove whitespace added here, and thus will fail to concatenate

   the tokens.  */

#define MY(OP) CONCAT2 (pdp11_aout_,OP)

/* This needs to start with a.out so GDB knows it is an a.out variant.  */

#define TARGETNAME "a.out-pdp11"

/* This is the normal load address for executables.  */

#define TEXT_START_ADDR   0

/* The header is not included in the text segment.  */

#define N_HEADER_IN_TEXT(x) 0

/* There is no flags field.  */

#define N_FLAGS(execp)    0

#define N_SET_FLAGS(execp, flags) do { } while (0)

#define N_BADMAG(x) (N_MAGIC(x) != OMAGIC  \

         && N_MAGIC(x) != NMAGIC  \

         && N_MAGIC(x) != IMAGIC  \

         && N_MAGIC(x) != ZMAGIC)

#include "sysdep.h"

#include <limits.h>

#include "bfd.h"

#define external_exec pdp11_external_exec

struct pdp11_external_exec

{

  bfd_byte e_info[2];   /* Magic number.  */

  bfd_byte e_text[2];   /* Length of text section in bytes.  */

  bfd_byte e_data[2];   /* Length of data section in bytes.  */

  bfd_byte e_bss[2];    /* Length of bss area in bytes.  */

  bfd_byte e_syms[2];   /* Length of symbol table in bytes.  */

  bfd_byte e_entry[2];    /* Start address.  */

  bfd_byte e_unused[2];   /* Not used.  */

  bfd_byte e_flag[2];   /* Relocation info stripped.  */

  bfd_byte e_relocatable; /* Ugly hack.  */

};

#define EXEC_BYTES_SIZE (8 * 2)

#define A_MAGIC1  OMAGIC

#define OMAGIC    0407  /* ...object file or impure executable.  */

#define A_MAGIC2  NMAGIC

#define NMAGIC    0410  /* Pure executable.  */

#define ZMAGIC    0413  /* Demand-paged executable.  */

#define IMAGIC    0411  /* Separated I&D.  */

#define A_MAGIC3  IMAGIC

#define A_MAGIC4  0405  /* Overlay.  */

#define A_MAGIC5  0430  /* Auto-overlay (nonseparate).  */

#define A_MAGIC6  0431  /* Auto-overlay (separate).  */

#define QMAGIC    0

#define BMAGIC    0

#define A_FLAG_RELOC_STRIPPED 0x0001

/* The following struct defines the format of an entry in the object file

   symbol table.  In the original 2.11BSD struct the index into the string

   table is stored as a long, but the PDP11 C convention for storing a long in

   memory placed the most significant word first even though the bytes within a

   word are stored least significant first.  So here the string table index is

   considered to be just 16 bits and the first two bytes of the struct were

   previously named e_unused.  To extend the symbol table format to accommodate

   .stab symbols, the e_unused bytes are renamed e_desc to store the desc field

   of the .stab symbol.  The GDP Project's STABS document says that the "other"

   field is almost always unused and can be set to zero; the only nonzero cases

   identified were for stabs in their own sections, which does not apply for

   pdp11 a.out format, and for a special case of GNU Modula2 which is not

   supported for the PDP11.  */

#define external_nlist pdp11_external_nlist

struct pdp11_external_nlist

{

  bfd_byte e_desc[2];   /* The desc field for .stab symbols, else 0.  */

  bfd_byte e_strx[2];   /* Index into string table of name.  */

  bfd_byte e_type[1];   /* Type of symbol.  */

  bfd_byte e_ovly[1];   /* Overlay number.  */

  bfd_byte e_value[2];    /* Value of symbol.  */

};

#define EXTERNAL_NLIST_SIZE 8

#define N_TXTOFF(x) (EXEC_BYTES_SIZE)

#define N_DATOFF(x) (N_TXTOFF(x) + (x)->a_text)

#define N_TRELOFF(x)  (N_DATOFF(x) + (x)->a_data)

#define N_DRELOFF(x)  (N_TRELOFF(x) + (x)->a_trsize)

#define N_SYMOFF(x) (N_DRELOFF(x) + (x)->a_drsize)

#define N_STROFF(x) (N_SYMOFF(x) + (x)->a_syms)

#define WRITE_HEADERS(abfd, execp) pdp11_aout_write_headers (abfd, execp)

#include "libbfd.h"

#include "libaout.h"

#define SWAP_MAGIC(ext) bfd_getl16 (ext)

#define MY_entry_is_text_address 1

#define MY_write_object_contents MY(write_object_contents)

static bool MY(write_object_contents) (bfd *);

#define MY_text_includes_header 1

#define MY_BFD_TARGET

#include "aout-target.h"

/* Start of modified aoutx.h.  */

#define KEEPIT udata.i

#include <string.h>   /* For strchr and friends.  */

#include "bfd.h"

#include "sysdep.h"

#include "safe-ctype.h"

#include "bfdlink.h"

#include "libaout.h"

#include "aout/aout64.h"

#include "aout/stab_gnu.h"

#include "aout/ar.h"

/* The symbol type numbers for the 16-bit a.out format from 2.11BSD differ from

   those defined in aout64.h so we must redefine them here.  N_EXT changes from

   0x01 to 0x20 which creates a conflict with some .stab values, in particular

   between undefined externals (N_UNDF+N_EXT) vs. global variables (N_GYSM) and

   between external bss symbols (N_BSS+N_EXT) vs. function names (N_FUN).  We

   disambiguate those conflicts with a hack in is_stab() to look for the ':' in

   the global variable or function name string.  */

#undef N_TYPE

#undef N_UNDF

#undef N_ABS

#undef N_TEXT

#undef N_DATA

#undef N_BSS

#undef N_REG

#undef N_FN

#undef N_EXT

#undef N_STAB

#define N_TYPE    0x1f  /* Type mask.  */

#define N_UNDF    0x00  /* Undefined.  */

#define N_ABS   0x01  /* Absolute.  */

#define N_TEXT    0x02  /* Text segment.  */

#define N_DATA    0x03  /* Data segment.  */

#define N_BSS   0x04  /* Bss segment.  */

#define N_REG   0x14  /* Register symbol.  */

#define N_FN    0x1f  /* File name.  */

#define N_EXT   0x20  /* External flag.  */

/* Type numbers from .stab entries that could conflict:

  N_GSYM    0x20     Global variable [conflict with external undef]

  N_FNAME   0x22     Function name (for BSD Fortran) [ignored]

  N_FUN   0x24     Function name [conflict with external BSS]

  N_NOMAP   0x34     No DST map for sym. [ext. reg. doesn't exist]

*/

#define RELOC_SIZE 2

#define RELFLG    0x0001  /* PC-relative flag.  */

#define RTYPE   0x000e  /* Type mask.  */

#define RIDXMASK  0xfff0  /* Index mask.  */

#define RABS    0x00  /* Absolute.  */

#define RTEXT   0x02  /* Text.  */

#define RDATA   0x04  /* Data.  */

#define RBSS    0x06  /* Bss.  */

#define REXT    0x08  /* External.  */

#define RINDEX(x) (((x) & 0xfff0) >> 4)

#ifndef MY_final_link_relocate

#define MY_final_link_relocate _bfd_final_link_relocate

#endif

#ifndef MY_relocate_contents

#define MY_relocate_contents _bfd_relocate_contents

#endif

/* A hash table used for header files with N_BINCL entries.  */

struct aout_link_includes_table

{

  struct bfd_hash_table root;

};

/* A linked list of totals that we have found for a particular header

   file.  */

struct aout_link_includes_totals

{

  struct aout_link_includes_totals *next;

  bfd_vma total;

};

/* An entry in the header file hash table.  */

struct aout_link_includes_entry

{

  struct bfd_hash_entry root;

  /* List of totals we have found for this file.  */

  struct aout_link_includes_totals *totals;

};

/* During the final link step we need to pass around a bunch of

   information, so we do it in an instance of this structure.  */

struct aout_final_link_info

{

  /* General link information.  */

  struct bfd_link_info *info;

  /* Output bfd.  */

  bfd *output_bfd;

  /* Reloc file positions.  */

  file_ptr treloff, dreloff;

  /* File position of symbols.  */

  file_ptr symoff;

  /* String table.  */

  struct bfd_strtab_hash *strtab;

  /* Header file hash table.  */

  struct aout_link_includes_table includes;

  /* A buffer large enough to hold the contents of any section.  */

  bfd_byte *contents;

  /* A buffer large enough to hold the relocs of any section.  */

  void * relocs;

  /* A buffer large enough to hold the symbol map of any input BFD.  */

  int *symbol_map;

  /* A buffer large enough to hold output symbols of any input BFD.  */

  struct external_nlist *output_syms;

};

/* Copy of the link_info.separate_code boolean to select the output format with

   separate instruction and data spaces selected by --imagic */

static bool separate_i_d = false;

reloc_howto_type howto_table_pdp11[] =

{

  /* type        rs size bsz  pcrel bitpos ovrf       sf name     part_inpl readmask  setmask    pcdone */

HOWTO( 0,        0,  2,  16,  false, 0, complain_overflow_dont,0,"16",  true, 0x0000ffff,0x0000ffff, false),

HOWTO( 1,        0,  2,  16,  true,  0, complain_overflow_dont,0,"DISP16",  true, 0x0000ffff,0x0000ffff, false),

HOWTO( 2,        0,  4,  32,  false, 0, complain_overflow_dont,0,"32",  true, 0x0000ffff,0x0000ffff, false),

};

#define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))

static bool aout_link_check_archive_element (bfd *, struct bfd_link_info *,

               struct bfd_link_hash_entry *,

               const char *, bool *);

static bool aout_link_add_object_symbols (bfd *, struct bfd_link_info *);

static bool aout_link_add_symbols (bfd *, struct bfd_link_info *);

static bool aout_link_write_symbols (struct aout_final_link_info *, bfd *);

reloc_howto_type *

NAME (aout, reloc_type_lookup) (bfd * abfd ATTRIBUTE_UNUSED,

        bfd_reloc_code_real_type code)

{

  switch (code)

    {

    case BFD_RELOC_16:

      return &howto_table_pdp11[0];

    case BFD_RELOC_16_PCREL:

      return &howto_table_pdp11[1];

    case BFD_RELOC_32:

      return &howto_table_pdp11[2];

    default:

      return NULL;

    }

}

reloc_howto_type *

NAME (aout, reloc_name_lookup) (bfd *abfd ATTRIBUTE_UNUSED,

              const char *r_name)

{

  unsigned int i;

  for (i = 0;

       i < sizeof (howto_table_pdp11) / sizeof (howto_table_pdp11[0]);

       i++)

    if (howto_table_pdp11[i].name != NULL

  && strcasecmp (howto_table_pdp11[i].name, r_name) == 0)

      return &howto_table_pdp11[i];

  return NULL;

}

/* Disambiguate conflicts between normal symbol types and .stab symbol types

   (undefined externals N_UNDF+N_EXT vs. global variables N_GYSM and external

   bss symbols N_BSS+N_EXT vs. function names N_FUN) with a hack to look for

   the ':' in the global variable or function name string.  */

static int

is_stab (int type, const char *name)

{

  if (type == N_GSYM || type == N_FUN)

    return strchr (name, ':') != NULL;

  return type > N_FUN;

}

static int

pdp11_aout_write_headers (bfd *abfd, struct internal_exec *execp)

{

  struct external_exec exec_bytes;

  if (adata(abfd).magic == undecided_magic)

    NAME (aout, adjust_sizes_and_vmas) (abfd);

  execp->a_syms = bfd_get_symcount (abfd) * EXTERNAL_NLIST_SIZE;

  execp->a_entry = bfd_get_start_address (abfd);

  if (obj_textsec (abfd)->reloc_count > 0

      || obj_datasec (abfd)->reloc_count > 0)

    {

      execp->a_trsize = execp->a_text;

      execp->a_drsize = execp->a_data;

    }

  else

    {

      execp->a_trsize = 0;

      execp->a_drsize = 0;

    }

  if (!NAME (aout, swap_exec_header_out) (abfd, execp, & exec_bytes))

    return false;

  if (bfd_seek (abfd, 0, SEEK_SET) != 0)

    return false;

  if (bfd_write (&exec_bytes, EXEC_BYTES_SIZE, abfd) != EXEC_BYTES_SIZE)

    return false;

  /* Now write out reloc info, followed by syms and strings.  */

  if (bfd_get_outsymbols (abfd) != NULL

      && bfd_get_symcount (abfd) != 0)

    {

      if (bfd_seek (abfd, N_SYMOFF (execp), SEEK_SET) != 0)

  return false;

      if (! NAME (aout, write_syms) (abfd))

  return false;

    }

  if (obj_textsec (abfd)->reloc_count > 0

      || obj_datasec (abfd)->reloc_count > 0)

    {

      if (bfd_seek (abfd, N_TRELOFF (execp), SEEK_SET) != 0

    || !NAME (aout, squirt_out_relocs) (abfd, obj_textsec (abfd))

    || bfd_seek (abfd, N_DRELOFF (execp), SEEK_SET) != 0

    || !NAME (aout, squirt_out_relocs) (abfd, obj_datasec (abfd)))

  return false;

    }

  return true;

}

/* Write an object file.

   Section contents have already been written.  We write the

   file header, symbols, and relocation.  */

static bool

MY(write_object_contents) (bfd *abfd)

{

  struct internal_exec *execp = exec_hdr (abfd);

  /* We must make certain that the magic number has been set.  This

     will normally have been done by set_section_contents, but only if

     there actually are some section contents.  */

  if (! abfd->output_has_begun)

    NAME (aout, adjust_sizes_and_vmas) (abfd);

  obj_reloc_entry_size (abfd) = RELOC_SIZE;

  return WRITE_HEADERS (abfd, execp);

}

/* Swap the information in an executable header @var{raw_bytes} taken

   from a raw byte stream memory image into the internal exec header

   structure "execp".  */

#ifndef NAME_swap_exec_header_in

void

NAME (aout, swap_exec_header_in) (bfd *abfd,

          struct external_exec *bytes,

          struct internal_exec *execp)

{

  /* The internal_exec structure has some fields that are unused in this

     configuration (IE for i960), so ensure that all such uninitialized

     fields are zero'd out.  There are places where two of these structs

     are memcmp'd, and thus the contents do matter.  */

  memset ((void *) execp, 0, sizeof (struct internal_exec));

  /* Now fill in fields in the execp, from the bytes in the raw data.  */

  execp->a_info   = GET_MAGIC (abfd, bytes->e_info);

  execp->a_text   = GET_WORD (abfd, bytes->e_text);

  execp->a_data   = GET_WORD (abfd, bytes->e_data);

  execp->a_bss    = GET_WORD (abfd, bytes->e_bss);

  execp->a_syms   = GET_WORD (abfd, bytes->e_syms);

  execp->a_entry  = GET_WORD (abfd, bytes->e_entry);

  if (GET_WORD (abfd, bytes->e_flag) & A_FLAG_RELOC_STRIPPED)

    {

      execp->a_trsize = 0;

      execp->a_drsize = 0;

    }

  else

    {

      execp->a_trsize = execp->a_text;

      execp->a_drsize = execp->a_data;

    }

}

#define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in)

#endif

/*  Swap the information in an internal exec header structure

    "execp" into the buffer "bytes" ready for writing to disk.  */

bool

NAME (aout, swap_exec_header_out) (bfd *abfd,

           struct internal_exec *execp,

           struct external_exec *bytes)

{

  const char *err = NULL;

  uint64_t val;

#define MAXVAL(x) ((UINT64_C (1) << (8 * sizeof (x) - 1) << 1) - 1)

  if ((val = execp->a_text) > MAXVAL (bytes->e_text))

    err = "e_text";

  else if ((val = execp->a_data) > MAXVAL (bytes->e_data))

    err = "e_data";

  else if ((val = execp->a_bss) > MAXVAL (bytes->e_bss))

    err = "e_bss";

  else if ((val = execp->a_syms) > MAXVAL (bytes->e_syms))

    err = "e_syms";

  else if ((val = execp->a_entry) > MAXVAL (bytes->e_entry))

    err = "e_entry";

#undef MAXVAL

  if (err)

    {

      _bfd_error_handler (_("%pB: %#" PRIx64 " overflows header %s field"),

        abfd, val, err);

      bfd_set_error (bfd_error_file_too_big);

      return false;

    }

  /* Now fill in fields in the raw data, from the fields in the exec struct.  */

  PUT_MAGIC (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);

  PUT_WORD (abfd, execp->a_bss,     bytes->e_bss);

  PUT_WORD (abfd, execp->a_syms,    bytes->e_syms);

  PUT_WORD (abfd, execp->a_entry,   bytes->e_entry);

  PUT_WORD (abfd, 0,        bytes->e_unused);

  if ((execp->a_trsize == 0 || execp->a_text == 0)

      && (execp->a_drsize == 0 || execp->a_data == 0))

    PUT_WORD (abfd, A_FLAG_RELOC_STRIPPED, bytes->e_flag);

  else if (execp->a_trsize == execp->a_text

     && execp->a_drsize == execp->a_data)

    PUT_WORD (abfd, 0, bytes->e_flag);

  else

    {

      /* TODO: print a proper warning message.  */

      fprintf (stderr, "BFD:%s:%d: internal error\n", __FILE__, __LINE__);

      PUT_WORD (abfd, 0,      bytes->e_flag);

    }

  return true;

}

/* Make all the section for an a.out file.  */

bool

NAME (aout, make_sections) (bfd *abfd)

{

  if (obj_textsec (abfd) == NULL && bfd_make_section (abfd, ".text") == NULL)

    return false;

  if (obj_datasec (abfd) == NULL && bfd_make_section (abfd, ".data") == NULL)

    return false;

  if (obj_bsssec (abfd) == NULL  && bfd_make_section (abfd, ".bss") == NULL)

    return false;

  return true;

}

/* Some a.out variant thinks that the file open in ABFD

   checking is an a.out file.  Do some more checking, and set up

   for access if it really is.  Call back to the calling

   environment's "finish up" function just before returning, to

   handle any last-minute setup.  */

bfd_cleanup

NAME (aout, some_aout_object_p) (bfd *abfd,

         struct internal_exec *execp,

         bfd_cleanup (*callback_to_real_object_p) (bfd *))

{

  struct aout_data_struct *rawptr;

  bfd_cleanup result;

  size_t amt = sizeof (*rawptr);

  rawptr = bfd_zalloc (abfd, amt);

  if (rawptr == NULL)

    return NULL;

  abfd->tdata.aout_data = rawptr;

  abfd->tdata.aout_data->a.hdr = &rawptr->e;

  /* Copy in the internal_exec struct.  */

  *(abfd->tdata.aout_data->a.hdr) = *execp;

  execp = abfd->tdata.aout_data->a.hdr;

  /* 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.  */

  if (execp->a_syms)

    abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;

  if (N_DYNAMIC (execp))

    abfd->flags |= DYNAMIC;

  if (N_MAGIC (execp) == ZMAGIC)

    {

      abfd->flags |= D_PAGED | WP_TEXT;

      adata (abfd).magic = z_magic;

    }

  else if (N_MAGIC (execp) == NMAGIC)

    {

      abfd->flags |= WP_TEXT;

      adata (abfd).magic = n_magic;

    }

  else if (N_MAGIC (execp) == OMAGIC)

    adata (abfd).magic = o_magic;

  else if (N_MAGIC (execp) == IMAGIC)

    adata (abfd).magic = i_magic;

  else

    {

      /* Should have been checked with N_BADMAG before this routine

   was called.  */

      abort ();

    }

  abfd->start_address = execp->a_entry;

  abfd->symcount = execp->a_syms / sizeof (struct external_nlist);

  /* The default relocation entry size is that of traditional V7 Unix.  */

  obj_reloc_entry_size (abfd) = RELOC_SIZE;

  /* The default symbol entry size is that of traditional Unix.  */

  obj_symbol_entry_size (abfd) = EXTERNAL_NLIST_SIZE;

  if (! NAME (aout, make_sections) (abfd))

    goto error_ret;

  obj_datasec (abfd)->size = execp->a_data;

  obj_bsssec (abfd)->size = execp->a_bss;

  obj_textsec (abfd)->flags =

    (execp->a_trsize != 0

     ? (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_RELOC)

     : (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS));

  obj_datasec (abfd)->flags =

    (execp->a_drsize != 0

     ? (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS | SEC_RELOC)

     : (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS));

  obj_bsssec (abfd)->flags = SEC_ALLOC;

#ifdef THIS_IS_ONLY_DOCUMENTATION

  /* The common code can't fill in these things because they depend

     on either the start address of the text segment, the rounding

     up of virtual addresses between segments, or the starting file

     position of the text segment -- all of which varies among different

     versions of a.out.  */

  /* Call back to the format-dependent code to fill in the rest of the

     fields and do any further cleanup.  Things that should be filled

     in by the callback:  */

  struct exec *execp = exec_hdr (abfd);

  obj_textsec (abfd)->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.  */

  obj_str_filepos (abfd) = N_STROFF (execp);

  obj_sym_filepos (abfd) = N_SYMOFF (execp);

  /* Determine the architecture and machine type of the object file.  */

  abfd->obj_arch = bfd_arch_obscure;

  adata (abfd)->page_size = TARGET_PAGE_SIZE;

  adata (abfd)->segment_size = SEGMENT_SIZE;

  adata (abfd)->exec_bytes_size = EXEC_BYTES_SIZE;

  return _bfd_no_cleanup;

  /* The architecture is encoded in various ways in various a.out variants,

     or is not encoded at all in some of them.  The relocation size depends

     on the architecture and the a.out variant.  Finally, the return value

     is the bfd_target vector in use.  If an error occurs, return zero and

     set bfd_error to the appropriate error code.

     Formats such as b.out, which have additional fields in the a.out

     header, should cope with them in this callback as well.  */

#endif  /* DOCUMENTATION */

  result = (*callback_to_real_object_p) (abfd);

  /* Now that the segment addresses have been worked out, take a better

     guess at whether the file is executable.  If the entry point

     is within the text segment, assume it is.  (This makes files

     executable even if their entry point address is 0, as long as

     their text starts at zero.).

     This test had to be changed to deal with systems where the text segment

     runs at a different location than the default.  The problem is that the

     entry address can appear to be outside the text segment, thus causing an

     erroneous conclusion that the file isn't executable.

     To fix this, we now accept any non-zero entry point as an indication of

     executability.  This will work most of the time, since only the linker

     sets the entry point, and that is likely to be non-zero for most systems.  */

  if (execp->a_entry != 0

      || (execp->a_entry >= obj_textsec (abfd)->vma

    && execp->a_entry < (obj_textsec (abfd)->vma

             + obj_textsec (abfd)->size)

    && execp->a_trsize == 0

    && execp->a_drsize == 0))

    abfd->flags |= EXEC_P;

#ifdef STAT_FOR_EXEC

  else

    {

      struct stat stat_buf;

      /* The original heuristic doesn't work in some important cases.

  The a.out file has no information about the text start

  address.  For files (like kernels) linked to non-standard

  addresses (ld -Ttext nnn) the entry point may not be between

  the default text start (obj_textsec(abfd)->vma) and

  (obj_textsec(abfd)->vma) + text size.  This is not just a mach

  issue.  Many kernels are loaded at non standard addresses.  */

      if (abfd->iostream != NULL

    && (abfd->flags & BFD_IN_MEMORY) == 0

    && (fstat (fileno ((FILE *) (abfd->iostream)), &stat_buf) == 0)

    && ((stat_buf.st_mode & 0111) != 0))

  abfd->flags |= EXEC_P;

    }

#endif /* STAT_FOR_EXEC */

  if (result)

    return result;

 error_ret:

  bfd_release (abfd, rawptr);

  return NULL;

}

/* Initialize ABFD for use with a.out files.  */

bool

NAME (aout, mkobject) (bfd *abfd)

{

  struct aout_data_struct  *rawptr;

  size_t amt = sizeof (struct aout_data_struct);

  bfd_set_error (bfd_error_system_call);

  /* Use an intermediate variable for clarity.  */

  rawptr = bfd_zalloc (abfd, amt);

  if (rawptr == NULL)

    return false;

  abfd->tdata.aout_data = rawptr;

  exec_hdr (abfd) = &(rawptr->e);

  obj_textsec (abfd) = NULL;

  obj_datasec (abfd) = NULL;

  obj_bsssec (abfd)  = NULL;

  return true;

}

/* Keep track of machine architecture and machine type for

   a.out's. Return the <<machine_type>> for a particular

   architecture and machine, or <<M_UNKNOWN>> if that exact architecture

   and machine can't be represented in a.out format.

   If the architecture is understood, machine type 0 (default)

   is always understood.  */

enum machine_type

NAME (aout, machine_type) (enum bfd_architecture arch,

         unsigned long machine,

         bool *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_v9)

  arch_flags = M_SPARC;

      else if (machine == bfd_mach_sparc_sparclet)

  arch_flags = M_SPARCLET;

      break;

    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_arm:

      if (machine == 0) arch_flags = M_ARM;

      break;

    case bfd_arch_mips:

      switch (machine)

  {

  case 0:

  case 2000:

  case bfd_mach_mips3000:

    arch_flags = M_MIPS1;

    break;

  case bfd_mach_mips4000: /* MIPS3 */

  case bfd_mach_mips4400:

  case bfd_mach_mips8000: /* MIPS4 */

  case bfd_mach_mips6000: /* Real MIPS2: */

    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_pdp11:

      /* TODO: arch_flags = M_PDP11; */

      *unknown = false;

      break;

    case bfd_arch_vax:

      *unknown = false;

      break;

    default:

      arch_flags = M_UNKNOWN;

    }

  if (arch_flags != M_UNKNOWN)

    *unknown = false;

  return arch_flags;

}

/* Set the architecture and the machine of the ABFD to the

   values ARCH and MACHINE.  Verify that @ABFD's format

   can support the architecture required.  */

bool

NAME (aout, set_arch_mach) (bfd *abfd,

          enum bfd_architecture arch,

          unsigned long machine)

{

  if (! bfd_default_set_arch_mach (abfd, arch, machine))

    return false;

  if (arch != bfd_arch_unknown)

    {

      bool unknown;

      NAME (aout, machine_type) (arch, machine, &unknown);

      if (unknown)

  return false;

    }

  obj_reloc_entry_size (abfd) = RELOC_SIZE;

  return (*aout_backend_info(abfd)->set_sizes) (abfd);

}

static void

adjust_o_magic (bfd *abfd, struct internal_exec *execp)

{

  file_ptr pos = adata (abfd).exec_bytes_size;

  bfd_vma vma = 0;

  int pad = 0;

  asection *text = obj_textsec (abfd);

  asection *data = obj_datasec (abfd);

  asection *bss = obj_bsssec (abfd);

  /* Text.  */

  text->filepos = pos;

  if (!text->user_set_vma)

    text->vma = vma;

  else

    vma = text->vma;

  pos += execp->a_text;

  vma += execp->a_text;

  /* Data.  */

  if (!data->user_set_vma)

    {

      pos += pad;

      vma += pad;

      data->vma = vma;

    }

  else

    vma = data->vma;

  execp->a_text += pad;

  data->filepos = pos;

  pos += data->size;

  vma += data->size;

  /* BSS.  */

  if (!bss->user_set_vma)

    {

      pos += pad;

      vma += pad;

      bss->vma = vma;

    }

  else if (data->size > 0 || bss->size > 0) /* PR25677: for objcopy --extract-symbol */

    {

      /* 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.  */

      pad = bss->vma - vma;

      if (pad < 0)

  pad = 0;

      pos += pad;

    }

  execp->a_data = data->size + pad;

  bss->filepos = pos;

  execp->a_bss = bss->size;

  N_SET_MAGIC (execp, OMAGIC);

}

static void

adjust_z_magic (bfd *abfd, struct internal_exec *execp)

{

  bfd_size_type data_pad, text_pad;

  file_ptr text_end;

  const struct aout_backend_data *abdp;

  /* TRUE if text includes exec header.  */

  bool ztih;

  asection *text = obj_textsec (abfd);

  asection *data = obj_datasec (abfd);

  asection *bss = obj_bsssec (abfd);

  abdp = aout_backend_info (abfd);

  /* Text.  */

  ztih = (abdp != NULL

    && (abdp->text_includes_header

        || obj_aout_subformat (abfd) == q_magic_format));

  text->filepos = (ztih

       ? adata (abfd).exec_bytes_size

       : adata (abfd).zmagic_disk_block_size);

  if (!text->user_set_vma)

    {

      /* ?? Do we really need to check for relocs here?  */

      text->vma = ((abfd->flags & HAS_RELOC)

       ? 0

       : (ztih

          ? abdp->default_text_vma + adata (abfd).exec_bytes_size

          : abdp->default_text_vma));

      text_pad = 0;

    }

  else

    {

      /* The .text section is being loaded at an unusual address.  We

   may need to pad it such that the .data section starts at a page

   boundary.  */

      if (ztih)

  text_pad = ((text->filepos - text->vma)

        & (adata (abfd).page_size - 1));

      else

  text_pad = (-text->vma

        & (adata (abfd).page_size - 1));

    }

  /* Find start of data.  */

  if (ztih)

    {

      text_end = text->filepos + execp->a_text;

      text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;

    }

  else

    {

      /* Note that if page_size == zmagic_disk_block_size, then

   filepos == page_size, and this case is the same as the ztih

   case.  */

      text_end = execp->a_text;

      text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;

      text_end += text->filepos;

    }

  execp->a_text += text_pad;

  /* Data.  */

  if (!data->user_set_vma)

    {

      bfd_vma vma;

      vma = text->vma + execp->a_text;

      data->vma = BFD_ALIGN (vma, adata (abfd).segment_size);

    }

  if (abdp && abdp->zmagic_mapped_contiguous)

    {

      text_pad = data->vma - (text->vma + execp->a_text);

      /* Only pad the text section if the data

   section is going to be placed after it.  */

      if (text_pad > 0)

  execp->a_text += text_pad;

    }

  data->filepos = text->filepos + execp->a_text;

  /* Fix up exec header while we're at it.  */

  if (ztih && (!abdp || (abdp && !abdp->exec_header_not_counted)))

    execp->a_text += adata (abfd).exec_bytes_size;

  N_SET_MAGIC (execp, ZMAGIC);

  /* Spec says data section should be rounded up to page boundary.  */

  execp->a_data = align_power (data->size, bss->alignment_power);

  execp->a_data = BFD_ALIGN (execp->a_data, adata (abfd).page_size);

  data_pad = execp->a_data - data->size;

  /* BSS.  */

  if (!bss->user_set_vma)

    bss->vma = data->vma + execp->a_data;

  /* If the BSS immediately follows the data section and extra space

     in the page is left after the data section, fudge data

     in the header so that the bss section looks smaller by that

     amount.  We'll start the bss section there, and lie to the OS.

     (Note that a linker script, as well as the above assignment,

     could have explicitly set the BSS vma to immediately follow

     the data section.)  */

  if (align_power (bss->vma, bss->alignment_power) == data->vma + execp->a_data)

    execp->a_bss = data_pad > bss->size ? 0 : bss->size - data_pad;

  else

    execp->a_bss = bss->size;

}