[deliverable/binutils-gdb.git] / bfd / coff-stgo32.c

/* BFD back-end for Intel 386 COFF files (DJGPP variant with a stub).
   Copyright 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
   Written by Robert Hoehne.

   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 handles now also stubbed coff images. The stub is a small
   DOS executable program before the coff image to load it in memory
   and execute it. This is needed, because DOS cannot run coff files.

   All the functions below are called by the corresponding functions
   from coffswap.h.
   The only thing what they do is to adjust the information stored in
   the COFF file which are offset into the file.
   This is needed, because DJGPP uses a very special way to load and run
   the coff image. It loads the image in memory and assumes then, that the
   image had no stub by using the filepointers as pointers in the coff
   image and NOT in the file.

   To be compatible with any existing executables I have fixed this
   here and NOT in the DJGPP startup code.
 */

#define TARGET_SYM		go32stubbedcoff_vec
#define TARGET_NAME		"coff-go32-exe"
#define TARGET_UNDERSCORE	'_'
#define COFF_GO32_EXE
#define COFF_LONG_SECTION_NAMES
#define COFF_SUPPORT_GNU_LINKONCE
#define COFF_LONG_FILENAMES

#define COFF_SECTION_ALIGNMENT_ENTRIES \
{ COFF_SECTION_NAME_EXACT_MATCH (".data"), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
{ COFF_SECTION_NAME_EXACT_MATCH (".text"), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }

#include "bfd.h"

/* At first the prototypes */

static void
adjust_filehdr_in_post PARAMS ((bfd * abfd, PTR src, PTR dst));
static void
adjust_filehdr_out_pre PARAMS ((bfd * abfd, PTR in, PTR out));
static void
adjust_filehdr_out_post PARAMS ((bfd * abfd, PTR in, PTR out));

static void
adjust_scnhdr_in_post PARAMS ((bfd * abfd, PTR ext, PTR in));
static void
adjust_scnhdr_out_pre PARAMS ((bfd * abfd, PTR in, PTR out));
static void
adjust_scnhdr_out_post PARAMS ((bfd * abfd, PTR in, PTR out));

static void
adjust_aux_in_post PARAMS ((bfd * abfd, PTR ext1, int type, int class, int indx,
			    int numaux, PTR in1));
static void
adjust_aux_out_pre PARAMS ((bfd * abfd, PTR inp, int type, int class, int indx,
			    int numaux, PTR extp));
static void
adjust_aux_out_post PARAMS ((bfd * abfd, PTR inp, int type, int class, int indx,
			     int numaux, PTR extp));

static void
create_go32_stub PARAMS ((bfd * abfd));

/*
   All that ..._PRE and ...POST functions are called from the corresponding
   coff_swap... functions. The ...PRE functions are called at the beginning
   of the function and the ...POST functions at the end of the swap routines.
 */

#define COFF_ADJUST_FILEHDR_IN_POST adjust_filehdr_in_post
#define COFF_ADJUST_FILEHDR_OUT_PRE adjust_filehdr_out_pre
#define COFF_ADJUST_FILEHDR_OUT_POST adjust_filehdr_out_post

#define COFF_ADJUST_SCNHDR_IN_POST adjust_scnhdr_in_post
#define COFF_ADJUST_SCNHDR_OUT_PRE adjust_scnhdr_out_pre
#define COFF_ADJUST_SCNHDR_OUT_POST adjust_scnhdr_out_post

#define COFF_ADJUST_AUX_IN_POST adjust_aux_in_post
#define COFF_ADJUST_AUX_OUT_PRE adjust_aux_out_pre
#define COFF_ADJUST_AUX_OUT_POST adjust_aux_out_post

static boolean
  go32_stubbed_coff_bfd_copy_private_bfd_data PARAMS ((bfd * ibfd, bfd * obfd));

#define coff_bfd_copy_private_bfd_data go32_stubbed_coff_bfd_copy_private_bfd_data

#include "coff-i386.c"

/* I hold in the usrdata the stub */
#define bfd_coff_go32stub bfd_usrdata

/* This macro is used, because I cannot assume the endianess of the
   host system */
#define _H(index) (bfd_h_get_16(abfd, (bfd_byte *) (header+index*2)))

/* These bytes are a 2048-byte DOS executable, which loads the COFF
   image into memory and then runs it. It is called 'stub' */

static unsigned char stub_bytes[STUBSIZE] =
{
#include "go32stub.h"
};

/*
   I have not commented each swap function below, because the
   technique is in any function the same. For the ...in function,
   all the pointers are adjusted by adding STUBSIZE and for the
   ...out function, it is subtracted first and after calling the
   standard swap function it is reset to the old value */

/* This macro is used for adjusting the filepointers, which
   is done only, if the pointer is nonzero */

#define ADJUST_VAL(val,diff) \
  if (val != 0) val += diff

static void
adjust_filehdr_in_post  (abfd, src, dst)
     bfd *abfd;
     PTR src;
     PTR dst;
{
  FILHDR *filehdr_src = (FILHDR *) src;
  struct internal_filehdr *filehdr_dst = (struct internal_filehdr *) dst;

  ADJUST_VAL (filehdr_dst->f_symptr, STUBSIZE);

  /* Save now the stub to be used later */
  bfd_coff_go32stub (abfd) = (PTR) bfd_alloc (abfd, STUBSIZE);

  /* Since this function returns no status, I do not set here
     any bfd_error_...
     That means, before the use of bfd_coff_go32stub (), this value
     should be checked if it is != NULL */
  if (bfd_coff_go32stub (abfd) == NULL)
    return;
  memcpy (bfd_coff_go32stub (abfd), filehdr_src->stub, STUBSIZE);
}

static void
adjust_filehdr_out_pre  (abfd, in, out)
     bfd *abfd;
     PTR in;
     PTR out;
{
  struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
  FILHDR *filehdr_out = (FILHDR *) out;

  /* Generate the stub */
  create_go32_stub (abfd);

  /* Copy the stub to the file header */
  if (bfd_coff_go32stub (abfd) != NULL)
    memcpy (filehdr_out->stub, bfd_coff_go32stub (abfd), STUBSIZE);
  else
    /* use the default */
    memcpy (filehdr_out->stub, stub_bytes, STUBSIZE);

  ADJUST_VAL (filehdr_in->f_symptr, -STUBSIZE);
}

static void
adjust_filehdr_out_post  (abfd, in, out)
     bfd *abfd ATTRIBUTE_UNUSED;
     PTR in;
     PTR out ATTRIBUTE_UNUSED;
{
  struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
  /* undo the above change */
  ADJUST_VAL (filehdr_in->f_symptr, STUBSIZE);
}

static void
adjust_scnhdr_in_post  (abfd, ext, in)
     bfd *abfd ATTRIBUTE_UNUSED;
     PTR ext ATTRIBUTE_UNUSED;
     PTR in;
{
  struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;

  ADJUST_VAL (scnhdr_int->s_scnptr, STUBSIZE);
  ADJUST_VAL (scnhdr_int->s_relptr, STUBSIZE);
  ADJUST_VAL (scnhdr_int->s_lnnoptr, STUBSIZE);
}

static void
adjust_scnhdr_out_pre  (abfd, in, out)
     bfd *abfd ATTRIBUTE_UNUSED;
     PTR in;
     PTR out ATTRIBUTE_UNUSED;
{
  struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;

  ADJUST_VAL (scnhdr_int->s_scnptr, -STUBSIZE);
  ADJUST_VAL (scnhdr_int->s_relptr, -STUBSIZE);
  ADJUST_VAL (scnhdr_int->s_lnnoptr, -STUBSIZE);
}

static void
adjust_scnhdr_out_post (abfd, in, out)
     bfd *abfd ATTRIBUTE_UNUSED;
     PTR in;
     PTR out ATTRIBUTE_UNUSED;
{
  struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;

  ADJUST_VAL (scnhdr_int->s_scnptr, STUBSIZE);
  ADJUST_VAL (scnhdr_int->s_relptr, STUBSIZE);
  ADJUST_VAL (scnhdr_int->s_lnnoptr, STUBSIZE);
}

static void
adjust_aux_in_post  (abfd, ext1, type, class, indx, numaux, in1)
     bfd *abfd ATTRIBUTE_UNUSED;
     PTR ext1 ATTRIBUTE_UNUSED;
     int type;
     int class;
     int indx ATTRIBUTE_UNUSED;
     int numaux ATTRIBUTE_UNUSED;
     PTR in1;
{
  union internal_auxent *in = (union internal_auxent *) in1;

  if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
    {
      ADJUST_VAL (in->x_sym.x_fcnary.x_fcn.x_lnnoptr, STUBSIZE);
    }
}

static void
adjust_aux_out_pre  (abfd, inp, type, class, indx, numaux, extp)
     bfd *abfd ATTRIBUTE_UNUSED;
     PTR inp;
     int type;
     int class;
     int indx ATTRIBUTE_UNUSED;
     int numaux ATTRIBUTE_UNUSED;
     PTR extp ATTRIBUTE_UNUSED;
{
  union internal_auxent *in = (union internal_auxent *) inp;

  if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
    {
      ADJUST_VAL (in->x_sym.x_fcnary.x_fcn.x_lnnoptr, -STUBSIZE);
    }
}

static void
adjust_aux_out_post (abfd, inp, type, class, indx, numaux, extp)
     bfd *abfd ATTRIBUTE_UNUSED;
     PTR inp;
     int type;
     int class;
     int indx ATTRIBUTE_UNUSED;
     int numaux ATTRIBUTE_UNUSED;
     PTR extp ATTRIBUTE_UNUSED;
{
  union internal_auxent *in = (union internal_auxent *) inp;

  if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
    {
      ADJUST_VAL (in->x_sym.x_fcnary.x_fcn.x_lnnoptr, STUBSIZE);
    }
}

/*
   That's the function, which creates the stub. There are
   different cases from where the stub is taken.
   At first the environment variable $(GO32STUB) is checked and then
   $(STUB) if it was not set.
   If it exists and points to a valid stub the stub is taken from
   that file. This file can be also a whole executable file, because
   the stub is computed from the exe information at the start of that
   file.

   If there was any error, the standard stub (compiled in this file)
   is taken.
 */

static void
create_go32_stub (abfd)
     bfd *abfd;
{
  /* Do it only once */
  if (bfd_coff_go32stub (abfd) == NULL)
    {
      char *stub;
      struct stat st;
      int f;
      unsigned char header[10];
      char magic[8];
      unsigned long coff_start, exe_start;

      /* Check at first the environment variable $(GO32STUB) */
      stub = getenv ("GO32STUB");
      /* Now check the environment variable $(STUB) */
      if (stub == NULL)
	stub = getenv ("STUB");
      if (stub == NULL)
	goto stub_end;
      if (stat (stub, &st) != 0)
	goto stub_end;
#ifdef O_BINARY
      f = open (stub, O_RDONLY | O_BINARY);
#else
      f = open (stub, O_RDONLY);
#endif
      if (f < 0)
	goto stub_end;
      if (read (f, &header, sizeof (header)) < 0)
	{
	  close (f);
	  goto stub_end;
	}
      if (_H (0) != 0x5a4d)	/* it is not an exe file */
	{
	  close (f);
	  goto stub_end;
	}
      /* Compute the size of the stub (it is every thing up
         to the beginning of the coff image) */
      coff_start = (long) _H (2) * 512L;
      if (_H (1))
	coff_start += (long) _H (1) - 512L;

      /* Currently there is only a fixed stub size of 2048 bytes
         supported */
      if (coff_start != 2048)
	{
	  close (f);
	  goto stub_end;
	}
      exe_start = _H (4) * 16;
      if ((unsigned long) lseek (f, exe_start, SEEK_SET) != exe_start)
	{
	  close (f);
	  goto stub_end;
	}
      if (read (f, &magic, 8) != 8)
	{
	  close (f);
	  goto stub_end;
	}
      if (memcmp (magic, "go32stub", 8) != 0)
	{
	  close (f);
	  goto stub_end;
	}
      /* Now we found a correct stub (hopefully) */
      bfd_coff_go32stub (abfd) = (PTR) bfd_alloc (abfd, coff_start);
      if (bfd_coff_go32stub (abfd) == NULL)
	{
	  close (f);
	  return;
	}
      lseek (f, 0L, SEEK_SET);
      if ((unsigned long) read (f, bfd_coff_go32stub (abfd), coff_start)
	  != coff_start)
	{
	  bfd_release (abfd, bfd_coff_go32stub (abfd));
	  bfd_coff_go32stub (abfd) = NULL;
	}
      close (f);
    }
stub_end:
  /* There was something wrong above, so use now the standard builtin
     stub */
  if (bfd_coff_go32stub (abfd) == NULL)
    {
      bfd_coff_go32stub (abfd) = (PTR) bfd_alloc (abfd, STUBSIZE);
      if (bfd_coff_go32stub (abfd) == NULL)
	{
	  return;
	}

      memcpy (bfd_coff_go32stub (abfd), stub_bytes, STUBSIZE);
    }
}

/* If ibfd was a stubbed coff image, copy the stub from that bfd
   to the new obfd.
 */

static boolean
go32_stubbed_coff_bfd_copy_private_bfd_data  (ibfd, obfd)
     bfd *ibfd;
     bfd *obfd;
{
  /* check if both are the same targets */
  if (ibfd->xvec != obfd->xvec)
    return true;

  /* check if both have a valid stub */
  if (bfd_coff_go32stub (ibfd) == NULL
      || bfd_coff_go32stub (obfd) == NULL)
    return true;

  /* Now copy the stub */
  memcpy (bfd_coff_go32stub (obfd), bfd_coff_go32stub (ibfd), STUBSIZE);

  return true;
}
Commit	Line	Data
a4f68544 NC	1	/* BFD back-end for Intel 386 COFF files (DJGPP variant with a stub).
a4f68544 NC	2	Copyright 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
252b5132 RH	3	Written by Robert Hoehne.
	4
	5	This file is part of BFD, the Binary File Descriptor library.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	20
	21	/* This file handles now also stubbed coff images. The stub is a small
	22	DOS executable program before the coff image to load it in memory
	23	and execute it. This is needed, because DOS cannot run coff files.
	24
	25	All the functions below are called by the corresponding functions
	26	from coffswap.h.
	27	The only thing what they do is to adjust the information stored in
	28	the COFF file which are offset into the file.
	29	This is needed, because DJGPP uses a very special way to load and run
	30	the coff image. It loads the image in memory and assumes then, that the
	31	image had no stub by using the filepointers as pointers in the coff
	32	image and NOT in the file.
	33
	34	To be compatible with any existing executables I have fixed this
	35	here and NOT in the DJGPP startup code.
	36	*/
	37
	38	#define TARGET_SYM go32stubbedcoff_vec
	39	#define TARGET_NAME "coff-go32-exe"
	40	#define TARGET_UNDERSCORE '_'
	41	#define COFF_GO32_EXE
242eabea ILT	42	#define COFF_LONG_SECTION_NAMES
242eabea ILT	43	#define COFF_SUPPORT_GNU_LINKONCE
a4f68544	44	#define COFF_LONG_FILENAMES
252b5132	45
5dccc1dd ILT	46	#define COFF_SECTION_ALIGNMENT_ENTRIES \
	47	{ COFF_SECTION_NAME_EXACT_MATCH (".data"), \
	48	COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
	49	{ COFF_SECTION_NAME_EXACT_MATCH (".text"), \
	50	COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }
	51
252b5132 RH	52	#include "bfd.h"
	53
	54	/* At first the prototypes */
	55
	56	static void
	57	adjust_filehdr_in_post PARAMS ((bfd * abfd, PTR src, PTR dst));
	58	static void
	59	adjust_filehdr_out_pre PARAMS ((bfd * abfd, PTR in, PTR out));
	60	static void
	61	adjust_filehdr_out_post PARAMS ((bfd * abfd, PTR in, PTR out));
	62
	63	static void
	64	adjust_scnhdr_in_post PARAMS ((bfd * abfd, PTR ext, PTR in));
	65	static void
	66	adjust_scnhdr_out_pre PARAMS ((bfd * abfd, PTR in, PTR out));
	67	static void
	68	adjust_scnhdr_out_post PARAMS ((bfd * abfd, PTR in, PTR out));
	69
	70	static void
	71	adjust_aux_in_post PARAMS ((bfd * abfd, PTR ext1, int type, int class, int indx,
	72	int numaux, PTR in1));
	73	static void
	74	adjust_aux_out_pre PARAMS ((bfd * abfd, PTR inp, int type, int class, int indx,
	75	int numaux, PTR extp));
	76	static void
	77	adjust_aux_out_post PARAMS ((bfd * abfd, PTR inp, int type, int class, int indx,
	78	int numaux, PTR extp));
	79
	80	static void
	81	create_go32_stub PARAMS ((bfd * abfd));
	82
	83	/*
	84	All that ..._PRE and ...POST functions are called from the corresponding
	85	coff_swap... functions. The ...PRE functions are called at the beginning
	86	of the function and the ...POST functions at the end of the swap routines.
	87	*/
	88
	89	#define COFF_ADJUST_FILEHDR_IN_POST adjust_filehdr_in_post
	90	#define COFF_ADJUST_FILEHDR_OUT_PRE adjust_filehdr_out_pre
	91	#define COFF_ADJUST_FILEHDR_OUT_POST adjust_filehdr_out_post
	92
	93	#define COFF_ADJUST_SCNHDR_IN_POST adjust_scnhdr_in_post
	94	#define COFF_ADJUST_SCNHDR_OUT_PRE adjust_scnhdr_out_pre
	95	#define COFF_ADJUST_SCNHDR_OUT_POST adjust_scnhdr_out_post
	96
	97	#define COFF_ADJUST_AUX_IN_POST adjust_aux_in_post
	98	#define COFF_ADJUST_AUX_OUT_PRE adjust_aux_out_pre
	99	#define COFF_ADJUST_AUX_OUT_POST adjust_aux_out_post
	100
	101	static boolean
	102	go32_stubbed_coff_bfd_copy_private_bfd_data PARAMS ((bfd * ibfd, bfd * obfd));
	103
	104	#define coff_bfd_copy_private_bfd_data go32_stubbed_coff_bfd_copy_private_bfd_data
	105
	106	#include "coff-i386.c"
	107
	108	/* I hold in the usrdata the stub */
	109	#define bfd_coff_go32stub bfd_usrdata
	110
	111	/* This macro is used, because I cannot assume the endianess of the
	112	host system */
6e301b2b	113	#define _H(index) (bfd_h_get_16(abfd, (bfd_byte ) (header+index2)))
252b5132	114
252b5132 RH	115	/* These bytes are a 2048-byte DOS executable, which loads the COFF
	116	image into memory and then runs it. It is called 'stub' */
	117
	118	static unsigned char stub_bytes[STUBSIZE] =
	119	{
	120	#include "go32stub.h"
	121	};
	122
	123	/*
	124	I have not commented each swap function below, because the
	125	technique is in any function the same. For the ...in function,
	126	all the pointers are adjusted by adding STUBSIZE and for the
	127	...out function, it is subtracted first and after calling the
	128	standard swap function it is reset to the old value */
	129
	130	/* This macro is used for adjusting the filepointers, which
	131	is done only, if the pointer is nonzero */
	132
	133	#define ADJUST_VAL(val,diff) \
	134	if (val != 0) val += diff
	135
	136	static void
	137	adjust_filehdr_in_post (abfd, src, dst)
	138	bfd *abfd;
	139	PTR src;
	140	PTR dst;
	141	{
	142	FILHDR filehdr_src = (FILHDR ) src;
	143	struct internal_filehdr filehdr_dst = (struct internal_filehdr ) dst;
	144
	145	ADJUST_VAL (filehdr_dst->f_symptr, STUBSIZE);
	146
	147	/* Save now the stub to be used later */
	148	bfd_coff_go32stub (abfd) = (PTR) bfd_alloc (abfd, STUBSIZE);
	149
	150	/* Since this function returns no status, I do not set here
	151	any bfd_error_...
	152	That means, before the use of bfd_coff_go32stub (), this value
	153	should be checked if it is != NULL */
	154	if (bfd_coff_go32stub (abfd) == NULL)
	155	return;
	156	memcpy (bfd_coff_go32stub (abfd), filehdr_src->stub, STUBSIZE);
	157	}
	158
	159	static void
	160	adjust_filehdr_out_pre (abfd, in, out)
	161	bfd *abfd;
	162	PTR in;
	163	PTR out;
	164	{
	165	struct internal_filehdr filehdr_in = (struct internal_filehdr ) in;
	166	FILHDR filehdr_out = (FILHDR ) out;
	167
	168	/* Generate the stub */
	169	create_go32_stub (abfd);
	170
	171	/* Copy the stub to the file header */
	172	if (bfd_coff_go32stub (abfd) != NULL)
	173	memcpy (filehdr_out->stub, bfd_coff_go32stub (abfd), STUBSIZE);
	174	else
	175	/* use the default */
	176	memcpy (filehdr_out->stub, stub_bytes, STUBSIZE);
	177
	178	ADJUST_VAL (filehdr_in->f_symptr, -STUBSIZE);
179	}
180
181	static void
182	adjust_filehdr_out_post (abfd, in, out)
5f771d47	183	bfd *abfd ATTRIBUTE_UNUSED;
252b5132	184	PTR in;
5f771d47	185	PTR out ATTRIBUTE_UNUSED;
252b5132 RH	186	{
	187	struct internal_filehdr filehdr_in = (struct internal_filehdr ) in;
	188	/* undo the above change */
	189	ADJUST_VAL (filehdr_in->f_symptr, STUBSIZE);
	190	}
	191
	192	static void
	193	adjust_scnhdr_in_post (abfd, ext, in)
5f771d47 ILT	194	bfd *abfd ATTRIBUTE_UNUSED;
5f771d47 ILT	195	PTR ext ATTRIBUTE_UNUSED;
252b5132 RH	196	PTR in;
	197	{
	198	struct internal_scnhdr scnhdr_int = (struct internal_scnhdr ) in;
	199
	200	ADJUST_VAL (scnhdr_int->s_scnptr, STUBSIZE);
	201	ADJUST_VAL (scnhdr_int->s_relptr, STUBSIZE);
	202	ADJUST_VAL (scnhdr_int->s_lnnoptr, STUBSIZE);
	203	}
	204
	205	static void
	206	adjust_scnhdr_out_pre (abfd, in, out)
5f771d47	207	bfd *abfd ATTRIBUTE_UNUSED;
252b5132	208	PTR in;
5f771d47	209	PTR out ATTRIBUTE_UNUSED;
252b5132 RH	210	{
	211	struct internal_scnhdr scnhdr_int = (struct internal_scnhdr ) in;
	212
	213	ADJUST_VAL (scnhdr_int->s_scnptr, -STUBSIZE);
	214	ADJUST_VAL (scnhdr_int->s_relptr, -STUBSIZE);
	215	ADJUST_VAL (scnhdr_int->s_lnnoptr, -STUBSIZE);
	216	}
	217
	218	static void
	219	adjust_scnhdr_out_post (abfd, in, out)
5f771d47	220	bfd *abfd ATTRIBUTE_UNUSED;
252b5132	221	PTR in;
5f771d47	222	PTR out ATTRIBUTE_UNUSED;
252b5132 RH	223	{
	224	struct internal_scnhdr scnhdr_int = (struct internal_scnhdr ) in;
	225
	226	ADJUST_VAL (scnhdr_int->s_scnptr, STUBSIZE);
	227	ADJUST_VAL (scnhdr_int->s_relptr, STUBSIZE);
	228	ADJUST_VAL (scnhdr_int->s_lnnoptr, STUBSIZE);
	229	}
	230
	231	static void
	232	adjust_aux_in_post (abfd, ext1, type, class, indx, numaux, in1)
5f771d47 ILT	233	bfd *abfd ATTRIBUTE_UNUSED;
5f771d47 ILT	234	PTR ext1 ATTRIBUTE_UNUSED;
252b5132 RH	235	int type;
252b5132 RH	236	int class;
5f771d47 ILT	237	int indx ATTRIBUTE_UNUSED;
5f771d47 ILT	238	int numaux ATTRIBUTE_UNUSED;
252b5132 RH	239	PTR in1;
	240	{
	241	union internal_auxent in = (union internal_auxent ) in1;
	242
	243	if (class == C_BLOCK \|\| class == C_FCN \|\| ISFCN (type) \|\| ISTAG (class))
	244	{
	245	ADJUST_VAL (in->x_sym.x_fcnary.x_fcn.x_lnnoptr, STUBSIZE);
	246	}
	247	}
	248
	249	static void
	250	adjust_aux_out_pre (abfd, inp, type, class, indx, numaux, extp)
5f771d47	251	bfd *abfd ATTRIBUTE_UNUSED;
252b5132 RH	252	PTR inp;
	253	int type;
	254	int class;
5f771d47 ILT	255	int indx ATTRIBUTE_UNUSED;
	256	int numaux ATTRIBUTE_UNUSED;
	257	PTR extp ATTRIBUTE_UNUSED;
252b5132 RH	258	{
	259	union internal_auxent in = (union internal_auxent ) inp;
	260
	261	if (class == C_BLOCK \|\| class == C_FCN \|\| ISFCN (type) \|\| ISTAG (class))
	262	{
	263	ADJUST_VAL (in->x_sym.x_fcnary.x_fcn.x_lnnoptr, -STUBSIZE);
	264	}
	265	}
	266
	267	static void
	268	adjust_aux_out_post (abfd, inp, type, class, indx, numaux, extp)
5f771d47	269	bfd *abfd ATTRIBUTE_UNUSED;
252b5132 RH	270	PTR inp;
	271	int type;
	272	int class;
5f771d47 ILT	273	int indx ATTRIBUTE_UNUSED;
	274	int numaux ATTRIBUTE_UNUSED;
	275	PTR extp ATTRIBUTE_UNUSED;
252b5132 RH	276	{
	277	union internal_auxent in = (union internal_auxent ) inp;
	278
	279	if (class == C_BLOCK \|\| class == C_FCN \|\| ISFCN (type) \|\| ISTAG (class))
	280	{
	281	ADJUST_VAL (in->x_sym.x_fcnary.x_fcn.x_lnnoptr, STUBSIZE);
	282	}
	283	}
	284
	285	/*
	286	That's the function, which creates the stub. There are
	287	different cases from where the stub is taken.
	288	At first the environment variable $(GO32STUB) is checked and then
	289	$(STUB) if it was not set.
	290	If it exists and points to a valid stub the stub is taken from
	291	that file. This file can be also a whole executable file, because
	292	the stub is computed from the exe information at the start of that
	293	file.
	294
	295	If there was any error, the standard stub (compiled in this file)
	296	is taken.
	297	*/
	298
	299	static void
	300	create_go32_stub (abfd)
	301	bfd *abfd;
	302	{
	303	/* Do it only once */
	304	if (bfd_coff_go32stub (abfd) == NULL)
	305	{
	306	char *stub;
	307	struct stat st;
	308	int f;
	309	unsigned char header[10];
	310	char magic[8];
	311	unsigned long coff_start, exe_start;
	312
	313	/* Check at first the environment variable $(GO32STUB) */
	314	stub = getenv ("GO32STUB");
	315	/* Now check the environment variable $(STUB) */
	316	if (stub == NULL)
	317	stub = getenv ("STUB");
	318	if (stub == NULL)
	319	goto stub_end;
	320	if (stat (stub, &st) != 0)
	321	goto stub_end;
	322	#ifdef O_BINARY
	323	f = open (stub, O_RDONLY \| O_BINARY);
	324	#else
	325	f = open (stub, O_RDONLY);
	326	#endif
	327	if (f < 0)
	328	goto stub_end;
	329	if (read (f, &header, sizeof (header)) < 0)
	330	{
	331	close (f);
	332	goto stub_end;
	333	}
	334	if (_H (0) != 0x5a4d) /* it is not an exe file */
	335	{
	336	close (f);
	337	goto stub_end;
	338	}
	339	/* Compute the size of the stub (it is every thing up
340	to the beginning of the coff image) */
341	coff_start = (long) _H (2) * 512L;
342	if (_H (1))
343	coff_start += (long) _H (1) - 512L;
344
345	/* Currently there is only a fixed stub size of 2048 bytes
346	supported */
347	if (coff_start != 2048)
348	{
349	close (f);
350	goto stub_end;
351	}
352	exe_start = _H (4) * 16;
353	if ((unsigned long) lseek (f, exe_start, SEEK_SET) != exe_start)
354	{
355	close (f);
356	goto stub_end;
357	}
358	if (read (f, &magic, 8) != 8)
359	{
360	close (f);
361	goto stub_end;
362	}
363	if (memcmp (magic, "go32stub", 8) != 0)
364	{
365	close (f);
366	goto stub_end;
367	}
368	/* Now we found a correct stub (hopefully) */
369	bfd_coff_go32stub (abfd) = (PTR) bfd_alloc (abfd, coff_start);
370	if (bfd_coff_go32stub (abfd) == NULL)
371	{
372	close (f);
373	return;
374	}
375	lseek (f, 0L, SEEK_SET);
376	if ((unsigned long) read (f, bfd_coff_go32stub (abfd), coff_start)
377	!= coff_start)
378	{
379	bfd_release (abfd, bfd_coff_go32stub (abfd));
380	bfd_coff_go32stub (abfd) = NULL;
381	}
382	close (f);
383	}
384	stub_end:
385	/* There was something wrong above, so use now the standard builtin
386	stub */
387	if (bfd_coff_go32stub (abfd) == NULL)
388	{
389	bfd_coff_go32stub (abfd) = (PTR) bfd_alloc (abfd, STUBSIZE);
390	if (bfd_coff_go32stub (abfd) == NULL)
391	{
392	return;
393	}
394
395	memcpy (bfd_coff_go32stub (abfd), stub_bytes, STUBSIZE);
396	}
397	}
398
399	/* If ibfd was a stubbed coff image, copy the stub from that bfd
400	to the new obfd.
401	*/
402
403	static boolean
404	go32_stubbed_coff_bfd_copy_private_bfd_data (ibfd, obfd)
405	bfd *ibfd;
406	bfd *obfd;
407	{
408	/* check if both are the same targets */
409	if (ibfd->xvec != obfd->xvec)
410	return true;
411
412	/* check if both have a valid stub */
413	if (bfd_coff_go32stub (ibfd) == NULL
414	\|\| bfd_coff_go32stub (obfd) == NULL)
415	return true;
416
417	/* Now copy the stub */
418	memcpy (bfd_coff_go32stub (obfd), bfd_coff_go32stub (ibfd), STUBSIZE);
419
420	return true;
421	}