1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright 1995, 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
3 Written by Cygnus Solutions.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 Most of this hacked by Steve Chamberlain,
25 PE/PEI rearrangement (and code added): Donn Terry
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.
61 #include "coff/internal.h"
63 /* NOTE: it's strange to be including an architecture specific header
64 in what's supposed to be general (to PE/PEI) code. However, that's
65 where the definitions are, and they don't vary per architecture
66 within PE/PEI, so we get them from there. FIXME: The lack of
67 variance is an assumption which may prove to be incorrect if new
68 PE/PEI targets are created. */
69 #include "coff/i386.h"
75 /* FIXME: This file has various tests of POWERPC_LE_PE. Those tests
76 worked when the code was in peicode.h, but no longer work now that
77 the code is in peigen.c. PowerPC NT is said to be dead. If
78 anybody wants to revive the code, you will have to figure out how
79 to handle those issues. */
81 static void add_data_entry
82 PARAMS ((bfd *, struct internal_extra_pe_aouthdr *, int, char *, bfd_vma));
83 static boolean pe_print_pdata PARAMS ((bfd *, PTR));
84 static boolean pe_print_reloc PARAMS ((bfd *, PTR));
86 /**********************************************************************/
89 _bfd_pei_swap_sym_in (abfd, ext1, in1)
94 SYMENT *ext = (SYMENT *)ext1;
95 struct internal_syment *in = (struct internal_syment *)in1;
97 if( ext->e.e_name[0] == 0) {
98 in->_n._n_n._n_zeroes = 0;
99 in->_n._n_n._n_offset = bfd_h_get_32(abfd, (bfd_byte *) ext->e.e.e_offset);
102 memcpy(in->_n._n_name, ext->e.e_name, SYMNMLEN);
105 in->n_value = bfd_h_get_32(abfd, (bfd_byte *) ext->e_value);
106 in->n_scnum = bfd_h_get_16(abfd, (bfd_byte *) ext->e_scnum);
107 if (sizeof(ext->e_type) == 2){
108 in->n_type = bfd_h_get_16(abfd, (bfd_byte *) ext->e_type);
111 in->n_type = bfd_h_get_32(abfd, (bfd_byte *) ext->e_type);
113 in->n_sclass = bfd_h_get_8(abfd, ext->e_sclass);
114 in->n_numaux = bfd_h_get_8(abfd, ext->e_numaux);
116 #ifndef STRICT_PE_FORMAT
117 /* This is for Gnu-created DLLs */
119 /* The section symbols for the .idata$ sections have class 0x68
120 (C_SECTION), which MS documentation indicates is a section
121 symbol. Unfortunately, the value field in the symbol is simply a
122 copy of the .idata section's flags rather than something useful.
123 When these symbols are encountered, change the value to 0 so that
124 they will be handled somewhat correctly in the bfd code. */
125 if (in->n_sclass == C_SECTION)
130 /* FIXME: This is clearly wrong. The problem seems to be that
131 undefined C_SECTION symbols appear in the first object of a
132 MS generated .lib file, and the symbols are not defined
136 /* I have tried setting the class to 3 and using the following
137 to set the section number. This will put the address of the
138 pointer to the string kernel32.dll at addresses 0 and 0x10
139 off start of idata section which is not correct */
140 /* if (strcmp (in->_n._n_name, ".idata$4") == 0) */
141 /* in->n_scnum = 3; */
143 /* in->n_scnum = 2; */
145 /* Create synthetic empty sections as needed. DJ */
146 if (in->n_scnum == 0)
149 for (sec=abfd->sections; sec; sec=sec->next)
151 if (strcmp (sec->name, in->n_name) == 0)
153 in->n_scnum = sec->target_index;
158 if (in->n_scnum == 0)
160 int unused_section_number = 0;
163 for (sec=abfd->sections; sec; sec=sec->next)
164 if (unused_section_number <= sec->target_index)
165 unused_section_number = sec->target_index+1;
167 name = bfd_alloc (abfd, strlen (in->n_name) + 10);
170 strcpy (name, in->n_name);
171 sec = bfd_make_section_anyway (abfd, name);
175 sec->_cooked_size = 0;
178 sec->rel_filepos = 0;
179 sec->reloc_count = 0;
180 sec->line_filepos = 0;
181 sec->lineno_count = 0;
182 sec->userdata = NULL;
183 sec->next = (asection *) NULL;
185 sec->alignment_power = 2;
186 sec->flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
188 sec->target_index = unused_section_number;
190 in->n_scnum = unused_section_number;
192 in->n_sclass = C_STAT;
197 #ifdef coff_swap_sym_in_hook
198 /* This won't work in peigen.c, but since it's for PPC PE, it's not
200 coff_swap_sym_in_hook(abfd, ext1, in1);
205 _bfd_pei_swap_sym_out (abfd, inp, extp)
210 struct internal_syment *in = (struct internal_syment *)inp;
211 SYMENT *ext =(SYMENT *)extp;
212 if(in->_n._n_name[0] == 0) {
213 bfd_h_put_32(abfd, 0, (bfd_byte *) ext->e.e.e_zeroes);
214 bfd_h_put_32(abfd, in->_n._n_n._n_offset, (bfd_byte *) ext->e.e.e_offset);
217 memcpy(ext->e.e_name, in->_n._n_name, SYMNMLEN);
220 bfd_h_put_32(abfd, in->n_value , (bfd_byte *) ext->e_value);
221 bfd_h_put_16(abfd, in->n_scnum , (bfd_byte *) ext->e_scnum);
222 if (sizeof(ext->e_type) == 2)
224 bfd_h_put_16(abfd, in->n_type , (bfd_byte *) ext->e_type);
228 bfd_h_put_32(abfd, in->n_type , (bfd_byte *) ext->e_type);
230 bfd_h_put_8(abfd, in->n_sclass , ext->e_sclass);
231 bfd_h_put_8(abfd, in->n_numaux , ext->e_numaux);
237 _bfd_pei_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
242 int indx ATTRIBUTE_UNUSED;
243 int numaux ATTRIBUTE_UNUSED;
246 AUXENT *ext = (AUXENT *)ext1;
247 union internal_auxent *in = (union internal_auxent *)in1;
251 if (ext->x_file.x_fname[0] == 0) {
252 in->x_file.x_n.x_zeroes = 0;
253 in->x_file.x_n.x_offset =
254 bfd_h_get_32(abfd, (bfd_byte *) ext->x_file.x_n.x_offset);
256 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
264 if (type == T_NULL) {
265 in->x_scn.x_scnlen = GET_SCN_SCNLEN(abfd, ext);
266 in->x_scn.x_nreloc = GET_SCN_NRELOC(abfd, ext);
267 in->x_scn.x_nlinno = GET_SCN_NLINNO(abfd, ext);
268 in->x_scn.x_checksum = bfd_h_get_32 (abfd,
269 (bfd_byte *) ext->x_scn.x_checksum);
270 in->x_scn.x_associated =
271 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_scn.x_associated);
272 in->x_scn.x_comdat = bfd_h_get_8 (abfd,
273 (bfd_byte *) ext->x_scn.x_comdat);
279 in->x_sym.x_tagndx.l = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_tagndx);
280 in->x_sym.x_tvndx = bfd_h_get_16(abfd, (bfd_byte *) ext->x_sym.x_tvndx);
282 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
284 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
285 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
289 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
290 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
291 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
292 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
293 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
294 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
295 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
296 bfd_h_get_16 (abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
300 in->x_sym.x_misc.x_fsize = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_misc.x_fsize);
303 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO(abfd, ext);
304 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE(abfd, ext);
309 _bfd_pei_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
314 int indx ATTRIBUTE_UNUSED;
315 int numaux ATTRIBUTE_UNUSED;
318 union internal_auxent *in = (union internal_auxent *)inp;
319 AUXENT *ext = (AUXENT *)extp;
321 memset((PTR)ext, 0, AUXESZ);
324 if (in->x_file.x_fname[0] == 0) {
325 bfd_h_put_32(abfd, 0, (bfd_byte *) ext->x_file.x_n.x_zeroes);
327 in->x_file.x_n.x_offset,
328 (bfd_byte *) ext->x_file.x_n.x_offset);
331 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
339 if (type == T_NULL) {
340 PUT_SCN_SCNLEN(abfd, in->x_scn.x_scnlen, ext);
341 PUT_SCN_NRELOC(abfd, in->x_scn.x_nreloc, ext);
342 PUT_SCN_NLINNO(abfd, in->x_scn.x_nlinno, ext);
343 bfd_h_put_32 (abfd, in->x_scn.x_checksum,
344 (bfd_byte *) ext->x_scn.x_checksum);
345 bfd_h_put_16 (abfd, in->x_scn.x_associated,
346 (bfd_byte *) ext->x_scn.x_associated);
347 bfd_h_put_8 (abfd, in->x_scn.x_comdat,
348 (bfd_byte *) ext->x_scn.x_comdat);
354 bfd_h_put_32(abfd, in->x_sym.x_tagndx.l, (bfd_byte *) ext->x_sym.x_tagndx);
355 bfd_h_put_16(abfd, in->x_sym.x_tvndx , (bfd_byte *) ext->x_sym.x_tvndx);
357 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
359 PUT_FCN_LNNOPTR(abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
360 PUT_FCN_ENDNDX(abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
364 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
365 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
366 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
367 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
368 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
369 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
370 bfd_h_put_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
371 (bfd_byte *) ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
375 bfd_h_put_32 (abfd, in->x_sym.x_misc.x_fsize,
376 (bfd_byte *) ext->x_sym.x_misc.x_fsize);
379 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
380 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
387 _bfd_pei_swap_lineno_in (abfd, ext1, in1)
392 LINENO *ext = (LINENO *)ext1;
393 struct internal_lineno *in = (struct internal_lineno *)in1;
395 in->l_addr.l_symndx = bfd_h_get_32(abfd, (bfd_byte *) ext->l_addr.l_symndx);
396 in->l_lnno = GET_LINENO_LNNO(abfd, ext);
400 _bfd_pei_swap_lineno_out (abfd, inp, outp)
405 struct internal_lineno *in = (struct internal_lineno *)inp;
406 struct external_lineno *ext = (struct external_lineno *)outp;
407 bfd_h_put_32(abfd, in->l_addr.l_symndx, (bfd_byte *)
408 ext->l_addr.l_symndx);
410 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
415 _bfd_pei_swap_aouthdr_in (abfd, aouthdr_ext1, aouthdr_int1)
420 struct internal_extra_pe_aouthdr *a;
421 PEAOUTHDR *src = (PEAOUTHDR *)(aouthdr_ext1);
422 AOUTHDR *aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
423 struct internal_aouthdr *aouthdr_int = (struct internal_aouthdr *)aouthdr_int1;
425 aouthdr_int->magic = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->magic);
426 aouthdr_int->vstamp = bfd_h_get_16(abfd, (bfd_byte *) aouthdr_ext->vstamp);
428 GET_AOUTHDR_TSIZE (abfd, (bfd_byte *) aouthdr_ext->tsize);
430 GET_AOUTHDR_DSIZE (abfd, (bfd_byte *) aouthdr_ext->dsize);
432 GET_AOUTHDR_BSIZE (abfd, (bfd_byte *) aouthdr_ext->bsize);
434 GET_AOUTHDR_ENTRY (abfd, (bfd_byte *) aouthdr_ext->entry);
435 aouthdr_int->text_start =
436 GET_AOUTHDR_TEXT_START (abfd, (bfd_byte *) aouthdr_ext->text_start);
437 aouthdr_int->data_start =
438 GET_AOUTHDR_DATA_START (abfd, (bfd_byte *) aouthdr_ext->data_start);
440 a = &aouthdr_int->pe;
441 a->ImageBase = bfd_h_get_32 (abfd, (bfd_byte *)src->ImageBase);
442 a->SectionAlignment = bfd_h_get_32 (abfd, (bfd_byte *)src->SectionAlignment);
443 a->FileAlignment = bfd_h_get_32 (abfd, (bfd_byte *)src->FileAlignment);
444 a->MajorOperatingSystemVersion =
445 bfd_h_get_16 (abfd, (bfd_byte *)src->MajorOperatingSystemVersion);
446 a->MinorOperatingSystemVersion =
447 bfd_h_get_16 (abfd, (bfd_byte *)src->MinorOperatingSystemVersion);
448 a->MajorImageVersion = bfd_h_get_16 (abfd, (bfd_byte *)src->MajorImageVersion);
449 a->MinorImageVersion = bfd_h_get_16 (abfd, (bfd_byte *)src->MinorImageVersion);
450 a->MajorSubsystemVersion = bfd_h_get_16 (abfd, (bfd_byte *)src->MajorSubsystemVersion);
451 a->MinorSubsystemVersion = bfd_h_get_16 (abfd, (bfd_byte *)src->MinorSubsystemVersion);
452 a->Reserved1 = bfd_h_get_32 (abfd, (bfd_byte *)src->Reserved1);
453 a->SizeOfImage = bfd_h_get_32 (abfd, (bfd_byte *)src->SizeOfImage);
454 a->SizeOfHeaders = bfd_h_get_32 (abfd, (bfd_byte *)src->SizeOfHeaders);
455 a->CheckSum = bfd_h_get_32 (abfd, (bfd_byte *)src->CheckSum);
456 a->Subsystem = bfd_h_get_16 (abfd, (bfd_byte *)src->Subsystem);
457 a->DllCharacteristics = bfd_h_get_16 (abfd, (bfd_byte *)src->DllCharacteristics);
458 a->SizeOfStackReserve = bfd_h_get_32 (abfd, (bfd_byte *)src->SizeOfStackReserve);
459 a->SizeOfStackCommit = bfd_h_get_32 (abfd, (bfd_byte *)src->SizeOfStackCommit);
460 a->SizeOfHeapReserve = bfd_h_get_32 (abfd, (bfd_byte *)src->SizeOfHeapReserve);
461 a->SizeOfHeapCommit = bfd_h_get_32 (abfd, (bfd_byte *)src->SizeOfHeapCommit);
462 a->LoaderFlags = bfd_h_get_32 (abfd, (bfd_byte *)src->LoaderFlags);
463 a->NumberOfRvaAndSizes = bfd_h_get_32 (abfd, (bfd_byte *)src->NumberOfRvaAndSizes);
467 for (idx=0; idx < 16; idx++)
469 a->DataDirectory[idx].VirtualAddress =
470 bfd_h_get_32 (abfd, (bfd_byte *)src->DataDirectory[idx][0]);
471 a->DataDirectory[idx].Size =
472 bfd_h_get_32 (abfd, (bfd_byte *)src->DataDirectory[idx][1]);
476 if (aouthdr_int->entry)
478 aouthdr_int->entry += a->ImageBase;
479 aouthdr_int->entry &= 0xffffffff;
481 if (aouthdr_int->tsize)
483 aouthdr_int->text_start += a->ImageBase;
484 aouthdr_int->text_start &= 0xffffffff;
486 if (aouthdr_int->dsize)
488 aouthdr_int->data_start += a->ImageBase;
489 aouthdr_int->data_start &= 0xffffffff;
493 /* These three fields are normally set up by ppc_relocate_section.
494 In the case of reading a file in, we can pick them up from the
496 first_thunk_address = a->DataDirectory[12].VirtualAddress ;
497 thunk_size = a->DataDirectory[12].Size;
498 import_table_size = a->DataDirectory[1].Size;
503 /* A support function for below. */
506 add_data_entry (abfd, aout, idx, name, base)
508 struct internal_extra_pe_aouthdr *aout;
513 asection *sec = bfd_get_section_by_name (abfd, name);
515 /* add import directory information if it exists */
517 && (coff_section_data (abfd, sec) != NULL)
518 && (pei_section_data (abfd, sec) != NULL))
520 aout->DataDirectory[idx].VirtualAddress = (sec->vma - base) & 0xffffffff;
521 aout->DataDirectory[idx].Size = pei_section_data (abfd, sec)->virt_size;
522 sec->flags |= SEC_DATA;
527 _bfd_pei_swap_aouthdr_out (abfd, in, out)
532 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *)in;
533 struct internal_extra_pe_aouthdr *extra = &pe_data (abfd)->pe_opthdr;
534 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *)out;
536 bfd_vma sa = extra->SectionAlignment;
537 bfd_vma fa = extra->FileAlignment;
538 bfd_vma ib = extra->ImageBase ;
540 if (aouthdr_in->tsize)
542 aouthdr_in->text_start -= ib;
543 aouthdr_in->text_start &= 0xffffffff;
545 if (aouthdr_in->dsize)
547 aouthdr_in->data_start -= ib;
548 aouthdr_in->data_start &= 0xffffffff;
550 if (aouthdr_in->entry)
552 aouthdr_in->entry -= ib;
553 aouthdr_in->entry &= 0xffffffff;
556 #define FA(x) (((x) + fa -1 ) & (- fa))
557 #define SA(x) (((x) + sa -1 ) & (- sa))
559 /* We like to have the sizes aligned */
561 aouthdr_in->bsize = FA (aouthdr_in->bsize);
564 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
566 /* first null out all data directory entries .. */
567 memset (extra->DataDirectory, sizeof (extra->DataDirectory), 0);
569 add_data_entry (abfd, extra, 0, ".edata", ib);
570 add_data_entry (abfd, extra, 1, ".idata", ib);
571 add_data_entry (abfd, extra, 2, ".rsrc" ,ib);
574 /* FIXME: do other PE platforms use this? */
575 add_data_entry (abfd, extra, 3, ".pdata" ,ib);
578 add_data_entry (abfd, extra, 5, ".reloc", ib);
581 /* On the PPC NT system, this field is set up as follows. It is not
582 an "officially" reserved field, so it currently has no title.
583 first_thunk_address is idata$5, and the thunk_size is the size of
584 the idata$5 chunk of the idata section. */
585 extra->DataDirectory[12].VirtualAddress = first_thunk_address;
586 extra->DataDirectory[12].Size = thunk_size;
588 /* On the PPC NT system, the size of the directory entry is not the
589 size of the entire section. It's actually offset to the end of
590 the idata$3 component of the idata section. This is the size of
591 the entire import table. (also known as the start of idata$4). */
592 extra->DataDirectory[1].Size = import_table_size;
598 bfd_vma isize = SA(abfd->sections->filepos);
601 for (sec = abfd->sections; sec; sec = sec->next)
603 int rounded = FA(sec->_raw_size);
605 if (sec->flags & SEC_DATA)
607 if (sec->flags & SEC_CODE)
609 /* The image size is the total VIRTUAL size (which is what is
610 in the virt_size field). Files have been seen (from MSVC
611 5.0 link.exe) where the file size of the .data segment is
612 quite small compared to the virtual size. Without this
613 fix, strip munges the file. */
614 isize += SA (FA (pei_section_data (abfd, sec)->virt_size));
617 aouthdr_in->dsize = dsize;
618 aouthdr_in->tsize = tsize;
619 extra->SizeOfImage = isize;
622 extra->SizeOfHeaders = abfd->sections->filepos;
623 bfd_h_put_16(abfd, aouthdr_in->magic, (bfd_byte *) aouthdr_out->standard.magic);
625 #define LINKER_VERSION 256 /* That is, 2.56 */
627 /* This piece of magic sets the "linker version" field to
630 LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256,
631 (bfd_byte *) aouthdr_out->standard.vstamp);
633 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, (bfd_byte *) aouthdr_out->standard.tsize);
634 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, (bfd_byte *) aouthdr_out->standard.dsize);
635 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, (bfd_byte *) aouthdr_out->standard.bsize);
636 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, (bfd_byte *) aouthdr_out->standard.entry);
637 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
638 (bfd_byte *) aouthdr_out->standard.text_start);
640 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
641 (bfd_byte *) aouthdr_out->standard.data_start);
644 bfd_h_put_32 (abfd, extra->ImageBase,
645 (bfd_byte *) aouthdr_out->ImageBase);
646 bfd_h_put_32 (abfd, extra->SectionAlignment,
647 (bfd_byte *) aouthdr_out->SectionAlignment);
648 bfd_h_put_32 (abfd, extra->FileAlignment,
649 (bfd_byte *) aouthdr_out->FileAlignment);
650 bfd_h_put_16 (abfd, extra->MajorOperatingSystemVersion,
651 (bfd_byte *) aouthdr_out->MajorOperatingSystemVersion);
652 bfd_h_put_16 (abfd, extra->MinorOperatingSystemVersion,
653 (bfd_byte *) aouthdr_out->MinorOperatingSystemVersion);
654 bfd_h_put_16 (abfd, extra->MajorImageVersion,
655 (bfd_byte *) aouthdr_out->MajorImageVersion);
656 bfd_h_put_16 (abfd, extra->MinorImageVersion,
657 (bfd_byte *) aouthdr_out->MinorImageVersion);
658 bfd_h_put_16 (abfd, extra->MajorSubsystemVersion,
659 (bfd_byte *) aouthdr_out->MajorSubsystemVersion);
660 bfd_h_put_16 (abfd, extra->MinorSubsystemVersion,
661 (bfd_byte *) aouthdr_out->MinorSubsystemVersion);
662 bfd_h_put_32 (abfd, extra->Reserved1,
663 (bfd_byte *) aouthdr_out->Reserved1);
664 bfd_h_put_32 (abfd, extra->SizeOfImage,
665 (bfd_byte *) aouthdr_out->SizeOfImage);
666 bfd_h_put_32 (abfd, extra->SizeOfHeaders,
667 (bfd_byte *) aouthdr_out->SizeOfHeaders);
668 bfd_h_put_32 (abfd, extra->CheckSum,
669 (bfd_byte *) aouthdr_out->CheckSum);
670 bfd_h_put_16 (abfd, extra->Subsystem,
671 (bfd_byte *) aouthdr_out->Subsystem);
672 bfd_h_put_16 (abfd, extra->DllCharacteristics,
673 (bfd_byte *) aouthdr_out->DllCharacteristics);
674 bfd_h_put_32 (abfd, extra->SizeOfStackReserve,
675 (bfd_byte *) aouthdr_out->SizeOfStackReserve);
676 bfd_h_put_32 (abfd, extra->SizeOfStackCommit,
677 (bfd_byte *) aouthdr_out->SizeOfStackCommit);
678 bfd_h_put_32 (abfd, extra->SizeOfHeapReserve,
679 (bfd_byte *) aouthdr_out->SizeOfHeapReserve);
680 bfd_h_put_32 (abfd, extra->SizeOfHeapCommit,
681 (bfd_byte *) aouthdr_out->SizeOfHeapCommit);
682 bfd_h_put_32 (abfd, extra->LoaderFlags,
683 (bfd_byte *) aouthdr_out->LoaderFlags);
684 bfd_h_put_32 (abfd, extra->NumberOfRvaAndSizes,
685 (bfd_byte *) aouthdr_out->NumberOfRvaAndSizes);
688 for (idx=0; idx < 16; idx++)
690 bfd_h_put_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
691 (bfd_byte *) aouthdr_out->DataDirectory[idx][0]);
692 bfd_h_put_32 (abfd, extra->DataDirectory[idx].Size,
693 (bfd_byte *) aouthdr_out->DataDirectory[idx][1]);
701 _bfd_pei_only_swap_filehdr_out (abfd, in, out)
707 struct internal_filehdr *filehdr_in = (struct internal_filehdr *)in;
708 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *)out;
710 if (pe_data (abfd)->has_reloc_section)
711 filehdr_in->f_flags &= ~F_RELFLG;
713 if (pe_data (abfd)->dll)
714 filehdr_in->f_flags |= F_DLL;
716 filehdr_in->pe.e_magic = DOSMAGIC;
717 filehdr_in->pe.e_cblp = 0x90;
718 filehdr_in->pe.e_cp = 0x3;
719 filehdr_in->pe.e_crlc = 0x0;
720 filehdr_in->pe.e_cparhdr = 0x4;
721 filehdr_in->pe.e_minalloc = 0x0;
722 filehdr_in->pe.e_maxalloc = 0xffff;
723 filehdr_in->pe.e_ss = 0x0;
724 filehdr_in->pe.e_sp = 0xb8;
725 filehdr_in->pe.e_csum = 0x0;
726 filehdr_in->pe.e_ip = 0x0;
727 filehdr_in->pe.e_cs = 0x0;
728 filehdr_in->pe.e_lfarlc = 0x40;
729 filehdr_in->pe.e_ovno = 0x0;
731 for (idx=0; idx < 4; idx++)
732 filehdr_in->pe.e_res[idx] = 0x0;
734 filehdr_in->pe.e_oemid = 0x0;
735 filehdr_in->pe.e_oeminfo = 0x0;
737 for (idx=0; idx < 10; idx++)
738 filehdr_in->pe.e_res2[idx] = 0x0;
740 filehdr_in->pe.e_lfanew = 0x80;
742 /* this next collection of data are mostly just characters. It appears
743 to be constant within the headers put on NT exes */
744 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
745 filehdr_in->pe.dos_message[1] = 0xcd09b400;
746 filehdr_in->pe.dos_message[2] = 0x4c01b821;
747 filehdr_in->pe.dos_message[3] = 0x685421cd;
748 filehdr_in->pe.dos_message[4] = 0x70207369;
749 filehdr_in->pe.dos_message[5] = 0x72676f72;
750 filehdr_in->pe.dos_message[6] = 0x63206d61;
751 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
752 filehdr_in->pe.dos_message[8] = 0x65622074;
753 filehdr_in->pe.dos_message[9] = 0x6e757220;
754 filehdr_in->pe.dos_message[10] = 0x206e6920;
755 filehdr_in->pe.dos_message[11] = 0x20534f44;
756 filehdr_in->pe.dos_message[12] = 0x65646f6d;
757 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
758 filehdr_in->pe.dos_message[14] = 0x24;
759 filehdr_in->pe.dos_message[15] = 0x0;
760 filehdr_in->pe.nt_signature = NT_SIGNATURE;
764 bfd_h_put_16(abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic);
765 bfd_h_put_16(abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns);
767 bfd_h_put_32(abfd, time (0), (bfd_byte *) filehdr_out->f_timdat);
768 PUT_FILEHDR_SYMPTR (abfd, (bfd_vma) filehdr_in->f_symptr,
769 (bfd_byte *) filehdr_out->f_symptr);
770 bfd_h_put_32(abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms);
771 bfd_h_put_16(abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr);
772 bfd_h_put_16(abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags);
774 /* put in extra dos header stuff. This data remains essentially
775 constant, it just has to be tacked on to the beginning of all exes
777 bfd_h_put_16(abfd, filehdr_in->pe.e_magic, (bfd_byte *) filehdr_out->e_magic);
778 bfd_h_put_16(abfd, filehdr_in->pe.e_cblp, (bfd_byte *) filehdr_out->e_cblp);
779 bfd_h_put_16(abfd, filehdr_in->pe.e_cp, (bfd_byte *) filehdr_out->e_cp);
780 bfd_h_put_16(abfd, filehdr_in->pe.e_crlc, (bfd_byte *) filehdr_out->e_crlc);
781 bfd_h_put_16(abfd, filehdr_in->pe.e_cparhdr,
782 (bfd_byte *) filehdr_out->e_cparhdr);
783 bfd_h_put_16(abfd, filehdr_in->pe.e_minalloc,
784 (bfd_byte *) filehdr_out->e_minalloc);
785 bfd_h_put_16(abfd, filehdr_in->pe.e_maxalloc,
786 (bfd_byte *) filehdr_out->e_maxalloc);
787 bfd_h_put_16(abfd, filehdr_in->pe.e_ss, (bfd_byte *) filehdr_out->e_ss);
788 bfd_h_put_16(abfd, filehdr_in->pe.e_sp, (bfd_byte *) filehdr_out->e_sp);
789 bfd_h_put_16(abfd, filehdr_in->pe.e_csum, (bfd_byte *) filehdr_out->e_csum);
790 bfd_h_put_16(abfd, filehdr_in->pe.e_ip, (bfd_byte *) filehdr_out->e_ip);
791 bfd_h_put_16(abfd, filehdr_in->pe.e_cs, (bfd_byte *) filehdr_out->e_cs);
792 bfd_h_put_16(abfd, filehdr_in->pe.e_lfarlc, (bfd_byte *) filehdr_out->e_lfarlc);
793 bfd_h_put_16(abfd, filehdr_in->pe.e_ovno, (bfd_byte *) filehdr_out->e_ovno);
796 for (idx=0; idx < 4; idx++)
797 bfd_h_put_16(abfd, filehdr_in->pe.e_res[idx],
798 (bfd_byte *) filehdr_out->e_res[idx]);
800 bfd_h_put_16(abfd, filehdr_in->pe.e_oemid, (bfd_byte *) filehdr_out->e_oemid);
801 bfd_h_put_16(abfd, filehdr_in->pe.e_oeminfo,
802 (bfd_byte *) filehdr_out->e_oeminfo);
805 for (idx=0; idx < 10; idx++)
806 bfd_h_put_16(abfd, filehdr_in->pe.e_res2[idx],
807 (bfd_byte *) filehdr_out->e_res2[idx]);
809 bfd_h_put_32(abfd, filehdr_in->pe.e_lfanew, (bfd_byte *) filehdr_out->e_lfanew);
813 for (idx=0; idx < 16; idx++)
814 bfd_h_put_32(abfd, filehdr_in->pe.dos_message[idx],
815 (bfd_byte *) filehdr_out->dos_message[idx]);
818 /* also put in the NT signature */
819 bfd_h_put_32(abfd, filehdr_in->pe.nt_signature,
820 (bfd_byte *) filehdr_out->nt_signature);
829 _bfd_pe_only_swap_filehdr_out (abfd, in, out)
834 struct internal_filehdr *filehdr_in = (struct internal_filehdr *)in;
835 FILHDR *filehdr_out = (FILHDR *)out;
837 bfd_h_put_16(abfd, filehdr_in->f_magic, (bfd_byte *) filehdr_out->f_magic);
838 bfd_h_put_16(abfd, filehdr_in->f_nscns, (bfd_byte *) filehdr_out->f_nscns);
839 bfd_h_put_32(abfd, filehdr_in->f_timdat, (bfd_byte *) filehdr_out->f_timdat);
840 PUT_FILEHDR_SYMPTR (abfd, (bfd_vma) filehdr_in->f_symptr,
841 (bfd_byte *) filehdr_out->f_symptr);
842 bfd_h_put_32(abfd, filehdr_in->f_nsyms, (bfd_byte *) filehdr_out->f_nsyms);
843 bfd_h_put_16(abfd, filehdr_in->f_opthdr, (bfd_byte *) filehdr_out->f_opthdr);
844 bfd_h_put_16(abfd, filehdr_in->f_flags, (bfd_byte *) filehdr_out->f_flags);
850 _bfd_pei_swap_scnhdr_out (abfd, in, out)
855 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *)in;
856 SCNHDR *scnhdr_ext = (SCNHDR *)out;
857 unsigned int ret = SCNHSZ;
861 memcpy(scnhdr_ext->s_name, scnhdr_int->s_name, sizeof(scnhdr_int->s_name));
863 PUT_SCNHDR_VADDR (abfd,
864 ((scnhdr_int->s_vaddr
865 - pe_data(abfd)->pe_opthdr.ImageBase)
867 (bfd_byte *) scnhdr_ext->s_vaddr);
869 /* NT wants the size data to be rounded up to the next
870 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
873 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
875 ps = scnhdr_int->s_size;
880 ps = scnhdr_int->s_paddr;
881 ss = scnhdr_int->s_size;
884 PUT_SCNHDR_SIZE (abfd, ss,
885 (bfd_byte *) scnhdr_ext->s_size);
888 /* s_paddr in PE is really the virtual size. */
889 PUT_SCNHDR_PADDR (abfd, ps, (bfd_byte *) scnhdr_ext->s_paddr);
891 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
892 (bfd_byte *) scnhdr_ext->s_scnptr);
893 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
894 (bfd_byte *) scnhdr_ext->s_relptr);
895 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
896 (bfd_byte *) scnhdr_ext->s_lnnoptr);
898 /* Extra flags must be set when dealing with NT. All sections should also
899 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
900 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
901 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
902 (this is especially important when dealing with the .idata section since
903 the addresses for routines from .dlls must be overwritten). If .reloc
904 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
905 (0x02000000). Also, the resource data should also be read and
908 /* FIXME: alignment is also encoded in this field, at least on ppc (krk) */
909 /* FIXME: even worse, I don't see how to get the original alignment field*/
912 /* FIXME: Basing this on section names is bogus. Also, this should
913 be in sec_to_styp_flags. */
916 int flags = scnhdr_int->s_flags;
917 if (strcmp (scnhdr_int->s_name, ".data") == 0 ||
918 strcmp (scnhdr_int->s_name, ".CRT") == 0 ||
919 strcmp (scnhdr_int->s_name, ".bss") == 0)
920 flags |= IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE;
921 else if (strcmp (scnhdr_int->s_name, ".text") == 0)
922 flags |= IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE;
923 else if (strcmp (scnhdr_int->s_name, ".reloc") == 0)
924 flags = (SEC_DATA | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE
925 | IMAGE_SCN_MEM_SHARED);
926 else if (strcmp (scnhdr_int->s_name, ".idata") == 0)
927 flags = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | SEC_DATA;
928 else if (strcmp (scnhdr_int->s_name, ".rdata") == 0
929 || strcmp (scnhdr_int->s_name, ".edata") == 0)
930 flags = IMAGE_SCN_MEM_READ | SEC_DATA;
931 else if (strcmp (scnhdr_int->s_name, ".pdata") == 0)
932 flags = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_4BYTES |
934 /* Remember this field is a max of 8 chars, so the null is _not_ there
935 for an 8 character name like ".reldata". (yep. Stupid bug) */
936 else if (strncmp (scnhdr_int->s_name, ".reldata", 8) == 0)
937 flags = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_8BYTES |
938 IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE ;
939 else if (strcmp (scnhdr_int->s_name, ".ydata") == 0)
940 flags = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_8BYTES |
941 IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE ;
942 else if (strncmp (scnhdr_int->s_name, ".drectve", 8) == 0)
943 flags = IMAGE_SCN_LNK_INFO | IMAGE_SCN_LNK_REMOVE ;
944 else if (strncmp (scnhdr_int->s_name, ".stab", 5) == 0)
945 flags |= (IMAGE_SCN_LNK_INFO | IMAGE_SCN_MEM_DISCARDABLE
946 | IMAGE_SCN_MEM_SHARED | IMAGE_SCN_MEM_READ);
947 else if (strcmp (scnhdr_int->s_name, ".rsrc") == 0)
948 flags |= IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_SHARED;
951 flags |= IMAGE_SCN_MEM_READ;
952 if (! (flags & SEC_READONLY))
953 flags |= IMAGE_SCN_MEM_WRITE;
954 if (flags & SEC_SHARED)
955 flags |= IMAGE_SCN_MEM_SHARED;
958 bfd_h_put_32(abfd, flags, (bfd_byte *) scnhdr_ext->s_flags);
961 if (coff_data (abfd)->link_info
962 && ! coff_data (abfd)->link_info->relocateable
963 && ! coff_data (abfd)->link_info->shared
964 && strcmp (scnhdr_int->s_name, ".text") == 0)
966 /* By inference from looking at MS output, the 32 bit field
967 which is the combintion of the number_of_relocs and
968 number_of_linenos is used for the line number count in
969 executables. A 16-bit field won't do for cc1. The MS
970 document says that the number of relocs is zero for
971 executables, but the 17-th bit has been observed to be there.
972 Overflow is not an issue: a 4G-line program will overflow a
973 bunch of other fields long before this! */
974 bfd_h_put_16 (abfd, scnhdr_int->s_nlnno & 0xffff,
975 (bfd_byte *) scnhdr_ext->s_nlnno);
976 bfd_h_put_16 (abfd, scnhdr_int->s_nlnno >> 16,
977 (bfd_byte *) scnhdr_ext->s_nreloc);
981 if (scnhdr_int->s_nlnno <= 0xffff)
982 bfd_h_put_16 (abfd, scnhdr_int->s_nlnno,
983 (bfd_byte *) scnhdr_ext->s_nlnno);
986 (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
987 bfd_get_filename (abfd),
988 scnhdr_int->s_nlnno);
989 bfd_set_error (bfd_error_file_truncated);
990 bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nlnno);
993 if (scnhdr_int->s_nreloc <= 0xffff)
994 bfd_h_put_16 (abfd, scnhdr_int->s_nreloc,
995 (bfd_byte *) scnhdr_ext->s_nreloc);
998 (*_bfd_error_handler) (_("%s: reloc overflow: 0x%lx > 0xffff"),
999 bfd_get_filename (abfd),
1000 scnhdr_int->s_nreloc);
1001 bfd_set_error (bfd_error_file_truncated);
1002 bfd_h_put_16 (abfd, 0xffff, (bfd_byte *) scnhdr_ext->s_nreloc);
1009 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1011 N_ ("Export Directory [.edata (or where ever we found it)]"),
1012 N_ ("Import Directory [parts of .idata]"),
1013 N_ ("Resource Directory [.rsrc]"),
1014 N_ ("Exception Directory [.pdata]"),
1015 N_ ("Security Directory"),
1016 N_ ("Base Relocation Directory [.reloc]"),
1017 N_ ("Debug Directory"),
1018 N_ ("Description Directory"),
1019 N_ ("Special Directory"),
1020 N_ ("Thread Storage Directory [.tls]"),
1021 N_ ("Load Configuration Directory"),
1022 N_ ("Bound Import Directory"),
1023 N_ ("Import Address Table Directory"),
1029 /**********************************************************************/
1030 #ifdef POWERPC_LE_PE
1031 /* The code for the PPC really falls in the "architecture dependent"
1032 category. However, it's not clear that anyone will ever care, so
1033 we're ignoring the issue for now; if/when PPC matters, some of this
1034 may need to go into peicode.h, or arguments passed to enable the
1035 PPC- specific code. */
1038 /**********************************************************************/
1040 pe_print_idata (abfd, vfile)
1044 FILE *file = (FILE *) vfile;
1046 asection *section = bfd_get_section_by_name (abfd, ".idata");
1049 #ifdef POWERPC_LE_PE
1050 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1053 bfd_size_type datasize;
1054 bfd_size_type dataoff;
1055 bfd_size_type secsize;
1059 pe_data_type *pe = pe_data (abfd);
1060 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1062 if (section != NULL)
1064 datasize = bfd_section_size (abfd, section);
1070 fprintf (file, _("\nThe import table is the .idata section\n"));
1074 /* idata buried in some other section: e.g. KERNEL32.DLL. */
1077 addr = extra->DataDirectory[1].VirtualAddress;
1078 size = extra->DataDirectory[1].Size;
1080 if (addr == 0 || size == 0)
1083 for (section = abfd->sections; section != NULL; section = section->next)
1085 if (addr >= section->vma
1086 && addr < section->vma + bfd_section_size(abfd,section))
1089 if (section == NULL)
1092 _("\nThere is an import table, but the section containing it could not be found\n"));
1096 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1097 section->name, (unsigned long)addr);
1099 dataoff = addr - section->vma;
1103 #ifdef POWERPC_LE_PE
1104 if (rel_section != 0 && bfd_section_size (abfd, rel_section) != 0)
1106 /* The toc address can be found by taking the starting address,
1107 which on the PPC locates a function descriptor. The
1108 descriptor consists of the function code starting address
1109 followed by the address of the toc. The starting address we
1110 get from the bfd, and the descriptor is supposed to be in the
1111 .reldata section. */
1113 bfd_vma loadable_toc_address;
1114 bfd_vma toc_address;
1115 bfd_vma start_address;
1118 data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd,
1120 if (data == NULL && bfd_section_size (abfd, rel_section) != 0)
1123 datasize = bfd_section_size (abfd, rel_section);
1125 bfd_get_section_contents (abfd,
1128 bfd_section_size (abfd, rel_section));
1130 offset = abfd->start_address - rel_section->vma;
1132 start_address = bfd_get_32(abfd, data+offset);
1133 loadable_toc_address = bfd_get_32(abfd, data+offset+4);
1134 toc_address = loadable_toc_address - 32768;
1137 _("\nFunction descriptor located at the start address: %04lx\n"),
1138 (unsigned long int) (abfd->start_address));
1140 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1141 start_address, loadable_toc_address, toc_address);
1146 _("\nNo reldata section! Function descriptor not decoded.\n"));
1151 _("\nThe Import Tables (interpreted .idata section contents)\n"));
1153 _(" vma: Hint Time Forward DLL First\n"));
1155 _(" Table Stamp Chain Name Thunk\n"));
1157 secsize = bfd_section_size (abfd, section);
1158 data = (bfd_byte *) bfd_malloc (secsize);
1159 if (data == NULL && secsize != 0)
1162 if (! bfd_get_section_contents (abfd, section, (PTR) data, 0, secsize))
1165 adj = - section->vma;
1167 for (i = 0; i < datasize; i += onaline)
1171 bfd_vma forward_chain;
1173 bfd_vma first_thunk;
1180 (unsigned long int) (i + section->vma + dataoff));
1182 if (i + 20 > datasize)
1188 hint_addr = bfd_get_32 (abfd, data + i + dataoff);
1189 time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff);
1190 forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff);
1191 dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff);
1192 first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff);
1194 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1201 if (hint_addr == 0 && first_thunk == 0)
1204 dll = (char *) data + dll_name - section->vma + dataoff;
1205 fprintf(file, _("\n\tDLL Name: %s\n"), dll);
1209 fprintf (file, _("\tvma: Hint/Ord Member-Name\n"));
1211 idx = hint_addr + adj;
1213 for (j = 0; j < datasize; j += 4)
1215 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1219 if (member & 0x80000000)
1220 fprintf (file, "\t%04lx\t %4lu", member,
1221 member & 0x7fffffff);
1227 ordinal = bfd_get_16 (abfd, data + member + adj);
1228 member_name = (char *) data + member + adj + 2;
1229 fprintf (file, "\t%04lx\t %4d %s",
1230 member, ordinal, member_name);
1233 /* If the time stamp is not zero, the import address
1234 table holds actual addresses. */
1237 && first_thunk != hint_addr)
1238 fprintf (file, "\t%04lx",
1239 bfd_get_32 (abfd, data + first_thunk + adj + j));
1241 fprintf (file, "\n");
1245 if (hint_addr != first_thunk && time_stamp == 0)
1250 idx2 = first_thunk + adj;
1252 for (j = 0; j < datasize; j += 4)
1256 bfd_vma hint_member = 0;
1260 hint_member = bfd_get_32 (abfd, data + idx + j);
1261 iat_member = bfd_get_32 (abfd, data + idx2 + j);
1263 if (hint_addr == 0 && iat_member == 0)
1266 if (hint_addr == 0 || hint_member != iat_member)
1271 _("\tThe Import Address Table (difference found)\n"));
1272 fprintf(file, _("\tvma: Hint/Ord Member-Name\n"));
1275 if (iat_member == 0)
1278 _("\t>>> Ran out of IAT members!\n"));
1282 ordinal = bfd_get_16(abfd,
1283 data + iat_member + adj);
1284 member_name = (char *) data + iat_member + adj + 2;
1285 fprintf(file, "\t%04lx\t %4d %s\n",
1286 iat_member, ordinal, member_name);
1290 if (hint_addr != 0 && hint_member == 0)
1296 _("\tThe Import Address Table is identical\n"));
1300 fprintf(file, "\n");
1310 pe_print_edata (abfd, vfile)
1314 FILE *file = (FILE *) vfile;
1316 asection *section = bfd_get_section_by_name (abfd, ".edata");
1318 bfd_size_type datasize;
1319 bfd_size_type dataoff;
1325 long export_flags; /* reserved - should be zero */
1329 bfd_vma name; /* rva - relative to image base */
1330 long base; /* ordinal base */
1331 unsigned long num_functions; /* Number in the export address table */
1332 unsigned long num_names; /* Number in the name pointer table */
1333 bfd_vma eat_addr; /* rva to the export address table */
1334 bfd_vma npt_addr; /* rva to the Export Name Pointer Table */
1335 bfd_vma ot_addr; /* rva to the Ordinal Table */
1338 pe_data_type *pe = pe_data (abfd);
1339 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1341 if (section != NULL)
1343 datasize = bfd_section_size (abfd, section);
1345 fprintf (file, _("\nThe export table is the .edata section\n"));
1349 /* edata is buried in some other section: e.g. NTDLL.DLL. */
1352 addr = extra->DataDirectory[0].VirtualAddress;
1353 size = extra->DataDirectory[0].Size;
1355 if (addr == 0 || size == 0)
1358 for (section = abfd->sections; section != NULL; section = section->next)
1360 if (addr >= section->vma
1361 && addr < section->vma + bfd_section_size (abfd, section))
1364 if (section == NULL)
1367 _("\nThere is an export table, but the section containing it could not be found\n"));
1371 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1372 section->name, (unsigned long) addr);
1375 dataoff = addr - section->vma;
1378 data = (bfd_byte *) bfd_malloc (datasize);
1379 if (data == NULL && datasize != 0)
1382 if (! bfd_get_section_contents (abfd, section, (PTR) data, dataoff,
1386 /* Go get Export Directory Table */
1387 edt.export_flags = bfd_get_32(abfd, data+0);
1388 edt.time_stamp = bfd_get_32(abfd, data+4);
1389 edt.major_ver = bfd_get_16(abfd, data+8);
1390 edt.minor_ver = bfd_get_16(abfd, data+10);
1391 edt.name = bfd_get_32(abfd, data+12);
1392 edt.base = bfd_get_32(abfd, data+16);
1393 edt.num_functions = bfd_get_32(abfd, data+20);
1394 edt.num_names = bfd_get_32(abfd, data+24);
1395 edt.eat_addr = bfd_get_32(abfd, data+28);
1396 edt.npt_addr = bfd_get_32(abfd, data+32);
1397 edt.ot_addr = bfd_get_32(abfd, data+36);
1399 adj = - (section->vma + dataoff);
1401 /* Dump the EDT first first */
1403 _("\nThe Export Tables (interpreted .edata section contents)\n\n"));
1406 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1409 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1412 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1415 _("Name \t\t\t\t"));
1416 fprintf_vma (file, edt.name);
1418 " %s\n", data + edt.name + adj);
1421 _("Ordinal Base \t\t\t%ld\n"), edt.base);
1427 _("\tExport Address Table \t\t%lx\n"),
1431 _("\t[Name Pointer/Ordinal] Table\t%lu\n"), edt.num_names);
1434 _("Table Addresses\n"));
1437 _("\tExport Address Table \t\t"));
1438 fprintf_vma (file, edt.eat_addr);
1439 fprintf (file, "\n");
1442 _("\tName Pointer Table \t\t"));
1443 fprintf_vma (file, edt.npt_addr);
1444 fprintf (file, "\n");
1447 _("\tOrdinal Table \t\t\t"));
1448 fprintf_vma (file, edt.ot_addr);
1449 fprintf (file, "\n");
1452 /* The next table to find is the Export Address Table. It's basically
1453 a list of pointers that either locate a function in this dll, or
1454 forward the call to another dll. Something like:
1459 } export_address_table_entry;
1463 _("\nExport Address Table -- Ordinal Base %ld\n"),
1466 for (i = 0; i < edt.num_functions; ++i)
1468 bfd_vma eat_member = bfd_get_32 (abfd,
1469 data + edt.eat_addr + (i * 4) + adj);
1470 bfd_vma eat_actual = eat_member;
1471 bfd_vma edata_start = bfd_get_section_vma (abfd, section);
1472 bfd_vma edata_end = edata_start + datasize;
1474 if (eat_member == 0)
1477 if (edata_start < eat_actual && eat_actual < edata_end)
1479 /* this rva is to a name (forwarding function) in our section */
1480 /* Should locate a function descriptor */
1482 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1483 (long) i, (long) (i + edt.base), eat_member,
1484 _("Forwarder RVA"), data + eat_member + adj);
1488 /* Should locate a function descriptor in the reldata section */
1490 "\t[%4ld] +base[%4ld] %04lx %s\n",
1491 (long) i, (long) (i + edt.base), eat_member,
1496 /* The Export Name Pointer Table is paired with the Export Ordinal Table */
1497 /* Dump them in parallel for clarity */
1499 _("\n[Ordinal/Name Pointer] Table\n"));
1501 for (i = 0; i < edt.num_names; ++i)
1503 bfd_vma name_ptr = bfd_get_32(abfd,
1508 char *name = (char *) data + name_ptr + adj;
1510 bfd_vma ord = bfd_get_16(abfd,
1515 "\t[%4ld] %s\n", (long) ord, name);
1525 pe_print_pdata (abfd, vfile)
1529 FILE *file = (FILE *) vfile;
1531 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1532 bfd_size_type datasize = 0;
1534 bfd_size_type start, stop;
1538 || coff_section_data (abfd, section) == NULL
1539 || pei_section_data (abfd, section) == NULL)
1542 stop = pei_section_data (abfd, section)->virt_size;
1543 if ((stop % onaline) != 0)
1544 fprintf (file, _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1545 (long)stop, onaline);
1548 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1550 _(" vma:\t\tBegin End EH EH PrologEnd Exception\n"));
1552 _(" \t\tAddress Address Handler Data Address Mask\n"));
1554 if (bfd_section_size (abfd, section) == 0)
1557 data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd, section));
1558 datasize = bfd_section_size (abfd, section);
1559 if (data == NULL && datasize != 0)
1562 bfd_get_section_contents (abfd,
1565 bfd_section_size (abfd, section));
1569 for (i = start; i < stop; i += onaline)
1575 bfd_vma prolog_end_addr;
1581 begin_addr = bfd_get_32(abfd, data+i);
1582 end_addr = bfd_get_32(abfd, data+i+4);
1583 eh_handler = bfd_get_32(abfd, data+i+8);
1584 eh_data = bfd_get_32(abfd, data+i+12);
1585 prolog_end_addr = bfd_get_32(abfd, data+i+16);
1587 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1588 && eh_data == 0 && prolog_end_addr == 0)
1590 /* We are probably into the padding of the section now. */
1596 (unsigned long int) (i + section->vma));
1598 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1599 eh_handler &= 0xfffffffc;
1600 prolog_end_addr &= 0xfffffffc;
1602 fprintf (file, "%08lx %08lx %08lx %08lx %08lx %x",
1610 #ifdef POWERPC_LE_PE
1611 if (eh_handler == 0 && eh_data != 0)
1613 /* Special bits here, although the meaning may */
1614 /* be a little mysterious. The only one I know */
1615 /* for sure is 0x03. */
1616 /* Code Significance */
1618 /* 0x01 Register Save Millicode */
1619 /* 0x02 Register Restore Millicode */
1620 /* 0x03 Glue Code Sequence */
1624 fprintf(file, _(" Register save millicode"));
1627 fprintf(file, _(" Register restore millicode"));
1630 fprintf(file, _(" Glue code sequence"));
1637 fprintf(file, "\n");
1645 #define IMAGE_REL_BASED_HIGHADJ 4
1646 static const char * const tbl[] =
1654 "UNKNOWN", /* MUST be last */
1658 pe_print_reloc (abfd, vfile)
1662 FILE *file = (FILE *) vfile;
1664 asection *section = bfd_get_section_by_name (abfd, ".reloc");
1665 bfd_size_type datasize = 0;
1667 bfd_size_type start, stop;
1669 if (section == NULL)
1672 if (bfd_section_size (abfd, section) == 0)
1676 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
1678 data = (bfd_byte *) bfd_malloc ((size_t) bfd_section_size (abfd, section));
1679 datasize = bfd_section_size (abfd, section);
1680 if (data == NULL && datasize != 0)
1683 bfd_get_section_contents (abfd,
1686 bfd_section_size (abfd, section));
1690 stop = bfd_section_size (abfd, section);
1692 for (i = start; i < stop;)
1695 bfd_vma virtual_address;
1698 /* The .reloc section is a sequence of blocks, with a header consisting
1699 of two 32 bit quantities, followed by a number of 16 bit entries */
1701 virtual_address = bfd_get_32(abfd, data+i);
1702 size = bfd_get_32(abfd, data+i+4);
1703 number = (size - 8) / 2;
1711 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
1712 virtual_address, size, size, number);
1714 for (j = 0; j < number; ++j)
1716 unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
1717 unsigned int t = (e & 0xF000) >> 12;
1718 int off = e & 0x0FFF;
1720 if (t >= sizeof (tbl) / sizeof (tbl[0]))
1721 t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
1724 _("\treloc %4d offset %4x [%4lx] %s"),
1725 j, off, (long) (off + virtual_address), tbl[t]);
1727 /* HIGHADJ takes an argument, but there's no documentation
1728 on what it does, or what it means. Inferred from
1730 if (t == IMAGE_REL_BASED_HIGHADJ)
1732 fprintf (file, " (%4x)\n",
1734 bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
1738 fprintf (file, "\n");
1748 /* Print out the program headers. */
1751 _bfd_pe_print_private_bfd_data_common (abfd, vfile)
1755 FILE *file = (FILE *) vfile;
1757 pe_data_type *pe = pe_data (abfd);
1758 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
1760 /* The MS dumpbin program reportedly ands with 0xff0f before
1761 printing the characteristics field. Not sure why. No reason to
1763 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
1765 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
1766 PF (F_RELFLG, "relocations stripped");
1767 PF (F_EXEC, "executable");
1768 PF (F_LNNO, "line numbers stripped");
1769 PF (F_LSYMS, "symbols stripped");
1770 PF (0x80, "little endian");
1771 PF (F_AR32WR, "32 bit words");
1772 PF (0x200, "debugging information removed");
1773 PF (0x1000, "system file");
1775 PF (0x8000, "big endian");
1778 /* ctime implies '\n'. */
1779 fprintf (file, "\nTime/Date\t\t%s", ctime (&pe->coff.timestamp));
1780 fprintf (file,"\nImageBase\t\t");
1781 fprintf_vma (file, i->ImageBase);
1782 fprintf (file,"\nSectionAlignment\t");
1783 fprintf_vma (file, i->SectionAlignment);
1784 fprintf (file,"\nFileAlignment\t\t");
1785 fprintf_vma (file, i->FileAlignment);
1786 fprintf (file,"\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
1787 fprintf (file,"MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
1788 fprintf (file,"MajorImageVersion\t%d\n", i->MajorImageVersion);
1789 fprintf (file,"MinorImageVersion\t%d\n", i->MinorImageVersion);
1790 fprintf (file,"MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
1791 fprintf (file,"MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
1792 fprintf (file,"Reserved1\t\t%08lx\n", i->Reserved1);
1793 fprintf (file,"SizeOfImage\t\t%08lx\n", i->SizeOfImage);
1794 fprintf (file,"SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders);
1795 fprintf (file,"CheckSum\t\t%08lx\n", i->CheckSum);
1796 fprintf (file,"Subsystem\t\t%08x\n", i->Subsystem);
1797 fprintf (file,"DllCharacteristics\t%08x\n", i->DllCharacteristics);
1798 fprintf (file,"SizeOfStackReserve\t");
1799 fprintf_vma (file, i->SizeOfStackReserve);
1800 fprintf (file,"\nSizeOfStackCommit\t");
1801 fprintf_vma (file, i->SizeOfStackCommit);
1802 fprintf (file,"\nSizeOfHeapReserve\t");
1803 fprintf_vma (file, i->SizeOfHeapReserve);
1804 fprintf (file,"\nSizeOfHeapCommit\t");
1805 fprintf_vma (file, i->SizeOfHeapCommit);
1806 fprintf (file,"\nLoaderFlags\t\t%08lx\n", i->LoaderFlags);
1807 fprintf (file,"NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes);
1809 fprintf (file,"\nThe Data Directory\n");
1810 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
1812 fprintf (file, "Entry %1x ", j);
1813 fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
1814 fprintf (file, " %08lx ", i->DataDirectory[j].Size);
1815 fprintf (file, "%s\n", dir_names[j]);
1818 pe_print_idata (abfd, vfile);
1819 pe_print_edata (abfd, vfile);
1820 pe_print_pdata (abfd, vfile);
1821 pe_print_reloc (abfd, vfile);
1826 /* Copy any private info we understand from the input bfd
1827 to the output bfd. */
1830 _bfd_pe_bfd_copy_private_bfd_data_common (ibfd, obfd)
1833 /* One day we may try to grok other private data. */
1834 if (ibfd->xvec->flavour != bfd_target_coff_flavour
1835 || obfd->xvec->flavour != bfd_target_coff_flavour)
1838 pe_data (obfd)->pe_opthdr = pe_data (ibfd)->pe_opthdr;
1839 pe_data (obfd)->dll = pe_data (ibfd)->dll;
1841 /* for strip: if we removed .reloc, we'll make a real mess of things
1842 if we don't remove this entry as well. */
1843 if (! pe_data (obfd)->has_reloc_section)
1845 pe_data(obfd)->pe_opthdr.DataDirectory[5].VirtualAddress = 0;
1846 pe_data(obfd)->pe_opthdr.DataDirectory[5].Size = 0;
1851 /* Copy private section data. */
1853 _bfd_pe_bfd_copy_private_section_data (ibfd, isec, obfd, osec)
1859 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
1860 || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
1863 if (coff_section_data (ibfd, isec) != NULL
1864 && pei_section_data (ibfd, isec) != NULL)
1866 if (coff_section_data (obfd, osec) == NULL)
1869 (PTR) bfd_zalloc (obfd, sizeof (struct coff_section_tdata));
1870 if (osec->used_by_bfd == NULL)
1873 if (pei_section_data (obfd, osec) == NULL)
1875 coff_section_data (obfd, osec)->tdata =
1876 (PTR) bfd_zalloc (obfd, sizeof (struct pei_section_tdata));
1877 if (coff_section_data (obfd, osec)->tdata == NULL)
1880 pei_section_data (obfd, osec)->virt_size =
1881 pei_section_data (ibfd, isec)->virt_size;
1882 pei_section_data (obfd, osec)->pe_flags =
1883 pei_section_data (ibfd, isec)->pe_flags;
1890 _bfd_pe_get_symbol_info (abfd, symbol, ret)
1895 coff_get_symbol_info (abfd, symbol, ret);
1897 if (pe_data (abfd) != NULL
1898 && ((symbol->flags & BSF_DEBUGGING) == 0
1899 || (symbol->flags & BSF_DEBUGGING_RELOC) != 0)
1900 && ! bfd_is_abs_section (symbol->section))
1901 ret->value += pe_data (abfd)->pe_opthdr.ImageBase;