1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005 Free Software Foundation, Inc.
4 Written by Cygnus Solutions.
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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
21
22 /* Most of this hacked by Steve Chamberlain <sac@cygnus.com>.
23
24 PE/PEI rearrangement (and code added): Donn Terry
25 Softway Systems, Inc. */
26
27 /* Hey look, some documentation [and in a place you expect to find it]!
28
29 The main reference for the pei format is "Microsoft Portable Executable
30 and Common Object File Format Specification 4.1". Get it if you need to
31 do some serious hacking on this code.
32
33 Another reference:
34 "Peering Inside the PE: A Tour of the Win32 Portable Executable
35 File Format", MSJ 1994, Volume 9.
36
37 The *sole* difference between the pe format and the pei format is that the
38 latter has an MSDOS 2.0 .exe header on the front that prints the message
39 "This app must be run under Windows." (or some such).
40 (FIXME: Whether that statement is *really* true or not is unknown.
41 Are there more subtle differences between pe and pei formats?
42 For now assume there aren't. If you find one, then for God sakes
43 document it here!)
44
45 The Microsoft docs use the word "image" instead of "executable" because
46 the former can also refer to a DLL (shared library). Confusion can arise
47 because the `i' in `pei' also refers to "image". The `pe' format can
48 also create images (i.e. executables), it's just that to run on a win32
49 system you need to use the pei format.
50
51 FIXME: Please add more docs here so the next poor fool that has to hack
52 on this code has a chance of getting something accomplished without
53 wasting too much time. */
54
55 /* This expands into COFF_WITH_pe or COFF_WITH_pep depending on whether
56 we're compiling for straight PE or PE+. */
57 #define COFF_WITH_XX
58
59 #include "bfd.h"
60 #include "sysdep.h"
61 #include "libbfd.h"
62 #include "coff/internal.h"
63
64 /* NOTE: it's strange to be including an architecture specific header
65 in what's supposed to be general (to PE/PEI) code. However, that's
66 where the definitions are, and they don't vary per architecture
67 within PE/PEI, so we get them from there. FIXME: The lack of
68 variance is an assumption which may prove to be incorrect if new
69 PE/PEI targets are created. */
70 #ifdef COFF_WITH_pep
71 # include "coff/ia64.h"
72 #else
73 # include "coff/i386.h"
74 #endif
75
76 #include "coff/pe.h"
77 #include "libcoff.h"
78 #include "libpei.h"
79
80 #ifdef COFF_WITH_pep
81 # undef AOUTSZ
82 # define AOUTSZ PEPAOUTSZ
83 # define PEAOUTHDR PEPAOUTHDR
84 #endif
85
86 /* FIXME: This file has various tests of POWERPC_LE_PE. Those tests
87 worked when the code was in peicode.h, but no longer work now that
88 the code is in peigen.c. PowerPC NT is said to be dead. If
89 anybody wants to revive the code, you will have to figure out how
90 to handle those issues. */
91
92 void
_bfd_XXi_swap_sym_in(bfd * abfd,void * ext1,void * in1)93 _bfd_XXi_swap_sym_in (bfd * abfd, void * ext1, void * in1)
94 {
95 SYMENT *ext = (SYMENT *) ext1;
96 struct internal_syment *in = (struct internal_syment *) in1;
97
98 if (ext->e.e_name[0] == 0)
99 {
100 in->_n._n_n._n_zeroes = 0;
101 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
102 }
103 else
104 memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
105
106 in->n_value = H_GET_32 (abfd, ext->e_value);
107 in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
108
109 if (sizeof (ext->e_type) == 2)
110 in->n_type = H_GET_16 (abfd, ext->e_type);
111 else
112 in->n_type = H_GET_32 (abfd, ext->e_type);
113
114 in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
115 in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
116
117 #ifndef STRICT_PE_FORMAT
118 /* This is for Gnu-created DLLs. */
119
120 /* The section symbols for the .idata$ sections have class 0x68
121 (C_SECTION), which MS documentation indicates is a section
122 symbol. Unfortunately, the value field in the symbol is simply a
123 copy of the .idata section's flags rather than something useful.
124 When these symbols are encountered, change the value to 0 so that
125 they will be handled somewhat correctly in the bfd code. */
126 if (in->n_sclass == C_SECTION)
127 {
128 in->n_value = 0x0;
129
130 /* Create synthetic empty sections as needed. DJ */
131 if (in->n_scnum == 0)
132 {
133 asection *sec;
134
135 for (sec = abfd->sections; sec; sec = sec->next)
136 {
137 if (strcmp (sec->name, in->n_name) == 0)
138 {
139 in->n_scnum = sec->target_index;
140 break;
141 }
142 }
143 }
144
145 if (in->n_scnum == 0)
146 {
147 int unused_section_number = 0;
148 asection *sec;
149 char *name;
150
151 for (sec = abfd->sections; sec; sec = sec->next)
152 if (unused_section_number <= sec->target_index)
153 unused_section_number = sec->target_index + 1;
154
155 name = bfd_alloc (abfd, (bfd_size_type) strlen (in->n_name) + 10);
156 if (name == NULL)
157 return;
158 strcpy (name, in->n_name);
159 sec = bfd_make_section_anyway (abfd, name);
160
161 sec->vma = 0;
162 sec->lma = 0;
163 sec->size = 0;
164 sec->filepos = 0;
165 sec->rel_filepos = 0;
166 sec->reloc_count = 0;
167 sec->line_filepos = 0;
168 sec->lineno_count = 0;
169 sec->userdata = NULL;
170 sec->next = NULL;
171 sec->alignment_power = 2;
172 sec->flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
173
174 sec->target_index = unused_section_number;
175
176 in->n_scnum = unused_section_number;
177 }
178 in->n_sclass = C_STAT;
179 }
180 #endif
181
182 #ifdef coff_swap_sym_in_hook
183 /* This won't work in peigen.c, but since it's for PPC PE, it's not
184 worth fixing. */
185 coff_swap_sym_in_hook (abfd, ext1, in1);
186 #endif
187 }
188
189 unsigned int
_bfd_XXi_swap_sym_out(bfd * abfd,void * inp,void * extp)190 _bfd_XXi_swap_sym_out (bfd * abfd, void * inp, void * extp)
191 {
192 struct internal_syment *in = (struct internal_syment *) inp;
193 SYMENT *ext = (SYMENT *) extp;
194
195 if (in->_n._n_name[0] == 0)
196 {
197 H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
198 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
199 }
200 else
201 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
202
203 H_PUT_32 (abfd, in->n_value, ext->e_value);
204 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
205
206 if (sizeof (ext->e_type) == 2)
207 H_PUT_16 (abfd, in->n_type, ext->e_type);
208 else
209 H_PUT_32 (abfd, in->n_type, ext->e_type);
210
211 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
212 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
213
214 return SYMESZ;
215 }
216
217 void
_bfd_XXi_swap_aux_in(bfd * abfd,void * ext1,int type,int class,int indx ATTRIBUTE_UNUSED,int numaux ATTRIBUTE_UNUSED,void * in1)218 _bfd_XXi_swap_aux_in (bfd * abfd,
219 void * ext1,
220 int type,
221 int class,
222 int indx ATTRIBUTE_UNUSED,
223 int numaux ATTRIBUTE_UNUSED,
224 void * in1)
225 {
226 AUXENT *ext = (AUXENT *) ext1;
227 union internal_auxent *in = (union internal_auxent *) in1;
228
229 switch (class)
230 {
231 case C_FILE:
232 if (ext->x_file.x_fname[0] == 0)
233 {
234 in->x_file.x_n.x_zeroes = 0;
235 in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
236 }
237 else
238 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
239 return;
240
241 case C_STAT:
242 case C_LEAFSTAT:
243 case C_HIDDEN:
244 if (type == T_NULL)
245 {
246 in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
247 in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
248 in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
249 in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
250 in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
251 in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
252 return;
253 }
254 break;
255 }
256
257 in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
258 in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
259
260 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
261 {
262 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
263 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
264 }
265 else
266 {
267 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
268 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
269 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
270 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
271 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
272 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
273 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
274 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
275 }
276
277 if (ISFCN (type))
278 {
279 in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
280 }
281 else
282 {
283 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
284 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
285 }
286 }
287
288 unsigned int
_bfd_XXi_swap_aux_out(bfd * abfd,void * inp,int type,int class,int indx ATTRIBUTE_UNUSED,int numaux ATTRIBUTE_UNUSED,void * extp)289 _bfd_XXi_swap_aux_out (bfd * abfd,
290 void * inp,
291 int type,
292 int class,
293 int indx ATTRIBUTE_UNUSED,
294 int numaux ATTRIBUTE_UNUSED,
295 void * extp)
296 {
297 union internal_auxent *in = (union internal_auxent *) inp;
298 AUXENT *ext = (AUXENT *) extp;
299
300 memset (ext, 0, AUXESZ);
301
302 switch (class)
303 {
304 case C_FILE:
305 if (in->x_file.x_fname[0] == 0)
306 {
307 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
308 H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
309 }
310 else
311 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
312
313 return AUXESZ;
314
315 case C_STAT:
316 case C_LEAFSTAT:
317 case C_HIDDEN:
318 if (type == T_NULL)
319 {
320 PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
321 PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
322 PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
323 H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
324 H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
325 H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
326 return AUXESZ;
327 }
328 break;
329 }
330
331 H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
332 H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
333
334 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
335 {
336 PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
337 PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
338 }
339 else
340 {
341 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
342 ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
343 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
344 ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
345 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
346 ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
347 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
348 ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
349 }
350
351 if (ISFCN (type))
352 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
353 else
354 {
355 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
356 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
357 }
358
359 return AUXESZ;
360 }
361
362 void
_bfd_XXi_swap_lineno_in(bfd * abfd,void * ext1,void * in1)363 _bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1)
364 {
365 LINENO *ext = (LINENO *) ext1;
366 struct internal_lineno *in = (struct internal_lineno *) in1;
367
368 in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
369 in->l_lnno = GET_LINENO_LNNO (abfd, ext);
370 }
371
372 unsigned int
_bfd_XXi_swap_lineno_out(bfd * abfd,void * inp,void * outp)373 _bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp)
374 {
375 struct internal_lineno *in = (struct internal_lineno *) inp;
376 struct external_lineno *ext = (struct external_lineno *) outp;
377 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
378
379 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
380 return LINESZ;
381 }
382
383 void
_bfd_XXi_swap_aouthdr_in(bfd * abfd,void * aouthdr_ext1,void * aouthdr_int1)384 _bfd_XXi_swap_aouthdr_in (bfd * abfd,
385 void * aouthdr_ext1,
386 void * aouthdr_int1)
387 {
388 struct internal_extra_pe_aouthdr *a;
389 PEAOUTHDR * src = (PEAOUTHDR *) (aouthdr_ext1);
390 AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
391 struct internal_aouthdr *aouthdr_int = (struct internal_aouthdr *)aouthdr_int1;
392
393 aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
394 aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
395 aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
396 aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
397 aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
398 aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
399 aouthdr_int->text_start =
400 GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
401 #ifndef COFF_WITH_pep
402 /* PE32+ does not have data_start member! */
403 aouthdr_int->data_start =
404 GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
405 #endif
406
407 a = &aouthdr_int->pe;
408 a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
409 a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
410 a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
411 a->MajorOperatingSystemVersion =
412 H_GET_16 (abfd, src->MajorOperatingSystemVersion);
413 a->MinorOperatingSystemVersion =
414 H_GET_16 (abfd, src->MinorOperatingSystemVersion);
415 a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
416 a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
417 a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
418 a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
419 a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
420 a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
421 a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
422 a->CheckSum = H_GET_32 (abfd, src->CheckSum);
423 a->Subsystem = H_GET_16 (abfd, src->Subsystem);
424 a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
425 a->SizeOfStackReserve =
426 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
427 a->SizeOfStackCommit =
428 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
429 a->SizeOfHeapReserve =
430 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
431 a->SizeOfHeapCommit =
432 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
433 a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
434 a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
435
436 {
437 int idx;
438
439 for (idx = 0; idx < 16; idx++)
440 {
441 /* If data directory is empty, rva also should be 0. */
442 int size =
443 H_GET_32 (abfd, src->DataDirectory[idx][1]);
444 a->DataDirectory[idx].Size = size;
445
446 if (size)
447 a->DataDirectory[idx].VirtualAddress =
448 H_GET_32 (abfd, src->DataDirectory[idx][0]);
449 else
450 a->DataDirectory[idx].VirtualAddress = 0;
451 }
452 }
453
454 if (aouthdr_int->entry)
455 {
456 aouthdr_int->entry += a->ImageBase;
457 #ifndef COFF_WITH_pep
458 aouthdr_int->entry &= 0xffffffff;
459 #endif
460 }
461
462 if (aouthdr_int->tsize)
463 {
464 aouthdr_int->text_start += a->ImageBase;
465 #ifndef COFF_WITH_pep
466 aouthdr_int->text_start &= 0xffffffff;
467 #endif
468 }
469
470 #ifndef COFF_WITH_pep
471 /* PE32+ does not have data_start member! */
472 if (aouthdr_int->dsize)
473 {
474 aouthdr_int->data_start += a->ImageBase;
475 aouthdr_int->data_start &= 0xffffffff;
476 }
477 #endif
478
479 #ifdef POWERPC_LE_PE
480 /* These three fields are normally set up by ppc_relocate_section.
481 In the case of reading a file in, we can pick them up from the
482 DataDirectory. */
483 first_thunk_address = a->DataDirectory[12].VirtualAddress;
484 thunk_size = a->DataDirectory[12].Size;
485 import_table_size = a->DataDirectory[1].Size;
486 #endif
487 }
488
489 /* A support function for below. */
490
491 static void
add_data_entry(bfd * abfd,struct internal_extra_pe_aouthdr * aout,int idx,char * name,bfd_vma base)492 add_data_entry (bfd * abfd,
493 struct internal_extra_pe_aouthdr *aout,
494 int idx,
495 char *name,
496 bfd_vma base)
497 {
498 asection *sec = bfd_get_section_by_name (abfd, name);
499
500 /* Add import directory information if it exists. */
501 if ((sec != NULL)
502 && (coff_section_data (abfd, sec) != NULL)
503 && (pei_section_data (abfd, sec) != NULL))
504 {
505 /* If data directory is empty, rva also should be 0. */
506 int size = pei_section_data (abfd, sec)->virt_size;
507 aout->DataDirectory[idx].Size = size;
508
509 if (size)
510 {
511 aout->DataDirectory[idx].VirtualAddress =
512 (sec->vma - base) & 0xffffffff;
513 sec->flags |= SEC_DATA;
514 }
515 }
516 }
517
518 unsigned int
_bfd_XXi_swap_aouthdr_out(bfd * abfd,void * in,void * out)519 _bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out)
520 {
521 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
522 pe_data_type *pe = pe_data (abfd);
523 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
524 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
525 bfd_vma sa, fa, ib;
526 IMAGE_DATA_DIRECTORY idata2, idata5, tls;
527
528 if (pe->force_minimum_alignment)
529 {
530 if (!extra->FileAlignment)
531 extra->FileAlignment = PE_DEF_FILE_ALIGNMENT;
532 if (!extra->SectionAlignment)
533 extra->SectionAlignment = PE_DEF_SECTION_ALIGNMENT;
534 }
535
536 if (extra->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
537 extra->Subsystem = pe->target_subsystem;
538
539 sa = extra->SectionAlignment;
540 fa = extra->FileAlignment;
541 ib = extra->ImageBase;
542
543 idata2 = pe->pe_opthdr.DataDirectory[1];
544 idata5 = pe->pe_opthdr.DataDirectory[12];
545 tls = pe->pe_opthdr.DataDirectory[9];
546
547 if (aouthdr_in->tsize)
548 {
549 aouthdr_in->text_start -= ib;
550 #ifndef COFF_WITH_pep
551 aouthdr_in->text_start &= 0xffffffff;
552 #endif
553 }
554
555 if (aouthdr_in->dsize)
556 {
557 aouthdr_in->data_start -= ib;
558 #ifndef COFF_WITH_pep
559 aouthdr_in->data_start &= 0xffffffff;
560 #endif
561 }
562
563 if (aouthdr_in->entry)
564 {
565 aouthdr_in->entry -= ib;
566 #ifndef COFF_WITH_pep
567 aouthdr_in->entry &= 0xffffffff;
568 #endif
569 }
570
571 #define FA(x) (((x) + fa -1 ) & (- fa))
572 #define SA(x) (((x) + sa -1 ) & (- sa))
573
574 /* We like to have the sizes aligned. */
575 aouthdr_in->bsize = FA (aouthdr_in->bsize);
576
577 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
578
579 /* First null out all data directory entries. */
580 memset (extra->DataDirectory, 0, sizeof (extra->DataDirectory));
581
582 add_data_entry (abfd, extra, 0, ".edata", ib);
583 add_data_entry (abfd, extra, 2, ".rsrc", ib);
584 add_data_entry (abfd, extra, 3, ".pdata", ib);
585
586 /* In theory we do not need to call add_data_entry for .idata$2 or
587 .idata$5. It will be done in bfd_coff_final_link where all the
588 required information is available. If however, we are not going
589 to perform a final link, eg because we have been invoked by objcopy
590 or strip, then we need to make sure that these Data Directory
591 entries are initialised properly.
592
593 So - we copy the input values into the output values, and then, if
594 a final link is going to be performed, it can overwrite them. */
595 extra->DataDirectory[1] = idata2;
596 extra->DataDirectory[12] = idata5;
597 extra->DataDirectory[9] = tls;
598
599 if (extra->DataDirectory[1].VirtualAddress == 0)
600 /* Until other .idata fixes are made (pending patch), the entry for
601 .idata is needed for backwards compatibility. FIXME. */
602 add_data_entry (abfd, extra, 1, ".idata", ib);
603
604 /* For some reason, the virtual size (which is what's set by
605 add_data_entry) for .reloc is not the same as the size recorded
606 in this slot by MSVC; it doesn't seem to cause problems (so far),
607 but since it's the best we've got, use it. It does do the right
608 thing for .pdata. */
609 if (pe->has_reloc_section)
610 add_data_entry (abfd, extra, 5, ".reloc", ib);
611
612 {
613 asection *sec;
614 bfd_vma hsize = 0;
615 bfd_vma dsize = 0;
616 bfd_vma isize = 0;
617 bfd_vma tsize = 0;
618
619 for (sec = abfd->sections; sec; sec = sec->next)
620 {
621 int rounded = FA (sec->size);
622
623 /* The first non-zero section filepos is the header size.
624 Sections without contents will have a filepos of 0. */
625 if (hsize == 0)
626 hsize = sec->filepos;
627 if (sec->flags & SEC_DATA)
628 dsize += rounded;
629 if (sec->flags & SEC_CODE)
630 tsize += rounded;
631 /* The image size is the total VIRTUAL size (which is what is
632 in the virt_size field). Files have been seen (from MSVC
633 5.0 link.exe) where the file size of the .data segment is
634 quite small compared to the virtual size. Without this
635 fix, strip munges the file. */
636 if (coff_section_data (abfd, sec) != NULL
637 && pei_section_data (abfd, sec) != NULL)
638 isize += SA (FA (pei_section_data (abfd, sec)->virt_size));
639 }
640
641 aouthdr_in->dsize = dsize;
642 aouthdr_in->tsize = tsize;
643 extra->SizeOfHeaders = hsize;
644 extra->SizeOfImage = SA (hsize) + isize;
645 }
646
647 H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
648
649 #define LINKER_VERSION 256 /* That is, 2.56 */
650
651 /* This piece of magic sets the "linker version" field to
652 LINKER_VERSION. */
653 H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
654 aouthdr_out->standard.vstamp);
655
656 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
657 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
658 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
659 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
660 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
661 aouthdr_out->standard.text_start);
662
663 #ifndef COFF_WITH_pep
664 /* PE32+ does not have data_start member! */
665 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
666 aouthdr_out->standard.data_start);
667 #endif
668
669 PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
670 H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
671 H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
672 H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
673 aouthdr_out->MajorOperatingSystemVersion);
674 H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
675 aouthdr_out->MinorOperatingSystemVersion);
676 H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
677 H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
678 H_PUT_16 (abfd, extra->MajorSubsystemVersion,
679 aouthdr_out->MajorSubsystemVersion);
680 H_PUT_16 (abfd, extra->MinorSubsystemVersion,
681 aouthdr_out->MinorSubsystemVersion);
682 H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
683 H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
684 H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
685 H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
686 H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
687 H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
688 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
689 aouthdr_out->SizeOfStackReserve);
690 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
691 aouthdr_out->SizeOfStackCommit);
692 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
693 aouthdr_out->SizeOfHeapReserve);
694 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
695 aouthdr_out->SizeOfHeapCommit);
696 H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
697 H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
698 aouthdr_out->NumberOfRvaAndSizes);
699 {
700 int idx;
701
702 for (idx = 0; idx < 16; idx++)
703 {
704 H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
705 aouthdr_out->DataDirectory[idx][0]);
706 H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
707 aouthdr_out->DataDirectory[idx][1]);
708 }
709 }
710
711 return AOUTSZ;
712 }
713
714 unsigned int
_bfd_XXi_only_swap_filehdr_out(bfd * abfd,void * in,void * out)715 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
716 {
717 int idx;
718 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
719 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
720
721 if (pe_data (abfd)->has_reloc_section)
722 filehdr_in->f_flags &= ~F_RELFLG;
723
724 if (pe_data (abfd)->dll)
725 filehdr_in->f_flags |= F_DLL;
726
727 filehdr_in->pe.e_magic = DOSMAGIC;
728 filehdr_in->pe.e_cblp = 0x90;
729 filehdr_in->pe.e_cp = 0x3;
730 filehdr_in->pe.e_crlc = 0x0;
731 filehdr_in->pe.e_cparhdr = 0x4;
732 filehdr_in->pe.e_minalloc = 0x0;
733 filehdr_in->pe.e_maxalloc = 0xffff;
734 filehdr_in->pe.e_ss = 0x0;
735 filehdr_in->pe.e_sp = 0xb8;
736 filehdr_in->pe.e_csum = 0x0;
737 filehdr_in->pe.e_ip = 0x0;
738 filehdr_in->pe.e_cs = 0x0;
739 filehdr_in->pe.e_lfarlc = 0x40;
740 filehdr_in->pe.e_ovno = 0x0;
741
742 for (idx = 0; idx < 4; idx++)
743 filehdr_in->pe.e_res[idx] = 0x0;
744
745 filehdr_in->pe.e_oemid = 0x0;
746 filehdr_in->pe.e_oeminfo = 0x0;
747
748 for (idx = 0; idx < 10; idx++)
749 filehdr_in->pe.e_res2[idx] = 0x0;
750
751 filehdr_in->pe.e_lfanew = 0x80;
752
753 /* This next collection of data are mostly just characters. It
754 appears to be constant within the headers put on NT exes. */
755 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
756 filehdr_in->pe.dos_message[1] = 0xcd09b400;
757 filehdr_in->pe.dos_message[2] = 0x4c01b821;
758 filehdr_in->pe.dos_message[3] = 0x685421cd;
759 filehdr_in->pe.dos_message[4] = 0x70207369;
760 filehdr_in->pe.dos_message[5] = 0x72676f72;
761 filehdr_in->pe.dos_message[6] = 0x63206d61;
762 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
763 filehdr_in->pe.dos_message[8] = 0x65622074;
764 filehdr_in->pe.dos_message[9] = 0x6e757220;
765 filehdr_in->pe.dos_message[10] = 0x206e6920;
766 filehdr_in->pe.dos_message[11] = 0x20534f44;
767 filehdr_in->pe.dos_message[12] = 0x65646f6d;
768 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
769 filehdr_in->pe.dos_message[14] = 0x24;
770 filehdr_in->pe.dos_message[15] = 0x0;
771 filehdr_in->pe.nt_signature = NT_SIGNATURE;
772
773 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
774 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
775
776 H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
777 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
778 filehdr_out->f_symptr);
779 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
780 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
781 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
782
783 /* Put in extra dos header stuff. This data remains essentially
784 constant, it just has to be tacked on to the beginning of all exes
785 for NT. */
786 H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
787 H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
788 H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
789 H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
790 H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
791 H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
792 H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
793 H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
794 H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
795 H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
796 H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
797 H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
798 H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
799 H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
800
801 for (idx = 0; idx < 4; idx++)
802 H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
803
804 H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
805 H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
806
807 for (idx = 0; idx < 10; idx++)
808 H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
809
810 H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
811
812 for (idx = 0; idx < 16; idx++)
813 H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
814 filehdr_out->dos_message[idx]);
815
816 /* Also put in the NT signature. */
817 H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
818
819 return FILHSZ;
820 }
821
822 unsigned int
_bfd_XX_only_swap_filehdr_out(bfd * abfd,void * in,void * out)823 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
824 {
825 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
826 FILHDR *filehdr_out = (FILHDR *) out;
827
828 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
829 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
830 H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
831 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
832 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
833 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
834 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
835
836 return FILHSZ;
837 }
838
839 unsigned int
_bfd_XXi_swap_scnhdr_out(bfd * abfd,void * in,void * out)840 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
841 {
842 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
843 SCNHDR *scnhdr_ext = (SCNHDR *) out;
844 unsigned int ret = SCNHSZ;
845 bfd_vma ps;
846 bfd_vma ss;
847
848 memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
849
850 PUT_SCNHDR_VADDR (abfd,
851 ((scnhdr_int->s_vaddr
852 - pe_data (abfd)->pe_opthdr.ImageBase)
853 & 0xffffffff),
854 scnhdr_ext->s_vaddr);
855
856 /* NT wants the size data to be rounded up to the next
857 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
858 sometimes). */
859 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
860 {
861 if (bfd_pe_executable_p (abfd))
862 {
863 ps = scnhdr_int->s_size;
864 ss = 0;
865 }
866 else
867 {
868 ps = 0;
869 ss = scnhdr_int->s_size;
870 }
871 }
872 else
873 {
874 if (bfd_pe_executable_p (abfd))
875 ps = scnhdr_int->s_paddr;
876 else
877 ps = 0;
878
879 ss = scnhdr_int->s_size;
880 }
881
882 PUT_SCNHDR_SIZE (abfd, ss,
883 scnhdr_ext->s_size);
884
885 /* s_paddr in PE is really the virtual size. */
886 PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
887
888 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
889 scnhdr_ext->s_scnptr);
890 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
891 scnhdr_ext->s_relptr);
892 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
893 scnhdr_ext->s_lnnoptr);
894
895 {
896 /* Extra flags must be set when dealing with PE. All sections should also
897 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
898 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
899 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
900 (this is especially important when dealing with the .idata section since
901 the addresses for routines from .dlls must be overwritten). If .reloc
902 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
903 (0x02000000). Also, the resource data should also be read and
904 writable. */
905
906 /* FIXME: Alignment is also encoded in this field, at least on PPC and
907 ARM-WINCE. Although - how do we get the original alignment field
908 back ? */
909
910 typedef struct
911 {
912 const char * section_name;
913 unsigned long must_have;
914 }
915 pe_required_section_flags;
916
917 pe_required_section_flags known_sections [] =
918 {
919 { ".arch", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
920 { ".bss", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
921 { ".data", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
922 { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
923 { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
924 { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
925 { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
926 { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
927 { ".rsrc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
928 { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
929 { ".tls", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
930 { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
931 { NULL, 0}
932 };
933
934 pe_required_section_flags * p;
935
936 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
937 we know exactly what this specific section wants so we remove it
938 and then allow the must_have field to add it back in if necessary.
939 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
940 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
941 by ld --enable-auto-import (if auto-import is actually needed),
942 by ld --omagic, or by obcopy --writable-text. */
943
944 for (p = known_sections; p->section_name; p++)
945 if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
946 {
947 if (strcmp (scnhdr_int->s_name, ".text")
948 || (bfd_get_file_flags (abfd) & WP_TEXT))
949 scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
950 scnhdr_int->s_flags |= p->must_have;
951 break;
952 }
953
954 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
955 }
956
957 if (coff_data (abfd)->link_info
958 && ! coff_data (abfd)->link_info->relocatable
959 && ! coff_data (abfd)->link_info->shared
960 && strcmp (scnhdr_int->s_name, ".text") == 0)
961 {
962 /* By inference from looking at MS output, the 32 bit field
963 which is the combination of the number_of_relocs and
964 number_of_linenos is used for the line number count in
965 executables. A 16-bit field won't do for cc1. The MS
966 document says that the number of relocs is zero for
967 executables, but the 17-th bit has been observed to be there.
968 Overflow is not an issue: a 4G-line program will overflow a
969 bunch of other fields long before this! */
970 H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
971 H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
972 }
973 else
974 {
975 if (scnhdr_int->s_nlnno <= 0xffff)
976 H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
977 else
978 {
979 (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
980 bfd_get_filename (abfd),
981 scnhdr_int->s_nlnno);
982 bfd_set_error (bfd_error_file_truncated);
983 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
984 ret = 0;
985 }
986
987 /* Although we could encode 0xffff relocs here, we do not, to be
988 consistent with other parts of bfd. Also it lets us warn, as
989 we should never see 0xffff here w/o having the overflow flag
990 set. */
991 if (scnhdr_int->s_nreloc < 0xffff)
992 H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
993 else
994 {
995 /* PE can deal with large #s of relocs, but not here. */
996 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
997 scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
998 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
999 }
1000 }
1001 return ret;
1002 }
1003
1004 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1005 {
1006 N_("Export Directory [.edata (or where ever we found it)]"),
1007 N_("Import Directory [parts of .idata]"),
1008 N_("Resource Directory [.rsrc]"),
1009 N_("Exception Directory [.pdata]"),
1010 N_("Security Directory"),
1011 N_("Base Relocation Directory [.reloc]"),
1012 N_("Debug Directory"),
1013 N_("Description Directory"),
1014 N_("Special Directory"),
1015 N_("Thread Storage Directory [.tls]"),
1016 N_("Load Configuration Directory"),
1017 N_("Bound Import Directory"),
1018 N_("Import Address Table Directory"),
1019 N_("Delay Import Directory"),
1020 N_("Reserved"),
1021 N_("Reserved")
1022 };
1023
1024 #ifdef POWERPC_LE_PE
1025 /* The code for the PPC really falls in the "architecture dependent"
1026 category. However, it's not clear that anyone will ever care, so
1027 we're ignoring the issue for now; if/when PPC matters, some of this
1028 may need to go into peicode.h, or arguments passed to enable the
1029 PPC- specific code. */
1030 #endif
1031
1032 static bfd_boolean
pe_print_idata(bfd * abfd,void * vfile)1033 pe_print_idata (bfd * abfd, void * vfile)
1034 {
1035 FILE *file = (FILE *) vfile;
1036 bfd_byte *data;
1037 asection *section;
1038 bfd_signed_vma adj;
1039
1040 #ifdef POWERPC_LE_PE
1041 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1042 #endif
1043
1044 bfd_size_type datasize = 0;
1045 bfd_size_type dataoff;
1046 bfd_size_type i;
1047 int onaline = 20;
1048
1049 pe_data_type *pe = pe_data (abfd);
1050 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1051
1052 bfd_vma addr;
1053
1054 addr = extra->DataDirectory[1].VirtualAddress;
1055
1056 if (addr == 0 && extra->DataDirectory[1].Size == 0)
1057 {
1058 /* Maybe the extra header isn't there. Look for the section. */
1059 section = bfd_get_section_by_name (abfd, ".idata");
1060 if (section == NULL)
1061 return TRUE;
1062
1063 addr = section->vma;
1064 datasize = section->size;
1065 if (datasize == 0)
1066 return TRUE;
1067 }
1068 else
1069 {
1070 addr += extra->ImageBase;
1071 for (section = abfd->sections; section != NULL; section = section->next)
1072 {
1073 datasize = section->size;
1074 if (addr >= section->vma && addr < section->vma + datasize)
1075 break;
1076 }
1077
1078 if (section == NULL)
1079 {
1080 fprintf (file,
1081 _("\nThere is an import table, but the section containing it could not be found\n"));
1082 return TRUE;
1083 }
1084 }
1085
1086 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1087 section->name, (unsigned long) addr);
1088
1089 dataoff = addr - section->vma;
1090 datasize -= dataoff;
1091
1092 #ifdef POWERPC_LE_PE
1093 if (rel_section != 0 && rel_section->size != 0)
1094 {
1095 /* The toc address can be found by taking the starting address,
1096 which on the PPC locates a function descriptor. The
1097 descriptor consists of the function code starting address
1098 followed by the address of the toc. The starting address we
1099 get from the bfd, and the descriptor is supposed to be in the
1100 .reldata section. */
1101
1102 bfd_vma loadable_toc_address;
1103 bfd_vma toc_address;
1104 bfd_vma start_address;
1105 bfd_byte *data;
1106 bfd_vma offset;
1107
1108 if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1109 {
1110 if (data != NULL)
1111 free (data);
1112 return FALSE;
1113 }
1114
1115 offset = abfd->start_address - rel_section->vma;
1116
1117 if (offset >= rel_section->size || offset + 8 > rel_section->size)
1118 {
1119 if (data != NULL)
1120 free (data);
1121 return FALSE;
1122 }
1123
1124 start_address = bfd_get_32 (abfd, data + offset);
1125 loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1126 toc_address = loadable_toc_address - 32768;
1127
1128 fprintf (file,
1129 _("\nFunction descriptor located at the start address: %04lx\n"),
1130 (unsigned long int) (abfd->start_address));
1131 fprintf (file,
1132 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1133 start_address, loadable_toc_address, toc_address);
1134 if (data != NULL)
1135 free (data);
1136 }
1137 else
1138 {
1139 fprintf (file,
1140 _("\nNo reldata section! Function descriptor not decoded.\n"));
1141 }
1142 #endif
1143
1144 fprintf (file,
1145 _("\nThe Import Tables (interpreted %s section contents)\n"),
1146 section->name);
1147 fprintf (file,
1148 _("\
1149 vma: Hint Time Forward DLL First\n\
1150 Table Stamp Chain Name Thunk\n"));
1151
1152 /* Read the whole section. Some of the fields might be before dataoff. */
1153 if (!bfd_malloc_and_get_section (abfd, section, &data))
1154 {
1155 if (data != NULL)
1156 free (data);
1157 return FALSE;
1158 }
1159
1160 adj = section->vma - extra->ImageBase;
1161
1162 /* Print all image import descriptors. */
1163 for (i = 0; i < datasize; i += onaline)
1164 {
1165 bfd_vma hint_addr;
1166 bfd_vma time_stamp;
1167 bfd_vma forward_chain;
1168 bfd_vma dll_name;
1169 bfd_vma first_thunk;
1170 int idx = 0;
1171 bfd_size_type j;
1172 char *dll;
1173
1174 /* Print (i + extra->DataDirectory[1].VirtualAddress). */
1175 fprintf (file, " %08lx\t", (unsigned long) (i + adj + dataoff));
1176 hint_addr = bfd_get_32 (abfd, data + i + dataoff);
1177 time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff);
1178 forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff);
1179 dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff);
1180 first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff);
1181
1182 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1183 (unsigned long) hint_addr,
1184 (unsigned long) time_stamp,
1185 (unsigned long) forward_chain,
1186 (unsigned long) dll_name,
1187 (unsigned long) first_thunk);
1188
1189 if (hint_addr == 0 && first_thunk == 0)
1190 break;
1191
1192 if (dll_name - adj >= section->size)
1193 break;
1194
1195 dll = (char *) data + dll_name - adj;
1196 fprintf (file, _("\n\tDLL Name: %s\n"), dll);
1197
1198 if (hint_addr != 0)
1199 {
1200 bfd_byte *ft_data;
1201 asection *ft_section;
1202 bfd_vma ft_addr;
1203 bfd_size_type ft_datasize;
1204 int ft_idx;
1205 int ft_allocated = 0;
1206
1207 fprintf (file, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1208
1209 idx = hint_addr - adj;
1210
1211 ft_addr = first_thunk + extra->ImageBase;
1212 ft_data = data;
1213 ft_idx = first_thunk - adj;
1214 ft_allocated = 0;
1215
1216 if (first_thunk != hint_addr)
1217 {
1218 /* Find the section which contains the first thunk. */
1219 for (ft_section = abfd->sections;
1220 ft_section != NULL;
1221 ft_section = ft_section->next)
1222 {
1223 ft_datasize = ft_section->size;
1224 if (ft_addr >= ft_section->vma
1225 && ft_addr < ft_section->vma + ft_datasize)
1226 break;
1227 }
1228
1229 if (ft_section == NULL)
1230 {
1231 fprintf (file,
1232 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1233 continue;
1234 }
1235
1236 /* Now check to see if this section is the same as our current
1237 section. If it is not then we will have to load its data in. */
1238 if (ft_section == section)
1239 {
1240 ft_data = data;
1241 ft_idx = first_thunk - adj;
1242 }
1243 else
1244 {
1245 ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1246 ft_data = bfd_malloc (datasize);
1247 if (ft_data == NULL)
1248 continue;
1249
1250 /* Read datasize bfd_bytes starting at offset ft_idx. */
1251 if (! bfd_get_section_contents
1252 (abfd, ft_section, ft_data, (bfd_vma) ft_idx, datasize))
1253 {
1254 free (ft_data);
1255 continue;
1256 }
1257
1258 ft_idx = 0;
1259 ft_allocated = 1;
1260 }
1261 }
1262
1263 /* Print HintName vector entries. */
1264 for (j = 0; j < datasize; j += 4)
1265 {
1266 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1267
1268 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1269 if (member == 0)
1270 break;
1271
1272 if (member & 0x80000000)
1273 fprintf (file, "\t%04lx\t %4lu <none>",
1274 member, member & 0x7fffffff);
1275 else
1276 {
1277 int ordinal;
1278 char *member_name;
1279
1280 ordinal = bfd_get_16 (abfd, data + member - adj);
1281 member_name = (char *) data + member - adj + 2;
1282 fprintf (file, "\t%04lx\t %4d %s",
1283 member, ordinal, member_name);
1284 }
1285
1286 /* If the time stamp is not zero, the import address
1287 table holds actual addresses. */
1288 if (time_stamp != 0
1289 && first_thunk != 0
1290 && first_thunk != hint_addr)
1291 fprintf (file, "\t%04lx",
1292 (long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1293
1294 fprintf (file, "\n");
1295 }
1296
1297 if (ft_allocated)
1298 free (ft_data);
1299 }
1300
1301 fprintf (file, "\n");
1302 }
1303
1304 free (data);
1305
1306 return TRUE;
1307 }
1308
1309 static bfd_boolean
pe_print_edata(bfd * abfd,void * vfile)1310 pe_print_edata (bfd * abfd, void * vfile)
1311 {
1312 FILE *file = (FILE *) vfile;
1313 bfd_byte *data;
1314 asection *section;
1315 bfd_size_type datasize = 0;
1316 bfd_size_type dataoff;
1317 bfd_size_type i;
1318 bfd_signed_vma adj;
1319 struct EDT_type
1320 {
1321 long export_flags; /* Reserved - should be zero. */
1322 long time_stamp;
1323 short major_ver;
1324 short minor_ver;
1325 bfd_vma name; /* RVA - relative to image base. */
1326 long base; /* Ordinal base. */
1327 unsigned long num_functions;/* Number in the export address table. */
1328 unsigned long num_names; /* Number in the name pointer table. */
1329 bfd_vma eat_addr; /* RVA to the export address table. */
1330 bfd_vma npt_addr; /* RVA to the Export Name Pointer Table. */
1331 bfd_vma ot_addr; /* RVA to the Ordinal Table. */
1332 } edt;
1333
1334 pe_data_type *pe = pe_data (abfd);
1335 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1336
1337 bfd_vma addr;
1338
1339 addr = extra->DataDirectory[0].VirtualAddress;
1340
1341 if (addr == 0 && extra->DataDirectory[0].Size == 0)
1342 {
1343 /* Maybe the extra header isn't there. Look for the section. */
1344 section = bfd_get_section_by_name (abfd, ".edata");
1345 if (section == NULL)
1346 return TRUE;
1347
1348 addr = section->vma;
1349 datasize = section->size;
1350 if (datasize == 0)
1351 return TRUE;
1352 }
1353 else
1354 {
1355 addr += extra->ImageBase;
1356
1357 for (section = abfd->sections; section != NULL; section = section->next)
1358 {
1359 datasize = section->size;
1360
1361 if (addr >= section->vma && addr < section->vma + datasize)
1362 break;
1363 }
1364
1365 if (section == NULL)
1366 {
1367 fprintf (file,
1368 _("\nThere is an export table, but the section containing it could not be found\n"));
1369 return TRUE;
1370 }
1371 }
1372
1373 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1374 section->name, (unsigned long) addr);
1375
1376 dataoff = addr - section->vma;
1377 datasize -= dataoff;
1378
1379 data = bfd_malloc (datasize);
1380 if (data == NULL)
1381 return FALSE;
1382
1383 if (! bfd_get_section_contents (abfd, section, data,
1384 (file_ptr) dataoff, datasize))
1385 return FALSE;
1386
1387 /* Go get Export Directory Table. */
1388 edt.export_flags = bfd_get_32 (abfd, data + 0);
1389 edt.time_stamp = bfd_get_32 (abfd, data + 4);
1390 edt.major_ver = bfd_get_16 (abfd, data + 8);
1391 edt.minor_ver = bfd_get_16 (abfd, data + 10);
1392 edt.name = bfd_get_32 (abfd, data + 12);
1393 edt.base = bfd_get_32 (abfd, data + 16);
1394 edt.num_functions = bfd_get_32 (abfd, data + 20);
1395 edt.num_names = bfd_get_32 (abfd, data + 24);
1396 edt.eat_addr = bfd_get_32 (abfd, data + 28);
1397 edt.npt_addr = bfd_get_32 (abfd, data + 32);
1398 edt.ot_addr = bfd_get_32 (abfd, data + 36);
1399
1400 adj = section->vma - extra->ImageBase + dataoff;
1401
1402 /* Dump the EDT first. */
1403 fprintf (file,
1404 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1405 section->name);
1406
1407 fprintf (file,
1408 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1409
1410 fprintf (file,
1411 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1412
1413 fprintf (file,
1414 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1415
1416 fprintf (file,
1417 _("Name \t\t\t\t"));
1418 fprintf_vma (file, edt.name);
1419 fprintf (file,
1420 " %s\n", data + edt.name - adj);
1421
1422 fprintf (file,
1423 _("Ordinal Base \t\t\t%ld\n"), edt.base);
1424
1425 fprintf (file,
1426 _("Number in:\n"));
1427
1428 fprintf (file,
1429 _("\tExport Address Table \t\t%08lx\n"),
1430 edt.num_functions);
1431
1432 fprintf (file,
1433 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1434
1435 fprintf (file,
1436 _("Table Addresses\n"));
1437
1438 fprintf (file,
1439 _("\tExport Address Table \t\t"));
1440 fprintf_vma (file, edt.eat_addr);
1441 fprintf (file, "\n");
1442
1443 fprintf (file,
1444 _("\tName Pointer Table \t\t"));
1445 fprintf_vma (file, edt.npt_addr);
1446 fprintf (file, "\n");
1447
1448 fprintf (file,
1449 _("\tOrdinal Table \t\t\t"));
1450 fprintf_vma (file, edt.ot_addr);
1451 fprintf (file, "\n");
1452
1453 /* The next table to find is the Export Address Table. It's basically
1454 a list of pointers that either locate a function in this dll, or
1455 forward the call to another dll. Something like:
1456 typedef union
1457 {
1458 long export_rva;
1459 long forwarder_rva;
1460 } export_address_table_entry; */
1461
1462 fprintf (file,
1463 _("\nExport Address Table -- Ordinal Base %ld\n"),
1464 edt.base);
1465
1466 for (i = 0; i < edt.num_functions; ++i)
1467 {
1468 bfd_vma eat_member = bfd_get_32 (abfd,
1469 data + edt.eat_addr + (i * 4) - adj);
1470 if (eat_member == 0)
1471 continue;
1472
1473 if (eat_member - adj <= datasize)
1474 {
1475 /* This rva is to a name (forwarding function) in our section. */
1476 /* Should locate a function descriptor. */
1477 fprintf (file,
1478 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1479 (long) i,
1480 (long) (i + edt.base),
1481 (unsigned long) eat_member,
1482 _("Forwarder RVA"),
1483 data + eat_member - adj);
1484 }
1485 else
1486 {
1487 /* Should locate a function descriptor in the reldata section. */
1488 fprintf (file,
1489 "\t[%4ld] +base[%4ld] %04lx %s\n",
1490 (long) i,
1491 (long) (i + edt.base),
1492 (unsigned long) eat_member,
1493 _("Export RVA"));
1494 }
1495 }
1496
1497 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1498 /* Dump them in parallel for clarity. */
1499 fprintf (file,
1500 _("\n[Ordinal/Name Pointer] Table\n"));
1501
1502 for (i = 0; i < edt.num_names; ++i)
1503 {
1504 bfd_vma name_ptr = bfd_get_32 (abfd,
1505 data +
1506 edt.npt_addr
1507 + (i*4) - adj);
1508
1509 char *name = (char *) data + name_ptr - adj;
1510
1511 bfd_vma ord = bfd_get_16 (abfd,
1512 data +
1513 edt.ot_addr
1514 + (i*2) - adj);
1515 fprintf (file,
1516 "\t[%4ld] %s\n", (long) ord, name);
1517 }
1518
1519 free (data);
1520
1521 return TRUE;
1522 }
1523
1524 /* This really is architecture dependent. On IA-64, a .pdata entry
1525 consists of three dwords containing relative virtual addresses that
1526 specify the start and end address of the code range the entry
1527 covers and the address of the corresponding unwind info data. */
1528
1529 static bfd_boolean
pe_print_pdata(bfd * abfd,void * vfile)1530 pe_print_pdata (bfd * abfd, void * vfile)
1531 {
1532 #ifdef COFF_WITH_pep
1533 # define PDATA_ROW_SIZE (3*8)
1534 #else
1535 # define PDATA_ROW_SIZE (5*4)
1536 #endif
1537 FILE *file = (FILE *) vfile;
1538 bfd_byte *data = 0;
1539 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1540 bfd_size_type datasize = 0;
1541 bfd_size_type i;
1542 bfd_size_type start, stop;
1543 int onaline = PDATA_ROW_SIZE;
1544
1545 if (section == NULL
1546 || coff_section_data (abfd, section) == NULL
1547 || pei_section_data (abfd, section) == NULL)
1548 return TRUE;
1549
1550 stop = pei_section_data (abfd, section)->virt_size;
1551 if ((stop % onaline) != 0)
1552 fprintf (file,
1553 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1554 (long) stop, onaline);
1555
1556 fprintf (file,
1557 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1558 #ifdef COFF_WITH_pep
1559 fprintf (file,
1560 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1561 #else
1562 fprintf (file, _("\
1563 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1564 \t\tAddress Address Handler Data Address Mask\n"));
1565 #endif
1566
1567 datasize = section->size;
1568 if (datasize == 0)
1569 return TRUE;
1570
1571 if (! bfd_malloc_and_get_section (abfd, section, &data))
1572 {
1573 if (data != NULL)
1574 free (data);
1575 return FALSE;
1576 }
1577
1578 start = 0;
1579
1580 for (i = start; i < stop; i += onaline)
1581 {
1582 bfd_vma begin_addr;
1583 bfd_vma end_addr;
1584 bfd_vma eh_handler;
1585 bfd_vma eh_data;
1586 bfd_vma prolog_end_addr;
1587 int em_data;
1588
1589 if (i + PDATA_ROW_SIZE > stop)
1590 break;
1591
1592 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
1593 end_addr = GET_PDATA_ENTRY (abfd, data + i + 4);
1594 eh_handler = GET_PDATA_ENTRY (abfd, data + i + 8);
1595 eh_data = GET_PDATA_ENTRY (abfd, data + i + 12);
1596 prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1597
1598 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1599 && eh_data == 0 && prolog_end_addr == 0)
1600 /* We are probably into the padding of the section now. */
1601 break;
1602
1603 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1604 eh_handler &= ~(bfd_vma) 0x3;
1605 prolog_end_addr &= ~(bfd_vma) 0x3;
1606
1607 fputc (' ', file);
1608 fprintf_vma (file, i + section->vma); fputc ('\t', file);
1609 fprintf_vma (file, begin_addr); fputc (' ', file);
1610 fprintf_vma (file, end_addr); fputc (' ', file);
1611 fprintf_vma (file, eh_handler);
1612 #ifndef COFF_WITH_pep
1613 fputc (' ', file);
1614 fprintf_vma (file, eh_data); fputc (' ', file);
1615 fprintf_vma (file, prolog_end_addr);
1616 fprintf (file, " %x", em_data);
1617 #endif
1618
1619 #ifdef POWERPC_LE_PE
1620 if (eh_handler == 0 && eh_data != 0)
1621 {
1622 /* Special bits here, although the meaning may be a little
1623 mysterious. The only one I know for sure is 0x03
1624 Code Significance
1625 0x00 None
1626 0x01 Register Save Millicode
1627 0x02 Register Restore Millicode
1628 0x03 Glue Code Sequence. */
1629 switch (eh_data)
1630 {
1631 case 0x01:
1632 fprintf (file, _(" Register save millicode"));
1633 break;
1634 case 0x02:
1635 fprintf (file, _(" Register restore millicode"));
1636 break;
1637 case 0x03:
1638 fprintf (file, _(" Glue code sequence"));
1639 break;
1640 default:
1641 break;
1642 }
1643 }
1644 #endif
1645 fprintf (file, "\n");
1646 }
1647
1648 free (data);
1649
1650 return TRUE;
1651 }
1652
1653 #define IMAGE_REL_BASED_HIGHADJ 4
1654 static const char * const tbl[] =
1655 {
1656 "ABSOLUTE",
1657 "HIGH",
1658 "LOW",
1659 "HIGHLOW",
1660 "HIGHADJ",
1661 "MIPS_JMPADDR",
1662 "SECTION",
1663 "REL32",
1664 "RESERVED1",
1665 "MIPS_JMPADDR16",
1666 "DIR64",
1667 "HIGH3ADJ"
1668 "UNKNOWN", /* MUST be last. */
1669 };
1670
1671 static bfd_boolean
pe_print_reloc(bfd * abfd,void * vfile)1672 pe_print_reloc (bfd * abfd, void * vfile)
1673 {
1674 FILE *file = (FILE *) vfile;
1675 bfd_byte *data = 0;
1676 asection *section = bfd_get_section_by_name (abfd, ".reloc");
1677 bfd_size_type datasize;
1678 bfd_size_type i;
1679 bfd_size_type start, stop;
1680
1681 if (section == NULL)
1682 return TRUE;
1683
1684 if (section->size == 0)
1685 return TRUE;
1686
1687 fprintf (file,
1688 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
1689
1690 datasize = section->size;
1691 if (! bfd_malloc_and_get_section (abfd, section, &data))
1692 {
1693 if (data != NULL)
1694 free (data);
1695 return FALSE;
1696 }
1697
1698 start = 0;
1699
1700 stop = section->size;
1701
1702 for (i = start; i < stop;)
1703 {
1704 int j;
1705 bfd_vma virtual_address;
1706 long number, size;
1707
1708 /* The .reloc section is a sequence of blocks, with a header consisting
1709 of two 32 bit quantities, followed by a number of 16 bit entries. */
1710 virtual_address = bfd_get_32 (abfd, data+i);
1711 size = bfd_get_32 (abfd, data+i+4);
1712 number = (size - 8) / 2;
1713
1714 if (size == 0)
1715 break;
1716
1717 fprintf (file,
1718 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
1719 (unsigned long) virtual_address, size, size, number);
1720
1721 for (j = 0; j < number; ++j)
1722 {
1723 unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
1724 unsigned int t = (e & 0xF000) >> 12;
1725 int off = e & 0x0FFF;
1726
1727 if (t >= sizeof (tbl) / sizeof (tbl[0]))
1728 t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
1729
1730 fprintf (file,
1731 _("\treloc %4d offset %4x [%4lx] %s"),
1732 j, off, (long) (off + virtual_address), tbl[t]);
1733
1734 /* HIGHADJ takes an argument, - the next record *is* the
1735 low 16 bits of addend. */
1736 if (t == IMAGE_REL_BASED_HIGHADJ)
1737 {
1738 fprintf (file, " (%4x)",
1739 ((unsigned int)
1740 bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
1741 j++;
1742 }
1743
1744 fprintf (file, "\n");
1745 }
1746
1747 i += size;
1748 }
1749
1750 free (data);
1751
1752 return TRUE;
1753 }
1754
1755 /* Print out the program headers. */
1756
1757 bfd_boolean
_bfd_XX_print_private_bfd_data_common(bfd * abfd,void * vfile)1758 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
1759 {
1760 FILE *file = (FILE *) vfile;
1761 int j;
1762 pe_data_type *pe = pe_data (abfd);
1763 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
1764 const char *subsystem_name = NULL;
1765
1766 /* The MS dumpbin program reportedly ands with 0xff0f before
1767 printing the characteristics field. Not sure why. No reason to
1768 emulate it here. */
1769 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
1770 #undef PF
1771 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
1772 PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
1773 PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
1774 PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
1775 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
1776 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
1777 PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
1778 PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
1779 PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
1780 PF (IMAGE_FILE_SYSTEM, "system file");
1781 PF (IMAGE_FILE_DLL, "DLL");
1782 PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
1783 #undef PF
1784
1785 /* ctime implies '\n'. */
1786 {
1787 time_t t = pe->coff.timestamp;
1788 fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
1789 }
1790 fprintf (file, "\nImageBase\t\t");
1791 fprintf_vma (file, i->ImageBase);
1792 fprintf (file, "\nSectionAlignment\t");
1793 fprintf_vma (file, i->SectionAlignment);
1794 fprintf (file, "\nFileAlignment\t\t");
1795 fprintf_vma (file, i->FileAlignment);
1796 fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
1797 fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
1798 fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
1799 fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
1800 fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
1801 fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
1802 fprintf (file, "Win32Version\t\t%08lx\n", i->Reserved1);
1803 fprintf (file, "SizeOfImage\t\t%08lx\n", i->SizeOfImage);
1804 fprintf (file, "SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders);
1805 fprintf (file, "CheckSum\t\t%08lx\n", i->CheckSum);
1806
1807 switch (i->Subsystem)
1808 {
1809 case IMAGE_SUBSYSTEM_UNKNOWN:
1810 subsystem_name = "unspecified";
1811 break;
1812 case IMAGE_SUBSYSTEM_NATIVE:
1813 subsystem_name = "NT native";
1814 break;
1815 case IMAGE_SUBSYSTEM_WINDOWS_GUI:
1816 subsystem_name = "Windows GUI";
1817 break;
1818 case IMAGE_SUBSYSTEM_WINDOWS_CUI:
1819 subsystem_name = "Windows CUI";
1820 break;
1821 case IMAGE_SUBSYSTEM_POSIX_CUI:
1822 subsystem_name = "POSIX CUI";
1823 break;
1824 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
1825 subsystem_name = "Wince CUI";
1826 break;
1827 case IMAGE_SUBSYSTEM_EFI_APPLICATION:
1828 subsystem_name = "EFI application";
1829 break;
1830 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
1831 subsystem_name = "EFI boot service driver";
1832 break;
1833 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
1834 subsystem_name = "EFI runtime driver";
1835 break;
1836 }
1837
1838 fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
1839 if (subsystem_name)
1840 fprintf (file, "\t(%s)", subsystem_name);
1841 fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
1842 fprintf (file, "SizeOfStackReserve\t");
1843 fprintf_vma (file, i->SizeOfStackReserve);
1844 fprintf (file, "\nSizeOfStackCommit\t");
1845 fprintf_vma (file, i->SizeOfStackCommit);
1846 fprintf (file, "\nSizeOfHeapReserve\t");
1847 fprintf_vma (file, i->SizeOfHeapReserve);
1848 fprintf (file, "\nSizeOfHeapCommit\t");
1849 fprintf_vma (file, i->SizeOfHeapCommit);
1850 fprintf (file, "\nLoaderFlags\t\t%08lx\n", i->LoaderFlags);
1851 fprintf (file, "NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes);
1852
1853 fprintf (file, "\nThe Data Directory\n");
1854 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
1855 {
1856 fprintf (file, "Entry %1x ", j);
1857 fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
1858 fprintf (file, " %08lx ", i->DataDirectory[j].Size);
1859 fprintf (file, "%s\n", dir_names[j]);
1860 }
1861
1862 pe_print_idata (abfd, vfile);
1863 pe_print_edata (abfd, vfile);
1864 pe_print_pdata (abfd, vfile);
1865 pe_print_reloc (abfd, vfile);
1866
1867 return TRUE;
1868 }
1869
1870 /* Copy any private info we understand from the input bfd
1871 to the output bfd. */
1872
1873 bfd_boolean
_bfd_XX_bfd_copy_private_bfd_data_common(bfd * ibfd,bfd * obfd)1874 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
1875 {
1876 /* One day we may try to grok other private data. */
1877 if (ibfd->xvec->flavour != bfd_target_coff_flavour
1878 || obfd->xvec->flavour != bfd_target_coff_flavour)
1879 return TRUE;
1880
1881 pe_data (obfd)->pe_opthdr = pe_data (ibfd)->pe_opthdr;
1882 pe_data (obfd)->dll = pe_data (ibfd)->dll;
1883
1884 /* For strip: if we removed .reloc, we'll make a real mess of things
1885 if we don't remove this entry as well. */
1886 if (! pe_data (obfd)->has_reloc_section)
1887 {
1888 pe_data (obfd)->pe_opthdr.DataDirectory[5].VirtualAddress = 0;
1889 pe_data (obfd)->pe_opthdr.DataDirectory[5].Size = 0;
1890 }
1891 return TRUE;
1892 }
1893
1894 /* Copy private section data. */
1895
1896 bfd_boolean
_bfd_XX_bfd_copy_private_section_data(bfd * ibfd,asection * isec,bfd * obfd,asection * osec)1897 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
1898 asection *isec,
1899 bfd *obfd,
1900 asection *osec)
1901 {
1902 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
1903 || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
1904 return TRUE;
1905
1906 if (coff_section_data (ibfd, isec) != NULL
1907 && pei_section_data (ibfd, isec) != NULL)
1908 {
1909 if (coff_section_data (obfd, osec) == NULL)
1910 {
1911 bfd_size_type amt = sizeof (struct coff_section_tdata);
1912 osec->used_by_bfd = bfd_zalloc (obfd, amt);
1913 if (osec->used_by_bfd == NULL)
1914 return FALSE;
1915 }
1916
1917 if (pei_section_data (obfd, osec) == NULL)
1918 {
1919 bfd_size_type amt = sizeof (struct pei_section_tdata);
1920 coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
1921 if (coff_section_data (obfd, osec)->tdata == NULL)
1922 return FALSE;
1923 }
1924
1925 pei_section_data (obfd, osec)->virt_size =
1926 pei_section_data (ibfd, isec)->virt_size;
1927 pei_section_data (obfd, osec)->pe_flags =
1928 pei_section_data (ibfd, isec)->pe_flags;
1929 }
1930
1931 return TRUE;
1932 }
1933
1934 void
_bfd_XX_get_symbol_info(bfd * abfd,asymbol * symbol,symbol_info * ret)1935 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
1936 {
1937 coff_get_symbol_info (abfd, symbol, ret);
1938 }
1939
1940 /* Handle the .idata section and other things that need symbol table
1941 access. */
1942
1943 bfd_boolean
_bfd_XXi_final_link_postscript(bfd * abfd,struct coff_final_link_info * pfinfo)1944 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
1945 {
1946 struct coff_link_hash_entry *h1;
1947 struct bfd_link_info *info = pfinfo->info;
1948
1949 /* There are a few fields that need to be filled in now while we
1950 have symbol table access.
1951
1952 The .idata subsections aren't directly available as sections, but
1953 they are in the symbol table, so get them from there. */
1954
1955 /* The import directory. This is the address of .idata$2, with size
1956 of .idata$2 + .idata$3. */
1957 h1 = coff_link_hash_lookup (coff_hash_table (info),
1958 ".idata$2", FALSE, FALSE, TRUE);
1959 if (h1 != NULL)
1960 {
1961 pe_data (abfd)->pe_opthdr.DataDirectory[1].VirtualAddress =
1962 (h1->root.u.def.value
1963 + h1->root.u.def.section->output_section->vma
1964 + h1->root.u.def.section->output_offset);
1965 h1 = coff_link_hash_lookup (coff_hash_table (info),
1966 ".idata$4", FALSE, FALSE, TRUE);
1967 pe_data (abfd)->pe_opthdr.DataDirectory[1].Size =
1968 ((h1->root.u.def.value
1969 + h1->root.u.def.section->output_section->vma
1970 + h1->root.u.def.section->output_offset)
1971 - pe_data (abfd)->pe_opthdr.DataDirectory[1].VirtualAddress);
1972
1973 /* The import address table. This is the size/address of
1974 .idata$5. */
1975 h1 = coff_link_hash_lookup (coff_hash_table (info),
1976 ".idata$5", FALSE, FALSE, TRUE);
1977 pe_data (abfd)->pe_opthdr.DataDirectory[12].VirtualAddress =
1978 (h1->root.u.def.value
1979 + h1->root.u.def.section->output_section->vma
1980 + h1->root.u.def.section->output_offset);
1981 h1 = coff_link_hash_lookup (coff_hash_table (info),
1982 ".idata$6", FALSE, FALSE, TRUE);
1983 pe_data (abfd)->pe_opthdr.DataDirectory[12].Size =
1984 ((h1->root.u.def.value
1985 + h1->root.u.def.section->output_section->vma
1986 + h1->root.u.def.section->output_offset)
1987 - pe_data (abfd)->pe_opthdr.DataDirectory[12].VirtualAddress);
1988 }
1989
1990 h1 = coff_link_hash_lookup (coff_hash_table (info),
1991 "__tls_used", FALSE, FALSE, TRUE);
1992 if (h1 != NULL)
1993 {
1994 pe_data (abfd)->pe_opthdr.DataDirectory[9].VirtualAddress =
1995 (h1->root.u.def.value
1996 + h1->root.u.def.section->output_section->vma
1997 + h1->root.u.def.section->output_offset
1998 - pe_data (abfd)->pe_opthdr.ImageBase);
1999 pe_data (abfd)->pe_opthdr.DataDirectory[9].Size = 0x18;
2000 }
2001
2002 /* If we couldn't find idata$2, we either have an excessively
2003 trivial program or are in DEEP trouble; we have to assume trivial
2004 program.... */
2005 return TRUE;
2006 }
2007