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, 2006, 2007 Free Software Foundation, Inc.
4 Written by Cygnus Solutions.
6 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
22 /* Most of this hacked by Steve Chamberlain <sac@cygnus.com>.
24 PE/PEI rearrangement (and code added): Donn Terry
25 Softway Systems, Inc. */
27 /* Hey look, some documentation [and in a place you expect to find it]!
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.
34 "Peering Inside the PE: A Tour of the Win32 Portable Executable
35 File Format", MSJ 1994, Volume 9.
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
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.
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. */
55 /* This expands into COFF_WITH_pe, COFF_WITH_pep, or COFF_WITH_pex64
56 depending on whether we're compiling for straight PE or PE+. */
62 #include "coff/internal.h"
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 #if defined COFF_WITH_pex64
71 # include "coff/x86_64.h"
72 #elif defined COFF_WITH_pep
73 # include "coff/ia64.h"
75 # include "coff/i386.h"
82 #if defined COFF_WITH_pep || defined COFF_WITH_pex64
84 # define AOUTSZ PEPAOUTSZ
85 # define PEAOUTHDR PEPAOUTHDR
88 /* FIXME: This file has various tests of POWERPC_LE_PE. Those tests
89 worked when the code was in peicode.h, but no longer work now that
90 the code is in peigen.c. PowerPC NT is said to be dead. If
91 anybody wants to revive the code, you will have to figure out how
92 to handle those issues. */
95 _bfd_XXi_swap_sym_in (bfd * abfd, void * ext1, void * in1)
97 SYMENT *ext = (SYMENT *) ext1;
98 struct internal_syment *in = (struct internal_syment *) in1;
100 if (ext->e.e_name[0] == 0)
102 in->_n._n_n._n_zeroes = 0;
103 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
106 memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
108 in->n_value = H_GET_32 (abfd, ext->e_value);
109 in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
111 if (sizeof (ext->e_type) == 2)
112 in->n_type = H_GET_16 (abfd, ext->e_type);
114 in->n_type = H_GET_32 (abfd, ext->e_type);
116 in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
117 in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
119 #ifndef STRICT_PE_FORMAT
120 /* This is for Gnu-created DLLs. */
122 /* The section symbols for the .idata$ sections have class 0x68
123 (C_SECTION), which MS documentation indicates is a section
124 symbol. Unfortunately, the value field in the symbol is simply a
125 copy of the .idata section's flags rather than something useful.
126 When these symbols are encountered, change the value to 0 so that
127 they will be handled somewhat correctly in the bfd code. */
128 if (in->n_sclass == C_SECTION)
132 /* Create synthetic empty sections as needed. DJ */
133 if (in->n_scnum == 0)
137 for (sec = abfd->sections; sec; sec = sec->next)
139 if (strcmp (sec->name, in->n_name) == 0)
141 in->n_scnum = sec->target_index;
147 if (in->n_scnum == 0)
149 int unused_section_number = 0;
154 for (sec = abfd->sections; sec; sec = sec->next)
155 if (unused_section_number <= sec->target_index)
156 unused_section_number = sec->target_index + 1;
158 name = bfd_alloc (abfd, (bfd_size_type) strlen (in->n_name) + 10);
161 strcpy (name, in->n_name);
162 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
163 sec = bfd_make_section_anyway_with_flags (abfd, name, flags);
169 sec->rel_filepos = 0;
170 sec->reloc_count = 0;
171 sec->line_filepos = 0;
172 sec->lineno_count = 0;
173 sec->userdata = NULL;
175 sec->alignment_power = 2;
177 sec->target_index = unused_section_number;
179 in->n_scnum = unused_section_number;
181 in->n_sclass = C_STAT;
185 #ifdef coff_swap_sym_in_hook
186 /* This won't work in peigen.c, but since it's for PPC PE, it's not
188 coff_swap_sym_in_hook (abfd, ext1, in1);
193 _bfd_XXi_swap_sym_out (bfd * abfd, void * inp, void * extp)
195 struct internal_syment *in = (struct internal_syment *) inp;
196 SYMENT *ext = (SYMENT *) extp;
198 if (in->_n._n_name[0] == 0)
200 H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
201 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
204 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
206 H_PUT_32 (abfd, in->n_value, ext->e_value);
207 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
209 if (sizeof (ext->e_type) == 2)
210 H_PUT_16 (abfd, in->n_type, ext->e_type);
212 H_PUT_32 (abfd, in->n_type, ext->e_type);
214 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
215 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
221 _bfd_XXi_swap_aux_in (bfd * abfd,
225 int indx ATTRIBUTE_UNUSED,
226 int numaux ATTRIBUTE_UNUSED,
229 AUXENT *ext = (AUXENT *) ext1;
230 union internal_auxent *in = (union internal_auxent *) in1;
235 if (ext->x_file.x_fname[0] == 0)
237 in->x_file.x_n.x_zeroes = 0;
238 in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
241 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
249 in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
250 in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
251 in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
252 in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
253 in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
254 in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
260 in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
261 in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
263 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
265 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
266 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
270 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
271 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
272 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
273 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
274 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
275 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
276 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
277 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
282 in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
286 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
287 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
292 _bfd_XXi_swap_aux_out (bfd * abfd,
296 int indx ATTRIBUTE_UNUSED,
297 int numaux ATTRIBUTE_UNUSED,
300 union internal_auxent *in = (union internal_auxent *) inp;
301 AUXENT *ext = (AUXENT *) extp;
303 memset (ext, 0, AUXESZ);
308 if (in->x_file.x_fname[0] == 0)
310 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
311 H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
314 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
323 PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
324 PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
325 PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
326 H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
327 H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
328 H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
334 H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
335 H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
337 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
339 PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
340 PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
344 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
345 ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
346 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
347 ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
348 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
349 ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
350 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
351 ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
355 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
358 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
359 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
366 _bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1)
368 LINENO *ext = (LINENO *) ext1;
369 struct internal_lineno *in = (struct internal_lineno *) in1;
371 in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
372 in->l_lnno = GET_LINENO_LNNO (abfd, ext);
376 _bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp)
378 struct internal_lineno *in = (struct internal_lineno *) inp;
379 struct external_lineno *ext = (struct external_lineno *) outp;
380 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
382 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
387 _bfd_XXi_swap_aouthdr_in (bfd * abfd,
391 PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1;
392 AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
393 struct internal_aouthdr *aouthdr_int
394 = (struct internal_aouthdr *) aouthdr_int1;
395 struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe;
397 aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
398 aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
399 aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
400 aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
401 aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
402 aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
403 aouthdr_int->text_start =
404 GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
405 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
406 /* PE32+ does not have data_start member! */
407 aouthdr_int->data_start =
408 GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
409 a->BaseOfData = aouthdr_int->data_start;
412 a->Magic = aouthdr_int->magic;
413 a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp);
414 a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1);
415 a->SizeOfCode = aouthdr_int->tsize ;
416 a->SizeOfInitializedData = aouthdr_int->dsize ;
417 a->SizeOfUninitializedData = aouthdr_int->bsize ;
418 a->AddressOfEntryPoint = aouthdr_int->entry;
419 a->BaseOfCode = aouthdr_int->text_start;
420 a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
421 a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
422 a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
423 a->MajorOperatingSystemVersion =
424 H_GET_16 (abfd, src->MajorOperatingSystemVersion);
425 a->MinorOperatingSystemVersion =
426 H_GET_16 (abfd, src->MinorOperatingSystemVersion);
427 a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
428 a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
429 a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
430 a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
431 a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
432 a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
433 a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
434 a->CheckSum = H_GET_32 (abfd, src->CheckSum);
435 a->Subsystem = H_GET_16 (abfd, src->Subsystem);
436 a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
437 a->SizeOfStackReserve =
438 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
439 a->SizeOfStackCommit =
440 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
441 a->SizeOfHeapReserve =
442 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
443 a->SizeOfHeapCommit =
444 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
445 a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
446 a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
451 /* PR 17512: Corrupt PE binaries can cause seg-faults. */
452 if (a->NumberOfRvaAndSizes > 16)
454 (*_bfd_error_handler)
455 (_("%B: aout header specifies an invalid number of data-directory entries: %d"),
456 abfd, a->NumberOfRvaAndSizes);
457 /* Paranoia: If the number is corrupt, then assume that the
458 actual entries themselves might be corrupt as well. */
459 a->NumberOfRvaAndSizes = 0;
462 for (idx = 0; idx < 16; idx++)
464 /* If data directory is empty, rva also should be 0. */
466 H_GET_32 (abfd, src->DataDirectory[idx][1]);
468 a->DataDirectory[idx].Size = size;
471 a->DataDirectory[idx].VirtualAddress =
472 H_GET_32 (abfd, src->DataDirectory[idx][0]);
474 a->DataDirectory[idx].VirtualAddress = 0;
478 if (aouthdr_int->entry)
480 aouthdr_int->entry += a->ImageBase;
481 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
482 aouthdr_int->entry &= 0xffffffff;
486 if (aouthdr_int->tsize)
488 aouthdr_int->text_start += a->ImageBase;
489 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
490 aouthdr_int->text_start &= 0xffffffff;
494 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
495 /* PE32+ does not have data_start member! */
496 if (aouthdr_int->dsize)
498 aouthdr_int->data_start += a->ImageBase;
499 aouthdr_int->data_start &= 0xffffffff;
504 /* These three fields are normally set up by ppc_relocate_section.
505 In the case of reading a file in, we can pick them up from the
507 first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress;
508 thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size;
509 import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size;
513 /* A support function for below. */
516 add_data_entry (bfd * abfd,
517 struct internal_extra_pe_aouthdr *aout,
522 asection *sec = bfd_get_section_by_name (abfd, name);
524 /* Add import directory information if it exists. */
526 && (coff_section_data (abfd, sec) != NULL)
527 && (pei_section_data (abfd, sec) != NULL))
529 /* If data directory is empty, rva also should be 0. */
530 int size = pei_section_data (abfd, sec)->virt_size;
531 aout->DataDirectory[idx].Size = size;
535 aout->DataDirectory[idx].VirtualAddress =
536 (sec->vma - base) & 0xffffffff;
537 sec->flags |= SEC_DATA;
543 _bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out)
545 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
546 pe_data_type *pe = pe_data (abfd);
547 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
548 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
550 IMAGE_DATA_DIRECTORY idata2, idata5, tls;
552 if (pe->force_minimum_alignment)
554 if (!extra->FileAlignment)
555 extra->FileAlignment = PE_DEF_FILE_ALIGNMENT;
556 if (!extra->SectionAlignment)
557 extra->SectionAlignment = PE_DEF_SECTION_ALIGNMENT;
560 if (extra->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
561 extra->Subsystem = pe->target_subsystem;
563 sa = extra->SectionAlignment;
564 fa = extra->FileAlignment;
565 ib = extra->ImageBase;
567 idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
568 idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
569 tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
571 if (aouthdr_in->tsize)
573 aouthdr_in->text_start -= ib;
574 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
575 aouthdr_in->text_start &= 0xffffffff;
579 if (aouthdr_in->dsize)
581 aouthdr_in->data_start -= ib;
582 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
583 aouthdr_in->data_start &= 0xffffffff;
587 if (aouthdr_in->entry)
589 aouthdr_in->entry -= ib;
590 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
591 aouthdr_in->entry &= 0xffffffff;
595 #define FA(x) (((x) + fa -1 ) & (- fa))
596 #define SA(x) (((x) + sa -1 ) & (- sa))
598 /* We like to have the sizes aligned. */
599 aouthdr_in->bsize = FA (aouthdr_in->bsize);
601 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
603 /* First null out all data directory entries. */
604 memset (extra->DataDirectory, 0, sizeof (extra->DataDirectory));
606 add_data_entry (abfd, extra, 0, ".edata", ib);
607 add_data_entry (abfd, extra, 2, ".rsrc", ib);
608 add_data_entry (abfd, extra, 3, ".pdata", ib);
610 /* In theory we do not need to call add_data_entry for .idata$2 or
611 .idata$5. It will be done in bfd_coff_final_link where all the
612 required information is available. If however, we are not going
613 to perform a final link, eg because we have been invoked by objcopy
614 or strip, then we need to make sure that these Data Directory
615 entries are initialised properly.
617 So - we copy the input values into the output values, and then, if
618 a final link is going to be performed, it can overwrite them. */
619 extra->DataDirectory[PE_IMPORT_TABLE] = idata2;
620 extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
621 extra->DataDirectory[PE_TLS_TABLE] = tls;
623 if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
624 /* Until other .idata fixes are made (pending patch), the entry for
625 .idata is needed for backwards compatibility. FIXME. */
626 add_data_entry (abfd, extra, 1, ".idata", ib);
628 /* For some reason, the virtual size (which is what's set by
629 add_data_entry) for .reloc is not the same as the size recorded
630 in this slot by MSVC; it doesn't seem to cause problems (so far),
631 but since it's the best we've got, use it. It does do the right
633 if (pe->has_reloc_section)
634 add_data_entry (abfd, extra, 5, ".reloc", ib);
643 for (sec = abfd->sections; sec; sec = sec->next)
645 int rounded = FA (sec->size);
647 /* The first non-zero section filepos is the header size.
648 Sections without contents will have a filepos of 0. */
650 hsize = sec->filepos;
651 if (sec->flags & SEC_DATA)
653 if (sec->flags & SEC_CODE)
655 /* The image size is the total VIRTUAL size (which is what is
656 in the virt_size field). Files have been seen (from MSVC
657 5.0 link.exe) where the file size of the .data segment is
658 quite small compared to the virtual size. Without this
659 fix, strip munges the file.
661 FIXME: We need to handle holes between sections, which may
662 happpen when we covert from another format. We just use
663 the virtual address and virtual size of the last section
664 for the image size. */
665 if (coff_section_data (abfd, sec) != NULL
666 && pei_section_data (abfd, sec) != NULL)
667 isize = (sec->vma - extra->ImageBase
668 + SA (FA (pei_section_data (abfd, sec)->virt_size)));
671 aouthdr_in->dsize = dsize;
672 aouthdr_in->tsize = tsize;
673 extra->SizeOfHeaders = hsize;
674 extra->SizeOfImage = isize;
677 H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
679 #define LINKER_VERSION 256 /* That is, 2.56 */
681 /* This piece of magic sets the "linker version" field to
683 H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
684 aouthdr_out->standard.vstamp);
686 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
687 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
688 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
689 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
690 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
691 aouthdr_out->standard.text_start);
693 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
694 /* PE32+ does not have data_start member! */
695 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
696 aouthdr_out->standard.data_start);
699 PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
700 H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
701 H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
702 H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
703 aouthdr_out->MajorOperatingSystemVersion);
704 H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
705 aouthdr_out->MinorOperatingSystemVersion);
706 H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
707 H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
708 H_PUT_16 (abfd, extra->MajorSubsystemVersion,
709 aouthdr_out->MajorSubsystemVersion);
710 H_PUT_16 (abfd, extra->MinorSubsystemVersion,
711 aouthdr_out->MinorSubsystemVersion);
712 H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
713 H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
714 H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
715 H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
716 H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
717 H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
718 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
719 aouthdr_out->SizeOfStackReserve);
720 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
721 aouthdr_out->SizeOfStackCommit);
722 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
723 aouthdr_out->SizeOfHeapReserve);
724 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
725 aouthdr_out->SizeOfHeapCommit);
726 H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
727 H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
728 aouthdr_out->NumberOfRvaAndSizes);
732 for (idx = 0; idx < 16; idx++)
734 H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
735 aouthdr_out->DataDirectory[idx][0]);
736 H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
737 aouthdr_out->DataDirectory[idx][1]);
745 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
748 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
749 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
751 if (pe_data (abfd)->has_reloc_section)
752 filehdr_in->f_flags &= ~F_RELFLG;
754 if (pe_data (abfd)->dll)
755 filehdr_in->f_flags |= F_DLL;
757 filehdr_in->pe.e_magic = DOSMAGIC;
758 filehdr_in->pe.e_cblp = 0x90;
759 filehdr_in->pe.e_cp = 0x3;
760 filehdr_in->pe.e_crlc = 0x0;
761 filehdr_in->pe.e_cparhdr = 0x4;
762 filehdr_in->pe.e_minalloc = 0x0;
763 filehdr_in->pe.e_maxalloc = 0xffff;
764 filehdr_in->pe.e_ss = 0x0;
765 filehdr_in->pe.e_sp = 0xb8;
766 filehdr_in->pe.e_csum = 0x0;
767 filehdr_in->pe.e_ip = 0x0;
768 filehdr_in->pe.e_cs = 0x0;
769 filehdr_in->pe.e_lfarlc = 0x40;
770 filehdr_in->pe.e_ovno = 0x0;
772 for (idx = 0; idx < 4; idx++)
773 filehdr_in->pe.e_res[idx] = 0x0;
775 filehdr_in->pe.e_oemid = 0x0;
776 filehdr_in->pe.e_oeminfo = 0x0;
778 for (idx = 0; idx < 10; idx++)
779 filehdr_in->pe.e_res2[idx] = 0x0;
781 filehdr_in->pe.e_lfanew = 0x80;
783 /* This next collection of data are mostly just characters. It
784 appears to be constant within the headers put on NT exes. */
785 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
786 filehdr_in->pe.dos_message[1] = 0xcd09b400;
787 filehdr_in->pe.dos_message[2] = 0x4c01b821;
788 filehdr_in->pe.dos_message[3] = 0x685421cd;
789 filehdr_in->pe.dos_message[4] = 0x70207369;
790 filehdr_in->pe.dos_message[5] = 0x72676f72;
791 filehdr_in->pe.dos_message[6] = 0x63206d61;
792 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
793 filehdr_in->pe.dos_message[8] = 0x65622074;
794 filehdr_in->pe.dos_message[9] = 0x6e757220;
795 filehdr_in->pe.dos_message[10] = 0x206e6920;
796 filehdr_in->pe.dos_message[11] = 0x20534f44;
797 filehdr_in->pe.dos_message[12] = 0x65646f6d;
798 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
799 filehdr_in->pe.dos_message[14] = 0x24;
800 filehdr_in->pe.dos_message[15] = 0x0;
801 filehdr_in->pe.nt_signature = NT_SIGNATURE;
803 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
804 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
806 H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
807 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
808 filehdr_out->f_symptr);
809 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
810 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
811 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
813 /* Put in extra dos header stuff. This data remains essentially
814 constant, it just has to be tacked on to the beginning of all exes
816 H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
817 H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
818 H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
819 H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
820 H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
821 H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
822 H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
823 H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
824 H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
825 H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
826 H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
827 H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
828 H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
829 H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
831 for (idx = 0; idx < 4; idx++)
832 H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
834 H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
835 H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
837 for (idx = 0; idx < 10; idx++)
838 H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
840 H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
842 for (idx = 0; idx < 16; idx++)
843 H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
844 filehdr_out->dos_message[idx]);
846 /* Also put in the NT signature. */
847 H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
853 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
855 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
856 FILHDR *filehdr_out = (FILHDR *) out;
858 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
859 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
860 H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
861 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
862 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
863 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
864 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
870 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
872 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
873 SCNHDR *scnhdr_ext = (SCNHDR *) out;
874 unsigned int ret = SCNHSZ;
878 memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
880 PUT_SCNHDR_VADDR (abfd,
881 ((scnhdr_int->s_vaddr
882 - pe_data (abfd)->pe_opthdr.ImageBase)
884 scnhdr_ext->s_vaddr);
886 /* NT wants the size data to be rounded up to the next
887 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
889 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
891 if (bfd_pe_executable_p (abfd))
893 ps = scnhdr_int->s_size;
899 ss = scnhdr_int->s_size;
904 if (bfd_pe_executable_p (abfd))
905 ps = scnhdr_int->s_paddr;
909 ss = scnhdr_int->s_size;
912 PUT_SCNHDR_SIZE (abfd, ss,
915 /* s_paddr in PE is really the virtual size. */
916 PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
918 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
919 scnhdr_ext->s_scnptr);
920 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
921 scnhdr_ext->s_relptr);
922 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
923 scnhdr_ext->s_lnnoptr);
926 /* Extra flags must be set when dealing with PE. All sections should also
927 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
928 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
929 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
930 (this is especially important when dealing with the .idata section since
931 the addresses for routines from .dlls must be overwritten). If .reloc
932 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
933 (0x02000000). Also, the resource data should also be read and
936 /* FIXME: Alignment is also encoded in this field, at least on PPC and
937 ARM-WINCE. Although - how do we get the original alignment field
942 const char * section_name;
943 unsigned long must_have;
945 pe_required_section_flags;
947 pe_required_section_flags known_sections [] =
949 { ".arch", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
950 { ".bss", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
951 { ".data", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
952 { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
953 { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
954 { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
955 { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
956 { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
957 { ".rsrc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
958 { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
959 { ".tls", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
960 { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
964 pe_required_section_flags * p;
966 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
967 we know exactly what this specific section wants so we remove it
968 and then allow the must_have field to add it back in if necessary.
969 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
970 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
971 by ld --enable-auto-import (if auto-import is actually needed),
972 by ld --omagic, or by obcopy --writable-text. */
974 for (p = known_sections; p->section_name; p++)
975 if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
977 if (strcmp (scnhdr_int->s_name, ".text")
978 || (bfd_get_file_flags (abfd) & WP_TEXT))
979 scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
980 scnhdr_int->s_flags |= p->must_have;
984 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
987 if (coff_data (abfd)->link_info
988 && ! coff_data (abfd)->link_info->relocatable
989 && ! coff_data (abfd)->link_info->shared
990 && strcmp (scnhdr_int->s_name, ".text") == 0)
992 /* By inference from looking at MS output, the 32 bit field
993 which is the combination of the number_of_relocs and
994 number_of_linenos is used for the line number count in
995 executables. A 16-bit field won't do for cc1. The MS
996 document says that the number of relocs is zero for
997 executables, but the 17-th bit has been observed to be there.
998 Overflow is not an issue: a 4G-line program will overflow a
999 bunch of other fields long before this! */
1000 H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
1001 H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
1005 if (scnhdr_int->s_nlnno <= 0xffff)
1006 H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
1009 (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
1010 bfd_get_filename (abfd),
1011 scnhdr_int->s_nlnno);
1012 bfd_set_error (bfd_error_file_truncated);
1013 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
1017 /* Although we could encode 0xffff relocs here, we do not, to be
1018 consistent with other parts of bfd. Also it lets us warn, as
1019 we should never see 0xffff here w/o having the overflow flag
1021 if (scnhdr_int->s_nreloc < 0xffff)
1022 H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
1025 /* PE can deal with large #s of relocs, but not here. */
1026 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1027 scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1028 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1034 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1036 N_("Export Directory [.edata (or where ever we found it)]"),
1037 N_("Import Directory [parts of .idata]"),
1038 N_("Resource Directory [.rsrc]"),
1039 N_("Exception Directory [.pdata]"),
1040 N_("Security Directory"),
1041 N_("Base Relocation Directory [.reloc]"),
1042 N_("Debug Directory"),
1043 N_("Description Directory"),
1044 N_("Special Directory"),
1045 N_("Thread Storage Directory [.tls]"),
1046 N_("Load Configuration Directory"),
1047 N_("Bound Import Directory"),
1048 N_("Import Address Table Directory"),
1049 N_("Delay Import Directory"),
1050 N_("CLR Runtime Header"),
1054 #ifdef POWERPC_LE_PE
1055 /* The code for the PPC really falls in the "architecture dependent"
1056 category. However, it's not clear that anyone will ever care, so
1057 we're ignoring the issue for now; if/when PPC matters, some of this
1058 may need to go into peicode.h, or arguments passed to enable the
1059 PPC- specific code. */
1063 pe_print_idata (bfd * abfd, void * vfile)
1065 FILE *file = (FILE *) vfile;
1070 #ifdef POWERPC_LE_PE
1071 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1074 bfd_size_type datasize = 0;
1075 bfd_size_type dataoff;
1079 pe_data_type *pe = pe_data (abfd);
1080 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1084 addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
1086 if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
1088 /* Maybe the extra header isn't there. Look for the section. */
1089 section = bfd_get_section_by_name (abfd, ".idata");
1090 if (section == NULL)
1093 addr = section->vma;
1094 datasize = section->size;
1100 addr += extra->ImageBase;
1101 for (section = abfd->sections; section != NULL; section = section->next)
1103 datasize = section->size;
1104 if (addr >= section->vma && addr < section->vma + datasize)
1108 if (section == NULL)
1111 _("\nThere is an import table, but the section containing it could not be found\n"));
1116 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1117 section->name, (unsigned long) addr);
1119 dataoff = addr - section->vma;
1120 datasize -= dataoff;
1122 #ifdef POWERPC_LE_PE
1123 if (rel_section != 0 && rel_section->size != 0)
1125 /* The toc address can be found by taking the starting address,
1126 which on the PPC locates a function descriptor. The
1127 descriptor consists of the function code starting address
1128 followed by the address of the toc. The starting address we
1129 get from the bfd, and the descriptor is supposed to be in the
1130 .reldata section. */
1132 bfd_vma loadable_toc_address;
1133 bfd_vma toc_address;
1134 bfd_vma start_address;
1138 if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1145 offset = abfd->start_address - rel_section->vma;
1147 if (offset >= rel_section->size || offset + 8 > rel_section->size)
1154 start_address = bfd_get_32 (abfd, data + offset);
1155 loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1156 toc_address = loadable_toc_address - 32768;
1159 _("\nFunction descriptor located at the start address: %04lx\n"),
1160 (unsigned long int) (abfd->start_address));
1162 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1163 start_address, loadable_toc_address, toc_address);
1170 _("\nNo reldata section! Function descriptor not decoded.\n"));
1175 _("\nThe Import Tables (interpreted %s section contents)\n"),
1179 vma: Hint Time Forward DLL First\n\
1180 Table Stamp Chain Name Thunk\n"));
1182 /* Read the whole section. Some of the fields might be before dataoff. */
1183 if (!bfd_malloc_and_get_section (abfd, section, &data))
1190 adj = section->vma - extra->ImageBase;
1192 /* Print all image import descriptors. */
1193 for (i = 0; i < datasize; i += onaline)
1197 bfd_vma forward_chain;
1199 bfd_vma first_thunk;
1204 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1205 fprintf (file, " %08lx\t", (unsigned long) (i + adj + dataoff));
1206 hint_addr = bfd_get_32 (abfd, data + i + dataoff);
1207 time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff);
1208 forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff);
1209 dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff);
1210 first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff);
1212 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1213 (unsigned long) hint_addr,
1214 (unsigned long) time_stamp,
1215 (unsigned long) forward_chain,
1216 (unsigned long) dll_name,
1217 (unsigned long) first_thunk);
1219 if (hint_addr == 0 && first_thunk == 0)
1222 if (dll_name - adj >= section->size)
1225 dll = (char *) data + dll_name - adj;
1226 fprintf (file, _("\n\tDLL Name: %s\n"), dll);
1231 asection *ft_section;
1233 bfd_size_type ft_datasize;
1235 int ft_allocated = 0;
1237 fprintf (file, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1239 idx = hint_addr - adj;
1241 ft_addr = first_thunk + extra->ImageBase;
1243 ft_idx = first_thunk - adj;
1246 if (first_thunk != hint_addr)
1248 /* Find the section which contains the first thunk. */
1249 for (ft_section = abfd->sections;
1251 ft_section = ft_section->next)
1253 ft_datasize = ft_section->size;
1254 if (ft_addr >= ft_section->vma
1255 && ft_addr < ft_section->vma + ft_datasize)
1259 if (ft_section == NULL)
1262 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1266 /* Now check to see if this section is the same as our current
1267 section. If it is not then we will have to load its data in. */
1268 if (ft_section == section)
1271 ft_idx = first_thunk - adj;
1275 ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1276 ft_data = bfd_malloc (datasize);
1277 if (ft_data == NULL)
1280 /* Read datasize bfd_bytes starting at offset ft_idx. */
1281 if (! bfd_get_section_contents
1282 (abfd, ft_section, ft_data, (bfd_vma) ft_idx, datasize))
1293 /* Print HintName vector entries. */
1294 #ifdef COFF_WITH_pex64
1295 for (j = 0; j < datasize; j += 8)
1297 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1298 unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1300 if (!member && !member_high)
1303 if (member_high & 0x80000000)
1304 fprintf (file, "\t%lx%08lx\t %4lx%08lx <none>",
1305 member_high,member, member_high & 0x7fffffff, member);
1311 ordinal = bfd_get_16 (abfd, data + member - adj);
1312 member_name = (char *) data + member - adj + 2;
1313 fprintf (file, "\t%04lx\t %4d %s",member, ordinal, member_name);
1316 /* If the time stamp is not zero, the import address
1317 table holds actual addresses. */
1320 && first_thunk != hint_addr)
1321 fprintf (file, "\t%04lx",
1322 (long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1323 fprintf (file, "\n");
1326 for (j = 0; j < datasize; j += 4)
1328 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1330 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1334 if (member & 0x80000000)
1335 fprintf (file, "\t%04lx\t %4lu <none>",
1336 member, member & 0x7fffffff);
1342 ordinal = bfd_get_16 (abfd, data + member - adj);
1343 member_name = (char *) data + member - adj + 2;
1344 fprintf (file, "\t%04lx\t %4d %s",
1345 member, ordinal, member_name);
1348 /* If the time stamp is not zero, the import address
1349 table holds actual addresses. */
1352 && first_thunk != hint_addr)
1353 fprintf (file, "\t%04lx",
1354 (long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1356 fprintf (file, "\n");
1363 fprintf (file, "\n");
1372 pe_print_edata (bfd * abfd, void * vfile)
1374 FILE *file = (FILE *) vfile;
1377 bfd_size_type datasize = 0;
1378 bfd_size_type dataoff;
1383 long export_flags; /* Reserved - should be zero. */
1387 bfd_vma name; /* RVA - relative to image base. */
1388 long base; /* Ordinal base. */
1389 unsigned long num_functions;/* Number in the export address table. */
1390 unsigned long num_names; /* Number in the name pointer table. */
1391 bfd_vma eat_addr; /* RVA to the export address table. */
1392 bfd_vma npt_addr; /* RVA to the Export Name Pointer Table. */
1393 bfd_vma ot_addr; /* RVA to the Ordinal Table. */
1396 pe_data_type *pe = pe_data (abfd);
1397 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1401 addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
1403 if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
1405 /* Maybe the extra header isn't there. Look for the section. */
1406 section = bfd_get_section_by_name (abfd, ".edata");
1407 if (section == NULL)
1410 addr = section->vma;
1412 datasize = section->size;
1418 addr += extra->ImageBase;
1420 for (section = abfd->sections; section != NULL; section = section->next)
1421 if (addr >= section->vma && addr < section->vma + section->size)
1424 if (section == NULL)
1427 _("\nThere is an export table, but the section containing it could not be found\n"));
1431 dataoff = addr - section->vma;
1432 datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
1433 if (datasize > section->size - dataoff)
1436 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1442 /* PR 17512: Handle corrupt PE binaries. */
1446 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1447 section->name, (int) datasize);
1451 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1452 section->name, (unsigned long) addr);
1454 data = bfd_malloc (datasize);
1458 if (! bfd_get_section_contents (abfd, section, data,
1459 (file_ptr) dataoff, datasize))
1462 /* Go get Export Directory Table. */
1463 edt.export_flags = bfd_get_32 (abfd, data + 0);
1464 edt.time_stamp = bfd_get_32 (abfd, data + 4);
1465 edt.major_ver = bfd_get_16 (abfd, data + 8);
1466 edt.minor_ver = bfd_get_16 (abfd, data + 10);
1467 edt.name = bfd_get_32 (abfd, data + 12);
1468 edt.base = bfd_get_32 (abfd, data + 16);
1469 edt.num_functions = bfd_get_32 (abfd, data + 20);
1470 edt.num_names = bfd_get_32 (abfd, data + 24);
1471 edt.eat_addr = bfd_get_32 (abfd, data + 28);
1472 edt.npt_addr = bfd_get_32 (abfd, data + 32);
1473 edt.ot_addr = bfd_get_32 (abfd, data + 36);
1475 adj = section->vma - extra->ImageBase + dataoff;
1477 /* Dump the EDT first. */
1479 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1483 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1486 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1489 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1492 _("Name \t\t\t\t"));
1493 fprintf_vma (file, edt.name);
1495 " %s\n", data + edt.name - adj);
1498 _("Ordinal Base \t\t\t%ld\n"), edt.base);
1504 _("\tExport Address Table \t\t%08lx\n"),
1508 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1511 _("Table Addresses\n"));
1514 _("\tExport Address Table \t\t"));
1515 fprintf_vma (file, edt.eat_addr);
1516 fprintf (file, "\n");
1519 _("\tName Pointer Table \t\t"));
1520 fprintf_vma (file, edt.npt_addr);
1521 fprintf (file, "\n");
1524 _("\tOrdinal Table \t\t\t"));
1525 fprintf_vma (file, edt.ot_addr);
1526 fprintf (file, "\n");
1528 /* The next table to find is the Export Address Table. It's basically
1529 a list of pointers that either locate a function in this dll, or
1530 forward the call to another dll. Something like:
1535 } export_address_table_entry; */
1538 _("\nExport Address Table -- Ordinal Base %ld\n"),
1541 for (i = 0; i < edt.num_functions; ++i)
1543 bfd_vma eat_member = bfd_get_32 (abfd,
1544 data + edt.eat_addr + (i * 4) - adj);
1545 if (eat_member == 0)
1548 if (eat_member - adj <= datasize)
1550 /* This rva is to a name (forwarding function) in our section. */
1551 /* Should locate a function descriptor. */
1553 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1555 (long) (i + edt.base),
1556 (unsigned long) eat_member,
1558 data + eat_member - adj);
1562 /* Should locate a function descriptor in the reldata section. */
1564 "\t[%4ld] +base[%4ld] %04lx %s\n",
1566 (long) (i + edt.base),
1567 (unsigned long) eat_member,
1572 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1573 /* Dump them in parallel for clarity. */
1575 _("\n[Ordinal/Name Pointer] Table\n"));
1577 for (i = 0; i < edt.num_names; ++i)
1579 bfd_vma name_ptr = bfd_get_32 (abfd,
1584 char *name = (char *) data + name_ptr - adj;
1586 bfd_vma ord = bfd_get_16 (abfd,
1591 "\t[%4ld] %s\n", (long) ord, name);
1599 /* This really is architecture dependent. On IA-64, a .pdata entry
1600 consists of three dwords containing relative virtual addresses that
1601 specify the start and end address of the code range the entry
1602 covers and the address of the corresponding unwind info data. */
1605 pe_print_pdata (bfd * abfd, void * vfile)
1607 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1608 # define PDATA_ROW_SIZE (3 * 8)
1610 # define PDATA_ROW_SIZE (5 * 4)
1612 FILE *file = (FILE *) vfile;
1614 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1615 bfd_size_type datasize = 0;
1617 bfd_size_type start, stop;
1618 int onaline = PDATA_ROW_SIZE;
1621 || coff_section_data (abfd, section) == NULL
1622 || pei_section_data (abfd, section) == NULL)
1625 stop = pei_section_data (abfd, section)->virt_size;
1626 if ((stop % onaline) != 0)
1628 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1629 (long) stop, onaline);
1632 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1633 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1635 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1638 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1639 \t\tAddress Address Handler Data Address Mask\n"));
1642 datasize = section->size;
1646 if (! bfd_malloc_and_get_section (abfd, section, &data))
1655 for (i = start; i < stop; i += onaline)
1661 bfd_vma prolog_end_addr;
1664 if (i + PDATA_ROW_SIZE > stop)
1667 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
1668 end_addr = GET_PDATA_ENTRY (abfd, data + i + 4);
1669 eh_handler = GET_PDATA_ENTRY (abfd, data + i + 8);
1670 eh_data = GET_PDATA_ENTRY (abfd, data + i + 12);
1671 prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1673 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1674 && eh_data == 0 && prolog_end_addr == 0)
1675 /* We are probably into the padding of the section now. */
1678 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1679 eh_handler &= ~(bfd_vma) 0x3;
1680 prolog_end_addr &= ~(bfd_vma) 0x3;
1683 fprintf_vma (file, i + section->vma); fputc ('\t', file);
1684 fprintf_vma (file, begin_addr); fputc (' ', file);
1685 fprintf_vma (file, end_addr); fputc (' ', file);
1686 fprintf_vma (file, eh_handler);
1687 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1689 fprintf_vma (file, eh_data); fputc (' ', file);
1690 fprintf_vma (file, prolog_end_addr);
1691 fprintf (file, " %x", em_data);
1694 #ifdef POWERPC_LE_PE
1695 if (eh_handler == 0 && eh_data != 0)
1697 /* Special bits here, although the meaning may be a little
1698 mysterious. The only one I know for sure is 0x03
1701 0x01 Register Save Millicode
1702 0x02 Register Restore Millicode
1703 0x03 Glue Code Sequence. */
1707 fprintf (file, _(" Register save millicode"));
1710 fprintf (file, _(" Register restore millicode"));
1713 fprintf (file, _(" Glue code sequence"));
1720 fprintf (file, "\n");
1728 #define IMAGE_REL_BASED_HIGHADJ 4
1729 static const char * const tbl[] =
1743 "UNKNOWN", /* MUST be last. */
1747 pe_print_reloc (bfd * abfd, void * vfile)
1749 FILE *file = (FILE *) vfile;
1751 asection *section = bfd_get_section_by_name (abfd, ".reloc");
1752 bfd_size_type datasize;
1754 bfd_size_type start, stop;
1756 if (section == NULL)
1759 if (section->size == 0)
1763 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
1765 datasize = section->size;
1766 if (! bfd_malloc_and_get_section (abfd, section, &data))
1775 stop = section->size;
1777 for (i = start; i < stop;)
1780 bfd_vma virtual_address;
1783 /* The .reloc section is a sequence of blocks, with a header consisting
1784 of two 32 bit quantities, followed by a number of 16 bit entries. */
1785 virtual_address = bfd_get_32 (abfd, data+i);
1786 size = bfd_get_32 (abfd, data+i+4);
1787 number = (size - 8) / 2;
1793 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
1794 (unsigned long) virtual_address, size, size, number);
1796 for (j = 0; j < number; ++j)
1798 unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
1799 unsigned int t = (e & 0xF000) >> 12;
1800 int off = e & 0x0FFF;
1802 if (t >= sizeof (tbl) / sizeof (tbl[0]))
1803 t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
1806 _("\treloc %4d offset %4x [%4lx] %s"),
1807 j, off, (long) (off + virtual_address), tbl[t]);
1809 /* HIGHADJ takes an argument, - the next record *is* the
1810 low 16 bits of addend. */
1811 if (t == IMAGE_REL_BASED_HIGHADJ)
1813 fprintf (file, " (%4x)",
1815 bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
1819 fprintf (file, "\n");
1830 /* Print out the program headers. */
1833 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
1835 FILE *file = (FILE *) vfile;
1837 pe_data_type *pe = pe_data (abfd);
1838 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
1839 const char *subsystem_name = NULL;
1842 /* The MS dumpbin program reportedly ands with 0xff0f before
1843 printing the characteristics field. Not sure why. No reason to
1845 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
1847 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
1848 PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
1849 PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
1850 PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
1851 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
1852 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
1853 PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
1854 PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
1855 PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
1856 PF (IMAGE_FILE_SYSTEM, "system file");
1857 PF (IMAGE_FILE_DLL, "DLL");
1858 PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
1861 /* ctime implies '\n'. */
1863 time_t t = pe->coff.timestamp;
1864 fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
1867 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
1868 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
1870 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1871 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
1873 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
1874 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
1879 case IMAGE_NT_OPTIONAL_HDR_MAGIC:
1882 case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
1885 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
1892 fprintf (file, "Magic\t\t\t%04x", i->Magic);
1894 fprintf (file, "\t(%s)",name);
1895 fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
1896 fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
1897 fprintf (file, "SizeOfCode\t\t%08lx\n", i->SizeOfCode);
1898 fprintf (file, "SizeOfInitializedData\t%08lx\n",
1899 i->SizeOfInitializedData);
1900 fprintf (file, "SizeOfUninitializedData\t%08lx\n",
1901 i->SizeOfUninitializedData);
1902 fprintf (file, "AddressOfEntryPoint\t");
1903 fprintf_vma (file, i->AddressOfEntryPoint);
1904 fprintf (file, "\nBaseOfCode\t\t");
1905 fprintf_vma (file, i->BaseOfCode);
1906 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1907 /* PE32+ does not have BaseOfData member! */
1908 fprintf (file, "\nBaseOfData\t\t");
1909 fprintf_vma (file, i->BaseOfData);
1912 fprintf (file, "\nImageBase\t\t");
1913 fprintf_vma (file, i->ImageBase);
1914 fprintf (file, "\nSectionAlignment\t");
1915 fprintf_vma (file, i->SectionAlignment);
1916 fprintf (file, "\nFileAlignment\t\t");
1917 fprintf_vma (file, i->FileAlignment);
1918 fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
1919 fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
1920 fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
1921 fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
1922 fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
1923 fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
1924 fprintf (file, "Win32Version\t\t%08lx\n", i->Reserved1);
1925 fprintf (file, "SizeOfImage\t\t%08lx\n", i->SizeOfImage);
1926 fprintf (file, "SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders);
1927 fprintf (file, "CheckSum\t\t%08lx\n", i->CheckSum);
1929 switch (i->Subsystem)
1931 case IMAGE_SUBSYSTEM_UNKNOWN:
1932 subsystem_name = "unspecified";
1934 case IMAGE_SUBSYSTEM_NATIVE:
1935 subsystem_name = "NT native";
1937 case IMAGE_SUBSYSTEM_WINDOWS_GUI:
1938 subsystem_name = "Windows GUI";
1940 case IMAGE_SUBSYSTEM_WINDOWS_CUI:
1941 subsystem_name = "Windows CUI";
1943 case IMAGE_SUBSYSTEM_POSIX_CUI:
1944 subsystem_name = "POSIX CUI";
1946 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
1947 subsystem_name = "Wince CUI";
1949 case IMAGE_SUBSYSTEM_EFI_APPLICATION:
1950 subsystem_name = "EFI application";
1952 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
1953 subsystem_name = "EFI boot service driver";
1955 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
1956 subsystem_name = "EFI runtime driver";
1958 // These are from revision 8.0 of the MS PE/COFF spec
1959 case IMAGE_SUBSYSTEM_EFI_ROM:
1960 subsystem_name = "EFI ROM";
1962 case IMAGE_SUBSYSTEM_XBOX:
1963 subsystem_name = "XBOX";
1965 // Added default case for clarity - subsystem_name is NULL anyway.
1967 subsystem_name = NULL;
1970 fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
1972 fprintf (file, "\t(%s)", subsystem_name);
1973 fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
1974 fprintf (file, "SizeOfStackReserve\t");
1975 fprintf_vma (file, i->SizeOfStackReserve);
1976 fprintf (file, "\nSizeOfStackCommit\t");
1977 fprintf_vma (file, i->SizeOfStackCommit);
1978 fprintf (file, "\nSizeOfHeapReserve\t");
1979 fprintf_vma (file, i->SizeOfHeapReserve);
1980 fprintf (file, "\nSizeOfHeapCommit\t");
1981 fprintf_vma (file, i->SizeOfHeapCommit);
1982 fprintf (file, "\nLoaderFlags\t\t%08lx\n", i->LoaderFlags);
1983 fprintf (file, "NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes);
1985 fprintf (file, "\nThe Data Directory\n");
1986 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
1988 fprintf (file, "Entry %1x ", j);
1989 fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
1990 fprintf (file, " %08lx ", i->DataDirectory[j].Size);
1991 fprintf (file, "%s\n", dir_names[j]);
1994 pe_print_idata (abfd, vfile);
1995 pe_print_edata (abfd, vfile);
1996 pe_print_pdata (abfd, vfile);
1997 pe_print_reloc (abfd, vfile);
2002 /* Copy any private info we understand from the input bfd
2003 to the output bfd. */
2006 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
2008 /* One day we may try to grok other private data. */
2009 if (ibfd->xvec->flavour != bfd_target_coff_flavour
2010 || obfd->xvec->flavour != bfd_target_coff_flavour)
2013 pe_data (obfd)->pe_opthdr = pe_data (ibfd)->pe_opthdr;
2014 pe_data (obfd)->dll = pe_data (ibfd)->dll;
2016 /* For strip: if we removed .reloc, we'll make a real mess of things
2017 if we don't remove this entry as well. */
2018 if (! pe_data (obfd)->has_reloc_section)
2020 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2021 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
2026 /* Copy private section data. */
2029 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
2034 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
2035 || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
2038 if (coff_section_data (ibfd, isec) != NULL
2039 && pei_section_data (ibfd, isec) != NULL)
2041 if (coff_section_data (obfd, osec) == NULL)
2043 bfd_size_type amt = sizeof (struct coff_section_tdata);
2044 osec->used_by_bfd = bfd_zalloc (obfd, amt);
2045 if (osec->used_by_bfd == NULL)
2049 if (pei_section_data (obfd, osec) == NULL)
2051 bfd_size_type amt = sizeof (struct pei_section_tdata);
2052 coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
2053 if (coff_section_data (obfd, osec)->tdata == NULL)
2057 pei_section_data (obfd, osec)->virt_size =
2058 pei_section_data (ibfd, isec)->virt_size;
2059 pei_section_data (obfd, osec)->pe_flags =
2060 pei_section_data (ibfd, isec)->pe_flags;
2067 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
2069 coff_get_symbol_info (abfd, symbol, ret);
2072 /* Handle the .idata section and other things that need symbol table
2076 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
2078 struct coff_link_hash_entry *h1;
2079 struct bfd_link_info *info = pfinfo->info;
2080 bfd_boolean result = TRUE;
2082 /* There are a few fields that need to be filled in now while we
2083 have symbol table access.
2085 The .idata subsections aren't directly available as sections, but
2086 they are in the symbol table, so get them from there. */
2088 /* The import directory. This is the address of .idata$2, with size
2089 of .idata$2 + .idata$3. */
2090 h1 = coff_link_hash_lookup (coff_hash_table (info),
2091 ".idata$2", FALSE, FALSE, TRUE);
2094 /* PR ld/2729: We cannot rely upon all the output sections having been
2095 created properly, so check before referencing them. Issue a warning
2096 message for any sections tht could not be found. */
2097 if (h1->root.u.def.section != NULL
2098 && h1->root.u.def.section->output_section != NULL)
2099 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
2100 (h1->root.u.def.value
2101 + h1->root.u.def.section->output_section->vma
2102 + h1->root.u.def.section->output_offset);
2106 (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
2111 h1 = coff_link_hash_lookup (coff_hash_table (info),
2112 ".idata$4", FALSE, FALSE, TRUE);
2114 && h1->root.u.def.section != NULL
2115 && h1->root.u.def.section->output_section != NULL)
2116 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
2117 ((h1->root.u.def.value
2118 + h1->root.u.def.section->output_section->vma
2119 + h1->root.u.def.section->output_offset)
2120 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
2124 (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
2129 /* The import address table. This is the size/address of
2131 h1 = coff_link_hash_lookup (coff_hash_table (info),
2132 ".idata$5", FALSE, FALSE, TRUE);
2134 && h1->root.u.def.section != NULL
2135 && h1->root.u.def.section->output_section != NULL)
2136 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
2137 (h1->root.u.def.value
2138 + h1->root.u.def.section->output_section->vma
2139 + h1->root.u.def.section->output_offset);
2143 (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
2148 h1 = coff_link_hash_lookup (coff_hash_table (info),
2149 ".idata$6", FALSE, FALSE, TRUE);
2151 && h1->root.u.def.section != NULL
2152 && h1->root.u.def.section->output_section != NULL)
2153 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
2154 ((h1->root.u.def.value
2155 + h1->root.u.def.section->output_section->vma
2156 + h1->root.u.def.section->output_offset)
2157 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
2161 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
2167 h1 = coff_link_hash_lookup (coff_hash_table (info),
2168 "__tls_used", FALSE, FALSE, TRUE);
2171 if (h1->root.u.def.section != NULL
2172 && h1->root.u.def.section->output_section != NULL)
2173 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
2174 (h1->root.u.def.value
2175 + h1->root.u.def.section->output_section->vma
2176 + h1->root.u.def.section->output_offset
2177 - pe_data (abfd)->pe_opthdr.ImageBase);
2181 (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
2186 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
2189 /* If we couldn't find idata$2, we either have an excessively
2190 trivial program or are in DEEP trouble; we have to assume trivial