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, 2008, 2009 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 3 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,
21 MA 02110-1301, USA. */
24 /* Most of this hacked by Steve Chamberlain <sac@cygnus.com>.
26 PE/PEI rearrangement (and code added): Donn Terry
27 Softway Systems, Inc. */
29 /* Hey look, some documentation [and in a place you expect to find it]!
31 The main reference for the pei format is "Microsoft Portable Executable
32 and Common Object File Format Specification 4.1". Get it if you need to
33 do some serious hacking on this code.
36 "Peering Inside the PE: A Tour of the Win32 Portable Executable
37 File Format", MSJ 1994, Volume 9.
39 The *sole* difference between the pe format and the pei format is that the
40 latter has an MSDOS 2.0 .exe header on the front that prints the message
41 "This app must be run under Windows." (or some such).
42 (FIXME: Whether that statement is *really* true or not is unknown.
43 Are there more subtle differences between pe and pei formats?
44 For now assume there aren't. If you find one, then for God sakes
47 The Microsoft docs use the word "image" instead of "executable" because
48 the former can also refer to a DLL (shared library). Confusion can arise
49 because the `i' in `pei' also refers to "image". The `pe' format can
50 also create images (i.e. executables), it's just that to run on a win32
51 system you need to use the pei format.
53 FIXME: Please add more docs here so the next poor fool that has to hack
54 on this code has a chance of getting something accomplished without
55 wasting too much time. */
57 /* This expands into COFF_WITH_pe, COFF_WITH_pep, or COFF_WITH_pex64
58 depending on whether we're compiling for straight PE or PE+. */
64 #include "coff/internal.h"
66 /* NOTE: it's strange to be including an architecture specific header
67 in what's supposed to be general (to PE/PEI) code. However, that's
68 where the definitions are, and they don't vary per architecture
69 within PE/PEI, so we get them from there. FIXME: The lack of
70 variance is an assumption which may prove to be incorrect if new
71 PE/PEI targets are created. */
72 #if defined COFF_WITH_pex64
73 # include "coff/x86_64.h"
74 #elif defined COFF_WITH_pep
75 # include "coff/ia64.h"
77 # include "coff/i386.h"
84 #if defined COFF_WITH_pep || defined COFF_WITH_pex64
86 # define AOUTSZ PEPAOUTSZ
87 # define PEAOUTHDR PEPAOUTHDR
90 /* FIXME: This file has various tests of POWERPC_LE_PE. Those tests
91 worked when the code was in peicode.h, but no longer work now that
92 the code is in peigen.c. PowerPC NT is said to be dead. If
93 anybody wants to revive the code, you will have to figure out how
94 to handle those issues. */
97 _bfd_XXi_swap_sym_in (bfd * abfd, void * ext1, void * in1)
99 SYMENT *ext = (SYMENT *) ext1;
100 struct internal_syment *in = (struct internal_syment *) in1;
102 if (ext->e.e_name[0] == 0)
104 in->_n._n_n._n_zeroes = 0;
105 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
108 memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
110 in->n_value = H_GET_32 (abfd, ext->e_value);
111 in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
113 if (sizeof (ext->e_type) == 2)
114 in->n_type = H_GET_16 (abfd, ext->e_type);
116 in->n_type = H_GET_32 (abfd, ext->e_type);
118 in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
119 in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
121 #ifndef STRICT_PE_FORMAT
122 /* This is for Gnu-created DLLs. */
124 /* The section symbols for the .idata$ sections have class 0x68
125 (C_SECTION), which MS documentation indicates is a section
126 symbol. Unfortunately, the value field in the symbol is simply a
127 copy of the .idata section's flags rather than something useful.
128 When these symbols are encountered, change the value to 0 so that
129 they will be handled somewhat correctly in the bfd code. */
130 if (in->n_sclass == C_SECTION)
132 char namebuf[SYMNMLEN + 1];
133 const char *name = NULL;
137 /* Create synthetic empty sections as needed. DJ */
138 if (in->n_scnum == 0)
142 name = _bfd_coff_internal_syment_name (abfd, in, namebuf);
144 /* FIXME: Return error. */
146 sec = bfd_get_section_by_name (abfd, name);
148 in->n_scnum = sec->target_index;
151 if (in->n_scnum == 0)
153 int unused_section_number = 0;
157 for (sec = abfd->sections; sec; sec = sec->next)
158 if (unused_section_number <= sec->target_index)
159 unused_section_number = sec->target_index + 1;
163 name = bfd_alloc (abfd, strlen (namebuf) + 1);
165 /* FIXME: Return error. */
167 strcpy ((char *) name, namebuf);
169 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
170 sec = bfd_make_section_anyway_with_flags (abfd, name, flags);
172 /* FIXME: Return error. */
179 sec->rel_filepos = 0;
180 sec->reloc_count = 0;
181 sec->line_filepos = 0;
182 sec->lineno_count = 0;
183 sec->userdata = NULL;
185 sec->alignment_power = 2;
187 sec->target_index = unused_section_number;
189 in->n_scnum = unused_section_number;
191 in->n_sclass = C_STAT;
195 #ifdef coff_swap_sym_in_hook
196 /* This won't work in peigen.c, but since it's for PPC PE, it's not
198 coff_swap_sym_in_hook (abfd, ext1, in1);
203 _bfd_XXi_swap_sym_out (bfd * abfd, void * inp, void * extp)
205 struct internal_syment *in = (struct internal_syment *) inp;
206 SYMENT *ext = (SYMENT *) extp;
208 if (in->_n._n_name[0] == 0)
210 H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
211 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
214 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
216 H_PUT_32 (abfd, in->n_value, ext->e_value);
217 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
219 if (sizeof (ext->e_type) == 2)
220 H_PUT_16 (abfd, in->n_type, ext->e_type);
222 H_PUT_32 (abfd, in->n_type, ext->e_type);
224 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
225 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
231 _bfd_XXi_swap_aux_in (bfd * abfd,
235 int indx ATTRIBUTE_UNUSED,
236 int numaux ATTRIBUTE_UNUSED,
239 AUXENT *ext = (AUXENT *) ext1;
240 union internal_auxent *in = (union internal_auxent *) in1;
245 if (ext->x_file.x_fname[0] == 0)
247 in->x_file.x_n.x_zeroes = 0;
248 in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
251 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
259 in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
260 in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
261 in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
262 in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
263 in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
264 in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
270 in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
271 in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
273 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
275 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
276 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
280 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
281 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
282 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
283 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
284 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
285 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
286 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
287 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
292 in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
296 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
297 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
302 _bfd_XXi_swap_aux_out (bfd * abfd,
306 int indx ATTRIBUTE_UNUSED,
307 int numaux ATTRIBUTE_UNUSED,
310 union internal_auxent *in = (union internal_auxent *) inp;
311 AUXENT *ext = (AUXENT *) extp;
313 memset (ext, 0, AUXESZ);
318 if (in->x_file.x_fname[0] == 0)
320 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
321 H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
324 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
333 PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
334 PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
335 PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
336 H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
337 H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
338 H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
344 H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
345 H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
347 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
349 PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
350 PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
354 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
355 ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
356 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
357 ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
358 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
359 ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
360 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
361 ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
365 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
368 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
369 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
376 _bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1)
378 LINENO *ext = (LINENO *) ext1;
379 struct internal_lineno *in = (struct internal_lineno *) in1;
381 in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
382 in->l_lnno = GET_LINENO_LNNO (abfd, ext);
386 _bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp)
388 struct internal_lineno *in = (struct internal_lineno *) inp;
389 struct external_lineno *ext = (struct external_lineno *) outp;
390 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
392 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
397 _bfd_XXi_swap_aouthdr_in (bfd * abfd,
401 PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1;
402 AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
403 struct internal_aouthdr *aouthdr_int
404 = (struct internal_aouthdr *) aouthdr_int1;
405 struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe;
407 aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
408 aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
409 aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
410 aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
411 aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
412 aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
413 aouthdr_int->text_start =
414 GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
415 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
416 /* PE32+ does not have data_start member! */
417 aouthdr_int->data_start =
418 GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
419 a->BaseOfData = aouthdr_int->data_start;
422 a->Magic = aouthdr_int->magic;
423 a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp);
424 a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1);
425 a->SizeOfCode = aouthdr_int->tsize ;
426 a->SizeOfInitializedData = aouthdr_int->dsize ;
427 a->SizeOfUninitializedData = aouthdr_int->bsize ;
428 a->AddressOfEntryPoint = aouthdr_int->entry;
429 a->BaseOfCode = aouthdr_int->text_start;
430 a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
431 a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
432 a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
433 a->MajorOperatingSystemVersion =
434 H_GET_16 (abfd, src->MajorOperatingSystemVersion);
435 a->MinorOperatingSystemVersion =
436 H_GET_16 (abfd, src->MinorOperatingSystemVersion);
437 a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
438 a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
439 a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
440 a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
441 a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
442 a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
443 a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
444 a->CheckSum = H_GET_32 (abfd, src->CheckSum);
445 a->Subsystem = H_GET_16 (abfd, src->Subsystem);
446 a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
447 a->SizeOfStackReserve =
448 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
449 a->SizeOfStackCommit =
450 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
451 a->SizeOfHeapReserve =
452 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
453 a->SizeOfHeapCommit =
454 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
455 a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
456 a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
461 for (idx = 0; idx < 16; idx++)
463 /* If data directory is empty, rva also should be 0. */
465 H_GET_32 (abfd, src->DataDirectory[idx][1]);
467 a->DataDirectory[idx].Size = size;
470 a->DataDirectory[idx].VirtualAddress =
471 H_GET_32 (abfd, src->DataDirectory[idx][0]);
473 a->DataDirectory[idx].VirtualAddress = 0;
477 if (aouthdr_int->entry)
479 aouthdr_int->entry += a->ImageBase;
480 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
481 aouthdr_int->entry &= 0xffffffff;
485 if (aouthdr_int->tsize)
487 aouthdr_int->text_start += a->ImageBase;
488 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
489 aouthdr_int->text_start &= 0xffffffff;
493 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
494 /* PE32+ does not have data_start member! */
495 if (aouthdr_int->dsize)
497 aouthdr_int->data_start += a->ImageBase;
498 aouthdr_int->data_start &= 0xffffffff;
503 /* These three fields are normally set up by ppc_relocate_section.
504 In the case of reading a file in, we can pick them up from the
506 first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress;
507 thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size;
508 import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size;
512 /* A support function for below. */
515 add_data_entry (bfd * abfd,
516 struct internal_extra_pe_aouthdr *aout,
521 asection *sec = bfd_get_section_by_name (abfd, name);
523 /* Add import directory information if it exists. */
525 && (coff_section_data (abfd, sec) != NULL)
526 && (pei_section_data (abfd, sec) != NULL))
528 /* If data directory is empty, rva also should be 0. */
529 int size = pei_section_data (abfd, sec)->virt_size;
530 aout->DataDirectory[idx].Size = size;
534 aout->DataDirectory[idx].VirtualAddress =
535 (sec->vma - base) & 0xffffffff;
536 sec->flags |= SEC_DATA;
542 _bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out)
544 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
545 pe_data_type *pe = pe_data (abfd);
546 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
547 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
549 IMAGE_DATA_DIRECTORY idata2, idata5, tls;
551 sa = extra->SectionAlignment;
552 fa = extra->FileAlignment;
553 ib = extra->ImageBase;
555 idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
556 idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
557 tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
559 if (aouthdr_in->tsize)
561 aouthdr_in->text_start -= ib;
562 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
563 aouthdr_in->text_start &= 0xffffffff;
567 if (aouthdr_in->dsize)
569 aouthdr_in->data_start -= ib;
570 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
571 aouthdr_in->data_start &= 0xffffffff;
575 if (aouthdr_in->entry)
577 aouthdr_in->entry -= ib;
578 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
579 aouthdr_in->entry &= 0xffffffff;
583 #define FA(x) (((x) + fa -1 ) & (- fa))
584 #define SA(x) (((x) + sa -1 ) & (- sa))
586 /* We like to have the sizes aligned. */
587 aouthdr_in->bsize = FA (aouthdr_in->bsize);
589 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
591 /* First null out all data directory entries. */
592 memset (extra->DataDirectory, 0, sizeof (extra->DataDirectory));
594 add_data_entry (abfd, extra, 0, ".edata", ib);
595 add_data_entry (abfd, extra, 2, ".rsrc", ib);
596 add_data_entry (abfd, extra, 3, ".pdata", ib);
598 /* In theory we do not need to call add_data_entry for .idata$2 or
599 .idata$5. It will be done in bfd_coff_final_link where all the
600 required information is available. If however, we are not going
601 to perform a final link, eg because we have been invoked by objcopy
602 or strip, then we need to make sure that these Data Directory
603 entries are initialised properly.
605 So - we copy the input values into the output values, and then, if
606 a final link is going to be performed, it can overwrite them. */
607 extra->DataDirectory[PE_IMPORT_TABLE] = idata2;
608 extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
609 extra->DataDirectory[PE_TLS_TABLE] = tls;
611 if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
612 /* Until other .idata fixes are made (pending patch), the entry for
613 .idata is needed for backwards compatibility. FIXME. */
614 add_data_entry (abfd, extra, 1, ".idata", ib);
616 /* For some reason, the virtual size (which is what's set by
617 add_data_entry) for .reloc is not the same as the size recorded
618 in this slot by MSVC; it doesn't seem to cause problems (so far),
619 but since it's the best we've got, use it. It does do the right
621 if (pe->has_reloc_section)
622 add_data_entry (abfd, extra, 5, ".reloc", ib);
631 for (sec = abfd->sections; sec; sec = sec->next)
633 int rounded = FA (sec->size);
635 /* The first non-zero section filepos is the header size.
636 Sections without contents will have a filepos of 0. */
638 hsize = sec->filepos;
639 if (sec->flags & SEC_DATA)
641 if (sec->flags & SEC_CODE)
643 /* The image size is the total VIRTUAL size (which is what is
644 in the virt_size field). Files have been seen (from MSVC
645 5.0 link.exe) where the file size of the .data segment is
646 quite small compared to the virtual size. Without this
647 fix, strip munges the file.
649 FIXME: We need to handle holes between sections, which may
650 happpen when we covert from another format. We just use
651 the virtual address and virtual size of the last section
652 for the image size. */
653 if (coff_section_data (abfd, sec) != NULL
654 && pei_section_data (abfd, sec) != NULL)
655 isize = (sec->vma - extra->ImageBase
656 + SA (FA (pei_section_data (abfd, sec)->virt_size)));
659 aouthdr_in->dsize = dsize;
660 aouthdr_in->tsize = tsize;
661 extra->SizeOfHeaders = hsize;
662 extra->SizeOfImage = isize;
665 H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
667 #define LINKER_VERSION 256 /* That is, 2.56 */
669 /* This piece of magic sets the "linker version" field to
671 H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
672 aouthdr_out->standard.vstamp);
674 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
675 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
676 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
677 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
678 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
679 aouthdr_out->standard.text_start);
681 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
682 /* PE32+ does not have data_start member! */
683 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
684 aouthdr_out->standard.data_start);
687 PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
688 H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
689 H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
690 H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
691 aouthdr_out->MajorOperatingSystemVersion);
692 H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
693 aouthdr_out->MinorOperatingSystemVersion);
694 H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
695 H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
696 H_PUT_16 (abfd, extra->MajorSubsystemVersion,
697 aouthdr_out->MajorSubsystemVersion);
698 H_PUT_16 (abfd, extra->MinorSubsystemVersion,
699 aouthdr_out->MinorSubsystemVersion);
700 H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
701 H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
702 H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
703 H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
704 H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
705 H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
706 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
707 aouthdr_out->SizeOfStackReserve);
708 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
709 aouthdr_out->SizeOfStackCommit);
710 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
711 aouthdr_out->SizeOfHeapReserve);
712 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
713 aouthdr_out->SizeOfHeapCommit);
714 H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
715 H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
716 aouthdr_out->NumberOfRvaAndSizes);
720 for (idx = 0; idx < 16; idx++)
722 H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
723 aouthdr_out->DataDirectory[idx][0]);
724 H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
725 aouthdr_out->DataDirectory[idx][1]);
733 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
736 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
737 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
739 if (pe_data (abfd)->has_reloc_section)
740 filehdr_in->f_flags &= ~F_RELFLG;
742 if (pe_data (abfd)->dll)
743 filehdr_in->f_flags |= F_DLL;
745 filehdr_in->pe.e_magic = DOSMAGIC;
746 filehdr_in->pe.e_cblp = 0x90;
747 filehdr_in->pe.e_cp = 0x3;
748 filehdr_in->pe.e_crlc = 0x0;
749 filehdr_in->pe.e_cparhdr = 0x4;
750 filehdr_in->pe.e_minalloc = 0x0;
751 filehdr_in->pe.e_maxalloc = 0xffff;
752 filehdr_in->pe.e_ss = 0x0;
753 filehdr_in->pe.e_sp = 0xb8;
754 filehdr_in->pe.e_csum = 0x0;
755 filehdr_in->pe.e_ip = 0x0;
756 filehdr_in->pe.e_cs = 0x0;
757 filehdr_in->pe.e_lfarlc = 0x40;
758 filehdr_in->pe.e_ovno = 0x0;
760 for (idx = 0; idx < 4; idx++)
761 filehdr_in->pe.e_res[idx] = 0x0;
763 filehdr_in->pe.e_oemid = 0x0;
764 filehdr_in->pe.e_oeminfo = 0x0;
766 for (idx = 0; idx < 10; idx++)
767 filehdr_in->pe.e_res2[idx] = 0x0;
769 filehdr_in->pe.e_lfanew = 0x80;
771 /* This next collection of data are mostly just characters. It
772 appears to be constant within the headers put on NT exes. */
773 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
774 filehdr_in->pe.dos_message[1] = 0xcd09b400;
775 filehdr_in->pe.dos_message[2] = 0x4c01b821;
776 filehdr_in->pe.dos_message[3] = 0x685421cd;
777 filehdr_in->pe.dos_message[4] = 0x70207369;
778 filehdr_in->pe.dos_message[5] = 0x72676f72;
779 filehdr_in->pe.dos_message[6] = 0x63206d61;
780 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
781 filehdr_in->pe.dos_message[8] = 0x65622074;
782 filehdr_in->pe.dos_message[9] = 0x6e757220;
783 filehdr_in->pe.dos_message[10] = 0x206e6920;
784 filehdr_in->pe.dos_message[11] = 0x20534f44;
785 filehdr_in->pe.dos_message[12] = 0x65646f6d;
786 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
787 filehdr_in->pe.dos_message[14] = 0x24;
788 filehdr_in->pe.dos_message[15] = 0x0;
789 filehdr_in->pe.nt_signature = NT_SIGNATURE;
791 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
792 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
794 H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
795 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
796 filehdr_out->f_symptr);
797 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
798 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
799 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
801 /* Put in extra dos header stuff. This data remains essentially
802 constant, it just has to be tacked on to the beginning of all exes
804 H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
805 H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
806 H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
807 H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
808 H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
809 H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
810 H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
811 H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
812 H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
813 H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
814 H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
815 H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
816 H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
817 H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
819 for (idx = 0; idx < 4; idx++)
820 H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
822 H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
823 H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
825 for (idx = 0; idx < 10; idx++)
826 H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
828 H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
830 for (idx = 0; idx < 16; idx++)
831 H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
832 filehdr_out->dos_message[idx]);
834 /* Also put in the NT signature. */
835 H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
841 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
843 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
844 FILHDR *filehdr_out = (FILHDR *) out;
846 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
847 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
848 H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
849 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
850 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
851 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
852 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
858 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
860 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
861 SCNHDR *scnhdr_ext = (SCNHDR *) out;
862 unsigned int ret = SCNHSZ;
866 memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
868 PUT_SCNHDR_VADDR (abfd,
869 ((scnhdr_int->s_vaddr
870 - pe_data (abfd)->pe_opthdr.ImageBase)
872 scnhdr_ext->s_vaddr);
874 /* NT wants the size data to be rounded up to the next
875 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
877 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
879 if (bfd_pei_p (abfd))
881 ps = scnhdr_int->s_size;
887 ss = scnhdr_int->s_size;
892 if (bfd_pei_p (abfd))
893 ps = scnhdr_int->s_paddr;
897 ss = scnhdr_int->s_size;
900 PUT_SCNHDR_SIZE (abfd, ss,
903 /* s_paddr in PE is really the virtual size. */
904 PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
906 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
907 scnhdr_ext->s_scnptr);
908 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
909 scnhdr_ext->s_relptr);
910 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
911 scnhdr_ext->s_lnnoptr);
914 /* Extra flags must be set when dealing with PE. All sections should also
915 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
916 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
917 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
918 (this is especially important when dealing with the .idata section since
919 the addresses for routines from .dlls must be overwritten). If .reloc
920 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
921 (0x02000000). Also, the resource data should also be read and
924 /* FIXME: Alignment is also encoded in this field, at least on PPC and
925 ARM-WINCE. Although - how do we get the original alignment field
930 const char * section_name;
931 unsigned long must_have;
933 pe_required_section_flags;
935 pe_required_section_flags known_sections [] =
937 { ".arch", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
938 { ".bss", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
939 { ".data", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
940 { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
941 { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
942 { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
943 { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
944 { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
945 { ".rsrc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
946 { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
947 { ".tls", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
948 { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
952 pe_required_section_flags * p;
954 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
955 we know exactly what this specific section wants so we remove it
956 and then allow the must_have field to add it back in if necessary.
957 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
958 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
959 by ld --enable-auto-import (if auto-import is actually needed),
960 by ld --omagic, or by obcopy --writable-text. */
962 for (p = known_sections; p->section_name; p++)
963 if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
965 if (strcmp (scnhdr_int->s_name, ".text")
966 || (bfd_get_file_flags (abfd) & WP_TEXT))
967 scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
968 scnhdr_int->s_flags |= p->must_have;
972 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
975 if (coff_data (abfd)->link_info
976 && ! coff_data (abfd)->link_info->relocatable
977 && ! coff_data (abfd)->link_info->shared
978 && strcmp (scnhdr_int->s_name, ".text") == 0)
980 /* By inference from looking at MS output, the 32 bit field
981 which is the combination of the number_of_relocs and
982 number_of_linenos is used for the line number count in
983 executables. A 16-bit field won't do for cc1. The MS
984 document says that the number of relocs is zero for
985 executables, but the 17-th bit has been observed to be there.
986 Overflow is not an issue: a 4G-line program will overflow a
987 bunch of other fields long before this! */
988 H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
989 H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
993 if (scnhdr_int->s_nlnno <= 0xffff)
994 H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
997 (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
998 bfd_get_filename (abfd),
999 scnhdr_int->s_nlnno);
1000 bfd_set_error (bfd_error_file_truncated);
1001 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
1005 /* Although we could encode 0xffff relocs here, we do not, to be
1006 consistent with other parts of bfd. Also it lets us warn, as
1007 we should never see 0xffff here w/o having the overflow flag
1009 if (scnhdr_int->s_nreloc < 0xffff)
1010 H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
1013 /* PE can deal with large #s of relocs, but not here. */
1014 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1015 scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1016 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1022 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1024 N_("Export Directory [.edata (or where ever we found it)]"),
1025 N_("Import Directory [parts of .idata]"),
1026 N_("Resource Directory [.rsrc]"),
1027 N_("Exception Directory [.pdata]"),
1028 N_("Security Directory"),
1029 N_("Base Relocation Directory [.reloc]"),
1030 N_("Debug Directory"),
1031 N_("Description Directory"),
1032 N_("Special Directory"),
1033 N_("Thread Storage Directory [.tls]"),
1034 N_("Load Configuration Directory"),
1035 N_("Bound Import Directory"),
1036 N_("Import Address Table Directory"),
1037 N_("Delay Import Directory"),
1038 N_("CLR Runtime Header"),
1042 #ifdef POWERPC_LE_PE
1043 /* The code for the PPC really falls in the "architecture dependent"
1044 category. However, it's not clear that anyone will ever care, so
1045 we're ignoring the issue for now; if/when PPC matters, some of this
1046 may need to go into peicode.h, or arguments passed to enable the
1047 PPC- specific code. */
1051 pe_print_idata (bfd * abfd, void * vfile)
1053 FILE *file = (FILE *) vfile;
1058 #ifdef POWERPC_LE_PE
1059 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1062 bfd_size_type datasize = 0;
1063 bfd_size_type dataoff;
1067 pe_data_type *pe = pe_data (abfd);
1068 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1072 addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
1074 if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
1076 /* Maybe the extra header isn't there. Look for the section. */
1077 section = bfd_get_section_by_name (abfd, ".idata");
1078 if (section == NULL)
1081 addr = section->vma;
1082 datasize = section->size;
1088 addr += extra->ImageBase;
1089 for (section = abfd->sections; section != NULL; section = section->next)
1091 datasize = section->size;
1092 if (addr >= section->vma && addr < section->vma + datasize)
1096 if (section == NULL)
1099 _("\nThere is an import table, but the section containing it could not be found\n"));
1104 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1105 section->name, (unsigned long) addr);
1107 dataoff = addr - section->vma;
1108 datasize -= dataoff;
1110 #ifdef POWERPC_LE_PE
1111 if (rel_section != 0 && rel_section->size != 0)
1113 /* The toc address can be found by taking the starting address,
1114 which on the PPC locates a function descriptor. The
1115 descriptor consists of the function code starting address
1116 followed by the address of the toc. The starting address we
1117 get from the bfd, and the descriptor is supposed to be in the
1118 .reldata section. */
1120 bfd_vma loadable_toc_address;
1121 bfd_vma toc_address;
1122 bfd_vma start_address;
1126 if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1133 offset = abfd->start_address - rel_section->vma;
1135 if (offset >= rel_section->size || offset + 8 > rel_section->size)
1142 start_address = bfd_get_32 (abfd, data + offset);
1143 loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1144 toc_address = loadable_toc_address - 32768;
1147 _("\nFunction descriptor located at the start address: %04lx\n"),
1148 (unsigned long int) (abfd->start_address));
1150 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1151 start_address, loadable_toc_address, toc_address);
1158 _("\nNo reldata section! Function descriptor not decoded.\n"));
1163 _("\nThe Import Tables (interpreted %s section contents)\n"),
1167 vma: Hint Time Forward DLL First\n\
1168 Table Stamp Chain Name Thunk\n"));
1170 /* Read the whole section. Some of the fields might be before dataoff. */
1171 if (!bfd_malloc_and_get_section (abfd, section, &data))
1178 adj = section->vma - extra->ImageBase;
1180 /* Print all image import descriptors. */
1181 for (i = 0; i < datasize; i += onaline)
1185 bfd_vma forward_chain;
1187 bfd_vma first_thunk;
1192 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1193 fprintf (file, " %08lx\t", (unsigned long) (i + adj + dataoff));
1194 hint_addr = bfd_get_32 (abfd, data + i + dataoff);
1195 time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff);
1196 forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff);
1197 dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff);
1198 first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff);
1200 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1201 (unsigned long) hint_addr,
1202 (unsigned long) time_stamp,
1203 (unsigned long) forward_chain,
1204 (unsigned long) dll_name,
1205 (unsigned long) first_thunk);
1207 if (hint_addr == 0 && first_thunk == 0)
1210 if (dll_name - adj >= section->size)
1213 dll = (char *) data + dll_name - adj;
1214 fprintf (file, _("\n\tDLL Name: %s\n"), dll);
1219 asection *ft_section;
1221 bfd_size_type ft_datasize;
1223 int ft_allocated = 0;
1225 fprintf (file, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1227 idx = hint_addr - adj;
1229 ft_addr = first_thunk + extra->ImageBase;
1231 ft_idx = first_thunk - adj;
1234 if (first_thunk != hint_addr)
1236 /* Find the section which contains the first thunk. */
1237 for (ft_section = abfd->sections;
1239 ft_section = ft_section->next)
1241 ft_datasize = ft_section->size;
1242 if (ft_addr >= ft_section->vma
1243 && ft_addr < ft_section->vma + ft_datasize)
1247 if (ft_section == NULL)
1250 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1254 /* Now check to see if this section is the same as our current
1255 section. If it is not then we will have to load its data in. */
1256 if (ft_section == section)
1259 ft_idx = first_thunk - adj;
1263 ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1264 ft_data = bfd_malloc (datasize);
1265 if (ft_data == NULL)
1268 /* Read datasize bfd_bytes starting at offset ft_idx. */
1269 if (! bfd_get_section_contents
1270 (abfd, ft_section, ft_data, (bfd_vma) ft_idx, datasize))
1281 /* Print HintName vector entries. */
1282 #ifdef COFF_WITH_pex64
1283 for (j = 0; j < datasize; j += 8)
1285 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1286 unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1288 if (!member && !member_high)
1291 if (member_high & 0x80000000)
1292 fprintf (file, "\t%lx%08lx\t %4lx%08lx <none>",
1293 member_high,member, member_high & 0x7fffffff, member);
1299 ordinal = bfd_get_16 (abfd, data + member - adj);
1300 member_name = (char *) data + member - adj + 2;
1301 fprintf (file, "\t%04lx\t %4d %s",member, ordinal, member_name);
1304 /* If the time stamp is not zero, the import address
1305 table holds actual addresses. */
1308 && first_thunk != hint_addr)
1309 fprintf (file, "\t%04lx",
1310 (unsigned long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1311 fprintf (file, "\n");
1314 for (j = 0; j < datasize; j += 4)
1316 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1318 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1322 if (member & 0x80000000)
1323 fprintf (file, "\t%04lx\t %4lu <none>",
1324 member, member & 0x7fffffff);
1330 ordinal = bfd_get_16 (abfd, data + member - adj);
1331 member_name = (char *) data + member - adj + 2;
1332 fprintf (file, "\t%04lx\t %4d %s",
1333 member, ordinal, member_name);
1336 /* If the time stamp is not zero, the import address
1337 table holds actual addresses. */
1340 && first_thunk != hint_addr)
1341 fprintf (file, "\t%04lx",
1342 (unsigned long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1344 fprintf (file, "\n");
1351 fprintf (file, "\n");
1360 pe_print_edata (bfd * abfd, void * vfile)
1362 FILE *file = (FILE *) vfile;
1365 bfd_size_type datasize = 0;
1366 bfd_size_type dataoff;
1371 long export_flags; /* Reserved - should be zero. */
1375 bfd_vma name; /* RVA - relative to image base. */
1376 long base; /* Ordinal base. */
1377 unsigned long num_functions;/* Number in the export address table. */
1378 unsigned long num_names; /* Number in the name pointer table. */
1379 bfd_vma eat_addr; /* RVA to the export address table. */
1380 bfd_vma npt_addr; /* RVA to the Export Name Pointer Table. */
1381 bfd_vma ot_addr; /* RVA to the Ordinal Table. */
1384 pe_data_type *pe = pe_data (abfd);
1385 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1389 addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
1391 if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
1393 /* Maybe the extra header isn't there. Look for the section. */
1394 section = bfd_get_section_by_name (abfd, ".edata");
1395 if (section == NULL)
1398 addr = section->vma;
1400 datasize = section->size;
1406 addr += extra->ImageBase;
1408 for (section = abfd->sections; section != NULL; section = section->next)
1409 if (addr >= section->vma && addr < section->vma + section->size)
1412 if (section == NULL)
1415 _("\nThere is an export table, but the section containing it could not be found\n"));
1419 dataoff = addr - section->vma;
1420 datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
1421 if (datasize > section->size - dataoff)
1424 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1430 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1431 section->name, (unsigned long) addr);
1433 data = bfd_malloc (datasize);
1437 if (! bfd_get_section_contents (abfd, section, data,
1438 (file_ptr) dataoff, datasize))
1441 /* Go get Export Directory Table. */
1442 edt.export_flags = bfd_get_32 (abfd, data + 0);
1443 edt.time_stamp = bfd_get_32 (abfd, data + 4);
1444 edt.major_ver = bfd_get_16 (abfd, data + 8);
1445 edt.minor_ver = bfd_get_16 (abfd, data + 10);
1446 edt.name = bfd_get_32 (abfd, data + 12);
1447 edt.base = bfd_get_32 (abfd, data + 16);
1448 edt.num_functions = bfd_get_32 (abfd, data + 20);
1449 edt.num_names = bfd_get_32 (abfd, data + 24);
1450 edt.eat_addr = bfd_get_32 (abfd, data + 28);
1451 edt.npt_addr = bfd_get_32 (abfd, data + 32);
1452 edt.ot_addr = bfd_get_32 (abfd, data + 36);
1454 adj = section->vma - extra->ImageBase + dataoff;
1456 /* Dump the EDT first. */
1458 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1462 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1465 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1468 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1471 _("Name \t\t\t\t"));
1472 fprintf_vma (file, edt.name);
1474 " %s\n", data + edt.name - adj);
1477 _("Ordinal Base \t\t\t%ld\n"), edt.base);
1483 _("\tExport Address Table \t\t%08lx\n"),
1487 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1490 _("Table Addresses\n"));
1493 _("\tExport Address Table \t\t"));
1494 fprintf_vma (file, edt.eat_addr);
1495 fprintf (file, "\n");
1498 _("\tName Pointer Table \t\t"));
1499 fprintf_vma (file, edt.npt_addr);
1500 fprintf (file, "\n");
1503 _("\tOrdinal Table \t\t\t"));
1504 fprintf_vma (file, edt.ot_addr);
1505 fprintf (file, "\n");
1507 /* The next table to find is the Export Address Table. It's basically
1508 a list of pointers that either locate a function in this dll, or
1509 forward the call to another dll. Something like:
1514 } export_address_table_entry; */
1517 _("\nExport Address Table -- Ordinal Base %ld\n"),
1520 for (i = 0; i < edt.num_functions; ++i)
1522 bfd_vma eat_member = bfd_get_32 (abfd,
1523 data + edt.eat_addr + (i * 4) - adj);
1524 if (eat_member == 0)
1527 if (eat_member - adj <= datasize)
1529 /* This rva is to a name (forwarding function) in our section. */
1530 /* Should locate a function descriptor. */
1532 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1534 (long) (i + edt.base),
1535 (unsigned long) eat_member,
1537 data + eat_member - adj);
1541 /* Should locate a function descriptor in the reldata section. */
1543 "\t[%4ld] +base[%4ld] %04lx %s\n",
1545 (long) (i + edt.base),
1546 (unsigned long) eat_member,
1551 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1552 /* Dump them in parallel for clarity. */
1554 _("\n[Ordinal/Name Pointer] Table\n"));
1556 for (i = 0; i < edt.num_names; ++i)
1558 bfd_vma name_ptr = bfd_get_32 (abfd,
1563 char *name = (char *) data + name_ptr - adj;
1565 bfd_vma ord = bfd_get_16 (abfd,
1570 "\t[%4ld] %s\n", (long) ord, name);
1578 /* This really is architecture dependent. On IA-64, a .pdata entry
1579 consists of three dwords containing relative virtual addresses that
1580 specify the start and end address of the code range the entry
1581 covers and the address of the corresponding unwind info data.
1583 On ARM and SH-4, a compressed PDATA structure is used :
1584 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1585 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1586 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1588 This is the version for uncompressed data. */
1591 pe_print_pdata (bfd * abfd, void * vfile)
1593 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1594 # define PDATA_ROW_SIZE (3 * 8)
1596 # define PDATA_ROW_SIZE (5 * 4)
1598 FILE *file = (FILE *) vfile;
1600 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1601 bfd_size_type datasize = 0;
1603 bfd_size_type start, stop;
1604 int onaline = PDATA_ROW_SIZE;
1607 || coff_section_data (abfd, section) == NULL
1608 || pei_section_data (abfd, section) == NULL)
1611 stop = pei_section_data (abfd, section)->virt_size;
1612 if ((stop % onaline) != 0)
1614 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1615 (long) stop, onaline);
1618 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1619 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1621 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1624 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1625 \t\tAddress Address Handler Data Address Mask\n"));
1628 datasize = section->size;
1632 if (! bfd_malloc_and_get_section (abfd, section, &data))
1641 for (i = start; i < stop; i += onaline)
1647 bfd_vma prolog_end_addr;
1650 if (i + PDATA_ROW_SIZE > stop)
1653 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
1654 end_addr = GET_PDATA_ENTRY (abfd, data + i + 4);
1655 eh_handler = GET_PDATA_ENTRY (abfd, data + i + 8);
1656 eh_data = GET_PDATA_ENTRY (abfd, data + i + 12);
1657 prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1659 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1660 && eh_data == 0 && prolog_end_addr == 0)
1661 /* We are probably into the padding of the section now. */
1664 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1665 eh_handler &= ~(bfd_vma) 0x3;
1666 prolog_end_addr &= ~(bfd_vma) 0x3;
1669 fprintf_vma (file, i + section->vma); fputc ('\t', file);
1670 fprintf_vma (file, begin_addr); fputc (' ', file);
1671 fprintf_vma (file, end_addr); fputc (' ', file);
1672 fprintf_vma (file, eh_handler);
1673 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1675 fprintf_vma (file, eh_data); fputc (' ', file);
1676 fprintf_vma (file, prolog_end_addr);
1677 fprintf (file, " %x", em_data);
1680 #ifdef POWERPC_LE_PE
1681 if (eh_handler == 0 && eh_data != 0)
1683 /* Special bits here, although the meaning may be a little
1684 mysterious. The only one I know for sure is 0x03
1687 0x01 Register Save Millicode
1688 0x02 Register Restore Millicode
1689 0x03 Glue Code Sequence. */
1693 fprintf (file, _(" Register save millicode"));
1696 fprintf (file, _(" Register restore millicode"));
1699 fprintf (file, _(" Glue code sequence"));
1706 fprintf (file, "\n");
1712 #undef PDATA_ROW_SIZE
1715 typedef struct sym_cache
1722 slurp_symtab (bfd *abfd, sym_cache *psc)
1724 asymbol ** sy = NULL;
1727 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1733 storage = bfd_get_symtab_upper_bound (abfd);
1737 sy = bfd_malloc (storage);
1739 psc->symcount = bfd_canonicalize_symtab (abfd, sy);
1740 if (psc->symcount < 0)
1746 my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc)
1751 psc->syms = slurp_symtab (abfd, psc);
1753 for (i = 0; i < psc->symcount; i++)
1755 if (psc->syms[i]->section->vma + psc->syms[i]->value == func)
1756 return psc->syms[i]->name;
1763 cleanup_syms (sym_cache *psc)
1770 /* This is the version for "compressed" pdata. */
1773 _bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile)
1775 # define PDATA_ROW_SIZE (2 * 4)
1776 FILE *file = (FILE *) vfile;
1777 bfd_byte *data = NULL;
1778 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1779 bfd_size_type datasize = 0;
1781 bfd_size_type start, stop;
1782 int onaline = PDATA_ROW_SIZE;
1783 struct sym_cache sym_cache = {0, 0} ;
1786 || coff_section_data (abfd, section) == NULL
1787 || pei_section_data (abfd, section) == NULL)
1790 stop = pei_section_data (abfd, section)->virt_size;
1791 if ((stop % onaline) != 0)
1793 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1794 (long) stop, onaline);
1797 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1800 vma:\t\tBegin Prolog Function Flags Exception EH\n\
1801 \t\tAddress Length Length 32b exc Handler Data\n"));
1803 datasize = section->size;
1807 if (! bfd_malloc_and_get_section (abfd, section, &data))
1816 for (i = start; i < stop; i += onaline)
1820 bfd_vma prolog_length, function_length;
1821 int flag32bit, exception_flag;
1822 bfd_byte *tdata = 0;
1825 if (i + PDATA_ROW_SIZE > stop)
1828 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
1829 other_data = GET_PDATA_ENTRY (abfd, data + i + 4);
1831 if (begin_addr == 0 && other_data == 0)
1832 /* We are probably into the padding of the section now. */
1835 prolog_length = (other_data & 0x000000FF);
1836 function_length = (other_data & 0x3FFFFF00) >> 8;
1837 flag32bit = (int)((other_data & 0x40000000) >> 30);
1838 exception_flag = (int)((other_data & 0x80000000) >> 31);
1841 fprintf_vma (file, i + section->vma); fputc ('\t', file);
1842 fprintf_vma (file, begin_addr); fputc (' ', file);
1843 fprintf_vma (file, prolog_length); fputc (' ', file);
1844 fprintf_vma (file, function_length); fputc (' ', file);
1845 fprintf (file, "%2d %2d ", flag32bit, exception_flag);
1847 /* Get the exception handler's address and the data passed from the
1848 .text section. This is really the data that belongs with the .pdata
1849 but got "compressed" out for the ARM and SH4 architectures. */
1850 tsection = bfd_get_section_by_name (abfd, ".text");
1851 if (tsection && coff_section_data (abfd, tsection)
1852 && pei_section_data (abfd, tsection))
1854 if (bfd_malloc_and_get_section (abfd, tsection, & tdata))
1856 int xx = (begin_addr - 8) - tsection->vma;
1858 tdata = bfd_malloc (8);
1859 if (bfd_get_section_contents (abfd, tsection, tdata, (bfd_vma) xx, 8))
1861 bfd_vma eh, eh_data;
1863 eh = bfd_get_32 (abfd, tdata);
1864 eh_data = bfd_get_32 (abfd, tdata + 4);
1865 fprintf (file, "%08x ", (unsigned int) eh);
1866 fprintf (file, "%08x", (unsigned int) eh_data);
1869 const char *s = my_symbol_for_address (abfd, eh, &sym_cache);
1872 fprintf (file, " (%s) ", s);
1884 fprintf (file, "\n");
1889 cleanup_syms (& sym_cache);
1892 #undef PDATA_ROW_SIZE
1896 #define IMAGE_REL_BASED_HIGHADJ 4
1897 static const char * const tbl[] =
1911 "UNKNOWN", /* MUST be last. */
1915 pe_print_reloc (bfd * abfd, void * vfile)
1917 FILE *file = (FILE *) vfile;
1919 asection *section = bfd_get_section_by_name (abfd, ".reloc");
1920 bfd_size_type datasize;
1922 bfd_size_type start, stop;
1924 if (section == NULL)
1927 if (section->size == 0)
1931 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
1933 datasize = section->size;
1934 if (! bfd_malloc_and_get_section (abfd, section, &data))
1943 stop = section->size;
1945 for (i = start; i < stop;)
1948 bfd_vma virtual_address;
1951 /* The .reloc section is a sequence of blocks, with a header consisting
1952 of two 32 bit quantities, followed by a number of 16 bit entries. */
1953 virtual_address = bfd_get_32 (abfd, data+i);
1954 size = bfd_get_32 (abfd, data+i+4);
1955 number = (size - 8) / 2;
1961 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
1962 (unsigned long) virtual_address, size, (unsigned long) size, number);
1964 for (j = 0; j < number; ++j)
1966 unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
1967 unsigned int t = (e & 0xF000) >> 12;
1968 int off = e & 0x0FFF;
1970 if (t >= sizeof (tbl) / sizeof (tbl[0]))
1971 t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
1974 _("\treloc %4d offset %4x [%4lx] %s"),
1975 j, off, (unsigned long) (off + virtual_address), tbl[t]);
1977 /* HIGHADJ takes an argument, - the next record *is* the
1978 low 16 bits of addend. */
1979 if (t == IMAGE_REL_BASED_HIGHADJ)
1981 fprintf (file, " (%4x)",
1983 bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
1987 fprintf (file, "\n");
1998 /* Print out the program headers. */
2001 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
2003 FILE *file = (FILE *) vfile;
2005 pe_data_type *pe = pe_data (abfd);
2006 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
2007 const char *subsystem_name = NULL;
2010 /* The MS dumpbin program reportedly ands with 0xff0f before
2011 printing the characteristics field. Not sure why. No reason to
2013 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
2015 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2016 PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
2017 PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
2018 PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
2019 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
2020 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
2021 PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
2022 PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
2023 PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
2024 PF (IMAGE_FILE_SYSTEM, "system file");
2025 PF (IMAGE_FILE_DLL, "DLL");
2026 PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
2029 /* ctime implies '\n'. */
2031 time_t t = pe->coff.timestamp;
2032 fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
2035 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2036 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2038 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2039 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2041 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2042 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2047 case IMAGE_NT_OPTIONAL_HDR_MAGIC:
2050 case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
2053 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
2060 fprintf (file, "Magic\t\t\t%04x", i->Magic);
2062 fprintf (file, "\t(%s)",name);
2063 fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
2064 fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
2065 fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode);
2066 fprintf (file, "SizeOfInitializedData\t%08lx\n",
2067 (unsigned long) i->SizeOfInitializedData);
2068 fprintf (file, "SizeOfUninitializedData\t%08lx\n",
2069 (unsigned long) i->SizeOfUninitializedData);
2070 fprintf (file, "AddressOfEntryPoint\t");
2071 fprintf_vma (file, i->AddressOfEntryPoint);
2072 fprintf (file, "\nBaseOfCode\t\t");
2073 fprintf_vma (file, i->BaseOfCode);
2074 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2075 /* PE32+ does not have BaseOfData member! */
2076 fprintf (file, "\nBaseOfData\t\t");
2077 fprintf_vma (file, i->BaseOfData);
2080 fprintf (file, "\nImageBase\t\t");
2081 fprintf_vma (file, i->ImageBase);
2082 fprintf (file, "\nSectionAlignment\t");
2083 fprintf_vma (file, i->SectionAlignment);
2084 fprintf (file, "\nFileAlignment\t\t");
2085 fprintf_vma (file, i->FileAlignment);
2086 fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
2087 fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
2088 fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
2089 fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
2090 fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
2091 fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
2092 fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1);
2093 fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage);
2094 fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders);
2095 fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum);
2097 switch (i->Subsystem)
2099 case IMAGE_SUBSYSTEM_UNKNOWN:
2100 subsystem_name = "unspecified";
2102 case IMAGE_SUBSYSTEM_NATIVE:
2103 subsystem_name = "NT native";
2105 case IMAGE_SUBSYSTEM_WINDOWS_GUI:
2106 subsystem_name = "Windows GUI";
2108 case IMAGE_SUBSYSTEM_WINDOWS_CUI:
2109 subsystem_name = "Windows CUI";
2111 case IMAGE_SUBSYSTEM_POSIX_CUI:
2112 subsystem_name = "POSIX CUI";
2114 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
2115 subsystem_name = "Wince CUI";
2117 // These are from UEFI Platform Initialization Specification 1.1.
2118 case IMAGE_SUBSYSTEM_EFI_APPLICATION:
2119 subsystem_name = "EFI application";
2121 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
2122 subsystem_name = "EFI boot service driver";
2124 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
2125 subsystem_name = "EFI runtime driver";
2127 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
2128 subsystem_name = "SAL runtime driver";
2130 // This is from revision 8.0 of the MS PE/COFF spec
2131 case IMAGE_SUBSYSTEM_XBOX:
2132 subsystem_name = "XBOX";
2134 // Added default case for clarity - subsystem_name is NULL anyway.
2136 subsystem_name = NULL;
2139 fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
2141 fprintf (file, "\t(%s)", subsystem_name);
2142 fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
2143 fprintf (file, "SizeOfStackReserve\t");
2144 fprintf_vma (file, i->SizeOfStackReserve);
2145 fprintf (file, "\nSizeOfStackCommit\t");
2146 fprintf_vma (file, i->SizeOfStackCommit);
2147 fprintf (file, "\nSizeOfHeapReserve\t");
2148 fprintf_vma (file, i->SizeOfHeapReserve);
2149 fprintf (file, "\nSizeOfHeapCommit\t");
2150 fprintf_vma (file, i->SizeOfHeapCommit);
2151 fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
2152 fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
2153 (unsigned long) i->NumberOfRvaAndSizes);
2155 fprintf (file, "\nThe Data Directory\n");
2156 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
2158 fprintf (file, "Entry %1x ", j);
2159 fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
2160 fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
2161 fprintf (file, "%s\n", dir_names[j]);
2164 pe_print_idata (abfd, vfile);
2165 pe_print_edata (abfd, vfile);
2166 if (bfd_coff_have_print_pdata (abfd))
2167 bfd_coff_print_pdata (abfd, vfile);
2169 pe_print_pdata (abfd, vfile);
2170 pe_print_reloc (abfd, vfile);
2175 /* Copy any private info we understand from the input bfd
2176 to the output bfd. */
2179 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
2181 pe_data_type *ipe, *ope;
2183 /* One day we may try to grok other private data. */
2184 if (ibfd->xvec->flavour != bfd_target_coff_flavour
2185 || obfd->xvec->flavour != bfd_target_coff_flavour)
2188 ipe = pe_data (ibfd);
2189 ope = pe_data (obfd);
2191 ope->pe_opthdr = ipe->pe_opthdr;
2192 ope->dll = ipe->dll;
2194 /* Don't copy input subsystem if output is different from input. */
2195 if (obfd->xvec != ibfd->xvec)
2196 ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
2198 /* For strip: if we removed .reloc, we'll make a real mess of things
2199 if we don't remove this entry as well. */
2200 if (! pe_data (obfd)->has_reloc_section)
2202 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2203 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
2208 /* Copy private section data. */
2211 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
2216 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
2217 || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
2220 if (coff_section_data (ibfd, isec) != NULL
2221 && pei_section_data (ibfd, isec) != NULL)
2223 if (coff_section_data (obfd, osec) == NULL)
2225 bfd_size_type amt = sizeof (struct coff_section_tdata);
2226 osec->used_by_bfd = bfd_zalloc (obfd, amt);
2227 if (osec->used_by_bfd == NULL)
2231 if (pei_section_data (obfd, osec) == NULL)
2233 bfd_size_type amt = sizeof (struct pei_section_tdata);
2234 coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
2235 if (coff_section_data (obfd, osec)->tdata == NULL)
2239 pei_section_data (obfd, osec)->virt_size =
2240 pei_section_data (ibfd, isec)->virt_size;
2241 pei_section_data (obfd, osec)->pe_flags =
2242 pei_section_data (ibfd, isec)->pe_flags;
2249 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
2251 coff_get_symbol_info (abfd, symbol, ret);
2254 /* Handle the .idata section and other things that need symbol table
2258 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
2260 struct coff_link_hash_entry *h1;
2261 struct bfd_link_info *info = pfinfo->info;
2262 bfd_boolean result = TRUE;
2264 /* There are a few fields that need to be filled in now while we
2265 have symbol table access.
2267 The .idata subsections aren't directly available as sections, but
2268 they are in the symbol table, so get them from there. */
2270 /* The import directory. This is the address of .idata$2, with size
2271 of .idata$2 + .idata$3. */
2272 h1 = coff_link_hash_lookup (coff_hash_table (info),
2273 ".idata$2", FALSE, FALSE, TRUE);
2276 /* PR ld/2729: We cannot rely upon all the output sections having been
2277 created properly, so check before referencing them. Issue a warning
2278 message for any sections tht could not be found. */
2279 if ((h1->root.type == bfd_link_hash_defined
2280 || h1->root.type == bfd_link_hash_defweak)
2281 && h1->root.u.def.section != NULL
2282 && h1->root.u.def.section->output_section != NULL)
2283 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
2284 (h1->root.u.def.value
2285 + h1->root.u.def.section->output_section->vma
2286 + h1->root.u.def.section->output_offset);
2290 (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
2295 h1 = coff_link_hash_lookup (coff_hash_table (info),
2296 ".idata$4", FALSE, FALSE, TRUE);
2298 && (h1->root.type == bfd_link_hash_defined
2299 || h1->root.type == bfd_link_hash_defweak)
2300 && h1->root.u.def.section != NULL
2301 && h1->root.u.def.section->output_section != NULL)
2302 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
2303 ((h1->root.u.def.value
2304 + h1->root.u.def.section->output_section->vma
2305 + h1->root.u.def.section->output_offset)
2306 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
2310 (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
2315 /* The import address table. This is the size/address of
2317 h1 = coff_link_hash_lookup (coff_hash_table (info),
2318 ".idata$5", FALSE, FALSE, TRUE);
2320 && (h1->root.type == bfd_link_hash_defined
2321 || h1->root.type == bfd_link_hash_defweak)
2322 && h1->root.u.def.section != NULL
2323 && h1->root.u.def.section->output_section != NULL)
2324 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
2325 (h1->root.u.def.value
2326 + h1->root.u.def.section->output_section->vma
2327 + h1->root.u.def.section->output_offset);
2331 (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
2336 h1 = coff_link_hash_lookup (coff_hash_table (info),
2337 ".idata$6", FALSE, FALSE, TRUE);
2339 && (h1->root.type == bfd_link_hash_defined
2340 || h1->root.type == bfd_link_hash_defweak)
2341 && h1->root.u.def.section != NULL
2342 && h1->root.u.def.section->output_section != NULL)
2343 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
2344 ((h1->root.u.def.value
2345 + h1->root.u.def.section->output_section->vma
2346 + h1->root.u.def.section->output_offset)
2347 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
2351 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
2357 h1 = coff_link_hash_lookup (coff_hash_table (info),
2358 "__tls_used", FALSE, FALSE, TRUE);
2361 if ((h1->root.type == bfd_link_hash_defined
2362 || h1->root.type == bfd_link_hash_defweak)
2363 && h1->root.u.def.section != NULL
2364 && h1->root.u.def.section->output_section != NULL)
2365 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
2366 (h1->root.u.def.value
2367 + h1->root.u.def.section->output_section->vma
2368 + h1->root.u.def.section->output_offset
2369 - pe_data (abfd)->pe_opthdr.ImageBase);
2373 (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
2378 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
2381 /* If we couldn't find idata$2, we either have an excessively
2382 trivial program or are in DEEP trouble; we have to assume trivial