[deliverable/binutils-gdb.git] / bfd / aout-adobe.c

/* BFD back-end for a.out.adobe binaries.
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
   Free Software Foundation, Inc.
   Written by Cygnus Support.  Based on bout.c.

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

#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"

#include "aout/adobe.h"

#include "aout/stab_gnu.h"
#include "libaout.h"		/* BFD a.out internal data structures.  */

/* Forward decl.  */
extern const bfd_target a_out_adobe_vec;

static const bfd_target *aout_adobe_callback PARAMS ((bfd *));

extern boolean aout_32_slurp_symbol_table PARAMS ((bfd *abfd));
extern boolean aout_32_write_syms PARAMS ((bfd *));
static void    aout_adobe_write_section PARAMS ((bfd *abfd, sec_ptr sect));
static const bfd_target * aout_adobe_object_p PARAMS ((bfd *));
static boolean aout_adobe_mkobject PARAMS ((bfd *));
static boolean aout_adobe_write_object_contents PARAMS ((bfd *));
static boolean aout_adobe_set_section_contents PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
static boolean aout_adobe_set_arch_mach PARAMS ((bfd *, enum bfd_architecture, unsigned long));
static int     aout_adobe_sizeof_headers PARAMS ((bfd *, boolean));

/* Swaps the information in an executable header taken from a raw byte
   stream memory image, into the internal exec_header structure.  */

void aout_adobe_swap_exec_header_in
  PARAMS ((bfd *abfd, struct external_exec *raw_bytes,
	   struct internal_exec *execp));

void
aout_adobe_swap_exec_header_in (abfd, raw_bytes, execp)
     bfd *abfd;
     struct external_exec *raw_bytes;
     struct internal_exec *execp;
{
  struct external_exec *bytes = (struct external_exec *) raw_bytes;

  /* Now fill in fields in the execp, from the bytes in the raw data.  */
  execp->a_info   = bfd_h_get_32 (abfd, bytes->e_info);
  execp->a_text   = GET_WORD (abfd, bytes->e_text);
  execp->a_data   = GET_WORD (abfd, bytes->e_data);
  execp->a_bss    = GET_WORD (abfd, bytes->e_bss);
  execp->a_syms   = GET_WORD (abfd, bytes->e_syms);
  execp->a_entry  = GET_WORD (abfd, bytes->e_entry);
  execp->a_trsize = GET_WORD (abfd, bytes->e_trsize);
  execp->a_drsize = GET_WORD (abfd, bytes->e_drsize);
}

/* Swaps the information in an internal exec header structure into the
   supplied buffer ready for writing to disk.  */

PROTO(void, aout_adobe_swap_exec_header_out,
	  (bfd *abfd,
	   struct internal_exec *execp,
	   struct external_exec *raw_bytes));
void
aout_adobe_swap_exec_header_out (abfd, execp, raw_bytes)
     bfd *abfd;
     struct internal_exec *execp;
     struct external_exec *raw_bytes;
{
  struct external_exec *bytes = (struct external_exec *) raw_bytes;

  /* Now fill in fields in the raw data, from the fields in the exec
     struct.  */
  bfd_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);
  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, execp->a_trsize, bytes->e_trsize);
  PUT_WORD (abfd, execp->a_drsize, bytes->e_drsize);
}

static const bfd_target *
aout_adobe_object_p (abfd)
     bfd *abfd;
{
  struct internal_exec anexec;
  struct external_exec exec_bytes;
  char *targ;

  if (bfd_read ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd)
      != EXEC_BYTES_SIZE)
    {
      if (bfd_get_error () != bfd_error_system_call)
	bfd_set_error (bfd_error_wrong_format);
      return 0;
    }

  anexec.a_info = bfd_h_get_32 (abfd, exec_bytes.e_info);

  /* Normally we just compare for the magic number.
     However, a bunch of Adobe tools aren't fixed up yet; they generate
     files using ZMAGIC(!).
     If the environment variable GNUTARGET is set to "a.out.adobe", we will
     take just about any a.out file as an Adobe a.out file.  FIXME!  */

  if (N_BADMAG (anexec))
    {
      targ = getenv ("GNUTARGET");
      if (targ && !strcmp (targ, a_out_adobe_vec.name))
	/* Just continue anyway, if specifically set to this format.  */
	;
      else
	{
	  bfd_set_error (bfd_error_wrong_format);
	  return 0;
	}
    }

  aout_adobe_swap_exec_header_in (abfd, &exec_bytes, &anexec);
  return aout_32_some_aout_object_p (abfd, &anexec, aout_adobe_callback);
}

/* Finish up the opening of a b.out file for reading.  Fill in all the
   fields that are not handled by common code.  */

static const bfd_target *
aout_adobe_callback (abfd)
     bfd *abfd;
{
  struct internal_exec *execp = exec_hdr (abfd);
  asection *sect;
  struct external_segdesc ext[1];
  char *section_name;
  char try_again[30];	/* Name and number.  */
  char *newname;
  int trynum;
  flagword flags;

  /* Architecture and machine type -- unknown in this format.  */
  bfd_set_arch_mach (abfd, bfd_arch_unknown, 0);

  /* The positions of the string table and symbol table.  */
  obj_str_filepos (abfd) = N_STROFF (*execp);
  obj_sym_filepos (abfd) = N_SYMOFF (*execp);

  /* Suck up the section information from the file, one section at a time.  */
  for (;;)
    {
      if (bfd_read ((PTR) ext, 1, sizeof (*ext), abfd) != sizeof (*ext))
	{
	  if (bfd_get_error () != bfd_error_system_call)
	    bfd_set_error (bfd_error_wrong_format);

	  return 0;
	}
      switch (ext->e_type[0])
	{
	case N_TEXT:
	  section_name = ".text";
	  flags = SEC_CODE | SEC_LOAD | SEC_ALLOC | SEC_HAS_CONTENTS;
	  break;

	case N_DATA:
	  section_name = ".data";
	  flags = SEC_DATA | SEC_LOAD | SEC_ALLOC | SEC_HAS_CONTENTS;
	  break;

	case N_BSS:
	  section_name = ".bss";
	  flags = SEC_DATA | SEC_HAS_CONTENTS;
	  break;

	case 0:
	  goto no_more_sections;

	default:
	  (*_bfd_error_handler)
	    (_("%s: Unknown section type in a.out.adobe file: %x\n"),
	     bfd_get_filename (abfd), ext->e_type[0]);
	  goto no_more_sections;
	}

      /* First one is called ".text" or whatever; subsequent ones are
	 ".text1", ".text2", ...  */
      bfd_set_error (bfd_error_no_error);
      sect = bfd_make_section (abfd, section_name);
      trynum = 0;

      while (!sect)
	{
	  if (bfd_get_error () != bfd_error_no_error)
	    /* Some other error -- slide into the sunset.  */
	    return 0;
	  sprintf (try_again, "%s%d", section_name, ++trynum);
	  sect = bfd_make_section (abfd, try_again);
	}

      /* Fix the name, if it is a sprintf'd name.  */
      if (sect->name == try_again)
	{
	  newname = (char *) bfd_zalloc (abfd, strlen (sect->name));
	  if (newname == NULL)
	    return 0;
	  strcpy (newname, sect->name);
	  sect->name = newname;
	}

      /* Now set the section's attributes.  */
      bfd_set_section_flags (abfd, sect, flags);
      /* Assumed big-endian.  */
      sect->_raw_size = ((ext->e_size[0] << 8)
			 | ext->e_size[1] << 8)
	| ext->e_size[2];
      sect->_cooked_size = sect->_raw_size;
      sect->vma = bfd_h_get_32 (abfd, ext->e_virtbase);
      sect->filepos = bfd_h_get_32 (abfd, ext->e_filebase);
      /* FIXME XXX alignment?  */

      /* Set relocation information for first section of each type.  */
      if (trynum == 0)
	switch (ext->e_type[0])
	  {
	  case N_TEXT:
	    sect->rel_filepos = N_TRELOFF (*execp);
	    sect->reloc_count = execp->a_trsize;
	    break;

	  case N_DATA:
	    sect->rel_filepos = N_DRELOFF (*execp);
	    sect->reloc_count = execp->a_drsize;
	    break;

	  default:
	    break;
	  }
    }
 no_more_sections:

  adata (abfd).reloc_entry_size = sizeof (struct reloc_std_external);
  adata (abfd).symbol_entry_size = sizeof (struct external_nlist);
  adata (abfd).page_size = 1; /* Not applicable.  */
  adata (abfd).segment_size = 1; /* Not applicable.  */
  adata (abfd).exec_bytes_size = EXEC_BYTES_SIZE;

  return abfd->xvec;
}

struct bout_data_struct
  {
    struct aoutdata a;
    struct internal_exec e;
  };

static boolean
aout_adobe_mkobject (abfd)
     bfd *abfd;
{
  struct bout_data_struct *rawptr;

  rawptr = (struct bout_data_struct *) bfd_zalloc (abfd, sizeof (struct bout_data_struct));
  if (rawptr == NULL)
    return false;

  abfd->tdata.bout_data = rawptr;
  exec_hdr (abfd) = &rawptr->e;

  adata (abfd).reloc_entry_size = sizeof (struct reloc_std_external);
  adata (abfd).symbol_entry_size = sizeof (struct external_nlist);
  adata (abfd).page_size = 1; /* Not applicable.  */
  adata (abfd).segment_size = 1; /* Not applicable.  */
  adata (abfd).exec_bytes_size = EXEC_BYTES_SIZE;

  return true;
}

static boolean
aout_adobe_write_object_contents (abfd)
     bfd *abfd;
{
  struct external_exec swapped_hdr;
  static struct external_segdesc sentinel[1];	/* Initialized to zero.  */
  asection *sect;

  exec_hdr (abfd)->a_info = ZMAGIC;

  /* Calculate text size as total of text sections, etc.  */

  exec_hdr (abfd)->a_text = 0;
  exec_hdr (abfd)->a_data = 0;
  exec_hdr (abfd)->a_bss  = 0;
  exec_hdr (abfd)->a_trsize = 0;
  exec_hdr (abfd)->a_drsize = 0;

  for (sect = abfd->sections; sect; sect = sect->next)
    {
      if (sect->flags & SEC_CODE)
	{
	  exec_hdr (abfd)->a_text += sect->_raw_size;
	  exec_hdr (abfd)->a_trsize += sect->reloc_count *
	    sizeof (struct reloc_std_external);
	}
      else if (sect->flags & SEC_DATA)
	{
	  exec_hdr (abfd)->a_data += sect->_raw_size;
	  exec_hdr (abfd)->a_drsize += sect->reloc_count *
	    sizeof (struct reloc_std_external);
	}
      else if (sect->flags & SEC_ALLOC && !(sect->flags & SEC_LOAD))
	{
	  exec_hdr (abfd)->a_bss += sect->_raw_size;
	}
    }

  exec_hdr (abfd)->a_syms = bfd_get_symcount (abfd)
    * sizeof (struct external_nlist);
  exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);

  aout_adobe_swap_exec_header_out (abfd, exec_hdr (abfd), &swapped_hdr);

  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
      || (bfd_write ((PTR) &swapped_hdr, 1, EXEC_BYTES_SIZE, abfd)
	  != EXEC_BYTES_SIZE))
    return false;

  /* Now write out the section information.  Text first, data next, rest
     afterward.  */

  for (sect = abfd->sections; sect; sect = sect->next)
    if (sect->flags & SEC_CODE)
      aout_adobe_write_section (abfd, sect);

  for (sect = abfd->sections; sect; sect = sect->next)
    if (sect->flags & SEC_DATA)
      aout_adobe_write_section (abfd, sect);

  for (sect = abfd->sections; sect; sect = sect->next)
    if (!(sect->flags & (SEC_CODE | SEC_DATA)))
      aout_adobe_write_section (abfd, sect);

  /* Write final `sentinel` section header (with type of 0).  */
  if (bfd_write ((PTR) sentinel, 1, sizeof (*sentinel), abfd)
      != sizeof (*sentinel))
    return false;

  /* Now write out reloc info, followed by syms and strings.  */
  if (bfd_get_symcount (abfd) != 0)
    {
      if (bfd_seek (abfd, (file_ptr) (N_SYMOFF (*exec_hdr (abfd))), SEEK_SET)
	  != 0)
	return false;

      if (! aout_32_write_syms (abfd))
	return false;

      if (bfd_seek (abfd, (file_ptr) (N_TRELOFF (*exec_hdr (abfd))), SEEK_SET)
	  != 0)
	return false;

      for (sect = abfd->sections; sect; sect = sect->next)
	if (sect->flags & SEC_CODE)
	  if (!aout_32_squirt_out_relocs (abfd, sect))
	    return false;

      if (bfd_seek (abfd, (file_ptr) (N_DRELOFF (*exec_hdr (abfd))), SEEK_SET)
	  != 0)
	return false;

      for (sect = abfd->sections; sect; sect = sect->next)
	if (sect->flags & SEC_DATA)
	  if (!aout_32_squirt_out_relocs (abfd, sect))
	    return false;
    }

  return true;
}

static void
aout_adobe_write_section (abfd, sect)
     bfd *abfd ATTRIBUTE_UNUSED;
     sec_ptr sect ATTRIBUTE_UNUSED;
{
  /* FIXME XXX */
}
\f
static boolean
aout_adobe_set_section_contents (abfd, section, location, offset, count)
     bfd *abfd;
     asection *section;
     PTR location;
     file_ptr offset;
     bfd_size_type count;
{
  file_ptr section_start;
  sec_ptr sect;

  /* Set by bfd.c handler.  */
  if (abfd->output_has_begun == false)
    {
      /* Assign file offsets to sections.  Text sections are first, and
	 are contiguous.  Then data sections.  Everything else at the end.  */
      section_start = N_TXTOFF (ignore<-->me);

      for (sect = abfd->sections; sect; sect = sect->next)
	{
	  if (sect->flags & SEC_CODE)
	    {
	      sect->filepos = section_start;
	      /* FIXME:  Round to alignment.  */
	      section_start += sect->_raw_size;
	    }
	}

      for (sect = abfd->sections; sect; sect = sect->next)
	{
	  if (sect->flags & SEC_DATA)
	    {
	      sect->filepos = section_start;
	      /* FIXME:  Round to alignment.  */
	      section_start += sect->_raw_size;
	    }
	}

      for (sect = abfd->sections; sect; sect = sect->next)
	{
	  if (sect->flags & SEC_HAS_CONTENTS &&
	      !(sect->flags & (SEC_CODE | SEC_DATA)))
	    {
	      sect->filepos = section_start;
	      /* FIXME:  Round to alignment.  */
	      section_start += sect->_raw_size;
	    }
	}
    }

  /* Regardless, once we know what we're doing, we might as well get
     going.  */
  if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
    return false;

  if (count != 0)
    return (bfd_write ((PTR) location, 1, count, abfd) == count) ? true : false;

  return true;
}

static boolean
aout_adobe_set_arch_mach (abfd, arch, machine)
     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
      || arch == bfd_arch_m68k)
    return true;

  return false;
}

static int
aout_adobe_sizeof_headers (ignore_abfd, ignore)
     bfd *ignore_abfd ATTRIBUTE_UNUSED;
     boolean ignore ATTRIBUTE_UNUSED;
{
  return sizeof (struct internal_exec);
}

/* Build the transfer vector for Adobe A.Out files.  */

#define aout_32_close_and_cleanup aout_32_bfd_free_cached_info

#define aout_32_bfd_make_debug_symbol \
  ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)

#define aout_32_bfd_reloc_type_lookup \
  ((reloc_howto_type *(*) \
    PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)

#define	aout_32_set_arch_mach		aout_adobe_set_arch_mach
#define	aout_32_set_section_contents	aout_adobe_set_section_contents

#define	aout_32_sizeof_headers		aout_adobe_sizeof_headers
#define aout_32_bfd_get_relocated_section_contents \
  bfd_generic_get_relocated_section_contents
#define aout_32_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
#define aout_32_bfd_relax_section       bfd_generic_relax_section
#define aout_32_bfd_gc_sections         bfd_generic_gc_sections
#define aout_32_bfd_merge_sections	bfd_generic_merge_sections
#define aout_32_bfd_link_hash_table_create \
  _bfd_generic_link_hash_table_create
#define aout_32_bfd_link_add_symbols	_bfd_generic_link_add_symbols
#define aout_32_bfd_final_link		_bfd_generic_final_link
#define aout_32_bfd_link_split_section	_bfd_generic_link_split_section

const bfd_target a_out_adobe_vec =
  {
    "a.out.adobe",		/* name */
    bfd_target_aout_flavour,
    BFD_ENDIAN_BIG,		/* data byte order is unknown (big assumed) */
    BFD_ENDIAN_BIG,		/* hdr byte order is big */
    (HAS_RELOC | EXEC_P |	/* object flags */
     HAS_LINENO | HAS_DEBUG |
     HAS_SYMS | HAS_LOCALS | WP_TEXT ),
    /* section flags */
    (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_DATA | SEC_RELOC),
    '_',				/*  symbol leading char */
    ' ',				/* ar_pad_char */
    16,					/* ar_max_namelen */

    bfd_getb64, bfd_getb_signed_64, bfd_putb64,
    bfd_getb32, bfd_getb_signed_32, bfd_putb32,
    bfd_getb16, bfd_getb_signed_16, bfd_putb16,	/* data */
    bfd_getb64, bfd_getb_signed_64, bfd_putb64,
    bfd_getb32, bfd_getb_signed_32, bfd_putb32,
    bfd_getb16, bfd_getb_signed_16, bfd_putb16,	/* hdrs */
    {_bfd_dummy_target, aout_adobe_object_p,	/* bfd_check_format */
     bfd_generic_archive_p, _bfd_dummy_target},
    {bfd_false, aout_adobe_mkobject,		/* bfd_set_format */
     _bfd_generic_mkarchive, bfd_false},
    {bfd_false, aout_adobe_write_object_contents,/* bfd_write_contents */
     _bfd_write_archive_contents, bfd_false},

    BFD_JUMP_TABLE_GENERIC (aout_32),
    BFD_JUMP_TABLE_COPY (_bfd_generic),
    BFD_JUMP_TABLE_CORE (_bfd_nocore),
    BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_bsd),
    BFD_JUMP_TABLE_SYMBOLS (aout_32),
    BFD_JUMP_TABLE_RELOCS (aout_32),
    BFD_JUMP_TABLE_WRITE (aout_32),
    BFD_JUMP_TABLE_LINK (aout_32),
    BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),

    NULL,

    (PTR) 0
  };
Commit	Line	Data
252b5132	1	/* BFD back-end for a.out.adobe binaries.
1725a96e	2	Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
5f771d47	3	Free Software Foundation, Inc.
252b5132 RH	4	Written by Cygnus Support. Based on bout.c.
	5
	6	This file is part of BFD, the Binary File Descriptor library.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
	20	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	21
	22	#include "bfd.h"
	23	#include "sysdep.h"
	24	#include "libbfd.h"
	25
	26	#include "aout/adobe.h"
	27
	28	#include "aout/stab_gnu.h"
1725a96e	29	#include "libaout.h" /* BFD a.out internal data structures. */
252b5132	30
336eced2 KH	31	/* Forward decl. */
336eced2 KH	32	extern const bfd_target a_out_adobe_vec;
252b5132 RH	33
	34	static const bfd_target aout_adobe_callback PARAMS ((bfd ));
	35
	36	extern boolean aout_32_slurp_symbol_table PARAMS ((bfd *abfd));
	37	extern boolean aout_32_write_syms PARAMS ((bfd *));
1725a96e NC	38	static void aout_adobe_write_section PARAMS ((bfd *abfd, sec_ptr sect));
	39	static const bfd_target * aout_adobe_object_p PARAMS ((bfd *));
	40	static boolean aout_adobe_mkobject PARAMS ((bfd *));
	41	static boolean aout_adobe_write_object_contents PARAMS ((bfd *));
	42	static boolean aout_adobe_set_section_contents PARAMS ((bfd , asection , PTR, file_ptr, bfd_size_type));
	43	static boolean aout_adobe_set_arch_mach PARAMS ((bfd *, enum bfd_architecture, unsigned long));
	44	static int aout_adobe_sizeof_headers PARAMS ((bfd *, boolean));
252b5132 RH	45
	46	/* Swaps the information in an executable header taken from a raw byte
	47	stream memory image, into the internal exec_header structure. */
	48
	49	void aout_adobe_swap_exec_header_in
	50	PARAMS ((bfd abfd, struct external_exec raw_bytes,
	51	struct internal_exec *execp));
c4dfa77f	52
252b5132 RH	53	void
	54	aout_adobe_swap_exec_header_in (abfd, raw_bytes, execp)
	55	bfd *abfd;
	56	struct external_exec *raw_bytes;
	57	struct internal_exec *execp;
	58	{
336eced2	59	struct external_exec bytes = (struct external_exec ) raw_bytes;
252b5132 RH	60
	61	/* Now fill in fields in the execp, from the bytes in the raw data. */
	62	execp->a_info = bfd_h_get_32 (abfd, bytes->e_info);
	63	execp->a_text = GET_WORD (abfd, bytes->e_text);
	64	execp->a_data = GET_WORD (abfd, bytes->e_data);
	65	execp->a_bss = GET_WORD (abfd, bytes->e_bss);
	66	execp->a_syms = GET_WORD (abfd, bytes->e_syms);
	67	execp->a_entry = GET_WORD (abfd, bytes->e_entry);
	68	execp->a_trsize = GET_WORD (abfd, bytes->e_trsize);
	69	execp->a_drsize = GET_WORD (abfd, bytes->e_drsize);
	70	}
	71
	72	/* Swaps the information in an internal exec header structure into the
	73	supplied buffer ready for writing to disk. */
	74
	75	PROTO(void, aout_adobe_swap_exec_header_out,
	76	(bfd *abfd,
	77	struct internal_exec *execp,
	78	struct external_exec *raw_bytes));
	79	void
	80	aout_adobe_swap_exec_header_out (abfd, execp, raw_bytes)
	81	bfd *abfd;
	82	struct internal_exec *execp;
	83	struct external_exec *raw_bytes;
	84	{
336eced2	85	struct external_exec bytes = (struct external_exec ) raw_bytes;
252b5132	86
336eced2 KH	87	/* Now fill in fields in the raw data, from the fields in the exec
336eced2 KH	88	struct. */
252b5132 RH	89	bfd_h_put_32 (abfd, execp->a_info , bytes->e_info);
	90	PUT_WORD (abfd, execp->a_text , bytes->e_text);
	91	PUT_WORD (abfd, execp->a_data , bytes->e_data);
	92	PUT_WORD (abfd, execp->a_bss , bytes->e_bss);
	93	PUT_WORD (abfd, execp->a_syms , bytes->e_syms);
	94	PUT_WORD (abfd, execp->a_entry , bytes->e_entry);
	95	PUT_WORD (abfd, execp->a_trsize, bytes->e_trsize);
	96	PUT_WORD (abfd, execp->a_drsize, bytes->e_drsize);
	97	}
	98
252b5132 RH	99	static const bfd_target *
	100	aout_adobe_object_p (abfd)
	101	bfd *abfd;
	102	{
	103	struct internal_exec anexec;
	104	struct external_exec exec_bytes;
	105	char *targ;
	106
	107	if (bfd_read ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd)
336eced2 KH	108	!= EXEC_BYTES_SIZE)
	109	{
	110	if (bfd_get_error () != bfd_error_system_call)
	111	bfd_set_error (bfd_error_wrong_format);
	112	return 0;
	113	}
252b5132 RH	114
	115	anexec.a_info = bfd_h_get_32 (abfd, exec_bytes.e_info);
	116
	117	/* Normally we just compare for the magic number.
	118	However, a bunch of Adobe tools aren't fixed up yet; they generate
	119	files using ZMAGIC(!).
	120	If the environment variable GNUTARGET is set to "a.out.adobe", we will
	121	take just about any a.out file as an Adobe a.out file. FIXME! */
	122
336eced2 KH	123	if (N_BADMAG (anexec))
	124	{
	125	targ = getenv ("GNUTARGET");
	126	if (targ && !strcmp (targ, a_out_adobe_vec.name))
	127	/* Just continue anyway, if specifically set to this format. */
	128	;
	129	else
	130	{
	131	bfd_set_error (bfd_error_wrong_format);
	132	return 0;
	133	}
	134	}
252b5132 RH	135
	136	aout_adobe_swap_exec_header_in (abfd, &exec_bytes, &anexec);
	137	return aout_32_some_aout_object_p (abfd, &anexec, aout_adobe_callback);
	138	}
	139
252b5132 RH	140	/* Finish up the opening of a b.out file for reading. Fill in all the
	141	fields that are not handled by common code. */
	142
	143	static const bfd_target *
	144	aout_adobe_callback (abfd)
	145	bfd *abfd;
	146	{
	147	struct internal_exec *execp = exec_hdr (abfd);
	148	asection *sect;
	149	struct external_segdesc ext[1];
	150	char *section_name;
1725a96e	151	char try_again[30]; /* Name and number. */
252b5132 RH	152	char *newname;
	153	int trynum;
	154	flagword flags;
	155
	156	/* Architecture and machine type -- unknown in this format. */
336eced2	157	bfd_set_arch_mach (abfd, bfd_arch_unknown, 0);
252b5132 RH	158
	159	/* The positions of the string table and symbol table. */
	160	obj_str_filepos (abfd) = N_STROFF (*execp);
	161	obj_sym_filepos (abfd) = N_SYMOFF (*execp);
	162
	163	/* Suck up the section information from the file, one section at a time. */
336eced2 KH	164	for (;;)
	165	{
	166	if (bfd_read ((PTR) ext, 1, sizeof (ext), abfd) != sizeof (ext))
	167	{
	168	if (bfd_get_error () != bfd_error_system_call)
	169	bfd_set_error (bfd_error_wrong_format);
1725a96e	170
336eced2 KH	171	return 0;
	172	}
	173	switch (ext->e_type[0])
	174	{
	175	case N_TEXT:
	176	section_name = ".text";
	177	flags = SEC_CODE \| SEC_LOAD \| SEC_ALLOC \| SEC_HAS_CONTENTS;
	178	break;
	179
	180	case N_DATA:
	181	section_name = ".data";
	182	flags = SEC_DATA \| SEC_LOAD \| SEC_ALLOC \| SEC_HAS_CONTENTS;
	183	break;
	184
	185	case N_BSS:
	186	section_name = ".bss";
	187	flags = SEC_DATA \| SEC_HAS_CONTENTS;
	188	break;
	189
	190	case 0:
	191	goto no_more_sections;
	192
	193	default:
	194	(*_bfd_error_handler)
	195	(_("%s: Unknown section type in a.out.adobe file: %x\n"),
	196	bfd_get_filename (abfd), ext->e_type[0]);
	197	goto no_more_sections;
	198	}
	199
	200	/* First one is called ".text" or whatever; subsequent ones are
	201	".text1", ".text2", ... */
336eced2 KH	202	bfd_set_error (bfd_error_no_error);
	203	sect = bfd_make_section (abfd, section_name);
	204	trynum = 0;
1725a96e	205
336eced2 KH	206	while (!sect)
	207	{
	208	if (bfd_get_error () != bfd_error_no_error)
	209	/* Some other error -- slide into the sunset. */
	210	return 0;
	211	sprintf (try_again, "%s%d", section_name, ++trynum);
	212	sect = bfd_make_section (abfd, try_again);
	213	}
	214
	215	/* Fix the name, if it is a sprintf'd name. */
	216	if (sect->name == try_again)
	217	{
	218	newname = (char *) bfd_zalloc (abfd, strlen (sect->name));
	219	if (newname == NULL)
	220	return 0;
	221	strcpy (newname, sect->name);
	222	sect->name = newname;
	223	}
	224
	225	/* Now set the section's attributes. */
	226	bfd_set_section_flags (abfd, sect, flags);
	227	/* Assumed big-endian. */
	228	sect->_raw_size = ((ext->e_size[0] << 8)
	229	\| ext->e_size[1] << 8)
	230	\| ext->e_size[2];
	231	sect->_cooked_size = sect->_raw_size;
	232	sect->vma = bfd_h_get_32 (abfd, ext->e_virtbase);
	233	sect->filepos = bfd_h_get_32 (abfd, ext->e_filebase);
	234	/* FIXME XXX alignment? */
	235
	236	/* Set relocation information for first section of each type. */
	237	if (trynum == 0)
	238	switch (ext->e_type[0])
	239	{
	240	case N_TEXT:
	241	sect->rel_filepos = N_TRELOFF (*execp);
	242	sect->reloc_count = execp->a_trsize;
	243	break;
	244
	245	case N_DATA:
	246	sect->rel_filepos = N_DRELOFF (*execp);
	247	sect->reloc_count = execp->a_drsize;
	248	break;
1725a96e NC	249
	250	default:
	251	break;
336eced2	252	}
252b5132	253	}
336eced2	254	no_more_sections:
252b5132	255
336eced2 KH	256	adata (abfd).reloc_entry_size = sizeof (struct reloc_std_external);
	257	adata (abfd).symbol_entry_size = sizeof (struct external_nlist);
	258	adata (abfd).page_size = 1; /* Not applicable. */
	259	adata (abfd).segment_size = 1; /* Not applicable. */
	260	adata (abfd).exec_bytes_size = EXEC_BYTES_SIZE;
252b5132 RH	261
	262	return abfd->xvec;
	263	}
	264
1725a96e NC	265	struct bout_data_struct
	266	{
	267	struct aoutdata a;
	268	struct internal_exec e;
	269	};
252b5132 RH	270
	271	static boolean
	272	aout_adobe_mkobject (abfd)
	273	bfd *abfd;
	274	{
	275	struct bout_data_struct *rawptr;
	276
	277	rawptr = (struct bout_data_struct *) bfd_zalloc (abfd, sizeof (struct bout_data_struct));
	278	if (rawptr == NULL)
336eced2	279	return false;
252b5132 RH	280
	281	abfd->tdata.bout_data = rawptr;
	282	exec_hdr (abfd) = &rawptr->e;
	283
336eced2 KH	284	adata (abfd).reloc_entry_size = sizeof (struct reloc_std_external);
	285	adata (abfd).symbol_entry_size = sizeof (struct external_nlist);
	286	adata (abfd).page_size = 1; /* Not applicable. */
	287	adata (abfd).segment_size = 1; /* Not applicable. */
	288	adata (abfd).exec_bytes_size = EXEC_BYTES_SIZE;
252b5132 RH	289
	290	return true;
	291	}
	292
252b5132 RH	293	static boolean
	294	aout_adobe_write_object_contents (abfd)
	295	bfd *abfd;
	296	{
	297	struct external_exec swapped_hdr;
336eced2	298	static struct external_segdesc sentinel[1]; /* Initialized to zero. */
252b5132 RH	299	asection *sect;
	300
	301	exec_hdr (abfd)->a_info = ZMAGIC;
	302
c4dfa77f	303	/* Calculate text size as total of text sections, etc. */
252b5132 RH	304
	305	exec_hdr (abfd)->a_text = 0;
	306	exec_hdr (abfd)->a_data = 0;
	307	exec_hdr (abfd)->a_bss = 0;
	308	exec_hdr (abfd)->a_trsize = 0;
	309	exec_hdr (abfd)->a_drsize = 0;
	310
336eced2 KH	311	for (sect = abfd->sections; sect; sect = sect->next)
	312	{
	313	if (sect->flags & SEC_CODE)
	314	{
	315	exec_hdr (abfd)->a_text += sect->_raw_size;
	316	exec_hdr (abfd)->a_trsize += sect->reloc_count *
	317	sizeof (struct reloc_std_external);
	318	}
	319	else if (sect->flags & SEC_DATA)
	320	{
	321	exec_hdr (abfd)->a_data += sect->_raw_size;
	322	exec_hdr (abfd)->a_drsize += sect->reloc_count *
	323	sizeof (struct reloc_std_external);
	324	}
	325	else if (sect->flags & SEC_ALLOC && !(sect->flags & SEC_LOAD))
	326	{
	327	exec_hdr (abfd)->a_bss += sect->_raw_size;
	328	}
252b5132	329	}
252b5132 RH	330
252b5132 RH	331	exec_hdr (abfd)->a_syms = bfd_get_symcount (abfd)
336eced2	332	* sizeof (struct external_nlist);
252b5132 RH	333	exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
	334
	335	aout_adobe_swap_exec_header_out (abfd, exec_hdr (abfd), &swapped_hdr);
	336
	337	if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
	338	\|\| (bfd_write ((PTR) &swapped_hdr, 1, EXEC_BYTES_SIZE, abfd)
	339	!= EXEC_BYTES_SIZE))
	340	return false;
	341
	342	/* Now write out the section information. Text first, data next, rest
	343	afterward. */
	344
336eced2	345	for (sect = abfd->sections; sect; sect = sect->next)
1725a96e NC	346	if (sect->flags & SEC_CODE)
	347	aout_adobe_write_section (abfd, sect);
	348
336eced2	349	for (sect = abfd->sections; sect; sect = sect->next)
1725a96e NC	350	if (sect->flags & SEC_DATA)
	351	aout_adobe_write_section (abfd, sect);
	352
336eced2	353	for (sect = abfd->sections; sect; sect = sect->next)
1725a96e NC	354	if (!(sect->flags & (SEC_CODE \| SEC_DATA)))
1725a96e NC	355	aout_adobe_write_section (abfd, sect);
252b5132 RH	356
	357	/* Write final `sentinel` section header (with type of 0). */
	358	if (bfd_write ((PTR) sentinel, 1, sizeof (*sentinel), abfd)
	359	!= sizeof (*sentinel))
	360	return false;
	361
336eced2	362	/* Now write out reloc info, followed by syms and strings. */
c4dfa77f	363	if (bfd_get_symcount (abfd) != 0)
252b5132	364	{
336eced2	365	if (bfd_seek (abfd, (file_ptr) (N_SYMOFF (*exec_hdr (abfd))), SEEK_SET)
252b5132 RH	366	!= 0)
	367	return false;
	368
	369	if (! aout_32_write_syms (abfd))
	370	return false;
	371
336eced2	372	if (bfd_seek (abfd, (file_ptr) (N_TRELOFF (*exec_hdr (abfd))), SEEK_SET)
252b5132 RH	373	!= 0)
	374	return false;
	375
336eced2	376	for (sect = abfd->sections; sect; sect = sect->next)
1725a96e NC	377	if (sect->flags & SEC_CODE)
	378	if (!aout_32_squirt_out_relocs (abfd, sect))
	379	return false;
252b5132	380
336eced2	381	if (bfd_seek (abfd, (file_ptr) (N_DRELOFF (*exec_hdr (abfd))), SEEK_SET)
252b5132 RH	382	!= 0)
	383	return false;
	384
336eced2	385	for (sect = abfd->sections; sect; sect = sect->next)
1725a96e NC	386	if (sect->flags & SEC_DATA)
	387	if (!aout_32_squirt_out_relocs (abfd, sect))
	388	return false;
252b5132	389	}
1725a96e	390
252b5132 RH	391	return true;
	392	}
	393
	394	static void
	395	aout_adobe_write_section (abfd, sect)
5f771d47 ILT	396	bfd *abfd ATTRIBUTE_UNUSED;
5f771d47 ILT	397	sec_ptr sect ATTRIBUTE_UNUSED;
252b5132 RH	398	{
	399	/* FIXME XXX */
	400	}
	401	\f
	402	static boolean
	403	aout_adobe_set_section_contents (abfd, section, location, offset, count)
	404	bfd *abfd;
	405	asection *section;
	406	PTR location;
	407	file_ptr offset;
	408	bfd_size_type count;
	409	{
	410	file_ptr section_start;
	411	sec_ptr sect;
	412
336eced2 KH	413	/* Set by bfd.c handler. */
	414	if (abfd->output_has_begun == false)
	415	{
	416	/* Assign file offsets to sections. Text sections are first, and
	417	are contiguous. Then data sections. Everything else at the end. */
336eced2 KH	418	section_start = N_TXTOFF (ignore<-->me);
	419
	420	for (sect = abfd->sections; sect; sect = sect->next)
	421	{
	422	if (sect->flags & SEC_CODE)
	423	{
	424	sect->filepos = section_start;
	425	/* FIXME: Round to alignment. */
	426	section_start += sect->_raw_size;
	427	}
	428	}
	429
	430	for (sect = abfd->sections; sect; sect = sect->next)
	431	{
	432	if (sect->flags & SEC_DATA)
	433	{
	434	sect->filepos = section_start;
	435	/* FIXME: Round to alignment. */
	436	section_start += sect->_raw_size;
	437	}
	438	}
	439
	440	for (sect = abfd->sections; sect; sect = sect->next)
	441	{
	442	if (sect->flags & SEC_HAS_CONTENTS &&
	443	!(sect->flags & (SEC_CODE \| SEC_DATA)))
	444	{
	445	sect->filepos = section_start;
	446	/* FIXME: Round to alignment. */
	447	section_start += sect->_raw_size;
	448	}
	449	}
252b5132	450	}
252b5132	451
336eced2 KH	452	/* Regardless, once we know what we're doing, we might as well get
336eced2 KH	453	going. */
252b5132 RH	454	if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
	455	return false;
	456
336eced2	457	if (count != 0)
1725a96e NC	458	return (bfd_write ((PTR) location, 1, count, abfd) == count) ? true : false;
1725a96e NC	459
252b5132 RH	460	return true;
	461	}
	462
	463	static boolean
	464	aout_adobe_set_arch_mach (abfd, arch, machine)
	465	bfd *abfd;
	466	enum bfd_architecture arch;
	467	unsigned long machine;
	468	{
	469	if (! bfd_default_set_arch_mach (abfd, arch, machine))
	470	return false;
	471
	472	if (arch == bfd_arch_unknown
	473	\|\| arch == bfd_arch_m68k)
	474	return true;
	475
	476	return false;
	477	}
	478
c4dfa77f	479	static int
252b5132	480	aout_adobe_sizeof_headers (ignore_abfd, ignore)
5f771d47 ILT	481	bfd *ignore_abfd ATTRIBUTE_UNUSED;
5f771d47 ILT	482	boolean ignore ATTRIBUTE_UNUSED;
252b5132	483	{
beb0d161	484	return sizeof (struct internal_exec);
252b5132 RH	485	}
252b5132 RH	486
252b5132 RH	487	/* Build the transfer vector for Adobe A.Out files. */
	488
	489	#define aout_32_close_and_cleanup aout_32_bfd_free_cached_info
	490
	491	#define aout_32_bfd_make_debug_symbol \
	492	((asymbol () PARAMS ((bfd , void , unsigned long))) bfd_nullvoidptr)
	493
	494	#define aout_32_bfd_reloc_type_lookup \
	495	((reloc_howto_type () \
	496	PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)
	497
	498	#define aout_32_set_arch_mach aout_adobe_set_arch_mach
	499	#define aout_32_set_section_contents aout_adobe_set_section_contents
	500
	501	#define aout_32_sizeof_headers aout_adobe_sizeof_headers
	502	#define aout_32_bfd_get_relocated_section_contents \
	503	bfd_generic_get_relocated_section_contents
	504	#define aout_32_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
	505	#define aout_32_bfd_relax_section bfd_generic_relax_section
	506	#define aout_32_bfd_gc_sections bfd_generic_gc_sections
8550eb6e	507	#define aout_32_bfd_merge_sections bfd_generic_merge_sections
252b5132 RH	508	#define aout_32_bfd_link_hash_table_create \
	509	_bfd_generic_link_hash_table_create
	510	#define aout_32_bfd_link_add_symbols _bfd_generic_link_add_symbols
	511	#define aout_32_bfd_final_link _bfd_generic_final_link
	512	#define aout_32_bfd_link_split_section _bfd_generic_link_split_section
	513
1725a96e NC	514	const bfd_target a_out_adobe_vec =
	515	{
	516	"a.out.adobe", /* name */
	517	bfd_target_aout_flavour,
	518	BFD_ENDIAN_BIG, /* data byte order is unknown (big assumed) */
	519	BFD_ENDIAN_BIG, /* hdr byte order is big */
	520	(HAS_RELOC \| EXEC_P \| /* object flags */
	521	HAS_LINENO \| HAS_DEBUG \|
	522	HAS_SYMS \| HAS_LOCALS \| WP_TEXT ),
	523	/* section flags */
	524	(SEC_HAS_CONTENTS \| SEC_ALLOC \| SEC_LOAD \| SEC_CODE \| SEC_DATA \| SEC_RELOC),
	525	'_', /* symbol leading char */
	526	' ', /* ar_pad_char */
	527	16, /* ar_max_namelen */
	528
	529	bfd_getb64, bfd_getb_signed_64, bfd_putb64,
	530	bfd_getb32, bfd_getb_signed_32, bfd_putb32,
	531	bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
	532	bfd_getb64, bfd_getb_signed_64, bfd_putb64,
	533	bfd_getb32, bfd_getb_signed_32, bfd_putb32,
	534	bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
	535	{_bfd_dummy_target, aout_adobe_object_p, /* bfd_check_format */
	536	bfd_generic_archive_p, _bfd_dummy_target},
	537	{bfd_false, aout_adobe_mkobject, /* bfd_set_format */
	538	_bfd_generic_mkarchive, bfd_false},
	539	{bfd_false, aout_adobe_write_object_contents,/* bfd_write_contents */
	540	_bfd_write_archive_contents, bfd_false},
	541
	542	BFD_JUMP_TABLE_GENERIC (aout_32),
	543	BFD_JUMP_TABLE_COPY (_bfd_generic),
	544	BFD_JUMP_TABLE_CORE (_bfd_nocore),
	545	BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_bsd),
	546	BFD_JUMP_TABLE_SYMBOLS (aout_32),
	547	BFD_JUMP_TABLE_RELOCS (aout_32),
	548	BFD_JUMP_TABLE_WRITE (aout_32),
	549	BFD_JUMP_TABLE_LINK (aout_32),
	550	BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
	551
	552	NULL,
	553
	554	(PTR) 0
	555	};