[binutils.git] / bfd / aout-encap.c

/* BFD back-end for a.out files encapsulated with COFF headers.
   Copyright (C) 1990, 1991 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 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */

/* THIS MODULE IS NOT FINISHED.  IT PROBABLY DOESN'T EVEN COMPILE.  */

#if 0
#define	PAGE_SIZE	4096
#define	SEGMENT_SIZE	PAGE_SIZE
#define TEXT_START_ADDR 0
#define ARCH 32
#define BYTES_IN_WORD 4
#endif

#include "bfd.h"
#include <sysdep.h>
#include "libbfd.h"
#include <aout/aout64.h>
#include "aout/stab_gnu.h"
#include "aout/ar.h"
#include "libaout.h"           /* BFD a.out internal data structures */

const bfd_target *encap_real_callback ();

const bfd_target *
encap_object_p (abfd)
     bfd *abfd;
{
  unsigned char magicbuf[4]; /* Raw bytes of magic number from file */
  unsigned long magic;		/* Swapped magic number */
  short coff_magic;
  struct external_exec exec_bytes;
  struct internal_exec exec;

  if (bfd_read ((PTR)magicbuf, 1, sizeof (magicbuf), abfd) !=
      sizeof (magicbuf))
    {
      if (bfd_get_error () != bfd_error_system_call)
	bfd_set_error (bfd_error_wrong_format);
      return 0;
    }
  
  coff_magic = bfd_h_get_16 (abfd, magicbuf);
  if (coff_magic != COFF_MAGIC)
    return 0;			/* Not an encap coff file */

  __header_offset_temp==COFF_MAGIC ? sizeof(struct coffheader) : 0)
  (fseek ((f), HEADER_OFFSET((f)), 1))

  magic = bfd_h_get_32 (abfd, magicbuf);

  if (N_BADMAG (*((struct internal_exec *) &magic))) return 0;

  struct external_exec exec_bytes;
  if (bfd_read ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd)
      != EXEC_BYTES_SIZE) {
    if (bfd_get_error () != bfd_error_system_call)
      bfd_set_error (bfd_error_wrong_format);
    return 0;
  }
  NAME(aout,swap_exec_header_in)(abfd, &exec_bytes, &exec);

  return aout_32_some_aout_object_p (abfd, &exec, encap_realcallback);
}

/* Finish up the reading of a encapsulated-coff a.out file header */
const bfd_target *
encap_real_callback (abfd)
     bfd *abfd;
{
  struct internal_exec *execp = exec_hdr (abfd);
  
  MY(callback)(abfd, execp);
  
  /* If we have a coff header, it can give us better values for
     text_start and exec_data_start.  This is particularly useful
     for remote debugging of embedded systems.  */
  if (N_FLAGS(exec_aouthdr) & N_FLAGS_COFF_ENCAPSULATE)
  {
	  struct coffheader ch;
	  int val;
	  val = lseek (execchan, -(sizeof (AOUTHDR) + sizeof (ch)), 1);
	  if (val == -1)
		  perror_with_name (filename);
	  val = myread (execchan, &ch, sizeof (ch));
	  if (val < 0)
		  perror_with_name (filename);
	  text_start = ch.text_start;
	  exec_data_start = ch.data_start;
  } else
	 {
	  text_start =
	    IS_OBJECT_FILE (exec_aouthdr) ? 0 : N_TXTADDR (exec_aouthdr);
	  exec_data_start = IS_OBJECT_FILE (exec_aouthdr)
	    ? exec_aouthdr.a_text : N_DATADDR (exec_aouthdr);
  }

  /* Determine the architecture and machine type of the object file.  */
  bfd_default_set_arch_mach(abfd, bfd_arch_m68k, 0); /* FIXME */

  return abfd->xvec;
}

/* Write an object file in Encapsulated COFF format.
   Section contents have already been written.  We write the
   file header, symbols, and relocation.  */

boolean
encap_write_object_contents (abfd)
     bfd *abfd;
{
  bfd_size_type data_pad = 0;
  struct external_exec exec_bytes;
  struct internal_exec *execp = exec_hdr (abfd);

/****** FIXME:  Fragments from the old GNU LD program for dealing with
        encap coff.  */
struct coffheader coffheader;
int need_coff_header;

  /* Determine whether to count the header as part of
     the text size, and initialize the text size accordingly.
     This depends on the kind of system and on the output format selected.  */

  N_SET_MAGIC (outheader, magic);
#ifdef INITIALIZE_HEADER
  INITIALIZE_HEADER;
#endif

  text_size = sizeof (struct exec);
#ifdef COFF_ENCAPSULATE
  if (relocatable_output == 0 && file_table[0].just_syms_flag == 0)
    {
      need_coff_header = 1;
      /* set this flag now, since it will change the values of N_TXTOFF, etc */
      N_SET_FLAGS (outheader, aout_backend_info (abfd)->exec_hdr_flags);
      text_size += sizeof (struct coffheader);
    }
#endif

#ifdef COFF_ENCAPSULATE
  if (need_coff_header)
    {
      /* We are encapsulating BSD format within COFF format.  */
      struct coffscn *tp, *dp, *bp;

      tp = &coffheader.scns[0];
      dp = &coffheader.scns[1];
      bp = &coffheader.scns[2];

      strcpy (tp->s_name, ".text");
      tp->s_paddr = text_start;
      tp->s_vaddr = text_start;
      tp->s_size = text_size;
      tp->s_scnptr = sizeof (struct coffheader) + sizeof (struct exec);
      tp->s_relptr = 0;
      tp->s_lnnoptr = 0;
      tp->s_nreloc = 0;
      tp->s_nlnno = 0;
      tp->s_flags = 0x20;
      strcpy (dp->s_name, ".data");
      dp->s_paddr = data_start;
      dp->s_vaddr = data_start;
      dp->s_size = data_size;
      dp->s_scnptr = tp->s_scnptr + tp->s_size;
      dp->s_relptr = 0;
      dp->s_lnnoptr = 0;
      dp->s_nreloc = 0;
      dp->s_nlnno = 0;
      dp->s_flags = 0x40;
      strcpy (bp->s_name, ".bss");
      bp->s_paddr = dp->s_vaddr + dp->s_size;
      bp->s_vaddr = bp->s_paddr;
      bp->s_size = bss_size;
      bp->s_scnptr = 0;
      bp->s_relptr = 0;
      bp->s_lnnoptr = 0;
      bp->s_nreloc = 0;
      bp->s_nlnno = 0;
      bp->s_flags = 0x80;

      coffheader.f_magic = COFF_MAGIC;
      coffheader.f_nscns = 3;
      /* store an unlikely time so programs can
       * tell that there is a bsd header
       */
      coffheader.f_timdat = 1;
      coffheader.f_symptr = 0;
      coffheader.f_nsyms = 0;
      coffheader.f_opthdr = 28;
      coffheader.f_flags = 0x103;
      /* aouthdr */
      coffheader.magic = ZMAGIC;
      coffheader.vstamp = 0;
      coffheader.tsize = tp->s_size;
      coffheader.dsize = dp->s_size;
      coffheader.bsize = bp->s_size;
      coffheader.entry = outheader.a_entry;
      coffheader.text_start = tp->s_vaddr;
      coffheader.data_start = dp->s_vaddr;
    }
#endif

#ifdef COFF_ENCAPSULATE
  if (need_coff_header)
    mywrite (&coffheader, sizeof coffheader, 1, outdesc);
#endif

#ifndef COFF_ENCAPSULATE
  padfile (N_TXTOFF (outheader) - sizeof outheader, outdesc);
#endif

  text_size -= N_TXTOFF (outheader);
  WRITE_HEADERS(abfd, execp);
  return true;
}

#define MY_write_object_content encap_write_object_contents
#define MY_object_p encap_object_p
#define MY_exec_hdr_flags N_FLAGS_COFF_ENCAPSULATE

#include "aout-target.h"
Commit	Line	Data
2c3f93e5	1	/* BFD back-end for a.out files encapsulated with COFF headers.
57a1867e	2	Copyright (C) 1990, 1991 Free Software Foundation, Inc.
2c3f93e5 JG	3
	4	This file is part of BFD, the Binary File Descriptor library.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	19
	20	/* THIS MODULE IS NOT FINISHED. IT PROBABLY DOESN'T EVEN COMPILE. */
	21
	22	#if 0
	23	#define PAGE_SIZE 4096
	24	#define SEGMENT_SIZE PAGE_SIZE
	25	#define TEXT_START_ADDR 0
	26	#define ARCH 32
	27	#define BYTES_IN_WORD 4
	28	#endif
	29
	30	#include "bfd.h"
	31	#include <sysdep.h>
	32	#include "libbfd.h"
608de555	33	#include <aout/aout64.h>
c3eb25fc SC	34	#include "aout/stab_gnu.h"
c3eb25fc SC	35	#include "aout/ar.h"
2c3f93e5 JG	36	#include "libaout.h" /* BFD a.out internal data structures */
2c3f93e5 JG	37
2f3508ad	38	const bfd_target *encap_real_callback ();
2c3f93e5	39
2f3508ad	40	const bfd_target *
57a1867e DM	41	encap_object_p (abfd)
57a1867e DM	42	bfd *abfd;
2c3f93e5 JG	43	{
	44	unsigned char magicbuf[4]; /* Raw bytes of magic number from file */
	45	unsigned long magic; /* Swapped magic number */
	46	short coff_magic;
	47	struct external_exec exec_bytes;
	48	struct internal_exec exec;
	49
2c3f93e5 JG	50	if (bfd_read ((PTR)magicbuf, 1, sizeof (magicbuf), abfd) !=
2c3f93e5 JG	51	sizeof (magicbuf))
25057836 JL	52	{
	53	if (bfd_get_error () != bfd_error_system_call)
	54	bfd_set_error (bfd_error_wrong_format);
	55	return 0;
	56	}
2c3f93e5 JG	57
	58	coff_magic = bfd_h_get_16 (abfd, magicbuf);
	59	if (coff_magic != COFF_MAGIC)
	60	return 0; /* Not an encap coff file */
	61
	62	__header_offset_temp==COFF_MAGIC ? sizeof(struct coffheader) : 0)
	63	(fseek ((f), HEADER_OFFSET((f)), 1))
	64
	65	magic = bfd_h_get_32 (abfd, magicbuf);
	66
	67	if (N_BADMAG (((struct internal_exec ) &magic))) return 0;
	68
	69	struct external_exec exec_bytes;
	70	if (bfd_read ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd)
	71	!= EXEC_BYTES_SIZE) {
4002f18a ILT	72	if (bfd_get_error () != bfd_error_system_call)
4002f18a ILT	73	bfd_set_error (bfd_error_wrong_format);
2c3f93e5 JG	74	return 0;
	75	}
	76	NAME(aout,swap_exec_header_in)(abfd, &exec_bytes, &exec);
	77
608de555	78	return aout_32_some_aout_object_p (abfd, &exec, encap_realcallback);
2c3f93e5 JG	79	}
	80
	81	/* Finish up the reading of a encapsulated-coff a.out file header */
2f3508ad	82	const bfd_target *
57a1867e DM	83	encap_real_callback (abfd)
57a1867e DM	84	bfd *abfd;
2c3f93e5 JG	85	{
	86	struct internal_exec *execp = exec_hdr (abfd);
	87
608de555	88	MY(callback)(abfd, execp);
2c3f93e5 JG	89
	90	/* If we have a coff header, it can give us better values for
	91	text_start and exec_data_start. This is particularly useful
	92	for remote debugging of embedded systems. */
	93	if (N_FLAGS(exec_aouthdr) & N_FLAGS_COFF_ENCAPSULATE)
	94	{
	95	struct coffheader ch;
	96	int val;
	97	val = lseek (execchan, -(sizeof (AOUTHDR) + sizeof (ch)), 1);
	98	if (val == -1)
	99	perror_with_name (filename);
	100	val = myread (execchan, &ch, sizeof (ch));
	101	if (val < 0)
	102	perror_with_name (filename);
	103	text_start = ch.text_start;
	104	exec_data_start = ch.data_start;
	105	} else
	106	{
	107	text_start =
	108	IS_OBJECT_FILE (exec_aouthdr) ? 0 : N_TXTADDR (exec_aouthdr);
	109	exec_data_start = IS_OBJECT_FILE (exec_aouthdr)
	110	? exec_aouthdr.a_text : N_DATADDR (exec_aouthdr);
	111	}
	112
	113	/* Determine the architecture and machine type of the object file. */
	114	bfd_default_set_arch_mach(abfd, bfd_arch_m68k, 0); /* FIXME */
	115
	116	return abfd->xvec;
	117	}
	118
	119	/* Write an object file in Encapsulated COFF format.
	120	Section contents have already been written. We write the
	121	file header, symbols, and relocation. */
	122
	123	boolean
57a1867e DM	124	encap_write_object_contents (abfd)
57a1867e DM	125	bfd *abfd;
2c3f93e5 JG	126	{
	127	bfd_size_type data_pad = 0;
	128	struct external_exec exec_bytes;
	129	struct internal_exec *execp = exec_hdr (abfd);
	130
	131	/****** FIXME: Fragments from the old GNU LD program for dealing with
	132	encap coff. */
	133	struct coffheader coffheader;
	134	int need_coff_header;
	135
	136	/* Determine whether to count the header as part of
	137	the text size, and initialize the text size accordingly.
	138	This depends on the kind of system and on the output format selected. */
	139
	140	N_SET_MAGIC (outheader, magic);
	141	#ifdef INITIALIZE_HEADER
	142	INITIALIZE_HEADER;
	143	#endif
	144
	145	text_size = sizeof (struct exec);
	146	#ifdef COFF_ENCAPSULATE
	147	if (relocatable_output == 0 && file_table[0].just_syms_flag == 0)
	148	{
	149	need_coff_header = 1;
	150	/* set this flag now, since it will change the values of N_TXTOFF, etc */
77d11284	151	N_SET_FLAGS (outheader, aout_backend_info (abfd)->exec_hdr_flags);
2c3f93e5 JG	152	text_size += sizeof (struct coffheader);
	153	}
	154	#endif
	155
	156	#ifdef COFF_ENCAPSULATE
	157	if (need_coff_header)
	158	{
	159	/* We are encapsulating BSD format within COFF format. */
	160	struct coffscn tp, dp, *bp;
	161
	162	tp = &coffheader.scns[0];
	163	dp = &coffheader.scns[1];
	164	bp = &coffheader.scns[2];
	165
	166	strcpy (tp->s_name, ".text");
	167	tp->s_paddr = text_start;
	168	tp->s_vaddr = text_start;
	169	tp->s_size = text_size;
	170	tp->s_scnptr = sizeof (struct coffheader) + sizeof (struct exec);
	171	tp->s_relptr = 0;
	172	tp->s_lnnoptr = 0;
	173	tp->s_nreloc = 0;
	174	tp->s_nlnno = 0;
	175	tp->s_flags = 0x20;
	176	strcpy (dp->s_name, ".data");
	177	dp->s_paddr = data_start;
	178	dp->s_vaddr = data_start;
	179	dp->s_size = data_size;
	180	dp->s_scnptr = tp->s_scnptr + tp->s_size;
	181	dp->s_relptr = 0;
	182	dp->s_lnnoptr = 0;
	183	dp->s_nreloc = 0;
	184	dp->s_nlnno = 0;
	185	dp->s_flags = 0x40;
	186	strcpy (bp->s_name, ".bss");
	187	bp->s_paddr = dp->s_vaddr + dp->s_size;
	188	bp->s_vaddr = bp->s_paddr;
	189	bp->s_size = bss_size;
	190	bp->s_scnptr = 0;
	191	bp->s_relptr = 0;
	192	bp->s_lnnoptr = 0;
	193	bp->s_nreloc = 0;
	194	bp->s_nlnno = 0;
	195	bp->s_flags = 0x80;
	196
	197	coffheader.f_magic = COFF_MAGIC;
	198	coffheader.f_nscns = 3;
	199	/* store an unlikely time so programs can
	200	* tell that there is a bsd header
	201	*/
	202	coffheader.f_timdat = 1;
	203	coffheader.f_symptr = 0;
	204	coffheader.f_nsyms = 0;
	205	coffheader.f_opthdr = 28;
	206	coffheader.f_flags = 0x103;
	207	/* aouthdr */
	208	coffheader.magic = ZMAGIC;
	209	coffheader.vstamp = 0;
	210	coffheader.tsize = tp->s_size;
	211	coffheader.dsize = dp->s_size;
	212	coffheader.bsize = bp->s_size;
	213	coffheader.entry = outheader.a_entry;
	214	coffheader.text_start = tp->s_vaddr;
	215	coffheader.data_start = dp->s_vaddr;
216	}
217	#endif
218
219	#ifdef COFF_ENCAPSULATE
220	if (need_coff_header)
221	mywrite (&coffheader, sizeof coffheader, 1, outdesc);
222	#endif
223
224	#ifndef COFF_ENCAPSULATE
225	padfile (N_TXTOFF (outheader) - sizeof outheader, outdesc);
226	#endif
227
228	text_size -= N_TXTOFF (outheader);
229	WRITE_HEADERS(abfd, execp);
230	return true;
231	}
608de555 PB	232
	233	#define MY_write_object_content encap_write_object_contents
	234	#define MY_object_p encap_object_p
77d11284	235	#define MY_exec_hdr_flags N_FLAGS_COFF_ENCAPSULATE
608de555 PB	236
608de555 PB	237	#include "aout-target.h"