1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 or COFF_WITH_pep depending on whether
56 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. */
71 # include "coff/ia64.h"
73 # include "coff/i386.h"
82 # define AOUTSZ PEPAOUTSZ
83 # define PEAOUTHDR PEPAOUTHDR
86 /* FIXME: This file has various tests of POWERPC_LE_PE. Those tests
87 worked when the code was in peicode.h, but no longer work now that
88 the code is in peigen.c. PowerPC NT is said to be dead. If
89 anybody wants to revive the code, you will have to figure out how
90 to handle those issues. */
92 static void add_data_entry
93 PARAMS ((bfd *, struct internal_extra_pe_aouthdr *, int, char *, bfd_vma));
94 static bfd_boolean pe_print_pdata PARAMS ((bfd *, PTR));
95 static bfd_boolean pe_print_reloc PARAMS ((bfd *, PTR));
96 static bfd_boolean pe_print_idata PARAMS ((bfd *, PTR));
97 static bfd_boolean pe_print_edata PARAMS ((bfd *, PTR));
101 _bfd_XXi_swap_sym_in (abfd, ext1, in1)
106 SYMENT *ext = (SYMENT *) ext1;
107 struct internal_syment *in = (struct internal_syment *) in1;
109 if (ext->e.e_name[0] == 0)
111 in->_n._n_n._n_zeroes = 0;
112 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
115 memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
117 in->n_value = H_GET_32 (abfd, ext->e_value);
118 in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
120 if (sizeof (ext->e_type) == 2)
121 in->n_type = H_GET_16 (abfd, ext->e_type);
123 in->n_type = H_GET_32 (abfd, ext->e_type);
125 in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
126 in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
128 #ifndef STRICT_PE_FORMAT
129 /* This is for Gnu-created DLLs. */
131 /* The section symbols for the .idata$ sections have class 0x68
132 (C_SECTION), which MS documentation indicates is a section
133 symbol. Unfortunately, the value field in the symbol is simply a
134 copy of the .idata section's flags rather than something useful.
135 When these symbols are encountered, change the value to 0 so that
136 they will be handled somewhat correctly in the bfd code. */
137 if (in->n_sclass == C_SECTION)
142 /* FIXME: This is clearly wrong. The problem seems to be that
143 undefined C_SECTION symbols appear in the first object of a
144 MS generated .lib file, and the symbols are not defined
148 /* I have tried setting the class to 3 and using the following
149 to set the section number. This will put the address of the
150 pointer to the string kernel32.dll at addresses 0 and 0x10
151 off start of idata section which is not correct. */
153 if (strcmp (in->_n._n_name, ".idata$4") == 0)
159 /* Create synthetic empty sections as needed. DJ */
160 if (in->n_scnum == 0)
164 for (sec = abfd->sections; sec; sec = sec->next)
166 if (strcmp (sec->name, in->n_name) == 0)
168 in->n_scnum = sec->target_index;
174 if (in->n_scnum == 0)
176 int unused_section_number = 0;
180 for (sec = abfd->sections; sec; sec = sec->next)
181 if (unused_section_number <= sec->target_index)
182 unused_section_number = sec->target_index + 1;
184 name = bfd_alloc (abfd, (bfd_size_type) strlen (in->n_name) + 10);
187 strcpy (name, in->n_name);
188 sec = bfd_make_section_anyway (abfd, name);
192 sec->_cooked_size = 0;
195 sec->rel_filepos = 0;
196 sec->reloc_count = 0;
197 sec->line_filepos = 0;
198 sec->lineno_count = 0;
199 sec->userdata = NULL;
200 sec->next = (asection *) NULL;
202 sec->alignment_power = 2;
203 sec->flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
205 sec->target_index = unused_section_number;
207 in->n_scnum = unused_section_number;
209 in->n_sclass = C_STAT;
214 #ifdef coff_swap_sym_in_hook
215 /* This won't work in peigen.c, but since it's for PPC PE, it's not
217 coff_swap_sym_in_hook (abfd, ext1, in1);
222 _bfd_XXi_swap_sym_out (abfd, inp, extp)
227 struct internal_syment *in = (struct internal_syment *) inp;
228 SYMENT *ext = (SYMENT *) extp;
230 if (in->_n._n_name[0] == 0)
232 H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
233 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
236 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
238 H_PUT_32 (abfd, in->n_value, ext->e_value);
239 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
241 if (sizeof (ext->e_type) == 2)
242 H_PUT_16 (abfd, in->n_type, ext->e_type);
244 H_PUT_32 (abfd, in->n_type, ext->e_type);
246 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
247 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
253 _bfd_XXi_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
258 int indx ATTRIBUTE_UNUSED;
259 int numaux ATTRIBUTE_UNUSED;
262 AUXENT *ext = (AUXENT *) ext1;
263 union internal_auxent *in = (union internal_auxent *) in1;
268 if (ext->x_file.x_fname[0] == 0)
270 in->x_file.x_n.x_zeroes = 0;
271 in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
274 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
282 in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
283 in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
284 in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
285 in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
286 in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
287 in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
293 in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
294 in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
296 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
298 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
299 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
303 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
304 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
305 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
306 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
307 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
308 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
309 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
310 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
315 in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
319 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
320 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
325 _bfd_XXi_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
330 int indx ATTRIBUTE_UNUSED;
331 int numaux ATTRIBUTE_UNUSED;
334 union internal_auxent *in = (union internal_auxent *) inp;
335 AUXENT *ext = (AUXENT *) extp;
337 memset ((PTR) ext, 0, AUXESZ);
341 if (in->x_file.x_fname[0] == 0)
343 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
344 H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
347 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
356 PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
357 PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
358 PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
359 H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
360 H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
361 H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
367 H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
368 H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
370 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
372 PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
373 PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
377 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
378 ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
379 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
380 ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
381 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
382 ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
383 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
384 ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
388 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
391 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
392 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
399 _bfd_XXi_swap_lineno_in (abfd, ext1, in1)
404 LINENO *ext = (LINENO *) ext1;
405 struct internal_lineno *in = (struct internal_lineno *) in1;
407 in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
408 in->l_lnno = GET_LINENO_LNNO (abfd, ext);
412 _bfd_XXi_swap_lineno_out (abfd, inp, outp)
417 struct internal_lineno *in = (struct internal_lineno *) inp;
418 struct external_lineno *ext = (struct external_lineno *) outp;
419 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
421 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
426 _bfd_XXi_swap_aouthdr_in (abfd, aouthdr_ext1, aouthdr_int1)
431 struct internal_extra_pe_aouthdr *a;
432 PEAOUTHDR *src = (PEAOUTHDR *) (aouthdr_ext1);
433 AOUTHDR *aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
434 struct internal_aouthdr *aouthdr_int = (struct internal_aouthdr *)aouthdr_int1;
436 aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
437 aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
438 aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
439 aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
440 aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
441 aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
442 aouthdr_int->text_start =
443 GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
444 #ifndef COFF_WITH_pep
445 /* PE32+ does not have data_start member! */
446 aouthdr_int->data_start =
447 GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
450 a = &aouthdr_int->pe;
451 a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
452 a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
453 a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
454 a->MajorOperatingSystemVersion =
455 H_GET_16 (abfd, src->MajorOperatingSystemVersion);
456 a->MinorOperatingSystemVersion =
457 H_GET_16 (abfd, src->MinorOperatingSystemVersion);
458 a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
459 a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
460 a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
461 a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
462 a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
463 a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
464 a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
465 a->CheckSum = H_GET_32 (abfd, src->CheckSum);
466 a->Subsystem = H_GET_16 (abfd, src->Subsystem);
467 a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
468 a->SizeOfStackReserve =
469 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
470 a->SizeOfStackCommit =
471 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
472 a->SizeOfHeapReserve =
473 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
474 a->SizeOfHeapCommit =
475 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
476 a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
477 a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
482 for (idx = 0; idx < 16; idx++)
484 /* If data directory is empty, rva also should be 0. */
486 H_GET_32 (abfd, src->DataDirectory[idx][1]);
487 a->DataDirectory[idx].Size = size;
490 a->DataDirectory[idx].VirtualAddress =
491 H_GET_32 (abfd, src->DataDirectory[idx][0]);
493 a->DataDirectory[idx].VirtualAddress = 0;
497 if (aouthdr_int->entry)
499 aouthdr_int->entry += a->ImageBase;
500 #ifndef COFF_WITH_pep
501 aouthdr_int->entry &= 0xffffffff;
505 if (aouthdr_int->tsize)
507 aouthdr_int->text_start += a->ImageBase;
508 #ifndef COFF_WITH_pep
509 aouthdr_int->text_start &= 0xffffffff;
513 #ifndef COFF_WITH_pep
514 /* PE32+ does not have data_start member! */
515 if (aouthdr_int->dsize)
517 aouthdr_int->data_start += a->ImageBase;
518 aouthdr_int->data_start &= 0xffffffff;
523 /* These three fields are normally set up by ppc_relocate_section.
524 In the case of reading a file in, we can pick them up from the
526 first_thunk_address = a->DataDirectory[12].VirtualAddress;
527 thunk_size = a->DataDirectory[12].Size;
528 import_table_size = a->DataDirectory[1].Size;
532 /* A support function for below. */
535 add_data_entry (abfd, aout, idx, name, base)
537 struct internal_extra_pe_aouthdr *aout;
542 asection *sec = bfd_get_section_by_name (abfd, name);
544 /* Add import directory information if it exists. */
546 && (coff_section_data (abfd, sec) != NULL)
547 && (pei_section_data (abfd, sec) != NULL))
549 /* If data directory is empty, rva also should be 0. */
550 int size = pei_section_data (abfd, sec)->virt_size;
551 aout->DataDirectory[idx].Size = size;
555 aout->DataDirectory[idx].VirtualAddress =
556 (sec->vma - base) & 0xffffffff;
557 sec->flags |= SEC_DATA;
563 _bfd_XXi_swap_aouthdr_out (abfd, in, out)
568 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
569 pe_data_type *pe = pe_data (abfd);
570 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
571 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
573 IMAGE_DATA_DIRECTORY idata2, idata5;
576 if (pe->force_minimum_alignment)
578 if (!extra->FileAlignment)
579 extra->FileAlignment = PE_DEF_FILE_ALIGNMENT;
580 if (!extra->SectionAlignment)
581 extra->SectionAlignment = PE_DEF_SECTION_ALIGNMENT;
584 if (extra->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
585 extra->Subsystem = pe->target_subsystem;
587 sa = extra->SectionAlignment;
588 fa = extra->FileAlignment;
589 ib = extra->ImageBase;
591 idata2 = pe->pe_opthdr.DataDirectory[1];
592 idata5 = pe->pe_opthdr.DataDirectory[12];
594 if (aouthdr_in->tsize)
596 aouthdr_in->text_start -= ib;
597 #ifndef COFF_WITH_pep
598 aouthdr_in->text_start &= 0xffffffff;
602 if (aouthdr_in->dsize)
604 aouthdr_in->data_start -= ib;
605 #ifndef COFF_WITH_pep
606 aouthdr_in->data_start &= 0xffffffff;
610 if (aouthdr_in->entry)
612 aouthdr_in->entry -= ib;
613 #ifndef COFF_WITH_pep
614 aouthdr_in->entry &= 0xffffffff;
618 #define FA(x) (((x) + fa -1 ) & (- fa))
619 #define SA(x) (((x) + sa -1 ) & (- sa))
621 /* We like to have the sizes aligned. */
622 aouthdr_in->bsize = FA (aouthdr_in->bsize);
624 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
626 /* First null out all data directory entries. */
627 memset (extra->DataDirectory, 0, sizeof (extra->DataDirectory));
629 add_data_entry (abfd, extra, 0, ".edata", ib);
630 add_data_entry (abfd, extra, 2, ".rsrc", ib);
631 add_data_entry (abfd, extra, 3, ".pdata", ib);
633 /* In theory we do not need to call add_data_entry for .idata$2 or
634 .idata$5. It will be done in bfd_coff_final_link where all the
635 required information is available. If however, we are not going
636 to perform a final link, eg because we have been invoked by objcopy
637 or strip, then we need to make sure that these Data Directory
638 entries are initialised properly.
640 So - we copy the input values into the output values, and then, if
641 a final link is going to be performed, it can overwrite them. */
642 extra->DataDirectory[1] = idata2;
643 extra->DataDirectory[12] = idata5;
645 if (extra->DataDirectory[1].VirtualAddress == 0)
646 /* Until other .idata fixes are made (pending patch), the entry for
647 .idata is needed for backwards compatability. FIXME. */
648 add_data_entry (abfd, extra, 1, ".idata", ib);
650 /* For some reason, the virtual size (which is what's set by
651 add_data_entry) for .reloc is not the same as the size recorded
652 in this slot by MSVC; it doesn't seem to cause problems (so far),
653 but since it's the best we've got, use it. It does do the right
655 if (pe->has_reloc_section)
656 add_data_entry (abfd, extra, 5, ".reloc", ib);
661 bfd_vma isize = SA(abfd->sections->filepos);
664 for (sec = abfd->sections; sec; sec = sec->next)
666 int rounded = FA(sec->_raw_size);
668 if (sec->flags & SEC_DATA)
670 if (sec->flags & SEC_CODE)
672 /* The image size is the total VIRTUAL size (which is what is
673 in the virt_size field). Files have been seen (from MSVC
674 5.0 link.exe) where the file size of the .data segment is
675 quite small compared to the virtual size. Without this
676 fix, strip munges the file. */
677 if (coff_section_data (abfd, sec) != NULL
678 && pei_section_data (abfd, sec) != NULL)
679 isize += SA (FA (pei_section_data (abfd, sec)->virt_size));
682 aouthdr_in->dsize = dsize;
683 aouthdr_in->tsize = tsize;
684 extra->SizeOfImage = isize;
687 extra->SizeOfHeaders = abfd->sections->filepos;
688 H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
690 #define LINKER_VERSION 256 /* That is, 2.56 */
692 /* This piece of magic sets the "linker version" field to
694 H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
695 aouthdr_out->standard.vstamp);
697 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
698 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
699 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
700 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
701 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
702 aouthdr_out->standard.text_start);
704 #ifndef COFF_WITH_pep
705 /* PE32+ does not have data_start member! */
706 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
707 aouthdr_out->standard.data_start);
710 PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
711 H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
712 H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
713 H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
714 aouthdr_out->MajorOperatingSystemVersion);
715 H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
716 aouthdr_out->MinorOperatingSystemVersion);
717 H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
718 H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
719 H_PUT_16 (abfd, extra->MajorSubsystemVersion,
720 aouthdr_out->MajorSubsystemVersion);
721 H_PUT_16 (abfd, extra->MinorSubsystemVersion,
722 aouthdr_out->MinorSubsystemVersion);
723 H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
724 H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
725 H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
726 H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
727 H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
728 H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
729 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
730 aouthdr_out->SizeOfStackReserve);
731 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
732 aouthdr_out->SizeOfStackCommit);
733 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
734 aouthdr_out->SizeOfHeapReserve);
735 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
736 aouthdr_out->SizeOfHeapCommit);
737 H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
738 H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
739 aouthdr_out->NumberOfRvaAndSizes);
743 for (idx = 0; idx < 16; idx++)
745 H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
746 aouthdr_out->DataDirectory[idx][0]);
747 H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
748 aouthdr_out->DataDirectory[idx][1]);
756 _bfd_XXi_only_swap_filehdr_out (abfd, in, out)
762 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
763 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
765 if (pe_data (abfd)->has_reloc_section)
766 filehdr_in->f_flags &= ~F_RELFLG;
768 if (pe_data (abfd)->dll)
769 filehdr_in->f_flags |= F_DLL;
771 filehdr_in->pe.e_magic = DOSMAGIC;
772 filehdr_in->pe.e_cblp = 0x90;
773 filehdr_in->pe.e_cp = 0x3;
774 filehdr_in->pe.e_crlc = 0x0;
775 filehdr_in->pe.e_cparhdr = 0x4;
776 filehdr_in->pe.e_minalloc = 0x0;
777 filehdr_in->pe.e_maxalloc = 0xffff;
778 filehdr_in->pe.e_ss = 0x0;
779 filehdr_in->pe.e_sp = 0xb8;
780 filehdr_in->pe.e_csum = 0x0;
781 filehdr_in->pe.e_ip = 0x0;
782 filehdr_in->pe.e_cs = 0x0;
783 filehdr_in->pe.e_lfarlc = 0x40;
784 filehdr_in->pe.e_ovno = 0x0;
786 for (idx = 0; idx < 4; idx++)
787 filehdr_in->pe.e_res[idx] = 0x0;
789 filehdr_in->pe.e_oemid = 0x0;
790 filehdr_in->pe.e_oeminfo = 0x0;
792 for (idx = 0; idx < 10; idx++)
793 filehdr_in->pe.e_res2[idx] = 0x0;
795 filehdr_in->pe.e_lfanew = 0x80;
797 /* This next collection of data are mostly just characters. It
798 appears to be constant within the headers put on NT exes. */
799 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
800 filehdr_in->pe.dos_message[1] = 0xcd09b400;
801 filehdr_in->pe.dos_message[2] = 0x4c01b821;
802 filehdr_in->pe.dos_message[3] = 0x685421cd;
803 filehdr_in->pe.dos_message[4] = 0x70207369;
804 filehdr_in->pe.dos_message[5] = 0x72676f72;
805 filehdr_in->pe.dos_message[6] = 0x63206d61;
806 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
807 filehdr_in->pe.dos_message[8] = 0x65622074;
808 filehdr_in->pe.dos_message[9] = 0x6e757220;
809 filehdr_in->pe.dos_message[10] = 0x206e6920;
810 filehdr_in->pe.dos_message[11] = 0x20534f44;
811 filehdr_in->pe.dos_message[12] = 0x65646f6d;
812 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
813 filehdr_in->pe.dos_message[14] = 0x24;
814 filehdr_in->pe.dos_message[15] = 0x0;
815 filehdr_in->pe.nt_signature = NT_SIGNATURE;
817 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
818 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
820 H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
821 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
822 filehdr_out->f_symptr);
823 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
824 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
825 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
827 /* Put in extra dos header stuff. This data remains essentially
828 constant, it just has to be tacked on to the beginning of all exes
830 H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
831 H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
832 H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
833 H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
834 H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
835 H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
836 H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
837 H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
838 H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
839 H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
840 H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
841 H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
842 H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
843 H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
845 for (idx = 0; idx < 4; idx++)
846 H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
848 H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
849 H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
851 for (idx = 0; idx < 10; idx++)
852 H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
854 H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
856 for (idx = 0; idx < 16; idx++)
857 H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
858 filehdr_out->dos_message[idx]);
860 /* Also put in the NT signature. */
861 H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
867 _bfd_XX_only_swap_filehdr_out (abfd, in, out)
872 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
873 FILHDR *filehdr_out = (FILHDR *) out;
875 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
876 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
877 H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
878 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
879 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
880 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
881 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
887 _bfd_XXi_swap_scnhdr_out (abfd, in, out)
892 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
893 SCNHDR *scnhdr_ext = (SCNHDR *) out;
894 unsigned int ret = SCNHSZ;
898 memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
900 PUT_SCNHDR_VADDR (abfd,
901 ((scnhdr_int->s_vaddr
902 - pe_data (abfd)->pe_opthdr.ImageBase)
904 scnhdr_ext->s_vaddr);
906 /* NT wants the size data to be rounded up to the next
907 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
909 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
911 if (bfd_pe_executable_p (abfd))
913 ps = scnhdr_int->s_size;
919 ss = scnhdr_int->s_size;
924 if (bfd_pe_executable_p (abfd))
925 ps = scnhdr_int->s_paddr;
929 ss = scnhdr_int->s_size;
932 PUT_SCNHDR_SIZE (abfd, ss,
935 /* s_paddr in PE is really the virtual size. */
936 PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
938 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
939 scnhdr_ext->s_scnptr);
940 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
941 scnhdr_ext->s_relptr);
942 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
943 scnhdr_ext->s_lnnoptr);
945 /* Extra flags must be set when dealing with NT. All sections should also
946 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
947 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
948 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
949 (this is especially important when dealing with the .idata section since
950 the addresses for routines from .dlls must be overwritten). If .reloc
951 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
952 (0x02000000). Also, the resource data should also be read and
955 /* FIXME: alignment is also encoded in this field, at least on ppc (krk) */
956 /* FIXME: even worse, I don't see how to get the original alignment field*/
960 int flags = scnhdr_int->s_flags;
962 H_PUT_32 (abfd, flags, scnhdr_ext->s_flags);
965 if (coff_data (abfd)->link_info
966 && ! coff_data (abfd)->link_info->relocatable
967 && ! coff_data (abfd)->link_info->shared
968 && strcmp (scnhdr_int->s_name, ".text") == 0)
970 /* By inference from looking at MS output, the 32 bit field
971 which is the combintion of the number_of_relocs and
972 number_of_linenos is used for the line number count in
973 executables. A 16-bit field won't do for cc1. The MS
974 document says that the number of relocs is zero for
975 executables, but the 17-th bit has been observed to be there.
976 Overflow is not an issue: a 4G-line program will overflow a
977 bunch of other fields long before this! */
978 H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
979 H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
983 if (scnhdr_int->s_nlnno <= 0xffff)
984 H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
987 (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
988 bfd_get_filename (abfd),
989 scnhdr_int->s_nlnno);
990 bfd_set_error (bfd_error_file_truncated);
991 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
995 /* Although we could encode 0xffff relocs here, we do not, to be
996 consistent with other parts of bfd. Also it lets us warn, as
997 we should never see 0xffff here w/o having the overflow flag
999 if (scnhdr_int->s_nreloc < 0xffff)
1000 H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
1003 /* PE can deal with large #s of relocs, but not here. */
1004 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1005 scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1006 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1008 (*_bfd_error_handler) (_("%s: reloc overflow 1: 0x%lx > 0xffff"),
1009 bfd_get_filename (abfd),
1010 scnhdr_int->s_nreloc);
1011 bfd_set_error (bfd_error_file_truncated);
1012 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1020 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1022 N_("Export Directory [.edata (or where ever we found it)]"),
1023 N_("Import Directory [parts of .idata]"),
1024 N_("Resource Directory [.rsrc]"),
1025 N_("Exception Directory [.pdata]"),
1026 N_("Security Directory"),
1027 N_("Base Relocation Directory [.reloc]"),
1028 N_("Debug Directory"),
1029 N_("Description Directory"),
1030 N_("Special Directory"),
1031 N_("Thread Storage Directory [.tls]"),
1032 N_("Load Configuration Directory"),
1033 N_("Bound Import Directory"),
1034 N_("Import Address Table Directory"),
1035 N_("Delay Import Directory"),
1040 #ifdef POWERPC_LE_PE
1041 /* The code for the PPC really falls in the "architecture dependent"
1042 category. However, it's not clear that anyone will ever care, so
1043 we're ignoring the issue for now; if/when PPC matters, some of this
1044 may need to go into peicode.h, or arguments passed to enable the
1045 PPC- specific code. */
1049 pe_print_idata (abfd, 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;
1068 pe_data_type *pe = pe_data (abfd);
1069 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1073 addr = extra->DataDirectory[1].VirtualAddress;
1075 if (addr == 0 && extra->DataDirectory[1].Size == 0)
1077 /* Maybe the extra header isn't there. Look for the section. */
1078 section = bfd_get_section_by_name (abfd, ".idata");
1079 if (section == NULL)
1082 addr = section->vma;
1083 datasize = bfd_section_size (abfd, section);
1089 addr += extra->ImageBase;
1090 for (section = abfd->sections; section != NULL; section = section->next)
1092 datasize = bfd_section_size (abfd, section);
1093 if (addr >= section->vma && addr < section->vma + datasize)
1097 if (section == NULL)
1100 _("\nThere is an import table, but the section containing it could not be found\n"));
1105 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1106 section->name, (unsigned long) addr);
1108 dataoff = addr - section->vma;
1109 datasize -= dataoff;
1111 #ifdef POWERPC_LE_PE
1112 if (rel_section != 0 && bfd_section_size (abfd, rel_section) != 0)
1114 /* The toc address can be found by taking the starting address,
1115 which on the PPC locates a function descriptor. The
1116 descriptor consists of the function code starting address
1117 followed by the address of the toc. The starting address we
1118 get from the bfd, and the descriptor is supposed to be in the
1119 .reldata section. */
1121 bfd_vma loadable_toc_address;
1122 bfd_vma toc_address;
1123 bfd_vma start_address;
1127 amt = bfd_section_size (abfd, rel_section);
1128 data = (bfd_byte *) bfd_malloc (amt);
1129 if (data == NULL && amt != 0)
1132 bfd_get_section_contents (abfd, rel_section, (PTR) data, (bfd_vma) 0,
1135 offset = abfd->start_address - rel_section->vma;
1137 start_address = bfd_get_32 (abfd, data + offset);
1138 loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1139 toc_address = loadable_toc_address - 32768;
1142 _("\nFunction descriptor located at the start address: %04lx\n"),
1143 (unsigned long int) (abfd->start_address));
1145 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1146 start_address, loadable_toc_address, toc_address);
1151 _("\nNo reldata section! Function descriptor not decoded.\n"));
1156 _("\nThe Import Tables (interpreted %s section contents)\n"),
1160 vma: Hint Time Forward DLL First\n\
1161 Table Stamp Chain Name Thunk\n"));
1163 amt = dataoff + datasize;
1164 data = (bfd_byte *) bfd_malloc (amt);
1168 /* Read the whole section. Some of the fields might be before dataoff. */
1169 if (! bfd_get_section_contents (abfd, section, (PTR) data, (bfd_vma) 0, amt))
1172 adj = section->vma - extra->ImageBase;
1174 /* Print all image import descriptors. */
1175 for (i = 0; i < datasize; i += onaline)
1179 bfd_vma forward_chain;
1181 bfd_vma first_thunk;
1186 /* Print (i + extra->DataDirectory[1].VirtualAddress). */
1187 fprintf (file, " %08lx\t", (unsigned long) (i + adj + dataoff));
1189 if (i + 20 > datasize)
1193 hint_addr = bfd_get_32 (abfd, data + i + dataoff);
1194 time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff);
1195 forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff);
1196 dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff);
1197 first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff);
1199 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1200 (unsigned long) hint_addr,
1201 (unsigned long) time_stamp,
1202 (unsigned long) forward_chain,
1203 (unsigned long) dll_name,
1204 (unsigned long) first_thunk);
1206 if (hint_addr == 0 && first_thunk == 0)
1209 dll = (char *) data + dll_name - adj;
1210 fprintf (file, _("\n\tDLL Name: %s\n"), dll);
1215 asection *ft_section;
1217 bfd_size_type ft_datasize;
1219 int ft_allocated = 0;
1221 fprintf (file, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1223 idx = hint_addr - adj;
1225 ft_addr = first_thunk + extra->ImageBase;
1227 ft_idx = first_thunk - adj;
1230 if (first_thunk != hint_addr)
1232 /* Find the section which contains the first thunk. */
1233 for (ft_section = abfd->sections;
1235 ft_section = ft_section->next)
1237 ft_datasize = bfd_section_size (abfd, ft_section);
1238 if (ft_addr >= ft_section->vma
1239 && ft_addr < ft_section->vma + ft_datasize)
1243 if (ft_section == NULL)
1246 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1250 /* Now check to see if this section is the same as our current
1251 section. If it is not then we will have to load its data in. */
1252 if (ft_section == section)
1255 ft_idx = first_thunk - adj;
1259 ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1260 ft_data = (bfd_byte *) bfd_malloc (datasize);
1261 if (ft_data == NULL)
1264 /* Read datasize bfd_bytes starting at offset ft_idx. */
1265 if (! bfd_get_section_contents (abfd, ft_section,
1279 /* Print HintName vector entries. */
1280 for (j = 0; j < datasize; j += 4)
1282 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1284 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1288 if (member & 0x80000000)
1289 fprintf (file, "\t%04lx\t %4lu <none>",
1290 member, member & 0x7fffffff);
1296 ordinal = bfd_get_16 (abfd, data + member - adj);
1297 member_name = (char *) data + member - adj + 2;
1298 fprintf (file, "\t%04lx\t %4d %s",
1299 member, ordinal, member_name);
1302 /* If the time stamp is not zero, the import address
1303 table holds actual addresses. */
1306 && first_thunk != hint_addr)
1307 fprintf (file, "\t%04lx",
1308 (long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1310 fprintf (file, "\n");
1317 fprintf (file, "\n");
1326 pe_print_edata (abfd, vfile)
1330 FILE *file = (FILE *) vfile;
1333 bfd_size_type datasize = 0;
1334 bfd_size_type dataoff;
1339 long export_flags; /* reserved - should be zero */
1343 bfd_vma name; /* rva - relative to image base */
1344 long base; /* ordinal base */
1345 unsigned long num_functions;/* Number in the export address table */
1346 unsigned long num_names; /* Number in the name pointer table */
1347 bfd_vma eat_addr; /* rva to the export address table */
1348 bfd_vma npt_addr; /* rva to the Export Name Pointer Table */
1349 bfd_vma ot_addr; /* rva to the Ordinal Table */
1352 pe_data_type *pe = pe_data (abfd);
1353 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1357 addr = extra->DataDirectory[0].VirtualAddress;
1359 if (addr == 0 && extra->DataDirectory[0].Size == 0)
1361 /* Maybe the extra header isn't there. Look for the section. */
1362 section = bfd_get_section_by_name (abfd, ".edata");
1363 if (section == NULL)
1366 addr = section->vma;
1367 datasize = bfd_section_size (abfd, section);
1373 addr += extra->ImageBase;
1375 for (section = abfd->sections; section != NULL; section = section->next)
1377 datasize = bfd_section_size (abfd, section);
1379 if (addr >= section->vma && addr < section->vma + datasize)
1383 if (section == NULL)
1386 _("\nThere is an export table, but the section containing it could not be found\n"));
1391 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1392 section->name, (unsigned long) addr);
1394 dataoff = addr - section->vma;
1395 datasize -= dataoff;
1397 data = (bfd_byte *) bfd_malloc (datasize);
1401 if (! bfd_get_section_contents (abfd, section, (PTR) data,
1402 (file_ptr) dataoff, datasize))
1405 /* Go get Export Directory Table. */
1406 edt.export_flags = bfd_get_32 (abfd, data + 0);
1407 edt.time_stamp = bfd_get_32 (abfd, data + 4);
1408 edt.major_ver = bfd_get_16 (abfd, data + 8);
1409 edt.minor_ver = bfd_get_16 (abfd, data + 10);
1410 edt.name = bfd_get_32 (abfd, data + 12);
1411 edt.base = bfd_get_32 (abfd, data + 16);
1412 edt.num_functions = bfd_get_32 (abfd, data + 20);
1413 edt.num_names = bfd_get_32 (abfd, data + 24);
1414 edt.eat_addr = bfd_get_32 (abfd, data + 28);
1415 edt.npt_addr = bfd_get_32 (abfd, data + 32);
1416 edt.ot_addr = bfd_get_32 (abfd, data + 36);
1418 adj = section->vma - extra->ImageBase + dataoff;
1420 /* Dump the EDT first. */
1422 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1426 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1429 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1432 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1435 _("Name \t\t\t\t"));
1436 fprintf_vma (file, edt.name);
1438 " %s\n", data + edt.name - adj);
1441 _("Ordinal Base \t\t\t%ld\n"), edt.base);
1447 _("\tExport Address Table \t\t%08lx\n"),
1451 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1454 _("Table Addresses\n"));
1457 _("\tExport Address Table \t\t"));
1458 fprintf_vma (file, edt.eat_addr);
1459 fprintf (file, "\n");
1462 _("\tName Pointer Table \t\t"));
1463 fprintf_vma (file, edt.npt_addr);
1464 fprintf (file, "\n");
1467 _("\tOrdinal Table \t\t\t"));
1468 fprintf_vma (file, edt.ot_addr);
1469 fprintf (file, "\n");
1471 /* The next table to find is the Export Address Table. It's basically
1472 a list of pointers that either locate a function in this dll, or
1473 forward the call to another dll. Something like:
1478 } export_address_table_entry;
1482 _("\nExport Address Table -- Ordinal Base %ld\n"),
1485 for (i = 0; i < edt.num_functions; ++i)
1487 bfd_vma eat_member = bfd_get_32 (abfd,
1488 data + edt.eat_addr + (i * 4) - adj);
1489 if (eat_member == 0)
1492 if (eat_member - adj <= datasize)
1494 /* This rva is to a name (forwarding function) in our section. */
1495 /* Should locate a function descriptor. */
1497 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1499 (long) (i + edt.base),
1500 (unsigned long) eat_member,
1502 data + eat_member - adj);
1506 /* Should locate a function descriptor in the reldata section. */
1508 "\t[%4ld] +base[%4ld] %04lx %s\n",
1510 (long) (i + edt.base),
1511 (unsigned long) eat_member,
1516 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1517 /* Dump them in parallel for clarity. */
1519 _("\n[Ordinal/Name Pointer] Table\n"));
1521 for (i = 0; i < edt.num_names; ++i)
1523 bfd_vma name_ptr = bfd_get_32 (abfd,
1528 char *name = (char *) data + name_ptr - adj;
1530 bfd_vma ord = bfd_get_16 (abfd,
1535 "\t[%4ld] %s\n", (long) ord, name);
1543 /* This really is architecture dependent. On IA-64, a .pdata entry
1544 consists of three dwords containing relative virtual addresses that
1545 specify the start and end address of the code range the entry
1546 covers and the address of the corresponding unwind info data. */
1549 pe_print_pdata (abfd, vfile)
1553 #ifdef COFF_WITH_pep
1554 # define PDATA_ROW_SIZE (3*8)
1556 # define PDATA_ROW_SIZE (5*4)
1558 FILE *file = (FILE *) vfile;
1560 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1561 bfd_size_type datasize = 0;
1563 bfd_size_type start, stop;
1564 int onaline = PDATA_ROW_SIZE;
1567 || coff_section_data (abfd, section) == NULL
1568 || pei_section_data (abfd, section) == NULL)
1571 stop = pei_section_data (abfd, section)->virt_size;
1572 if ((stop % onaline) != 0)
1574 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1575 (long) stop, onaline);
1578 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1579 #ifdef COFF_WITH_pep
1581 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1584 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1585 \t\tAddress Address Handler Data Address Mask\n"));
1588 datasize = bfd_section_size (abfd, section);
1592 data = (bfd_byte *) bfd_malloc (datasize);
1593 if (data == NULL && datasize != 0)
1596 bfd_get_section_contents (abfd, section, (PTR) data, (bfd_vma) 0,
1601 for (i = start; i < stop; i += onaline)
1607 bfd_vma prolog_end_addr;
1610 if (i + PDATA_ROW_SIZE > stop)
1613 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
1614 end_addr = GET_PDATA_ENTRY (abfd, data + i + 4);
1615 eh_handler = GET_PDATA_ENTRY (abfd, data + i + 8);
1616 eh_data = GET_PDATA_ENTRY (abfd, data + i + 12);
1617 prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1619 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1620 && eh_data == 0 && prolog_end_addr == 0)
1621 /* We are probably into the padding of the section now. */
1624 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1625 eh_handler &= ~(bfd_vma) 0x3;
1626 prolog_end_addr &= ~(bfd_vma) 0x3;
1629 fprintf_vma (file, i + section->vma); fputc ('\t', file);
1630 fprintf_vma (file, begin_addr); fputc (' ', file);
1631 fprintf_vma (file, end_addr); fputc (' ', file);
1632 fprintf_vma (file, eh_handler);
1633 #ifndef COFF_WITH_pep
1635 fprintf_vma (file, eh_data); fputc (' ', file);
1636 fprintf_vma (file, prolog_end_addr);
1637 fprintf (file, " %x", em_data);
1640 #ifdef POWERPC_LE_PE
1641 if (eh_handler == 0 && eh_data != 0)
1643 /* Special bits here, although the meaning may be a little
1644 mysterious. The only one I know for sure is 0x03. */
1645 /* Code Significance */
1647 /* 0x01 Register Save Millicode */
1648 /* 0x02 Register Restore Millicode */
1649 /* 0x03 Glue Code Sequence */
1653 fprintf (file, _(" Register save millicode"));
1656 fprintf (file, _(" Register restore millicode"));
1659 fprintf (file, _(" Glue code sequence"));
1666 fprintf (file, "\n");
1674 #define IMAGE_REL_BASED_HIGHADJ 4
1675 static const char * const tbl[] =
1689 "UNKNOWN", /* MUST be last */
1693 pe_print_reloc (abfd, vfile)
1697 FILE *file = (FILE *) vfile;
1699 asection *section = bfd_get_section_by_name (abfd, ".reloc");
1700 bfd_size_type datasize;
1702 bfd_size_type start, stop;
1704 if (section == NULL)
1707 if (bfd_section_size (abfd, section) == 0)
1711 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
1713 datasize = bfd_section_size (abfd, section);
1714 data = (bfd_byte *) bfd_malloc (datasize);
1715 if (data == NULL && datasize != 0)
1718 bfd_get_section_contents (abfd, section, (PTR) data, (bfd_vma) 0,
1723 stop = bfd_section_size (abfd, section);
1725 for (i = start; i < stop;)
1728 bfd_vma virtual_address;
1731 /* The .reloc section is a sequence of blocks, with a header consisting
1732 of two 32 bit quantities, followed by a number of 16 bit entries. */
1733 virtual_address = bfd_get_32 (abfd, data+i);
1734 size = bfd_get_32 (abfd, data+i+4);
1735 number = (size - 8) / 2;
1741 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
1742 (unsigned long) virtual_address, size, size, number);
1744 for (j = 0; j < number; ++j)
1746 unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
1747 unsigned int t = (e & 0xF000) >> 12;
1748 int off = e & 0x0FFF;
1750 if (t >= sizeof (tbl) / sizeof (tbl[0]))
1751 t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
1754 _("\treloc %4d offset %4x [%4lx] %s"),
1755 j, off, (long) (off + virtual_address), tbl[t]);
1757 /* HIGHADJ takes an argument, - the next record *is* the
1758 low 16 bits of addend. */
1759 if (t == IMAGE_REL_BASED_HIGHADJ)
1761 fprintf (file, " (%4x)",
1763 bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
1767 fprintf (file, "\n");
1778 /* Print out the program headers. */
1781 _bfd_XX_print_private_bfd_data_common (abfd, vfile)
1785 FILE *file = (FILE *) vfile;
1787 pe_data_type *pe = pe_data (abfd);
1788 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
1789 const char *subsystem_name = NULL;
1791 /* The MS dumpbin program reportedly ands with 0xff0f before
1792 printing the characteristics field. Not sure why. No reason to
1794 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
1796 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
1797 PF (F_RELFLG, "relocations stripped");
1798 PF (F_EXEC, "executable");
1799 PF (F_LNNO, "line numbers stripped");
1800 PF (F_LSYMS, "symbols stripped");
1801 PF (0x80, "little endian");
1802 PF (F_AR32WR, "32 bit words");
1803 PF (0x200, "debugging information removed");
1804 PF (0x1000, "system file");
1806 PF (0x8000, "big endian");
1809 /* ctime implies '\n'. */
1811 time_t t = pe->coff.timestamp;
1812 fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
1814 fprintf (file, "\nImageBase\t\t");
1815 fprintf_vma (file, i->ImageBase);
1816 fprintf (file, "\nSectionAlignment\t");
1817 fprintf_vma (file, i->SectionAlignment);
1818 fprintf (file, "\nFileAlignment\t\t");
1819 fprintf_vma (file, i->FileAlignment);
1820 fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
1821 fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
1822 fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
1823 fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
1824 fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
1825 fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
1826 fprintf (file, "Win32Version\t\t%08lx\n", i->Reserved1);
1827 fprintf (file, "SizeOfImage\t\t%08lx\n", i->SizeOfImage);
1828 fprintf (file, "SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders);
1829 fprintf (file, "CheckSum\t\t%08lx\n", i->CheckSum);
1831 switch (i->Subsystem)
1833 case IMAGE_SUBSYSTEM_UNKNOWN:
1834 subsystem_name = "unspecified";
1836 case IMAGE_SUBSYSTEM_NATIVE:
1837 subsystem_name = "NT native";
1839 case IMAGE_SUBSYSTEM_WINDOWS_GUI:
1840 subsystem_name = "Windows GUI";
1842 case IMAGE_SUBSYSTEM_WINDOWS_CUI:
1843 subsystem_name = "Windows CUI";
1845 case IMAGE_SUBSYSTEM_POSIX_CUI:
1846 subsystem_name = "POSIX CUI";
1848 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
1849 subsystem_name = "Wince CUI";
1851 case IMAGE_SUBSYSTEM_EFI_APPLICATION:
1852 subsystem_name = "EFI application";
1854 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
1855 subsystem_name = "EFI boot service driver";
1857 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
1858 subsystem_name = "EFI runtime driver";
1862 fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
1864 fprintf (file, "\t(%s)", subsystem_name);
1865 fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
1866 fprintf (file, "SizeOfStackReserve\t");
1867 fprintf_vma (file, i->SizeOfStackReserve);
1868 fprintf (file, "\nSizeOfStackCommit\t");
1869 fprintf_vma (file, i->SizeOfStackCommit);
1870 fprintf (file, "\nSizeOfHeapReserve\t");
1871 fprintf_vma (file, i->SizeOfHeapReserve);
1872 fprintf (file, "\nSizeOfHeapCommit\t");
1873 fprintf_vma (file, i->SizeOfHeapCommit);
1874 fprintf (file, "\nLoaderFlags\t\t%08lx\n", i->LoaderFlags);
1875 fprintf (file, "NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes);
1877 fprintf (file, "\nThe Data Directory\n");
1878 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
1880 fprintf (file, "Entry %1x ", j);
1881 fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
1882 fprintf (file, " %08lx ", i->DataDirectory[j].Size);
1883 fprintf (file, "%s\n", dir_names[j]);
1886 pe_print_idata (abfd, vfile);
1887 pe_print_edata (abfd, vfile);
1888 pe_print_pdata (abfd, vfile);
1889 pe_print_reloc (abfd, vfile);
1894 /* Copy any private info we understand from the input bfd
1895 to the output bfd. */
1898 _bfd_XX_bfd_copy_private_bfd_data_common (ibfd, obfd)
1901 /* One day we may try to grok other private data. */
1902 if (ibfd->xvec->flavour != bfd_target_coff_flavour
1903 || obfd->xvec->flavour != bfd_target_coff_flavour)
1906 pe_data (obfd)->pe_opthdr = pe_data (ibfd)->pe_opthdr;
1907 pe_data (obfd)->dll = pe_data (ibfd)->dll;
1909 /* For strip: if we removed .reloc, we'll make a real mess of things
1910 if we don't remove this entry as well. */
1911 if (! pe_data (obfd)->has_reloc_section)
1913 pe_data (obfd)->pe_opthdr.DataDirectory[5].VirtualAddress = 0;
1914 pe_data (obfd)->pe_opthdr.DataDirectory[5].Size = 0;
1919 /* Copy private section data. */
1922 _bfd_XX_bfd_copy_private_section_data (ibfd, isec, obfd, osec)
1928 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
1929 || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
1932 if (coff_section_data (ibfd, isec) != NULL
1933 && pei_section_data (ibfd, isec) != NULL)
1935 if (coff_section_data (obfd, osec) == NULL)
1937 bfd_size_type amt = sizeof (struct coff_section_tdata);
1938 osec->used_by_bfd = (PTR) bfd_zalloc (obfd, amt);
1939 if (osec->used_by_bfd == NULL)
1943 if (pei_section_data (obfd, osec) == NULL)
1945 bfd_size_type amt = sizeof (struct pei_section_tdata);
1946 coff_section_data (obfd, osec)->tdata = (PTR) bfd_zalloc (obfd, amt);
1947 if (coff_section_data (obfd, osec)->tdata == NULL)
1951 pei_section_data (obfd, osec)->virt_size =
1952 pei_section_data (ibfd, isec)->virt_size;
1953 pei_section_data (obfd, osec)->pe_flags =
1954 pei_section_data (ibfd, isec)->pe_flags;
1961 _bfd_XX_get_symbol_info (abfd, symbol, ret)
1966 coff_get_symbol_info (abfd, symbol, ret);
1967 #if 0 /* This code no longer appears to be necessary.
1968 ImageBase has already been added in by coff_swap_scnhdr_in. */
1969 if (pe_data (abfd) != NULL
1970 && ((symbol->flags & BSF_DEBUGGING) == 0
1971 || (symbol->flags & BSF_DEBUGGING_RELOC) != 0)
1972 && ! bfd_is_abs_section (symbol->section))
1973 ret->value += pe_data (abfd)->pe_opthdr.ImageBase;
1977 /* Handle the .idata section and other things that need symbol table
1981 _bfd_XXi_final_link_postscript (abfd, pfinfo)
1983 struct coff_final_link_info *pfinfo;
1985 struct coff_link_hash_entry *h1;
1986 struct bfd_link_info *info = pfinfo->info;
1988 /* There are a few fields that need to be filled in now while we
1989 have symbol table access.
1991 The .idata subsections aren't directly available as sections, but
1992 they are in the symbol table, so get them from there. */
1994 /* The import directory. This is the address of .idata$2, with size
1995 of .idata$2 + .idata$3. */
1996 h1 = coff_link_hash_lookup (coff_hash_table (info),
1997 ".idata$2", FALSE, FALSE, TRUE);
2000 pe_data (abfd)->pe_opthdr.DataDirectory[1].VirtualAddress =
2001 (h1->root.u.def.value
2002 + h1->root.u.def.section->output_section->vma
2003 + h1->root.u.def.section->output_offset);
2004 h1 = coff_link_hash_lookup (coff_hash_table (info),
2005 ".idata$4", FALSE, FALSE, TRUE);
2006 pe_data (abfd)->pe_opthdr.DataDirectory[1].Size =
2007 ((h1->root.u.def.value
2008 + h1->root.u.def.section->output_section->vma
2009 + h1->root.u.def.section->output_offset)
2010 - pe_data (abfd)->pe_opthdr.DataDirectory[1].VirtualAddress);
2012 /* The import address table. This is the size/address of
2014 h1 = coff_link_hash_lookup (coff_hash_table (info),
2015 ".idata$5", FALSE, FALSE, TRUE);
2016 pe_data (abfd)->pe_opthdr.DataDirectory[12].VirtualAddress =
2017 (h1->root.u.def.value
2018 + h1->root.u.def.section->output_section->vma
2019 + h1->root.u.def.section->output_offset);
2020 h1 = coff_link_hash_lookup (coff_hash_table (info),
2021 ".idata$6", FALSE, FALSE, TRUE);
2022 pe_data (abfd)->pe_opthdr.DataDirectory[12].Size =
2023 ((h1->root.u.def.value
2024 + h1->root.u.def.section->output_section->vma
2025 + h1->root.u.def.section->output_offset)
2026 - pe_data (abfd)->pe_opthdr.DataDirectory[12].VirtualAddress);
2029 /* If we couldn't find idata$2, we either have an excessively
2030 trivial program or are in DEEP trouble; we have to assume trivial