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