aboutsummaryrefslogtreecommitdiff
path: root/bfd/coff-stgo32.c
blob: d1be578c6aa3d1edbb5f71e29748ec402cb396ae (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
/* BFD back-end for Intel 386 COFF files (DJGPP variant with a stub).
   Copyright (C) 1997-2020 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 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.  */

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

   The COFF image is loaded in memory without the stub attached, so
   all offsets are relative to the beginning of the image, not the
   actual file.  We handle this in bfd by setting bfd->origin to where
   the COFF image starts.  */

#define TARGET_SYM		i386_coff_go32stubbed_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 }, \
{ COFF_SECTION_NAME_PARTIAL_MATCH (".debug"), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
{ COFF_SECTION_NAME_PARTIAL_MATCH (".gnu.linkonce.wi"), \
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }

#include "sysdep.h"
#include "bfd.h"
#include "coff/msdos.h"

static bfd_cleanup go32exe_check_format (bfd *);
static bfd_boolean go32exe_write_object_contents (bfd *);
static bfd_boolean go32exe_mkobject (bfd *);
static bfd_boolean go32exe_copy_private_bfd_data (bfd *, bfd *);

#define COFF_CHECK_FORMAT go32exe_check_format
#define COFF_WRITE_CONTENTS go32exe_write_object_contents
#define coff_mkobject go32exe_mkobject
#define coff_bfd_copy_private_bfd_data go32exe_copy_private_bfd_data

#include "coff-i386.c"

/* This macro is used, because I cannot assume the endianness of the
   host system.  */
#define _H(index) (H_GET_16 (abfd, (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'.  */
#define GO32EXE_DEFAULT_STUB_SIZE 2048
static const unsigned char go32exe_default_stub[GO32EXE_DEFAULT_STUB_SIZE] =
{
#include "go32stub.h"
};

/* Temporary location for stub read from input file.  */
static char * go32exe_temp_stub = NULL;
static bfd_size_type go32exe_temp_stub_size = 0;

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

   Ideally this function should exec '$(TARGET)-stubify' to generate
   a stub, like gcc does.  */

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

      /* If we read a stub from an input file, use that one.  */
      if (go32exe_temp_stub != NULL)
	{
	  coff_data (abfd)->stub = bfd_alloc (abfd,
						  go32exe_temp_stub_size);
	  if (coff_data (abfd)->stub == NULL)
	    return;
	  memcpy (coff_data (abfd)->stub, go32exe_temp_stub,
		  go32exe_temp_stub_size);
	  coff_data (abfd)->stub_size = go32exe_temp_stub_size;
	  free (go32exe_temp_stub);
	  go32exe_temp_stub = NULL;
	  go32exe_temp_stub_size = 0;
	  return;
	}

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

      exe_start = _H (4) * 16;
      if ((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 (! CONST_STRNEQ (magic, "go32stub"))
	{
	  close (f);
	  goto stub_end;
	}
      /* Now we found a correct stub (hopefully).  */
      coff_data (abfd)->stub = bfd_alloc (abfd, (bfd_size_type) coff_start);
      if (coff_data (abfd)->stub == NULL)
	{
	  close (f);
	  return;
	}
      lseek (f, 0L, SEEK_SET);
      if ((unsigned long) read (f, coff_data (abfd)->stub, coff_start)
	  != coff_start)
	{
	  bfd_release (abfd, coff_data (abfd)->stub);
	  coff_data (abfd)->stub = NULL;
	}
      else
	coff_data (abfd)->stub_size = coff_start;
      close (f);
    }
 stub_end:
  /* There was something wrong above, so use now the standard builtin
     stub.  */
  if (coff_data (abfd)->stub == NULL)
    {
      coff_data (abfd)->stub
	= bfd_alloc (abfd, (bfd_size_type) GO32EXE_DEFAULT_STUB_SIZE);
      if (coff_data (abfd)->stub == NULL)
	return;
      memcpy (coff_data (abfd)->stub, go32exe_default_stub,
	      GO32EXE_DEFAULT_STUB_SIZE);
      coff_data (abfd)->stub_size = GO32EXE_DEFAULT_STUB_SIZE;
    }
}

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

static bfd_boolean
go32exe_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
{
  /* Check if both are the same targets.  */
  if (ibfd->xvec != obfd->xvec)
    return TRUE;

  /* Make sure we have a source stub.  */
  BFD_ASSERT (coff_data (ibfd)->stub != NULL);

  /* Reallocate the output stub if necessary.  */
  if (coff_data (ibfd)->stub_size > coff_data (obfd)->stub_size)
    coff_data (obfd)->stub = bfd_alloc (obfd, coff_data (ibfd)->stub_size);
  if (coff_data (obfd)->stub == NULL)
    return FALSE;

  /* Now copy the stub.  */
  memcpy (coff_data (obfd)->stub, coff_data (ibfd)->stub,
	  coff_data (ibfd)->stub_size);
  coff_data (obfd)->stub_size = coff_data (ibfd)->stub_size;
  obfd->origin = coff_data (obfd)->stub_size;

  return TRUE;
}

/* Cleanup function, returned from check_format hook.  */

static void
go32exe_cleanup (bfd *abfd)
{
  abfd->origin = 0;

  if (go32exe_temp_stub != NULL)
    free (go32exe_temp_stub);
  go32exe_temp_stub = NULL;
  go32exe_temp_stub_size = 0;
}

/* Check that there is a GO32 stub and read it to go32exe_temp_stub.
   Then set abfd->origin so that the COFF image is read at the correct
   file offset.  */

static bfd_cleanup
go32exe_check_format (bfd *abfd)
{
  struct external_DOS_hdr filehdr_dos;
  uint16_t num_pages;
  uint16_t last_page_size;
  uint32_t header_end;
  bfd_size_type stubsize;

  /* This format can not appear in an archive.  */
  if (abfd->origin != 0)
    {
      bfd_set_error (bfd_error_wrong_format);
      return NULL;
    }

  bfd_set_error (bfd_error_system_call);

  /* Read in the stub file header, which is a DOS MZ executable.  */
  if (bfd_bread (&filehdr_dos, DOS_HDR_SIZE, abfd) != DOS_HDR_SIZE)
    goto fail;

  /* Make sure that this is an MZ executable.  */
  if (H_GET_16 (abfd, filehdr_dos.e_magic) != IMAGE_DOS_SIGNATURE)
    goto fail_format;

  /* Determine the size of the stub  */
  num_pages = H_GET_16 (abfd, filehdr_dos.e_cp);
  last_page_size = H_GET_16 (abfd, filehdr_dos.e_cblp);
  stubsize = num_pages * 512;
  if (last_page_size != 0)
    stubsize += last_page_size - 512;

  /* Save now the stub to be used later.  Put the stub data to a temporary
     location first as tdata still does not exist.  It may not even
     be ever created if we are just checking the file format of ABFD.  */
  bfd_seek (abfd, 0, SEEK_SET);
  go32exe_temp_stub = bfd_malloc (stubsize);
  if (go32exe_temp_stub == NULL)
    goto fail;
  if (bfd_bread (go32exe_temp_stub, stubsize, abfd) != stubsize)
    goto fail;
  go32exe_temp_stub_size = stubsize;

  /* Confirm that this is a go32stub.  */
  header_end = H_GET_16 (abfd, filehdr_dos.e_cparhdr) * 16UL;
  if (! CONST_STRNEQ (go32exe_temp_stub + header_end, "go32stub"))
    goto fail_format;

  /* Set origin to where the COFF header starts and seek there.  */
  abfd->origin = stubsize;
  if (bfd_seek (abfd, 0, SEEK_SET) != 0)
    goto fail;

  /* Call coff_object_p to read the COFF image.  If this fails then the file
     must be just a stub with no COFF data attached.  */
  bfd_cleanup cleanup = coff_object_p (abfd);
  if (cleanup == NULL)
    goto fail;
  BFD_ASSERT (cleanup == _bfd_no_cleanup);

  return go32exe_cleanup;

 fail_format:
  bfd_set_error (bfd_error_wrong_format);
 fail:
  go32exe_cleanup (abfd);
  return NULL;
}

/* Write the stub to the output file, then call coff_write_object_contents.  */

static bfd_boolean
go32exe_write_object_contents (bfd *abfd)
{
  const bfd_size_type pos = bfd_tell (abfd);
  const bfd_size_type stubsize = coff_data (abfd)->stub_size;

  BFD_ASSERT (stubsize != 0);

  bfd_set_error (bfd_error_system_call);

  /* Write the stub.  */
  abfd->origin = 0;
  if (bfd_seek (abfd, 0, SEEK_SET) != 0)
    return FALSE;
  if (bfd_bwrite (coff_data (abfd)->stub, stubsize, abfd) != stubsize)
    return FALSE;

  /* Seek back to where we were.  */
  abfd->origin = stubsize;
  if (bfd_seek (abfd, pos, SEEK_SET) != 0)
    return FALSE;

  return coff_write_object_contents (abfd);
}

/* mkobject hook.  Called directly through bfd_set_format or via
   coff_mkobject_hook etc from bfd_check_format.  */

static bfd_boolean
go32exe_mkobject (bfd *abfd)
{
  coff_data_type *coff = NULL;
  const bfd_size_type amt = sizeof (coff_data_type);

  /* Don't output to an archive.  */
  if (abfd->my_archive != NULL)
    return FALSE;

  abfd->tdata.coff_obj_data = bfd_zalloc (abfd, amt);
  if (abfd->tdata.coff_obj_data == NULL)
    return FALSE;
  coff = coff_data (abfd);
  coff->symbols = NULL;
  coff->conversion_table = NULL;
  coff->raw_syments = NULL;
  coff->relocbase = 0;
  coff->local_toc_sym_map = 0;

  go32exe_create_stub (abfd);
  if (coff->stub == NULL)
    {
      bfd_release (abfd, coff);
      return FALSE;
    }
  abfd->origin = coff->stub_size;

/*  make_abs_section(abfd);*/ /* ??? */

  return TRUE;
}