1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright (C) 1995-2014 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 3 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., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
23 /* Most of this hacked by Steve Chamberlain <sac@cygnus.com>.
25 PE/PEI rearrangement (and code added): Donn Terry
26 Softway Systems, Inc. */
28 /* Hey look, some documentation [and in a place you expect to find it]!
30 The main reference for the pei format is "Microsoft Portable Executable
31 and Common Object File Format Specification 4.1". Get it if you need to
32 do some serious hacking on this code.
35 "Peering Inside the PE: A Tour of the Win32 Portable Executable
36 File Format", MSJ 1994, Volume 9.
38 The *sole* difference between the pe format and the pei format is that the
39 latter has an MSDOS 2.0 .exe header on the front that prints the message
40 "This app must be run under Windows." (or some such).
41 (FIXME: Whether that statement is *really* true or not is unknown.
42 Are there more subtle differences between pe and pei formats?
43 For now assume there aren't. If you find one, then for God sakes
46 The Microsoft docs use the word "image" instead of "executable" because
47 the former can also refer to a DLL (shared library). Confusion can arise
48 because the `i' in `pei' also refers to "image". The `pe' format can
49 also create images (i.e. executables), it's just that to run on a win32
50 system you need to use the pei format.
52 FIXME: Please add more docs here so the next poor fool that has to hack
53 on this code has a chance of getting something accomplished without
54 wasting too much time. */
56 /* This expands into COFF_WITH_pe, COFF_WITH_pep, or COFF_WITH_pex64
57 depending on whether we're compiling for straight PE or PE+. */
63 #include "coff/internal.h"
69 /* NOTE: it's strange to be including an architecture specific header
70 in what's supposed to be general (to PE/PEI) code. However, that's
71 where the definitions are, and they don't vary per architecture
72 within PE/PEI, so we get them from there. FIXME: The lack of
73 variance is an assumption which may prove to be incorrect if new
74 PE/PEI targets are created. */
75 #if defined COFF_WITH_pex64
76 # include "coff/x86_64.h"
77 #elif defined COFF_WITH_pep
78 # include "coff/ia64.h"
80 # include "coff/i386.h"
86 #include "safe-ctype.h"
88 #if defined COFF_WITH_pep || defined COFF_WITH_pex64
90 # define AOUTSZ PEPAOUTSZ
91 # define PEAOUTHDR PEPAOUTHDR
94 #define HighBitSet(val) ((val) & 0x80000000)
95 #define SetHighBit(val) ((val) | 0x80000000)
96 #define WithoutHighBit(val) ((val) & 0x7fffffff)
98 /* FIXME: This file has various tests of POWERPC_LE_PE. Those tests
99 worked when the code was in peicode.h, but no longer work now that
100 the code is in peigen.c. PowerPC NT is said to be dead. If
101 anybody wants to revive the code, you will have to figure out how
102 to handle those issues. */
105 _bfd_XXi_swap_sym_in (bfd * abfd, void * ext1, void * in1)
107 SYMENT *ext = (SYMENT *) ext1;
108 struct internal_syment *in = (struct internal_syment *) in1;
110 if (ext->e.e_name[0] == 0)
112 in->_n._n_n._n_zeroes = 0;
113 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
116 memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
118 in->n_value = H_GET_32 (abfd, ext->e_value);
119 in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
121 if (sizeof (ext->e_type) == 2)
122 in->n_type = H_GET_16 (abfd, ext->e_type);
124 in->n_type = H_GET_32 (abfd, ext->e_type);
126 in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
127 in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
129 #ifndef STRICT_PE_FORMAT
130 /* This is for Gnu-created DLLs. */
132 /* The section symbols for the .idata$ sections have class 0x68
133 (C_SECTION), which MS documentation indicates is a section
134 symbol. Unfortunately, the value field in the symbol is simply a
135 copy of the .idata section's flags rather than something useful.
136 When these symbols are encountered, change the value to 0 so that
137 they will be handled somewhat correctly in the bfd code. */
138 if (in->n_sclass == C_SECTION)
140 char namebuf[SYMNMLEN + 1];
141 const char *name = NULL;
145 /* Create synthetic empty sections as needed. DJ */
146 if (in->n_scnum == 0)
150 name = _bfd_coff_internal_syment_name (abfd, in, namebuf);
152 /* FIXME: Return error. */
154 sec = bfd_get_section_by_name (abfd, name);
156 in->n_scnum = sec->target_index;
159 if (in->n_scnum == 0)
161 int unused_section_number = 0;
165 for (sec = abfd->sections; sec; sec = sec->next)
166 if (unused_section_number <= sec->target_index)
167 unused_section_number = sec->target_index + 1;
171 name = (const char *) bfd_alloc (abfd, strlen (namebuf) + 1);
173 /* FIXME: Return error. */
175 strcpy ((char *) name, namebuf);
177 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
178 sec = bfd_make_section_anyway_with_flags (abfd, name, flags);
180 /* FIXME: Return error. */
187 sec->rel_filepos = 0;
188 sec->reloc_count = 0;
189 sec->line_filepos = 0;
190 sec->lineno_count = 0;
191 sec->userdata = NULL;
193 sec->alignment_power = 2;
195 sec->target_index = unused_section_number;
197 in->n_scnum = unused_section_number;
199 in->n_sclass = C_STAT;
203 #ifdef coff_swap_sym_in_hook
204 /* This won't work in peigen.c, but since it's for PPC PE, it's not
206 coff_swap_sym_in_hook (abfd, ext1, in1);
211 abs_finder (bfd * abfd ATTRIBUTE_UNUSED, asection * sec, void * data)
213 bfd_vma abs_val = * (bfd_vma *) data;
215 return (sec->vma <= abs_val) && ((sec->vma + (1ULL << 32)) > abs_val);
219 _bfd_XXi_swap_sym_out (bfd * abfd, void * inp, void * extp)
221 struct internal_syment *in = (struct internal_syment *) inp;
222 SYMENT *ext = (SYMENT *) extp;
224 if (in->_n._n_name[0] == 0)
226 H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
227 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
230 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
232 /* The PE32 and PE32+ formats only use 4 bytes to hold the value of a
233 symbol. This is a problem on 64-bit targets where we can generate
234 absolute symbols with values >= 1^32. We try to work around this
235 problem by finding a section whose base address is sufficient to
236 reduce the absolute value to < 1^32, and then transforming the
237 symbol into a section relative symbol. This of course is a hack. */
238 if (sizeof (in->n_value) > 4
239 /* The strange computation of the shift amount is here in order to
240 avoid a compile time warning about the comparison always being
241 false. It does not matter if this test fails to work as expected
242 as the worst that can happen is that some absolute symbols are
243 needlessly converted into section relative symbols. */
244 && in->n_value > ((1ULL << (sizeof (in->n_value) > 4 ? 32 : 31)) - 1)
245 && in->n_scnum == -1)
249 sec = bfd_sections_find_if (abfd, abs_finder, & in->n_value);
252 in->n_value -= sec->vma;
253 in->n_scnum = sec->target_index;
255 /* else: FIXME: The value is outside the range of any section. This
256 happens for __image_base__ and __ImageBase and maybe some other
257 symbols as well. We should find a way to handle these values. */
260 H_PUT_32 (abfd, in->n_value, ext->e_value);
261 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
263 if (sizeof (ext->e_type) == 2)
264 H_PUT_16 (abfd, in->n_type, ext->e_type);
266 H_PUT_32 (abfd, in->n_type, ext->e_type);
268 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
269 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
275 _bfd_XXi_swap_aux_in (bfd * abfd,
279 int indx ATTRIBUTE_UNUSED,
280 int numaux ATTRIBUTE_UNUSED,
283 AUXENT *ext = (AUXENT *) ext1;
284 union internal_auxent *in = (union internal_auxent *) in1;
289 if (ext->x_file.x_fname[0] == 0)
291 in->x_file.x_n.x_zeroes = 0;
292 in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
295 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
303 in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
304 in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
305 in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
306 in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
307 in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
308 in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
314 in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
315 in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
317 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
320 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
321 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
325 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
326 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
327 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
328 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
329 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
330 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
331 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
332 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
337 in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
341 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
342 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
347 _bfd_XXi_swap_aux_out (bfd * abfd,
351 int indx ATTRIBUTE_UNUSED,
352 int numaux ATTRIBUTE_UNUSED,
355 union internal_auxent *in = (union internal_auxent *) inp;
356 AUXENT *ext = (AUXENT *) extp;
358 memset (ext, 0, AUXESZ);
363 if (in->x_file.x_fname[0] == 0)
365 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
366 H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
369 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
378 PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
379 PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
380 PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
381 H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
382 H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
383 H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
389 H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
390 H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
392 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
395 PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
396 PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
400 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
401 ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
402 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
403 ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
404 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
405 ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
406 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
407 ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
411 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
414 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
415 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
422 _bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1)
424 LINENO *ext = (LINENO *) ext1;
425 struct internal_lineno *in = (struct internal_lineno *) in1;
427 in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
428 in->l_lnno = GET_LINENO_LNNO (abfd, ext);
432 _bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp)
434 struct internal_lineno *in = (struct internal_lineno *) inp;
435 struct external_lineno *ext = (struct external_lineno *) outp;
436 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
438 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
443 _bfd_XXi_swap_aouthdr_in (bfd * abfd,
447 PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1;
448 AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
449 struct internal_aouthdr *aouthdr_int
450 = (struct internal_aouthdr *) aouthdr_int1;
451 struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe;
453 aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
454 aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
455 aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
456 aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
457 aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
458 aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
459 aouthdr_int->text_start =
460 GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
461 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
462 /* PE32+ does not have data_start member! */
463 aouthdr_int->data_start =
464 GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
465 a->BaseOfData = aouthdr_int->data_start;
468 a->Magic = aouthdr_int->magic;
469 a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp);
470 a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1);
471 a->SizeOfCode = aouthdr_int->tsize ;
472 a->SizeOfInitializedData = aouthdr_int->dsize ;
473 a->SizeOfUninitializedData = aouthdr_int->bsize ;
474 a->AddressOfEntryPoint = aouthdr_int->entry;
475 a->BaseOfCode = aouthdr_int->text_start;
476 a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
477 a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
478 a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
479 a->MajorOperatingSystemVersion =
480 H_GET_16 (abfd, src->MajorOperatingSystemVersion);
481 a->MinorOperatingSystemVersion =
482 H_GET_16 (abfd, src->MinorOperatingSystemVersion);
483 a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
484 a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
485 a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
486 a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
487 a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
488 a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
489 a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
490 a->CheckSum = H_GET_32 (abfd, src->CheckSum);
491 a->Subsystem = H_GET_16 (abfd, src->Subsystem);
492 a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
493 a->SizeOfStackReserve =
494 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
495 a->SizeOfStackCommit =
496 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
497 a->SizeOfHeapReserve =
498 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
499 a->SizeOfHeapCommit =
500 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
501 a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
502 a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
507 /* PR 17512: Corrupt PE binaries can cause seg-faults. */
508 if (a->NumberOfRvaAndSizes > 16)
510 (*_bfd_error_handler)
511 (_("%B: aout header specifies an invalid number of data-directory entries: %d"),
512 abfd, a->NumberOfRvaAndSizes);
513 /* Paranoia: If the number is corrupt, then assume that the
514 actual entries themselves might be corrupt as well. */
515 a->NumberOfRvaAndSizes = 0;
519 for (idx = 0; idx < a->NumberOfRvaAndSizes; idx++)
521 /* If data directory is empty, rva also should be 0. */
523 H_GET_32 (abfd, src->DataDirectory[idx][1]);
525 a->DataDirectory[idx].Size = size;
528 a->DataDirectory[idx].VirtualAddress =
529 H_GET_32 (abfd, src->DataDirectory[idx][0]);
531 a->DataDirectory[idx].VirtualAddress = 0;
535 if (aouthdr_int->entry)
537 aouthdr_int->entry += a->ImageBase;
538 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
539 aouthdr_int->entry &= 0xffffffff;
543 if (aouthdr_int->tsize)
545 aouthdr_int->text_start += a->ImageBase;
546 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
547 aouthdr_int->text_start &= 0xffffffff;
551 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
552 /* PE32+ does not have data_start member! */
553 if (aouthdr_int->dsize)
555 aouthdr_int->data_start += a->ImageBase;
556 aouthdr_int->data_start &= 0xffffffff;
561 /* These three fields are normally set up by ppc_relocate_section.
562 In the case of reading a file in, we can pick them up from the
564 first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress;
565 thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size;
566 import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size;
570 /* A support function for below. */
573 add_data_entry (bfd * abfd,
574 struct internal_extra_pe_aouthdr *aout,
579 asection *sec = bfd_get_section_by_name (abfd, name);
581 /* Add import directory information if it exists. */
583 && (coff_section_data (abfd, sec) != NULL)
584 && (pei_section_data (abfd, sec) != NULL))
586 /* If data directory is empty, rva also should be 0. */
587 int size = pei_section_data (abfd, sec)->virt_size;
588 aout->DataDirectory[idx].Size = size;
592 aout->DataDirectory[idx].VirtualAddress =
593 (sec->vma - base) & 0xffffffff;
594 sec->flags |= SEC_DATA;
600 _bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out)
602 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
603 pe_data_type *pe = pe_data (abfd);
604 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
605 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
607 IMAGE_DATA_DIRECTORY idata2, idata5, tls;
609 sa = extra->SectionAlignment;
610 fa = extra->FileAlignment;
611 ib = extra->ImageBase;
613 idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
614 idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
615 tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
617 if (aouthdr_in->tsize)
619 aouthdr_in->text_start -= ib;
620 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
621 aouthdr_in->text_start &= 0xffffffff;
625 if (aouthdr_in->dsize)
627 aouthdr_in->data_start -= ib;
628 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
629 aouthdr_in->data_start &= 0xffffffff;
633 if (aouthdr_in->entry)
635 aouthdr_in->entry -= ib;
636 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
637 aouthdr_in->entry &= 0xffffffff;
641 #define FA(x) (((x) + fa -1 ) & (- fa))
642 #define SA(x) (((x) + sa -1 ) & (- sa))
644 /* We like to have the sizes aligned. */
645 aouthdr_in->bsize = FA (aouthdr_in->bsize);
647 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
649 add_data_entry (abfd, extra, 0, ".edata", ib);
650 add_data_entry (abfd, extra, 2, ".rsrc", ib);
651 add_data_entry (abfd, extra, 3, ".pdata", ib);
653 /* In theory we do not need to call add_data_entry for .idata$2 or
654 .idata$5. It will be done in bfd_coff_final_link where all the
655 required information is available. If however, we are not going
656 to perform a final link, eg because we have been invoked by objcopy
657 or strip, then we need to make sure that these Data Directory
658 entries are initialised properly.
660 So - we copy the input values into the output values, and then, if
661 a final link is going to be performed, it can overwrite them. */
662 extra->DataDirectory[PE_IMPORT_TABLE] = idata2;
663 extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
664 extra->DataDirectory[PE_TLS_TABLE] = tls;
666 if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
667 /* Until other .idata fixes are made (pending patch), the entry for
668 .idata is needed for backwards compatibility. FIXME. */
669 add_data_entry (abfd, extra, 1, ".idata", ib);
671 /* For some reason, the virtual size (which is what's set by
672 add_data_entry) for .reloc is not the same as the size recorded
673 in this slot by MSVC; it doesn't seem to cause problems (so far),
674 but since it's the best we've got, use it. It does do the right
676 if (pe->has_reloc_section)
677 add_data_entry (abfd, extra, 5, ".reloc", ib);
686 for (sec = abfd->sections; sec; sec = sec->next)
688 int rounded = FA (sec->size);
690 /* The first non-zero section filepos is the header size.
691 Sections without contents will have a filepos of 0. */
693 hsize = sec->filepos;
694 if (sec->flags & SEC_DATA)
696 if (sec->flags & SEC_CODE)
698 /* The image size is the total VIRTUAL size (which is what is
699 in the virt_size field). Files have been seen (from MSVC
700 5.0 link.exe) where the file size of the .data segment is
701 quite small compared to the virtual size. Without this
702 fix, strip munges the file.
704 FIXME: We need to handle holes between sections, which may
705 happpen when we covert from another format. We just use
706 the virtual address and virtual size of the last section
707 for the image size. */
708 if (coff_section_data (abfd, sec) != NULL
709 && pei_section_data (abfd, sec) != NULL)
710 isize = (sec->vma - extra->ImageBase
711 + SA (FA (pei_section_data (abfd, sec)->virt_size)));
714 aouthdr_in->dsize = dsize;
715 aouthdr_in->tsize = tsize;
716 extra->SizeOfHeaders = hsize;
717 extra->SizeOfImage = isize;
720 H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
722 /* e.g. 219510000 is linker version 2.19 */
723 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
725 /* This piece of magic sets the "linker version" field to
727 H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
728 aouthdr_out->standard.vstamp);
730 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
731 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
732 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
733 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
734 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
735 aouthdr_out->standard.text_start);
737 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
738 /* PE32+ does not have data_start member! */
739 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
740 aouthdr_out->standard.data_start);
743 PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
744 H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
745 H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
746 H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
747 aouthdr_out->MajorOperatingSystemVersion);
748 H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
749 aouthdr_out->MinorOperatingSystemVersion);
750 H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
751 H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
752 H_PUT_16 (abfd, extra->MajorSubsystemVersion,
753 aouthdr_out->MajorSubsystemVersion);
754 H_PUT_16 (abfd, extra->MinorSubsystemVersion,
755 aouthdr_out->MinorSubsystemVersion);
756 H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
757 H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
758 H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
759 H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
760 H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
761 H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
762 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
763 aouthdr_out->SizeOfStackReserve);
764 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
765 aouthdr_out->SizeOfStackCommit);
766 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
767 aouthdr_out->SizeOfHeapReserve);
768 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
769 aouthdr_out->SizeOfHeapCommit);
770 H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
771 H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
772 aouthdr_out->NumberOfRvaAndSizes);
776 for (idx = 0; idx < 16; idx++)
778 H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
779 aouthdr_out->DataDirectory[idx][0]);
780 H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
781 aouthdr_out->DataDirectory[idx][1]);
789 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
792 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
793 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
795 if (pe_data (abfd)->has_reloc_section
796 || pe_data (abfd)->dont_strip_reloc)
797 filehdr_in->f_flags &= ~F_RELFLG;
799 if (pe_data (abfd)->dll)
800 filehdr_in->f_flags |= F_DLL;
802 filehdr_in->pe.e_magic = DOSMAGIC;
803 filehdr_in->pe.e_cblp = 0x90;
804 filehdr_in->pe.e_cp = 0x3;
805 filehdr_in->pe.e_crlc = 0x0;
806 filehdr_in->pe.e_cparhdr = 0x4;
807 filehdr_in->pe.e_minalloc = 0x0;
808 filehdr_in->pe.e_maxalloc = 0xffff;
809 filehdr_in->pe.e_ss = 0x0;
810 filehdr_in->pe.e_sp = 0xb8;
811 filehdr_in->pe.e_csum = 0x0;
812 filehdr_in->pe.e_ip = 0x0;
813 filehdr_in->pe.e_cs = 0x0;
814 filehdr_in->pe.e_lfarlc = 0x40;
815 filehdr_in->pe.e_ovno = 0x0;
817 for (idx = 0; idx < 4; idx++)
818 filehdr_in->pe.e_res[idx] = 0x0;
820 filehdr_in->pe.e_oemid = 0x0;
821 filehdr_in->pe.e_oeminfo = 0x0;
823 for (idx = 0; idx < 10; idx++)
824 filehdr_in->pe.e_res2[idx] = 0x0;
826 filehdr_in->pe.e_lfanew = 0x80;
828 /* This next collection of data are mostly just characters. It
829 appears to be constant within the headers put on NT exes. */
830 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
831 filehdr_in->pe.dos_message[1] = 0xcd09b400;
832 filehdr_in->pe.dos_message[2] = 0x4c01b821;
833 filehdr_in->pe.dos_message[3] = 0x685421cd;
834 filehdr_in->pe.dos_message[4] = 0x70207369;
835 filehdr_in->pe.dos_message[5] = 0x72676f72;
836 filehdr_in->pe.dos_message[6] = 0x63206d61;
837 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
838 filehdr_in->pe.dos_message[8] = 0x65622074;
839 filehdr_in->pe.dos_message[9] = 0x6e757220;
840 filehdr_in->pe.dos_message[10] = 0x206e6920;
841 filehdr_in->pe.dos_message[11] = 0x20534f44;
842 filehdr_in->pe.dos_message[12] = 0x65646f6d;
843 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
844 filehdr_in->pe.dos_message[14] = 0x24;
845 filehdr_in->pe.dos_message[15] = 0x0;
846 filehdr_in->pe.nt_signature = NT_SIGNATURE;
848 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
849 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
851 /* Only use a real timestamp if the option was chosen. */
852 if ((pe_data (abfd)->insert_timestamp))
853 H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
855 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
856 filehdr_out->f_symptr);
857 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
858 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
859 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
861 /* Put in extra dos header stuff. This data remains essentially
862 constant, it just has to be tacked on to the beginning of all exes
864 H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
865 H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
866 H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
867 H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
868 H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
869 H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
870 H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
871 H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
872 H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
873 H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
874 H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
875 H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
876 H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
877 H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
879 for (idx = 0; idx < 4; idx++)
880 H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
882 H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
883 H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
885 for (idx = 0; idx < 10; idx++)
886 H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
888 H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
890 for (idx = 0; idx < 16; idx++)
891 H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
892 filehdr_out->dos_message[idx]);
894 /* Also put in the NT signature. */
895 H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
901 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
903 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
904 FILHDR *filehdr_out = (FILHDR *) out;
906 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
907 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
908 H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
909 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
910 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
911 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
912 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
918 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
920 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
921 SCNHDR *scnhdr_ext = (SCNHDR *) out;
922 unsigned int ret = SCNHSZ;
926 memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
928 PUT_SCNHDR_VADDR (abfd,
929 ((scnhdr_int->s_vaddr
930 - pe_data (abfd)->pe_opthdr.ImageBase)
932 scnhdr_ext->s_vaddr);
934 /* NT wants the size data to be rounded up to the next
935 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
937 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
939 if (bfd_pei_p (abfd))
941 ps = scnhdr_int->s_size;
947 ss = scnhdr_int->s_size;
952 if (bfd_pei_p (abfd))
953 ps = scnhdr_int->s_paddr;
957 ss = scnhdr_int->s_size;
960 PUT_SCNHDR_SIZE (abfd, ss,
963 /* s_paddr in PE is really the virtual size. */
964 PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
966 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
967 scnhdr_ext->s_scnptr);
968 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
969 scnhdr_ext->s_relptr);
970 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
971 scnhdr_ext->s_lnnoptr);
974 /* Extra flags must be set when dealing with PE. All sections should also
975 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
976 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
977 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
978 (this is especially important when dealing with the .idata section since
979 the addresses for routines from .dlls must be overwritten). If .reloc
980 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
981 (0x02000000). Also, the resource data should also be read and
984 /* FIXME: Alignment is also encoded in this field, at least on PPC and
985 ARM-WINCE. Although - how do we get the original alignment field
990 const char * section_name;
991 unsigned long must_have;
993 pe_required_section_flags;
995 pe_required_section_flags known_sections [] =
997 { ".arch", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
998 { ".bss", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
999 { ".data", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1000 { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1001 { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1002 { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1003 { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1004 { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
1005 { ".rsrc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1006 { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
1007 { ".tls", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1008 { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1012 pe_required_section_flags * p;
1014 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1015 we know exactly what this specific section wants so we remove it
1016 and then allow the must_have field to add it back in if necessary.
1017 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1018 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1019 by ld --enable-auto-import (if auto-import is actually needed),
1020 by ld --omagic, or by obcopy --writable-text. */
1022 for (p = known_sections; p->section_name; p++)
1023 if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
1025 if (strcmp (scnhdr_int->s_name, ".text")
1026 || (bfd_get_file_flags (abfd) & WP_TEXT))
1027 scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
1028 scnhdr_int->s_flags |= p->must_have;
1032 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1035 if (coff_data (abfd)->link_info
1036 && ! coff_data (abfd)->link_info->relocatable
1037 && ! coff_data (abfd)->link_info->shared
1038 && strcmp (scnhdr_int->s_name, ".text") == 0)
1040 /* By inference from looking at MS output, the 32 bit field
1041 which is the combination of the number_of_relocs and
1042 number_of_linenos is used for the line number count in
1043 executables. A 16-bit field won't do for cc1. The MS
1044 document says that the number of relocs is zero for
1045 executables, but the 17-th bit has been observed to be there.
1046 Overflow is not an issue: a 4G-line program will overflow a
1047 bunch of other fields long before this! */
1048 H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
1049 H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
1053 if (scnhdr_int->s_nlnno <= 0xffff)
1054 H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
1057 (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
1058 bfd_get_filename (abfd),
1059 scnhdr_int->s_nlnno);
1060 bfd_set_error (bfd_error_file_truncated);
1061 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
1065 /* Although we could encode 0xffff relocs here, we do not, to be
1066 consistent with other parts of bfd. Also it lets us warn, as
1067 we should never see 0xffff here w/o having the overflow flag
1069 if (scnhdr_int->s_nreloc < 0xffff)
1070 H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
1073 /* PE can deal with large #s of relocs, but not here. */
1074 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1075 scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1076 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1083 _bfd_XXi_swap_debugdir_in (bfd * abfd, void * ext1, void * in1)
1085 struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) ext1;
1086 struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) in1;
1088 in->Characteristics = H_GET_32(abfd, ext->Characteristics);
1089 in->TimeDateStamp = H_GET_32(abfd, ext->TimeDateStamp);
1090 in->MajorVersion = H_GET_16(abfd, ext->MajorVersion);
1091 in->MinorVersion = H_GET_16(abfd, ext->MinorVersion);
1092 in->Type = H_GET_32(abfd, ext->Type);
1093 in->SizeOfData = H_GET_32(abfd, ext->SizeOfData);
1094 in->AddressOfRawData = H_GET_32(abfd, ext->AddressOfRawData);
1095 in->PointerToRawData = H_GET_32(abfd, ext->PointerToRawData);
1099 _bfd_XXi_swap_debugdir_out (bfd * abfd, void * inp, void * extp)
1101 struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) extp;
1102 struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) inp;
1104 H_PUT_32(abfd, in->Characteristics, ext->Characteristics);
1105 H_PUT_32(abfd, in->TimeDateStamp, ext->TimeDateStamp);
1106 H_PUT_16(abfd, in->MajorVersion, ext->MajorVersion);
1107 H_PUT_16(abfd, in->MinorVersion, ext->MinorVersion);
1108 H_PUT_32(abfd, in->Type, ext->Type);
1109 H_PUT_32(abfd, in->SizeOfData, ext->SizeOfData);
1110 H_PUT_32(abfd, in->AddressOfRawData, ext->AddressOfRawData);
1111 H_PUT_32(abfd, in->PointerToRawData, ext->PointerToRawData);
1113 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY);
1116 static CODEVIEW_INFO *
1117 _bfd_XXi_slurp_codeview_record (bfd * abfd, file_ptr where, unsigned long length, CODEVIEW_INFO *cvinfo)
1121 if (bfd_seek (abfd, where, SEEK_SET) != 0)
1124 if (bfd_bread (buffer, 256, abfd) < 4)
1127 /* Ensure null termination of filename. */
1130 cvinfo->CVSignature = H_GET_32(abfd, buffer);
1133 if ((cvinfo->CVSignature == CVINFO_PDB70_CVSIGNATURE)
1134 && (length > sizeof (CV_INFO_PDB70)))
1136 CV_INFO_PDB70 *cvinfo70 = (CV_INFO_PDB70 *)(buffer);
1138 cvinfo->Age = H_GET_32(abfd, cvinfo70->Age);
1140 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1141 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1142 as 16 bytes in big-endian order. */
1143 bfd_putb32 (bfd_getl32 (cvinfo70->Signature), cvinfo->Signature);
1144 bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[4])), &(cvinfo->Signature[4]));
1145 bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[6])), &(cvinfo->Signature[6]));
1146 memcpy (&(cvinfo->Signature[8]), &(cvinfo70->Signature[8]), 8);
1148 cvinfo->SignatureLength = CV_INFO_SIGNATURE_LENGTH;
1149 // cvinfo->PdbFileName = cvinfo70->PdbFileName;
1153 else if ((cvinfo->CVSignature == CVINFO_PDB20_CVSIGNATURE)
1154 && (length > sizeof (CV_INFO_PDB20)))
1156 CV_INFO_PDB20 *cvinfo20 = (CV_INFO_PDB20 *)(buffer);
1157 cvinfo->Age = H_GET_32(abfd, cvinfo20->Age);
1158 memcpy (cvinfo->Signature, cvinfo20->Signature, 4);
1159 cvinfo->SignatureLength = 4;
1160 // cvinfo->PdbFileName = cvinfo20->PdbFileName;
1169 _bfd_XXi_write_codeview_record (bfd * abfd, file_ptr where, CODEVIEW_INFO *cvinfo)
1171 unsigned int size = sizeof (CV_INFO_PDB70) + 1;
1172 CV_INFO_PDB70 *cvinfo70;
1175 if (bfd_seek (abfd, where, SEEK_SET) != 0)
1178 cvinfo70 = (CV_INFO_PDB70 *) buffer;
1179 H_PUT_32 (abfd, CVINFO_PDB70_CVSIGNATURE, cvinfo70->CvSignature);
1181 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1182 in little-endian order, followed by 8 single bytes. */
1183 bfd_putl32 (bfd_getb32 (cvinfo->Signature), cvinfo70->Signature);
1184 bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[4])), &(cvinfo70->Signature[4]));
1185 bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[6])), &(cvinfo70->Signature[6]));
1186 memcpy (&(cvinfo70->Signature[8]), &(cvinfo->Signature[8]), 8);
1188 H_PUT_32 (abfd, cvinfo->Age, cvinfo70->Age);
1189 cvinfo70->PdbFileName[0] = '\0';
1191 if (bfd_bwrite (buffer, size, abfd) != size)
1197 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1199 N_("Export Directory [.edata (or where ever we found it)]"),
1200 N_("Import Directory [parts of .idata]"),
1201 N_("Resource Directory [.rsrc]"),
1202 N_("Exception Directory [.pdata]"),
1203 N_("Security Directory"),
1204 N_("Base Relocation Directory [.reloc]"),
1205 N_("Debug Directory"),
1206 N_("Description Directory"),
1207 N_("Special Directory"),
1208 N_("Thread Storage Directory [.tls]"),
1209 N_("Load Configuration Directory"),
1210 N_("Bound Import Directory"),
1211 N_("Import Address Table Directory"),
1212 N_("Delay Import Directory"),
1213 N_("CLR Runtime Header"),
1217 #ifdef POWERPC_LE_PE
1218 /* The code for the PPC really falls in the "architecture dependent"
1219 category. However, it's not clear that anyone will ever care, so
1220 we're ignoring the issue for now; if/when PPC matters, some of this
1221 may need to go into peicode.h, or arguments passed to enable the
1222 PPC- specific code. */
1226 pe_print_idata (bfd * abfd, void * vfile)
1228 FILE *file = (FILE *) vfile;
1233 #ifdef POWERPC_LE_PE
1234 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1237 bfd_size_type datasize = 0;
1238 bfd_size_type dataoff;
1242 pe_data_type *pe = pe_data (abfd);
1243 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1247 addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
1249 if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
1251 /* Maybe the extra header isn't there. Look for the section. */
1252 section = bfd_get_section_by_name (abfd, ".idata");
1253 if (section == NULL)
1256 addr = section->vma;
1257 datasize = section->size;
1263 addr += extra->ImageBase;
1264 for (section = abfd->sections; section != NULL; section = section->next)
1266 datasize = section->size;
1267 if (addr >= section->vma && addr < section->vma + datasize)
1271 if (section == NULL)
1274 _("\nThere is an import table, but the section containing it could not be found\n"));
1277 else if (!(section->flags & SEC_HAS_CONTENTS))
1280 _("\nThere is an import table in %s, but that section has no contents\n"),
1286 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1287 section->name, (unsigned long) addr);
1289 dataoff = addr - section->vma;
1291 #ifdef POWERPC_LE_PE
1292 if (rel_section != 0 && rel_section->size != 0)
1294 /* The toc address can be found by taking the starting address,
1295 which on the PPC locates a function descriptor. The
1296 descriptor consists of the function code starting address
1297 followed by the address of the toc. The starting address we
1298 get from the bfd, and the descriptor is supposed to be in the
1299 .reldata section. */
1301 bfd_vma loadable_toc_address;
1302 bfd_vma toc_address;
1303 bfd_vma start_address;
1307 if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1314 offset = abfd->start_address - rel_section->vma;
1316 if (offset >= rel_section->size || offset + 8 > rel_section->size)
1323 start_address = bfd_get_32 (abfd, data + offset);
1324 loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1325 toc_address = loadable_toc_address - 32768;
1328 _("\nFunction descriptor located at the start address: %04lx\n"),
1329 (unsigned long int) (abfd->start_address));
1331 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1332 start_address, loadable_toc_address, toc_address);
1339 _("\nNo reldata section! Function descriptor not decoded.\n"));
1344 _("\nThe Import Tables (interpreted %s section contents)\n"),
1348 vma: Hint Time Forward DLL First\n\
1349 Table Stamp Chain Name Thunk\n"));
1351 /* Read the whole section. Some of the fields might be before dataoff. */
1352 if (!bfd_malloc_and_get_section (abfd, section, &data))
1359 adj = section->vma - extra->ImageBase;
1361 /* Print all image import descriptors. */
1362 for (i = dataoff; i + onaline <= datasize; i += onaline)
1366 bfd_vma forward_chain;
1368 bfd_vma first_thunk;
1373 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1374 fprintf (file, " %08lx\t", (unsigned long) (i + adj));
1375 hint_addr = bfd_get_32 (abfd, data + i);
1376 time_stamp = bfd_get_32 (abfd, data + i + 4);
1377 forward_chain = bfd_get_32 (abfd, data + i + 8);
1378 dll_name = bfd_get_32 (abfd, data + i + 12);
1379 first_thunk = bfd_get_32 (abfd, data + i + 16);
1381 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1382 (unsigned long) hint_addr,
1383 (unsigned long) time_stamp,
1384 (unsigned long) forward_chain,
1385 (unsigned long) dll_name,
1386 (unsigned long) first_thunk);
1388 if (hint_addr == 0 && first_thunk == 0)
1391 if (dll_name - adj >= section->size)
1394 dll = (char *) data + dll_name - adj;
1395 fprintf (file, _("\n\tDLL Name: %s\n"), dll);
1400 asection *ft_section;
1402 bfd_size_type ft_datasize;
1406 fprintf (file, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1408 idx = hint_addr - adj;
1410 ft_addr = first_thunk + extra->ImageBase;
1411 ft_idx = first_thunk - adj;
1412 ft_data = data + ft_idx;
1413 ft_datasize = datasize - ft_idx;
1416 if (first_thunk != hint_addr)
1418 /* Find the section which contains the first thunk. */
1419 for (ft_section = abfd->sections;
1421 ft_section = ft_section->next)
1423 if (ft_addr >= ft_section->vma
1424 && ft_addr < ft_section->vma + ft_section->size)
1428 if (ft_section == NULL)
1431 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1435 /* Now check to see if this section is the same as our current
1436 section. If it is not then we will have to load its data in. */
1437 if (ft_section != section)
1439 ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1440 ft_datasize = ft_section->size - ft_idx;
1441 ft_data = (bfd_byte *) bfd_malloc (ft_datasize);
1442 if (ft_data == NULL)
1445 /* Read ft_datasize bytes starting at offset ft_idx. */
1446 if (!bfd_get_section_contents (abfd, ft_section, ft_data,
1447 (bfd_vma) ft_idx, ft_datasize))
1456 /* Print HintName vector entries. */
1457 #ifdef COFF_WITH_pex64
1458 for (j = 0; idx + j + 8 <= datasize; j += 8)
1460 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1461 unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1463 if (!member && !member_high)
1466 if (HighBitSet (member_high))
1467 fprintf (file, "\t%lx%08lx\t %4lx%08lx <none>",
1468 member_high, member,
1469 WithoutHighBit (member_high), member);
1475 ordinal = bfd_get_16 (abfd, data + member - adj);
1476 member_name = (char *) data + member - adj + 2;
1477 fprintf (file, "\t%04lx\t %4d %s",member, ordinal, member_name);
1480 /* If the time stamp is not zero, the import address
1481 table holds actual addresses. */
1484 && first_thunk != hint_addr
1485 && j + 4 <= ft_datasize)
1486 fprintf (file, "\t%04lx",
1487 (unsigned long) bfd_get_32 (abfd, ft_data + j));
1488 fprintf (file, "\n");
1491 for (j = 0; idx + j + 4 <= datasize; j += 4)
1493 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1495 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1499 if (HighBitSet (member))
1500 fprintf (file, "\t%04lx\t %4lu <none>",
1501 member, WithoutHighBit (member));
1507 ordinal = bfd_get_16 (abfd, data + member - adj);
1508 member_name = (char *) data + member - adj + 2;
1509 fprintf (file, "\t%04lx\t %4d %s",
1510 member, ordinal, member_name);
1513 /* If the time stamp is not zero, the import address
1514 table holds actual addresses. */
1517 && first_thunk != hint_addr
1518 && j + 4 <= ft_datasize)
1519 fprintf (file, "\t%04lx",
1520 (unsigned long) bfd_get_32 (abfd, ft_data + j));
1522 fprintf (file, "\n");
1529 fprintf (file, "\n");
1538 pe_print_edata (bfd * abfd, void * vfile)
1540 FILE *file = (FILE *) vfile;
1543 bfd_size_type datasize = 0;
1544 bfd_size_type dataoff;
1549 long export_flags; /* Reserved - should be zero. */
1553 bfd_vma name; /* RVA - relative to image base. */
1554 long base; /* Ordinal base. */
1555 unsigned long num_functions;/* Number in the export address table. */
1556 unsigned long num_names; /* Number in the name pointer table. */
1557 bfd_vma eat_addr; /* RVA to the export address table. */
1558 bfd_vma npt_addr; /* RVA to the Export Name Pointer Table. */
1559 bfd_vma ot_addr; /* RVA to the Ordinal Table. */
1562 pe_data_type *pe = pe_data (abfd);
1563 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1567 addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
1569 if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
1571 /* Maybe the extra header isn't there. Look for the section. */
1572 section = bfd_get_section_by_name (abfd, ".edata");
1573 if (section == NULL)
1576 addr = section->vma;
1578 datasize = section->size;
1584 addr += extra->ImageBase;
1586 for (section = abfd->sections; section != NULL; section = section->next)
1587 if (addr >= section->vma && addr < section->vma + section->size)
1590 if (section == NULL)
1593 _("\nThere is an export table, but the section containing it could not be found\n"));
1596 else if (!(section->flags & SEC_HAS_CONTENTS))
1599 _("\nThere is an export table in %s, but that section has no contents\n"),
1604 dataoff = addr - section->vma;
1605 datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
1606 if (datasize > section->size - dataoff)
1609 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1615 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1616 section->name, (unsigned long) addr);
1618 data = (bfd_byte *) bfd_malloc (datasize);
1622 if (! bfd_get_section_contents (abfd, section, data,
1623 (file_ptr) dataoff, datasize))
1626 /* Go get Export Directory Table. */
1627 edt.export_flags = bfd_get_32 (abfd, data + 0);
1628 edt.time_stamp = bfd_get_32 (abfd, data + 4);
1629 edt.major_ver = bfd_get_16 (abfd, data + 8);
1630 edt.minor_ver = bfd_get_16 (abfd, data + 10);
1631 edt.name = bfd_get_32 (abfd, data + 12);
1632 edt.base = bfd_get_32 (abfd, data + 16);
1633 edt.num_functions = bfd_get_32 (abfd, data + 20);
1634 edt.num_names = bfd_get_32 (abfd, data + 24);
1635 edt.eat_addr = bfd_get_32 (abfd, data + 28);
1636 edt.npt_addr = bfd_get_32 (abfd, data + 32);
1637 edt.ot_addr = bfd_get_32 (abfd, data + 36);
1639 adj = section->vma - extra->ImageBase + dataoff;
1641 /* Dump the EDT first. */
1643 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1647 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1650 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1653 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1656 _("Name \t\t\t\t"));
1657 bfd_fprintf_vma (abfd, file, edt.name);
1659 if ((edt.name >= adj) && (edt.name < adj + datasize))
1660 fprintf (file, " %s\n", data + edt.name - adj);
1662 fprintf (file, "(outside .edata section)\n");
1665 _("Ordinal Base \t\t\t%ld\n"), edt.base);
1671 _("\tExport Address Table \t\t%08lx\n"),
1675 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1678 _("Table Addresses\n"));
1681 _("\tExport Address Table \t\t"));
1682 bfd_fprintf_vma (abfd, file, edt.eat_addr);
1683 fprintf (file, "\n");
1686 _("\tName Pointer Table \t\t"));
1687 bfd_fprintf_vma (abfd, file, edt.npt_addr);
1688 fprintf (file, "\n");
1691 _("\tOrdinal Table \t\t\t"));
1692 bfd_fprintf_vma (abfd, file, edt.ot_addr);
1693 fprintf (file, "\n");
1695 /* The next table to find is the Export Address Table. It's basically
1696 a list of pointers that either locate a function in this dll, or
1697 forward the call to another dll. Something like:
1702 } export_address_table_entry; */
1705 _("\nExport Address Table -- Ordinal Base %ld\n"),
1708 /* PR 17512: Handle corrupt PE binaries. */
1709 if (edt.eat_addr + (edt.num_functions * 4) - adj >= datasize)
1710 fprintf (file, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1711 (long) edt.eat_addr,
1712 (long) edt.num_functions);
1713 else for (i = 0; i < edt.num_functions; ++i)
1715 bfd_vma eat_member = bfd_get_32 (abfd,
1716 data + edt.eat_addr + (i * 4) - adj);
1717 if (eat_member == 0)
1720 if (eat_member - adj <= datasize)
1722 /* This rva is to a name (forwarding function) in our section. */
1723 /* Should locate a function descriptor. */
1725 "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1727 (long) (i + edt.base),
1728 (unsigned long) eat_member,
1730 data + eat_member - adj);
1734 /* Should locate a function descriptor in the reldata section. */
1736 "\t[%4ld] +base[%4ld] %04lx %s\n",
1738 (long) (i + edt.base),
1739 (unsigned long) eat_member,
1744 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1745 /* Dump them in parallel for clarity. */
1747 _("\n[Ordinal/Name Pointer] Table\n"));
1749 /* PR 17512: Handle corrupt PE binaries. */
1750 if (edt.npt_addr + (edt.num_names * 4) - adj >= datasize)
1751 fprintf (file, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1752 (long) edt.npt_addr,
1753 (long) edt.num_names);
1754 else if (edt.ot_addr + (edt.num_names * 2) - adj >= datasize)
1755 fprintf (file, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1757 (long) edt.num_names);
1758 else for (i = 0; i < edt.num_names; ++i)
1760 bfd_vma name_ptr = bfd_get_32 (abfd,
1765 char *name = (char *) data + name_ptr - adj;
1767 bfd_vma ord = bfd_get_16 (abfd,
1772 "\t[%4ld] %s\n", (long) ord, name);
1780 /* This really is architecture dependent. On IA-64, a .pdata entry
1781 consists of three dwords containing relative virtual addresses that
1782 specify the start and end address of the code range the entry
1783 covers and the address of the corresponding unwind info data.
1785 On ARM and SH-4, a compressed PDATA structure is used :
1786 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1787 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1788 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1790 This is the version for uncompressed data. */
1793 pe_print_pdata (bfd * abfd, void * vfile)
1795 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1796 # define PDATA_ROW_SIZE (3 * 8)
1798 # define PDATA_ROW_SIZE (5 * 4)
1800 FILE *file = (FILE *) vfile;
1802 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1803 bfd_size_type datasize = 0;
1805 bfd_size_type start, stop;
1806 int onaline = PDATA_ROW_SIZE;
1809 || coff_section_data (abfd, section) == NULL
1810 || pei_section_data (abfd, section) == NULL)
1813 stop = pei_section_data (abfd, section)->virt_size;
1814 if ((stop % onaline) != 0)
1816 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1817 (long) stop, onaline);
1820 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1821 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1823 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1826 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1827 \t\tAddress Address Handler Data Address Mask\n"));
1830 datasize = section->size;
1834 if (! bfd_malloc_and_get_section (abfd, section, &data))
1843 for (i = start; i < stop; i += onaline)
1849 bfd_vma prolog_end_addr;
1850 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1854 if (i + PDATA_ROW_SIZE > stop)
1857 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
1858 end_addr = GET_PDATA_ENTRY (abfd, data + i + 4);
1859 eh_handler = GET_PDATA_ENTRY (abfd, data + i + 8);
1860 eh_data = GET_PDATA_ENTRY (abfd, data + i + 12);
1861 prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1863 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1864 && eh_data == 0 && prolog_end_addr == 0)
1865 /* We are probably into the padding of the section now. */
1868 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1869 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1871 eh_handler &= ~(bfd_vma) 0x3;
1872 prolog_end_addr &= ~(bfd_vma) 0x3;
1875 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
1876 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
1877 bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file);
1878 bfd_fprintf_vma (abfd, file, eh_handler);
1879 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1881 bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file);
1882 bfd_fprintf_vma (abfd, file, prolog_end_addr);
1883 fprintf (file, " %x", em_data);
1886 #ifdef POWERPC_LE_PE
1887 if (eh_handler == 0 && eh_data != 0)
1889 /* Special bits here, although the meaning may be a little
1890 mysterious. The only one I know for sure is 0x03
1893 0x01 Register Save Millicode
1894 0x02 Register Restore Millicode
1895 0x03 Glue Code Sequence. */
1899 fprintf (file, _(" Register save millicode"));
1902 fprintf (file, _(" Register restore millicode"));
1905 fprintf (file, _(" Glue code sequence"));
1912 fprintf (file, "\n");
1918 #undef PDATA_ROW_SIZE
1921 typedef struct sym_cache
1928 slurp_symtab (bfd *abfd, sym_cache *psc)
1930 asymbol ** sy = NULL;
1933 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
1939 storage = bfd_get_symtab_upper_bound (abfd);
1943 sy = (asymbol **) bfd_malloc (storage);
1945 psc->symcount = bfd_canonicalize_symtab (abfd, sy);
1946 if (psc->symcount < 0)
1952 my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc)
1957 psc->syms = slurp_symtab (abfd, psc);
1959 for (i = 0; i < psc->symcount; i++)
1961 if (psc->syms[i]->section->vma + psc->syms[i]->value == func)
1962 return psc->syms[i]->name;
1969 cleanup_syms (sym_cache *psc)
1976 /* This is the version for "compressed" pdata. */
1979 _bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile)
1981 # define PDATA_ROW_SIZE (2 * 4)
1982 FILE *file = (FILE *) vfile;
1983 bfd_byte *data = NULL;
1984 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1985 bfd_size_type datasize = 0;
1987 bfd_size_type start, stop;
1988 int onaline = PDATA_ROW_SIZE;
1989 struct sym_cache cache = {0, 0} ;
1992 || coff_section_data (abfd, section) == NULL
1993 || pei_section_data (abfd, section) == NULL)
1996 stop = pei_section_data (abfd, section)->virt_size;
1997 if ((stop % onaline) != 0)
1999 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
2000 (long) stop, onaline);
2003 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2006 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2007 \t\tAddress Length Length 32b exc Handler Data\n"));
2009 datasize = section->size;
2013 if (! bfd_malloc_and_get_section (abfd, section, &data))
2022 for (i = start; i < stop; i += onaline)
2026 bfd_vma prolog_length, function_length;
2027 int flag32bit, exception_flag;
2030 if (i + PDATA_ROW_SIZE > stop)
2033 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
2034 other_data = GET_PDATA_ENTRY (abfd, data + i + 4);
2036 if (begin_addr == 0 && other_data == 0)
2037 /* We are probably into the padding of the section now. */
2040 prolog_length = (other_data & 0x000000FF);
2041 function_length = (other_data & 0x3FFFFF00) >> 8;
2042 flag32bit = (int)((other_data & 0x40000000) >> 30);
2043 exception_flag = (int)((other_data & 0x80000000) >> 31);
2046 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
2047 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
2048 bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file);
2049 bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file);
2050 fprintf (file, "%2d %2d ", flag32bit, exception_flag);
2052 /* Get the exception handler's address and the data passed from the
2053 .text section. This is really the data that belongs with the .pdata
2054 but got "compressed" out for the ARM and SH4 architectures. */
2055 tsection = bfd_get_section_by_name (abfd, ".text");
2056 if (tsection && coff_section_data (abfd, tsection)
2057 && pei_section_data (abfd, tsection))
2059 bfd_vma eh_off = (begin_addr - 8) - tsection->vma;
2062 tdata = (bfd_byte *) bfd_malloc (8);
2065 if (bfd_get_section_contents (abfd, tsection, tdata, eh_off, 8))
2067 bfd_vma eh, eh_data;
2069 eh = bfd_get_32 (abfd, tdata);
2070 eh_data = bfd_get_32 (abfd, tdata + 4);
2071 fprintf (file, "%08x ", (unsigned int) eh);
2072 fprintf (file, "%08x", (unsigned int) eh_data);
2075 const char *s = my_symbol_for_address (abfd, eh, &cache);
2078 fprintf (file, " (%s) ", s);
2085 fprintf (file, "\n");
2090 cleanup_syms (& cache);
2093 #undef PDATA_ROW_SIZE
2097 #define IMAGE_REL_BASED_HIGHADJ 4
2098 static const char * const tbl[] =
2112 "UNKNOWN", /* MUST be last. */
2116 pe_print_reloc (bfd * abfd, void * vfile)
2118 FILE *file = (FILE *) vfile;
2120 asection *section = bfd_get_section_by_name (abfd, ".reloc");
2123 if (section == NULL || section->size == 0 || !(section->flags & SEC_HAS_CONTENTS))
2127 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2129 if (! bfd_malloc_and_get_section (abfd, section, &data))
2137 end = data + section->size;
2138 while (p + 8 <= end)
2141 bfd_vma virtual_address;
2143 bfd_byte *chunk_end;
2145 /* The .reloc section is a sequence of blocks, with a header consisting
2146 of two 32 bit quantities, followed by a number of 16 bit entries. */
2147 virtual_address = bfd_get_32 (abfd, p);
2148 size = bfd_get_32 (abfd, p + 4);
2150 number = (size - 8) / 2;
2156 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2157 (unsigned long) virtual_address, size, (unsigned long) size, number);
2159 chunk_end = p + size;
2160 if (chunk_end > end)
2163 while (p + 2 <= chunk_end)
2165 unsigned short e = bfd_get_16 (abfd, p);
2166 unsigned int t = (e & 0xF000) >> 12;
2167 int off = e & 0x0FFF;
2169 if (t >= sizeof (tbl) / sizeof (tbl[0]))
2170 t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
2173 _("\treloc %4d offset %4x [%4lx] %s"),
2174 j, off, (unsigned long) (off + virtual_address), tbl[t]);
2179 /* HIGHADJ takes an argument, - the next record *is* the
2180 low 16 bits of addend. */
2181 if (t == IMAGE_REL_BASED_HIGHADJ && p + 2 <= chunk_end)
2183 fprintf (file, " (%4x)", (unsigned int) bfd_get_16 (abfd, p));
2188 fprintf (file, "\n");
2197 /* A data structure describing the regions of a .rsrc section.
2198 Some fields are filled in as the section is parsed. */
2200 typedef struct rsrc_regions
2202 bfd_byte * section_start;
2203 bfd_byte * section_end;
2204 bfd_byte * strings_start;
2205 bfd_byte * resource_start;
2209 rsrc_print_resource_directory (FILE * , bfd *, unsigned int, bfd_byte *,
2210 rsrc_regions *, bfd_vma);
2213 rsrc_print_resource_entries (FILE * file,
2215 unsigned int indent,
2216 bfd_boolean is_name,
2218 rsrc_regions * regions,
2221 unsigned long entry, addr, size;
2223 if (data + 8 >= regions->section_end)
2224 return regions->section_end + 1;
2226 fprintf (file, _("%03x %*.s Entry: "), (int)(data - regions->section_start), indent, " ");
2228 entry = (long) bfd_get_32 (abfd, data);
2233 /* Note - the documentation says that this field is an RVA value
2234 but windres appears to produce a section relative offset with
2235 the top bit set. Support both styles for now. */
2236 if (HighBitSet (entry))
2237 name = regions->section_start + WithoutHighBit (entry);
2239 name = regions->section_start + entry - rva_bias;
2241 if (name + 2 < regions->section_end)
2245 if (regions->strings_start == NULL)
2246 regions->strings_start = name;
2248 len = bfd_get_16 (abfd, name);
2250 fprintf (file, _("name: [val: %08lx len %d]: "), entry, len);
2251 if (name + 2 + len * 2 < regions->section_end)
2253 /* This strange loop is to cope with multibyte characters. */
2257 fprintf (file, "%.1s", name);
2261 fprintf (file, _("<corrupt string length: %#x>"), len);
2264 fprintf (file, _("<corrupt string offset: %#lx>"), entry);
2267 fprintf (file, _("ID: %#08lx"), entry);
2269 entry = (long) bfd_get_32 (abfd, data + 4);
2270 fprintf (file, _(", Value: %#08lx\n"), entry);
2272 if (HighBitSet (entry))
2273 return rsrc_print_resource_directory (file, abfd, indent + 1,
2274 regions->section_start + WithoutHighBit (entry),
2277 if (regions->section_start + entry + 16 >= regions->section_end)
2278 return regions->section_end + 1;
2280 fprintf (file, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2283 addr = (long) bfd_get_32 (abfd, regions->section_start + entry),
2284 size = (long) bfd_get_32 (abfd, regions->section_start + entry + 4),
2285 (int) bfd_get_32 (abfd, regions->section_start + entry + 8));
2287 /* Check that the reserved entry is 0. */
2288 if (bfd_get_32 (abfd, regions->section_start + entry + 12) != 0
2289 /* And that the data address/size is valid too. */
2290 || (regions->section_start + (addr - rva_bias) + size > regions->section_end))
2291 return regions->section_end + 1;
2293 if (regions->resource_start == NULL)
2294 regions->resource_start = regions->section_start + (addr - rva_bias);
2296 return regions->section_start + (addr - rva_bias) + size;
2299 #define max(a,b) ((a) > (b) ? (a) : (b))
2300 #define min(a,b) ((a) < (b) ? (a) : (b))
2303 rsrc_print_resource_directory (FILE * file,
2305 unsigned int indent,
2307 rsrc_regions * regions,
2310 unsigned int num_names, num_ids;
2311 bfd_byte * highest_data = data;
2313 if (data + 16 >= regions->section_end)
2314 return regions->section_end + 1;
2316 fprintf (file, "%03x %*.s ", (int)(data - regions->section_start), indent, " ");
2319 case 0: fprintf (file, "Type"); break;
2320 case 2: fprintf (file, "Name"); break;
2321 case 4: fprintf (file, "Language"); break;
2322 default: fprintf (file, "<unknown>"); break;
2325 fprintf (file, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2326 (int) bfd_get_32 (abfd, data),
2327 (long) bfd_get_32 (abfd, data + 4),
2328 (int) bfd_get_16 (abfd, data + 8),
2329 (int) bfd_get_16 (abfd, data + 10),
2330 num_names = (int) bfd_get_16 (abfd, data + 12),
2331 num_ids = (int) bfd_get_16 (abfd, data + 14));
2334 while (num_names --)
2336 bfd_byte * entry_end;
2338 entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, TRUE,
2339 data, regions, rva_bias);
2341 highest_data = max (highest_data, entry_end);
2342 if (entry_end >= regions->section_end)
2348 bfd_byte * entry_end;
2350 entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, FALSE,
2351 data, regions, rva_bias);
2353 highest_data = max (highest_data, entry_end);
2354 if (entry_end >= regions->section_end)
2358 return max (highest_data, data);
2361 /* Display the contents of a .rsrc section. We do not try to
2362 reproduce the resources, windres does that. Instead we dump
2363 the tables in a human readable format. */
2366 rsrc_print_section (bfd * abfd, void * vfile)
2370 FILE * file = (FILE *) vfile;
2371 bfd_size_type datasize;
2374 rsrc_regions regions;
2376 pe = pe_data (abfd);
2380 section = bfd_get_section_by_name (abfd, ".rsrc");
2381 if (section == NULL)
2383 if (!(section->flags & SEC_HAS_CONTENTS))
2386 datasize = section->size;
2390 rva_bias = section->vma - pe->pe_opthdr.ImageBase;
2392 if (! bfd_malloc_and_get_section (abfd, section, & data))
2399 regions.section_start = data;
2400 regions.section_end = data + datasize;
2401 regions.strings_start = NULL;
2402 regions.resource_start = NULL;
2405 fprintf (file, "\nThe .rsrc Resource Directory section:\n");
2407 while (data < regions.section_end)
2409 bfd_byte * p = data;
2411 data = rsrc_print_resource_directory (file, abfd, 0, data, & regions, rva_bias);
2413 if (data == regions.section_end + 1)
2414 fprintf (file, _("Corrupt .rsrc section detected!\n"));
2417 /* Align data before continuing. */
2418 int align = (1 << section->alignment_power) - 1;
2420 data = (bfd_byte *) (((ptrdiff_t) (data + align)) & ~ align);
2421 rva_bias += data - p;
2423 /* For reasons that are unclear .rsrc sections are sometimes created
2424 aligned to a 1^3 boundary even when their alignment is set at
2425 1^2. Catch that case here before we issue a spurious warning
2427 if (data == (regions.section_end - 4))
2428 data = regions.section_end;
2429 else if (data < regions.section_end)
2431 /* If the extra data is all zeros then do not complain.
2432 This is just padding so that the section meets the
2433 page size requirements. */
2434 while (data ++ < regions.section_end)
2437 if (data < regions.section_end)
2438 fprintf (file, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2443 if (regions.strings_start != NULL)
2444 fprintf (file, " String table starts at %03x\n",
2445 (int) (regions.strings_start - regions.section_start));
2446 if (regions.resource_start != NULL)
2447 fprintf (file, " Resources start at %03xx\n",
2448 (int) (regions.resource_start - regions.section_start));
2450 free (regions.section_start);
2454 #define IMAGE_NUMBEROF_DEBUG_TYPES 12
2456 static char * debug_type_names[IMAGE_NUMBEROF_DEBUG_TYPES] =
2473 pe_print_debugdata (bfd * abfd, void * vfile)
2475 FILE *file = (FILE *) vfile;
2476 pe_data_type *pe = pe_data (abfd);
2477 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
2480 bfd_size_type dataoff;
2483 bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress;
2484 bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size;
2489 addr += extra->ImageBase;
2490 for (section = abfd->sections; section != NULL; section = section->next)
2492 if ((addr >= section->vma) && (addr < (section->vma + section->size)))
2496 if (section == NULL)
2499 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2502 else if (!(section->flags & SEC_HAS_CONTENTS))
2505 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2510 fprintf (file, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2511 section->name, (unsigned long) addr);
2513 dataoff = addr - section->vma;
2516 _("Type Size Rva Offset\n"));
2518 /* Read the whole section. */
2519 if (!bfd_malloc_and_get_section (abfd, section, &data))
2526 for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
2528 const char *type_name;
2529 struct external_IMAGE_DEBUG_DIRECTORY *ext
2530 = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i];
2531 struct internal_IMAGE_DEBUG_DIRECTORY idd;
2533 _bfd_XXi_swap_debugdir_in (abfd, ext, &idd);
2535 if ((idd.Type) > IMAGE_NUMBEROF_DEBUG_TYPES)
2536 type_name = debug_type_names[0];
2538 type_name = debug_type_names[idd.Type];
2540 fprintf (file, " %2ld %14s %08lx %08lx %08lx\n",
2541 idd.Type, type_name, idd.SizeOfData,
2542 idd.AddressOfRawData, idd.PointerToRawData);
2544 if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW)
2546 char signature[CV_INFO_SIGNATURE_LENGTH * 2 + 1];
2547 char buffer[256 + 1];
2548 CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer;
2550 /* The debug entry doesn't have to have to be in a section,
2551 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2552 if (!_bfd_XXi_slurp_codeview_record (abfd, (file_ptr) idd.PointerToRawData,
2553 idd.SizeOfData, cvinfo))
2556 for (i = 0; i < cvinfo->SignatureLength; i++)
2557 sprintf (&signature[i*2], "%02x", cvinfo->Signature[i] & 0xff);
2559 fprintf (file, "(format %c%c%c%c signature %s age %ld)\n",
2560 buffer[0], buffer[1], buffer[2], buffer[3],
2561 signature, cvinfo->Age);
2565 if (size % sizeof (struct external_IMAGE_DEBUG_DIRECTORY) != 0)
2567 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2572 /* Print out the program headers. */
2575 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
2577 FILE *file = (FILE *) vfile;
2579 pe_data_type *pe = pe_data (abfd);
2580 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
2581 const char *subsystem_name = NULL;
2584 /* The MS dumpbin program reportedly ands with 0xff0f before
2585 printing the characteristics field. Not sure why. No reason to
2587 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
2589 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2590 PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
2591 PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
2592 PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
2593 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
2594 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
2595 PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
2596 PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
2597 PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
2598 PF (IMAGE_FILE_SYSTEM, "system file");
2599 PF (IMAGE_FILE_DLL, "DLL");
2600 PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
2603 /* ctime implies '\n'. */
2605 time_t t = pe->coff.timestamp;
2606 fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
2609 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2610 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2612 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2613 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2615 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2616 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2621 case IMAGE_NT_OPTIONAL_HDR_MAGIC:
2624 case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
2627 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
2634 fprintf (file, "Magic\t\t\t%04x", i->Magic);
2636 fprintf (file, "\t(%s)",name);
2637 fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
2638 fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
2639 fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode);
2640 fprintf (file, "SizeOfInitializedData\t%08lx\n",
2641 (unsigned long) i->SizeOfInitializedData);
2642 fprintf (file, "SizeOfUninitializedData\t%08lx\n",
2643 (unsigned long) i->SizeOfUninitializedData);
2644 fprintf (file, "AddressOfEntryPoint\t");
2645 bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
2646 fprintf (file, "\nBaseOfCode\t\t");
2647 bfd_fprintf_vma (abfd, file, i->BaseOfCode);
2648 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2649 /* PE32+ does not have BaseOfData member! */
2650 fprintf (file, "\nBaseOfData\t\t");
2651 bfd_fprintf_vma (abfd, file, i->BaseOfData);
2654 fprintf (file, "\nImageBase\t\t");
2655 bfd_fprintf_vma (abfd, file, i->ImageBase);
2656 fprintf (file, "\nSectionAlignment\t");
2657 bfd_fprintf_vma (abfd, file, i->SectionAlignment);
2658 fprintf (file, "\nFileAlignment\t\t");
2659 bfd_fprintf_vma (abfd, file, i->FileAlignment);
2660 fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
2661 fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
2662 fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
2663 fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
2664 fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
2665 fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
2666 fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1);
2667 fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage);
2668 fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders);
2669 fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum);
2671 switch (i->Subsystem)
2673 case IMAGE_SUBSYSTEM_UNKNOWN:
2674 subsystem_name = "unspecified";
2676 case IMAGE_SUBSYSTEM_NATIVE:
2677 subsystem_name = "NT native";
2679 case IMAGE_SUBSYSTEM_WINDOWS_GUI:
2680 subsystem_name = "Windows GUI";
2682 case IMAGE_SUBSYSTEM_WINDOWS_CUI:
2683 subsystem_name = "Windows CUI";
2685 case IMAGE_SUBSYSTEM_POSIX_CUI:
2686 subsystem_name = "POSIX CUI";
2688 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
2689 subsystem_name = "Wince CUI";
2691 // These are from UEFI Platform Initialization Specification 1.1.
2692 case IMAGE_SUBSYSTEM_EFI_APPLICATION:
2693 subsystem_name = "EFI application";
2695 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
2696 subsystem_name = "EFI boot service driver";
2698 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
2699 subsystem_name = "EFI runtime driver";
2701 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
2702 subsystem_name = "SAL runtime driver";
2704 // This is from revision 8.0 of the MS PE/COFF spec
2705 case IMAGE_SUBSYSTEM_XBOX:
2706 subsystem_name = "XBOX";
2708 // Added default case for clarity - subsystem_name is NULL anyway.
2710 subsystem_name = NULL;
2713 fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
2715 fprintf (file, "\t(%s)", subsystem_name);
2716 fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
2717 fprintf (file, "SizeOfStackReserve\t");
2718 bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve);
2719 fprintf (file, "\nSizeOfStackCommit\t");
2720 bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit);
2721 fprintf (file, "\nSizeOfHeapReserve\t");
2722 bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve);
2723 fprintf (file, "\nSizeOfHeapCommit\t");
2724 bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit);
2725 fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
2726 fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
2727 (unsigned long) i->NumberOfRvaAndSizes);
2729 fprintf (file, "\nThe Data Directory\n");
2730 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
2732 fprintf (file, "Entry %1x ", j);
2733 bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress);
2734 fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
2735 fprintf (file, "%s\n", dir_names[j]);
2738 pe_print_idata (abfd, vfile);
2739 pe_print_edata (abfd, vfile);
2740 if (bfd_coff_have_print_pdata (abfd))
2741 bfd_coff_print_pdata (abfd, vfile);
2743 pe_print_pdata (abfd, vfile);
2744 pe_print_reloc (abfd, vfile);
2745 pe_print_debugdata (abfd, file);
2747 rsrc_print_section (abfd, vfile);
2753 is_vma_in_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sect, void *obj)
2755 bfd_vma addr = * (bfd_vma *) obj;
2756 return (addr >= sect->vma) && (addr < (sect->vma + sect->size));
2760 find_section_by_vma (bfd *abfd, bfd_vma addr)
2762 return bfd_sections_find_if (abfd, is_vma_in_section, (void *) & addr);
2765 /* Copy any private info we understand from the input bfd
2766 to the output bfd. */
2769 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
2771 pe_data_type *ipe, *ope;
2773 /* One day we may try to grok other private data. */
2774 if (ibfd->xvec->flavour != bfd_target_coff_flavour
2775 || obfd->xvec->flavour != bfd_target_coff_flavour)
2778 ipe = pe_data (ibfd);
2779 ope = pe_data (obfd);
2781 /* pe_opthdr is copied in copy_object. */
2782 ope->dll = ipe->dll;
2784 /* Don't copy input subsystem if output is different from input. */
2785 if (obfd->xvec != ibfd->xvec)
2786 ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
2788 /* For strip: if we removed .reloc, we'll make a real mess of things
2789 if we don't remove this entry as well. */
2790 if (! pe_data (obfd)->has_reloc_section)
2792 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2793 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
2796 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2797 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2799 if (! pe_data (ibfd)->has_reloc_section
2800 && ! (pe_data (ibfd)->real_flags & IMAGE_FILE_RELOCS_STRIPPED))
2801 pe_data (obfd)->dont_strip_reloc = 1;
2803 /* The file offsets contained in the debug directory need rewriting. */
2804 if (ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size != 0)
2806 bfd_vma addr = ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].VirtualAddress
2807 + ope->pe_opthdr.ImageBase;
2808 asection *section = find_section_by_vma (obfd, addr);
2811 if (section && bfd_malloc_and_get_section (obfd, section, &data))
2814 struct external_IMAGE_DEBUG_DIRECTORY *dd =
2815 (struct external_IMAGE_DEBUG_DIRECTORY *)(data + (addr - section->vma));
2817 for (i = 0; i < ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size
2818 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
2820 asection *ddsection;
2821 struct external_IMAGE_DEBUG_DIRECTORY *edd = &(dd[i]);
2822 struct internal_IMAGE_DEBUG_DIRECTORY idd;
2824 _bfd_XXi_swap_debugdir_in (obfd, edd, &idd);
2826 if (idd.AddressOfRawData == 0)
2827 continue; /* RVA 0 means only offset is valid, not handled yet. */
2829 ddsection = find_section_by_vma (obfd, idd.AddressOfRawData + ope->pe_opthdr.ImageBase);
2831 continue; /* Not in a section! */
2833 idd.PointerToRawData = ddsection->filepos + (idd.AddressOfRawData
2834 + ope->pe_opthdr.ImageBase) - ddsection->vma;
2836 _bfd_XXi_swap_debugdir_out (obfd, &idd, edd);
2839 if (!bfd_set_section_contents (obfd, section, data, 0, section->size))
2840 _bfd_error_handler (_("Failed to update file offsets in debug directory"));
2847 /* Copy private section data. */
2850 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
2855 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
2856 || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
2859 if (coff_section_data (ibfd, isec) != NULL
2860 && pei_section_data (ibfd, isec) != NULL)
2862 if (coff_section_data (obfd, osec) == NULL)
2864 bfd_size_type amt = sizeof (struct coff_section_tdata);
2865 osec->used_by_bfd = bfd_zalloc (obfd, amt);
2866 if (osec->used_by_bfd == NULL)
2870 if (pei_section_data (obfd, osec) == NULL)
2872 bfd_size_type amt = sizeof (struct pei_section_tdata);
2873 coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
2874 if (coff_section_data (obfd, osec)->tdata == NULL)
2878 pei_section_data (obfd, osec)->virt_size =
2879 pei_section_data (ibfd, isec)->virt_size;
2880 pei_section_data (obfd, osec)->pe_flags =
2881 pei_section_data (ibfd, isec)->pe_flags;
2888 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
2890 coff_get_symbol_info (abfd, symbol, ret);
2893 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
2895 sort_x64_pdata (const void *l, const void *r)
2897 const char *lp = (const char *) l;
2898 const char *rp = (const char *) r;
2900 vl = bfd_getl32 (lp); vr = bfd_getl32 (rp);
2902 return (vl < vr ? -1 : 1);
2903 /* We compare just begin address. */
2908 /* Functions to process a .rsrc section. */
2910 static unsigned int sizeof_leaves;
2911 static unsigned int sizeof_strings;
2912 static unsigned int sizeof_tables_and_entries;
2915 rsrc_count_directory (bfd *, bfd_byte *, bfd_byte *, bfd_byte *, bfd_vma);
2918 rsrc_count_entries (bfd * abfd,
2919 bfd_boolean is_name,
2920 bfd_byte * datastart,
2925 unsigned long entry, addr, size;
2927 if (data + 8 >= dataend)
2934 entry = (long) bfd_get_32 (abfd, data);
2936 if (HighBitSet (entry))
2937 name = datastart + WithoutHighBit (entry);
2939 name = datastart + entry - rva_bias;
2941 if (name + 2 >= dataend)
2944 unsigned int len = bfd_get_16 (abfd, name);
2945 if (len == 0 || len > 256)
2949 entry = (long) bfd_get_32 (abfd, data + 4);
2951 if (HighBitSet (entry))
2952 return rsrc_count_directory (abfd,
2954 datastart + WithoutHighBit (entry),
2957 if (datastart + entry + 16 >= dataend)
2960 addr = (long) bfd_get_32 (abfd, datastart + entry);
2961 size = (long) bfd_get_32 (abfd, datastart + entry + 4);
2963 return datastart + addr - rva_bias + size;
2967 rsrc_count_directory (bfd * abfd,
2968 bfd_byte * datastart,
2973 unsigned int num_entries, num_ids;
2974 bfd_byte * highest_data = data;
2976 if (data + 16 >= dataend)
2979 num_entries = (int) bfd_get_16 (abfd, data + 12);
2980 num_ids = (int) bfd_get_16 (abfd, data + 14);
2982 num_entries += num_ids;
2986 while (num_entries --)
2988 bfd_byte * entry_end;
2990 entry_end = rsrc_count_entries (abfd, num_entries >= num_ids,
2991 datastart, data, dataend, rva_bias);
2993 highest_data = max (highest_data, entry_end);
2994 if (entry_end >= dataend)
2998 return max (highest_data, data);
3001 typedef struct rsrc_dir_chain
3003 unsigned int num_entries;
3004 struct rsrc_entry * first_entry;
3005 struct rsrc_entry * last_entry;
3008 typedef struct rsrc_directory
3010 unsigned int characteristics;
3015 rsrc_dir_chain names;
3018 struct rsrc_entry * entry;
3021 typedef struct rsrc_string
3027 typedef struct rsrc_leaf
3030 unsigned int codepage;
3034 typedef struct rsrc_entry
3036 bfd_boolean is_name;
3040 struct rsrc_string name;
3046 struct rsrc_directory * directory;
3047 struct rsrc_leaf * leaf;
3050 struct rsrc_entry * next_entry;
3051 struct rsrc_directory * parent;
3055 rsrc_parse_directory (bfd *, rsrc_directory *, bfd_byte *,
3056 bfd_byte *, bfd_byte *, bfd_vma, rsrc_entry *);
3059 rsrc_parse_entry (bfd * abfd,
3060 bfd_boolean is_name,
3062 bfd_byte * datastart,
3066 rsrc_directory * parent)
3068 unsigned long val, addr, size;
3070 val = bfd_get_32 (abfd, data);
3072 entry->parent = parent;
3073 entry->is_name = is_name;
3077 /* FIXME: Add range checking ? */
3078 if (HighBitSet (val))
3080 val = WithoutHighBit (val);
3082 entry->name_id.name.len = bfd_get_16 (abfd, datastart + val);
3083 entry->name_id.name.string = datastart + val + 2;
3087 entry->name_id.name.len = bfd_get_16 (abfd, datastart + val
3089 entry->name_id.name.string = datastart + val - rva_bias + 2;
3093 entry->name_id.id = val;
3095 val = bfd_get_32 (abfd, data + 4);
3097 if (HighBitSet (val))
3099 entry->is_dir = TRUE;
3100 entry->value.directory = bfd_malloc (sizeof * entry->value.directory);
3101 if (entry->value.directory == NULL)
3104 return rsrc_parse_directory (abfd, entry->value.directory,
3106 datastart + WithoutHighBit (val),
3107 dataend, rva_bias, entry);
3110 entry->is_dir = FALSE;
3111 entry->value.leaf = bfd_malloc (sizeof * entry->value.leaf);
3112 if (entry->value.leaf == NULL)
3115 addr = bfd_get_32 (abfd, datastart + val);
3116 size = entry->value.leaf->size = bfd_get_32 (abfd, datastart + val + 4);
3117 entry->value.leaf->codepage = bfd_get_32 (abfd, datastart + val + 8);
3119 entry->value.leaf->data = bfd_malloc (size);
3120 if (entry->value.leaf->data == NULL)
3123 memcpy (entry->value.leaf->data, datastart + addr - rva_bias, size);
3124 return datastart + (addr - rva_bias) + size;
3128 rsrc_parse_entries (bfd * abfd,
3129 rsrc_dir_chain * chain,
3130 bfd_boolean is_name,
3131 bfd_byte * highest_data,
3132 bfd_byte * datastart,
3136 rsrc_directory * parent)
3141 if (chain->num_entries == 0)
3143 chain->first_entry = chain->last_entry = NULL;
3144 return highest_data;
3147 entry = bfd_malloc (sizeof * entry);
3151 chain->first_entry = entry;
3153 for (i = chain->num_entries; i--;)
3155 bfd_byte * entry_end;
3157 entry_end = rsrc_parse_entry (abfd, is_name, entry, datastart,
3158 data, dataend, rva_bias, parent);
3160 highest_data = max (entry_end, highest_data);
3161 if (entry_end > dataend)
3166 entry->next_entry = bfd_malloc (sizeof * entry);
3167 entry = entry->next_entry;
3172 entry->next_entry = NULL;
3175 chain->last_entry = entry;
3177 return highest_data;
3181 rsrc_parse_directory (bfd * abfd,
3182 rsrc_directory * table,
3183 bfd_byte * datastart,
3189 bfd_byte * highest_data = data;
3194 table->characteristics = bfd_get_32 (abfd, data);
3195 table->time = bfd_get_32 (abfd, data + 4);
3196 table->major = bfd_get_16 (abfd, data + 8);
3197 table->minor = bfd_get_16 (abfd, data + 10);
3198 table->names.num_entries = bfd_get_16 (abfd, data + 12);
3199 table->ids.num_entries = bfd_get_16 (abfd, data + 14);
3200 table->entry = entry;
3204 highest_data = rsrc_parse_entries (abfd, & table->names, TRUE, data,
3205 datastart, data, dataend, rva_bias, table);
3206 data += table->names.num_entries * 8;
3208 highest_data = rsrc_parse_entries (abfd, & table->ids, FALSE, highest_data,
3209 datastart, data, dataend, rva_bias, table);
3210 data += table->ids.num_entries * 8;
3212 return max (highest_data, data);
3215 typedef struct rsrc_write_data
3218 bfd_byte * datastart;
3219 bfd_byte * next_table;
3220 bfd_byte * next_leaf;
3221 bfd_byte * next_string;
3222 bfd_byte * next_data;
3227 rsrc_write_string (rsrc_write_data * data,
3228 rsrc_string * string)
3230 bfd_put_16 (data->abfd, string->len, data->next_string);
3231 memcpy (data->next_string + 2, string->string, string->len * 2);
3232 data->next_string += (string->len + 1) * 2;
3235 static inline unsigned int
3236 rsrc_compute_rva (rsrc_write_data * data,
3239 return (addr - data->datastart) + data->rva_bias;
3243 rsrc_write_leaf (rsrc_write_data * data,
3246 bfd_put_32 (data->abfd, rsrc_compute_rva (data, data->next_data),
3248 bfd_put_32 (data->abfd, leaf->size, data->next_leaf + 4);
3249 bfd_put_32 (data->abfd, leaf->codepage, data->next_leaf + 8);
3250 bfd_put_32 (data->abfd, 0 /*reserved*/, data->next_leaf + 12);
3251 data->next_leaf += 16;
3253 memcpy (data->next_data, leaf->data, leaf->size);
3254 /* An undocumented feature of Windows resources is that each unit
3255 of raw data is 8-byte aligned... */
3256 data->next_data += ((leaf->size + 7) & ~7);
3259 static void rsrc_write_directory (rsrc_write_data *, rsrc_directory *);
3262 rsrc_write_entry (rsrc_write_data * data,
3268 bfd_put_32 (data->abfd,
3269 SetHighBit (data->next_string - data->datastart),
3271 rsrc_write_string (data, & entry->name_id.name);
3274 bfd_put_32 (data->abfd, entry->name_id.id, where);
3278 bfd_put_32 (data->abfd,
3279 SetHighBit (data->next_table - data->datastart),
3281 rsrc_write_directory (data, entry->value.directory);
3285 bfd_put_32 (data->abfd, data->next_leaf - data->datastart, where + 4);
3286 rsrc_write_leaf (data, entry->value.leaf);
3291 rsrc_compute_region_sizes (rsrc_directory * dir)
3293 struct rsrc_entry * entry;
3298 sizeof_tables_and_entries += 16;
3300 for (entry = dir->names.first_entry; entry != NULL; entry = entry->next_entry)
3302 sizeof_tables_and_entries += 8;
3304 sizeof_strings += (entry->name_id.name.len + 1) * 2;
3307 rsrc_compute_region_sizes (entry->value.directory);
3309 sizeof_leaves += 16;
3312 for (entry = dir->ids.first_entry; entry != NULL; entry = entry->next_entry)
3314 sizeof_tables_and_entries += 8;
3317 rsrc_compute_region_sizes (entry->value.directory);
3319 sizeof_leaves += 16;
3324 rsrc_write_directory (rsrc_write_data * data,
3325 rsrc_directory * dir)
3329 bfd_byte * next_entry;
3332 bfd_put_32 (data->abfd, dir->characteristics, data->next_table);
3333 bfd_put_32 (data->abfd, 0 /*dir->time*/, data->next_table + 4);
3334 bfd_put_16 (data->abfd, dir->major, data->next_table + 8);
3335 bfd_put_16 (data->abfd, dir->minor, data->next_table + 10);
3336 bfd_put_16 (data->abfd, dir->names.num_entries, data->next_table + 12);
3337 bfd_put_16 (data->abfd, dir->ids.num_entries, data->next_table + 14);
3339 /* Compute where the entries and the next table will be placed. */
3340 next_entry = data->next_table + 16;
3341 data->next_table = next_entry + (dir->names.num_entries * 8)
3342 + (dir->ids.num_entries * 8);
3343 nt = data->next_table;
3345 /* Write the entries. */
3346 for (i = dir->names.num_entries, entry = dir->names.first_entry;
3347 i > 0 && entry != NULL;
3348 i--, entry = entry->next_entry)
3350 BFD_ASSERT (entry->is_name);
3351 rsrc_write_entry (data, next_entry, entry);
3354 BFD_ASSERT (i == 0);
3355 BFD_ASSERT (entry == NULL);
3357 for (i = dir->ids.num_entries, entry = dir->ids.first_entry;
3358 i > 0 && entry != NULL;
3359 i--, entry = entry->next_entry)
3361 BFD_ASSERT (! entry->is_name);
3362 rsrc_write_entry (data, next_entry, entry);
3365 BFD_ASSERT (i == 0);
3366 BFD_ASSERT (entry == NULL);
3367 BFD_ASSERT (nt == next_entry);
3370 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3371 /* Return the length (number of units) of the first character in S,
3372 putting its 'ucs4_t' representation in *PUC. */
3375 u16_mbtouc (wchar_t * puc, const unsigned short * s, unsigned int n)
3377 unsigned short c = * s;
3379 if (c < 0xd800 || c >= 0xe000)
3389 if (s[1] >= 0xdc00 && s[1] < 0xe000)
3391 *puc = 0x10000 + ((c - 0xd800) << 10) + (s[1] - 0xdc00);
3397 /* Incomplete multibyte character. */
3403 /* Invalid multibyte character. */
3407 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3409 /* Perform a comparison of two entries. */
3411 rsrc_cmp (bfd_boolean is_name, rsrc_entry * a, rsrc_entry * b)
3420 return a->name_id.id - b->name_id.id;
3422 /* We have to perform a case insenstive, unicode string comparison... */
3423 astring = a->name_id.name.string;
3424 alen = a->name_id.name.len;
3425 bstring = b->name_id.name.string;
3426 blen = b->name_id.name.len;
3428 #if defined __CYGWIN__ || defined __MINGW32__
3429 /* Under Windows hosts (both Cygwin and Mingw types),
3430 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3431 function however goes by different names in the two environments... */
3435 #define rscpcmp wcsncasecmp
3438 #define rscpcmp wcsnicmp
3441 res = rscpcmp ((const wchar_t *) astring, (const wchar_t *) bstring,
3444 #elif defined HAVE_WCHAR_H
3448 for (i = min (alen, blen); i--; astring += 2, bstring += 2)
3453 /* Convert UTF-16 unicode characters into wchar_t characters so
3454 that we can then perform a case insensitive comparison. */
3455 int Alen = u16_mbtouc (& awc, (const unsigned short *) astring, 2);
3456 int Blen = u16_mbtouc (& bwc, (const unsigned short *) bstring, 2);
3460 res = wcsncasecmp (& awc, & bwc, 1);
3466 /* Do the best we can - a case sensitive, untranslated comparison. */
3467 res = memcmp (astring, bstring, min (alen, blen) * 2);
3477 rsrc_print_name (char * buffer, rsrc_string string)
3480 bfd_byte * name = string.string;
3482 for (i = string.len; i--; name += 2)
3483 sprintf (buffer + strlen (buffer), "%.1s", name);
3487 rsrc_resource_name (rsrc_entry * entry, rsrc_directory * dir)
3489 static char buffer [256];
3490 bfd_boolean is_string = FALSE;
3494 if (dir != NULL && dir->entry != NULL && dir->entry->parent != NULL
3495 && dir->entry->parent->entry != NULL)
3497 strcpy (buffer, "type: ");
3498 if (dir->entry->parent->entry->is_name)
3499 rsrc_print_name (buffer + strlen (buffer),
3500 dir->entry->parent->entry->name_id.name);
3503 unsigned int id = dir->entry->parent->entry->name_id.id;
3505 sprintf (buffer + strlen (buffer), "%x", id);
3508 case 1: strcat (buffer, " (CURSOR)"); break;
3509 case 2: strcat (buffer, " (BITMAP)"); break;
3510 case 3: strcat (buffer, " (ICON)"); break;
3511 case 4: strcat (buffer, " (MENU)"); break;
3512 case 5: strcat (buffer, " (DIALOG)"); break;
3513 case 6: strcat (buffer, " (STRING)"); is_string = TRUE; break;
3514 case 7: strcat (buffer, " (FONTDIR)"); break;
3515 case 8: strcat (buffer, " (FONT)"); break;
3516 case 9: strcat (buffer, " (ACCELERATOR)"); break;
3517 case 10: strcat (buffer, " (RCDATA)"); break;
3518 case 11: strcat (buffer, " (MESSAGETABLE)"); break;
3519 case 12: strcat (buffer, " (GROUP_CURSOR)"); break;
3520 case 14: strcat (buffer, " (GROUP_ICON)"); break;
3521 case 16: strcat (buffer, " (VERSION)"); break;
3522 case 17: strcat (buffer, " (DLGINCLUDE)"); break;
3523 case 19: strcat (buffer, " (PLUGPLAY)"); break;
3524 case 20: strcat (buffer, " (VXD)"); break;
3525 case 21: strcat (buffer, " (ANICURSOR)"); break;
3526 case 22: strcat (buffer, " (ANIICON)"); break;
3527 case 23: strcat (buffer, " (HTML)"); break;
3528 case 24: strcat (buffer, " (MANIFEST)"); break;
3529 case 240: strcat (buffer, " (DLGINIT)"); break;
3530 case 241: strcat (buffer, " (TOOLBAR)"); break;
3535 if (dir != NULL && dir->entry != NULL)
3537 strcat (buffer, " name: ");
3538 if (dir->entry->is_name)
3539 rsrc_print_name (buffer + strlen (buffer), dir->entry->name_id.name);
3542 unsigned int id = dir->entry->name_id.id;
3544 sprintf (buffer + strlen (buffer), "%x", id);
3547 sprintf (buffer + strlen (buffer), " (resource id range: %d - %d)",
3548 (id - 1) << 4, (id << 4) - 1);
3554 strcat (buffer, " lang: ");
3557 rsrc_print_name (buffer + strlen (buffer), entry->name_id.name);
3559 sprintf (buffer + strlen (buffer), "%x", entry->name_id.id);
3565 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3566 their ID is stored in the NAME entry. The bottom four bits are used as
3567 an index into unicode string table that makes up the data of the leaf.
3568 So identical type-name-lang string resources may not actually be
3571 This function is called when we have detected two string resources with
3572 match top-28-bit IDs. We have to scan the string tables inside the leaves
3573 and discover if there are any real collisions. If there are then we report
3574 them and return FALSE. Otherwise we copy any strings from B into A and
3575 then return TRUE. */
3578 rsrc_merge_string_entries (rsrc_entry * a ATTRIBUTE_UNUSED,
3579 rsrc_entry * b ATTRIBUTE_UNUSED)
3581 unsigned int copy_needed = 0;
3585 bfd_byte * new_data;
3588 /* Step one: Find out what we have to do. */
3589 BFD_ASSERT (! a->is_dir);
3590 astring = a->value.leaf->data;
3592 BFD_ASSERT (! b->is_dir);
3593 bstring = b->value.leaf->data;
3595 for (i = 0; i < 16; i++)
3597 unsigned int alen = astring[0] + (astring[1] << 8);
3598 unsigned int blen = bstring[0] + (bstring[1] << 8);
3602 copy_needed += blen * 2;
3606 else if (alen != blen)
3607 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3609 /* alen == blen != 0. We might have two identical strings. If so we
3610 can ignore the second one. There is no need for wchar_t vs UTF-16
3611 theatrics here - we are only interested in (case sensitive) equality. */
3612 else if (memcmp (astring + 2, bstring + 2, alen * 2) != 0)
3615 astring += (alen + 1) * 2;
3616 bstring += (blen + 1) * 2;
3621 if (a->parent != NULL
3622 && a->parent->entry != NULL
3623 && a->parent->entry->is_name == FALSE)
3624 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3625 ((a->parent->entry->name_id.id - 1) << 4) + i);
3629 if (copy_needed == 0)
3632 /* If we reach here then A and B must both have non-colliding strings.
3633 (We never get string resources with fully empty string tables).
3634 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3636 new_data = bfd_malloc (a->value.leaf->size + copy_needed);
3637 if (new_data == NULL)
3641 astring = a->value.leaf->data;
3642 bstring = b->value.leaf->data;
3644 for (i = 0; i < 16; i++)
3646 unsigned int alen = astring[0] + (astring[1] << 8);
3647 unsigned int blen = bstring[0] + (bstring[1] << 8);
3651 memcpy (nstring, astring, (alen + 1) * 2);
3652 nstring += (alen + 1) * 2;
3656 memcpy (nstring, bstring, (blen + 1) * 2);
3657 nstring += (blen + 1) * 2;
3665 astring += (alen + 1) * 2;
3666 bstring += (blen + 1) * 2;
3669 BFD_ASSERT (nstring - new_data == (signed) (a->value.leaf->size + copy_needed));
3671 free (a->value.leaf->data);
3672 a->value.leaf->data = new_data;
3673 a->value.leaf->size += copy_needed;
3678 static void rsrc_merge (rsrc_entry *, rsrc_entry *);
3680 /* Sort the entries in given part of the directory.
3681 We use an old fashioned bubble sort because we are dealing
3682 with lists and we want to handle matches specially. */
3685 rsrc_sort_entries (rsrc_dir_chain * chain,
3686 bfd_boolean is_name,
3687 rsrc_directory * dir)
3691 rsrc_entry ** points_to_entry;
3692 bfd_boolean swapped;
3694 if (chain->num_entries < 2)
3700 points_to_entry = & chain->first_entry;
3701 entry = * points_to_entry;
3702 next = entry->next_entry;
3706 signed int cmp = rsrc_cmp (is_name, entry, next);
3710 entry->next_entry = next->next_entry;
3711 next->next_entry = entry;
3712 * points_to_entry = next;
3713 points_to_entry = & next->next_entry;
3714 next = entry->next_entry;
3719 if (entry->is_dir && next->is_dir)
3721 /* When we encounter identical directory entries we have to
3722 merge them together. The exception to this rule is for
3723 resource manifests - there can only be one of these,
3724 even if they differ in language. Zero-language manifests
3725 are assumed to be default manifests (provided by the
3726 Cygwin/MinGW build system) and these can be silently dropped,
3727 unless that would reduce the number of manifests to zero.
3728 There should only ever be one non-zero lang manifest -
3729 if there are more it is an error. A non-zero lang
3730 manifest takes precedence over a default manifest. */
3731 if (entry->is_name == FALSE
3732 && entry->name_id.id == 1
3734 && dir->entry != NULL
3735 && dir->entry->is_name == FALSE
3736 && dir->entry->name_id.id == 0x18)
3738 if (next->value.directory->names.num_entries == 0
3739 && next->value.directory->ids.num_entries == 1
3740 && next->value.directory->ids.first_entry->is_name == FALSE
3741 && next->value.directory->ids.first_entry->name_id.id == 0)
3742 /* Fall through so that NEXT is dropped. */
3744 else if (entry->value.directory->names.num_entries == 0
3745 && entry->value.directory->ids.num_entries == 1
3746 && entry->value.directory->ids.first_entry->is_name == FALSE
3747 && entry->value.directory->ids.first_entry->name_id.id == 0)
3749 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3750 entry->next_entry = next->next_entry;
3751 next->next_entry = entry;
3752 * points_to_entry = next;
3753 points_to_entry = & next->next_entry;
3754 next = entry->next_entry;
3759 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3760 bfd_set_error (bfd_error_file_truncated);
3764 /* Unhook NEXT from the chain. */
3765 /* FIXME: memory loss here. */
3766 entry->next_entry = next->next_entry;
3767 chain->num_entries --;
3768 if (chain->num_entries < 2)
3770 next = next->next_entry;
3773 rsrc_merge (entry, next);
3775 else if (entry->is_dir != next->is_dir)
3777 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
3778 bfd_set_error (bfd_error_file_truncated);
3783 /* Otherwise with identical leaves we issue an error
3784 message - because there should never be duplicates.
3785 The exception is Type 18/Name 1/Lang 0 which is the
3786 defaul manifest - this can just be dropped. */
3787 if (entry->is_name == FALSE
3788 && entry->name_id.id == 0
3790 && dir->entry != NULL
3791 && dir->entry->is_name == FALSE
3792 && dir->entry->name_id.id == 1
3793 && dir->entry->parent != NULL
3794 && dir->entry->parent->entry != NULL
3795 && dir->entry->parent->entry->is_name == FALSE
3796 && dir->entry->parent->entry->name_id.id == 0x18 /* RT_MANIFEST */)
3798 else if (dir != NULL
3799 && dir->entry != NULL
3800 && dir->entry->parent != NULL
3801 && dir->entry->parent->entry != NULL
3802 && dir->entry->parent->entry->is_name == FALSE
3803 && dir->entry->parent->entry->name_id.id == 0x6 /* RT_STRING */)
3805 /* Strings need special handling. */
3806 if (! rsrc_merge_string_entries (entry, next))
3808 /* _bfd_error_handler should have been called inside merge_strings. */
3809 bfd_set_error (bfd_error_file_truncated);
3816 || dir->entry == NULL
3817 || dir->entry->parent == NULL
3818 || dir->entry->parent->entry == NULL)
3819 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
3821 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
3822 rsrc_resource_name (entry, dir));
3823 bfd_set_error (bfd_error_file_truncated);
3828 /* Unhook NEXT from the chain. */
3829 entry->next_entry = next->next_entry;
3830 chain->num_entries --;
3831 if (chain->num_entries < 2)
3833 next = next->next_entry;
3837 points_to_entry = & entry->next_entry;
3839 next = next->next_entry;
3844 chain->last_entry = entry;
3849 /* Attach B's chain onto A. */
3851 rsrc_attach_chain (rsrc_dir_chain * achain, rsrc_dir_chain * bchain)
3853 if (bchain->num_entries == 0)
3856 achain->num_entries += bchain->num_entries;
3858 if (achain->first_entry == NULL)
3860 achain->first_entry = bchain->first_entry;
3861 achain->last_entry = bchain->last_entry;
3865 achain->last_entry->next_entry = bchain->first_entry;
3866 achain->last_entry = bchain->last_entry;
3869 bchain->num_entries = 0;
3870 bchain->first_entry = bchain->last_entry = NULL;
3874 rsrc_merge (struct rsrc_entry * a, struct rsrc_entry * b)
3876 rsrc_directory * adir;
3877 rsrc_directory * bdir;
3879 BFD_ASSERT (a->is_dir);
3880 BFD_ASSERT (b->is_dir);
3882 adir = a->value.directory;
3883 bdir = b->value.directory;
3885 if (adir->characteristics != bdir->characteristics)
3887 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics\n"));
3888 bfd_set_error (bfd_error_file_truncated);
3892 if (adir->major != bdir->major || adir->minor != bdir->minor)
3894 _bfd_error_handler (_(".rsrc merge failure: differing directory versions\n"));
3895 bfd_set_error (bfd_error_file_truncated);
3899 /* Attach B's name chain to A. */
3900 rsrc_attach_chain (& adir->names, & bdir->names);
3902 /* Attach B's ID chain to A. */
3903 rsrc_attach_chain (& adir->ids, & bdir->ids);
3905 /* Now sort A's entries. */
3906 rsrc_sort_entries (& adir->names, TRUE, adir);
3907 rsrc_sort_entries (& adir->ids, FALSE, adir);
3910 /* Check the .rsrc section. If it contains multiple concatenated
3911 resources then we must merge them properly. Otherwise Windows
3912 will ignore all but the first set. */
3915 rsrc_process_section (bfd * abfd,
3916 struct coff_final_link_info * pfinfo)
3918 rsrc_directory new_table;
3924 bfd_byte * datastart;
3926 bfd_byte * new_data;
3927 unsigned int num_resource_sets;
3928 rsrc_directory * type_tables;
3929 rsrc_write_data write_data;
3932 unsigned int num_input_rsrc = 0;
3933 unsigned int max_num_input_rsrc = 4;
3934 ptrdiff_t * rsrc_sizes = NULL;
3936 new_table.names.num_entries = 0;
3937 new_table.ids.num_entries = 0;
3939 sec = bfd_get_section_by_name (abfd, ".rsrc");
3940 if (sec == NULL || (size = sec->rawsize) == 0)
3943 pe = pe_data (abfd);
3947 rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
3949 data = bfd_malloc (size);
3955 if (! bfd_get_section_contents (abfd, sec, data, 0, size))
3958 /* Step zero: Scan the input bfds looking for .rsrc sections and record
3959 their lengths. Note - we rely upon the fact that the linker script
3960 does *not* sort the input .rsrc sections, so that the order in the
3961 linkinfo list matches the order in the output .rsrc section.
3963 We need to know the lengths because each input .rsrc section has padding
3964 at the end of a variable amount. (It does not appear to be based upon
3965 the section alignment or the file alignment). We need to skip any
3966 padding bytes when parsing the input .rsrc sections. */
3967 rsrc_sizes = bfd_malloc (max_num_input_rsrc * sizeof * rsrc_sizes);
3968 if (rsrc_sizes == NULL)
3971 for (input = pfinfo->info->input_bfds;
3973 input = input->link.next)
3975 asection * rsrc_sec = bfd_get_section_by_name (input, ".rsrc");
3977 if (rsrc_sec != NULL)
3979 if (num_input_rsrc == max_num_input_rsrc)
3981 max_num_input_rsrc += 10;
3982 rsrc_sizes = bfd_realloc (rsrc_sizes, max_num_input_rsrc
3983 * sizeof * rsrc_sizes);
3984 if (rsrc_sizes == NULL)
3988 BFD_ASSERT (rsrc_sec->size > 0);
3989 rsrc_sizes [num_input_rsrc ++] = rsrc_sec->size;
3993 if (num_input_rsrc < 2)
3996 /* Step one: Walk the section, computing the size of the tables,
3997 leaves and data and decide if we need to do anything. */
3998 dataend = data + size;
3999 num_resource_sets = 0;
4001 while (data < dataend)
4003 bfd_byte * p = data;
4005 data = rsrc_count_directory (abfd, data, data, dataend, rva_bias);
4009 /* Corrupted .rsrc section - cannot merge. */
4010 _bfd_error_handler (_("%s: .rsrc merge failure: corrupt .rsrc section"),
4011 bfd_get_filename (abfd));
4012 bfd_set_error (bfd_error_file_truncated);
4016 if ((data - p) > rsrc_sizes [num_resource_sets])
4018 _bfd_error_handler (_("%s: .rsrc merge failure: unexpected .rsrc size"),
4019 bfd_get_filename (abfd));
4020 bfd_set_error (bfd_error_file_truncated);
4023 /* FIXME: Should we add a check for "data - p" being much smaller
4024 than rsrc_sizes[num_resource_sets] ? */
4026 data = p + rsrc_sizes[num_resource_sets];
4027 rva_bias += data - p;
4028 ++ num_resource_sets;
4030 BFD_ASSERT (num_resource_sets == num_input_rsrc);
4032 /* Step two: Walk the data again, building trees of the resources. */
4034 rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4036 type_tables = bfd_malloc (num_resource_sets * sizeof * type_tables);
4037 if (type_tables == NULL)
4041 while (data < dataend)
4043 bfd_byte * p = data;
4045 (void) rsrc_parse_directory (abfd, type_tables + indx, data, data,
4046 dataend, rva_bias, NULL);
4047 data = p + rsrc_sizes[indx];
4048 rva_bias += data - p;
4051 BFD_ASSERT (indx == num_resource_sets);
4053 /* Step three: Merge the top level tables (there can be only one).
4055 We must ensure that the merged entries are in ascending order.
4057 We also thread the top level table entries from the old tree onto
4058 the new table, so that they can be pulled off later. */
4060 /* FIXME: Should we verify that all type tables are the same ? */
4061 new_table.characteristics = type_tables[0].characteristics;
4062 new_table.time = type_tables[0].time;
4063 new_table.major = type_tables[0].major;
4064 new_table.minor = type_tables[0].minor;
4066 /* Chain the NAME entries onto the table. */
4067 new_table.names.first_entry = NULL;
4068 new_table.names.last_entry = NULL;
4070 for (indx = 0; indx < num_resource_sets; indx++)
4071 rsrc_attach_chain (& new_table.names, & type_tables[indx].names);
4073 rsrc_sort_entries (& new_table.names, TRUE, & new_table);
4075 /* Chain the ID entries onto the table. */
4076 new_table.ids.first_entry = NULL;
4077 new_table.ids.last_entry = NULL;
4079 for (indx = 0; indx < num_resource_sets; indx++)
4080 rsrc_attach_chain (& new_table.ids, & type_tables[indx].ids);
4082 rsrc_sort_entries (& new_table.ids, FALSE, & new_table);
4084 /* Step four: Create new contents for the .rsrc section. */
4085 /* Step four point one: Compute the size of each region of the .rsrc section.
4086 We do this now, rather than earlier, as the merging above may have dropped
4088 sizeof_leaves = sizeof_strings = sizeof_tables_and_entries = 0;
4089 rsrc_compute_region_sizes (& new_table);
4090 /* We increment sizeof_strings to make sure that resource data
4091 starts on an 8-byte boundary. FIXME: Is this correct ? */
4092 sizeof_strings = (sizeof_strings + 7) & ~ 7;
4094 new_data = bfd_zalloc (abfd, size);
4095 if (new_data == NULL)
4098 write_data.abfd = abfd;
4099 write_data.datastart = new_data;
4100 write_data.next_table = new_data;
4101 write_data.next_leaf = new_data + sizeof_tables_and_entries;
4102 write_data.next_string = write_data.next_leaf + sizeof_leaves;
4103 write_data.next_data = write_data.next_string + sizeof_strings;
4104 write_data.rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4106 rsrc_write_directory (& write_data, & new_table);
4108 /* Step five: Replace the old contents with the new.
4109 We recompute the size as we may have lost entries due to mergeing. */
4110 size = ((write_data.next_data - new_data) + 3) & ~ 3;
4115 if (coff_data (abfd)->link_info)
4117 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
4119 /* If no file alignment has been set, default to one.
4120 This repairs 'ld -r' for arm-wince-pe target. */
4125 page_size = PE_DEF_FILE_ALIGNMENT;
4126 size = (size + page_size - 1) & - page_size;
4129 bfd_set_section_contents (pfinfo->output_bfd, sec, new_data, 0, size);
4130 sec->size = sec->rawsize = size;
4133 /* Step six: Free all the memory that we have used. */
4134 /* FIXME: Free the resource tree, if we have one. */
4139 /* Handle the .idata section and other things that need symbol table
4143 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
4145 struct coff_link_hash_entry *h1;
4146 struct bfd_link_info *info = pfinfo->info;
4147 bfd_boolean result = TRUE;
4149 /* There are a few fields that need to be filled in now while we
4150 have symbol table access.
4152 The .idata subsections aren't directly available as sections, but
4153 they are in the symbol table, so get them from there. */
4155 /* The import directory. This is the address of .idata$2, with size
4156 of .idata$2 + .idata$3. */
4157 h1 = coff_link_hash_lookup (coff_hash_table (info),
4158 ".idata$2", FALSE, FALSE, TRUE);
4161 /* PR ld/2729: We cannot rely upon all the output sections having been
4162 created properly, so check before referencing them. Issue a warning
4163 message for any sections tht could not be found. */
4164 if ((h1->root.type == bfd_link_hash_defined
4165 || h1->root.type == bfd_link_hash_defweak)
4166 && h1->root.u.def.section != NULL
4167 && h1->root.u.def.section->output_section != NULL)
4168 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
4169 (h1->root.u.def.value
4170 + h1->root.u.def.section->output_section->vma
4171 + h1->root.u.def.section->output_offset);
4175 (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4180 h1 = coff_link_hash_lookup (coff_hash_table (info),
4181 ".idata$4", FALSE, FALSE, TRUE);
4183 && (h1->root.type == bfd_link_hash_defined
4184 || h1->root.type == bfd_link_hash_defweak)
4185 && h1->root.u.def.section != NULL
4186 && h1->root.u.def.section->output_section != NULL)
4187 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
4188 ((h1->root.u.def.value
4189 + h1->root.u.def.section->output_section->vma
4190 + h1->root.u.def.section->output_offset)
4191 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
4195 (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4200 /* The import address table. This is the size/address of
4202 h1 = coff_link_hash_lookup (coff_hash_table (info),
4203 ".idata$5", FALSE, FALSE, TRUE);
4205 && (h1->root.type == bfd_link_hash_defined
4206 || h1->root.type == bfd_link_hash_defweak)
4207 && h1->root.u.def.section != NULL
4208 && h1->root.u.def.section->output_section != NULL)
4209 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4210 (h1->root.u.def.value
4211 + h1->root.u.def.section->output_section->vma
4212 + h1->root.u.def.section->output_offset);
4216 (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4221 h1 = coff_link_hash_lookup (coff_hash_table (info),
4222 ".idata$6", FALSE, FALSE, TRUE);
4224 && (h1->root.type == bfd_link_hash_defined
4225 || h1->root.type == bfd_link_hash_defweak)
4226 && h1->root.u.def.section != NULL
4227 && h1->root.u.def.section->output_section != NULL)
4228 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4229 ((h1->root.u.def.value
4230 + h1->root.u.def.section->output_section->vma
4231 + h1->root.u.def.section->output_offset)
4232 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
4236 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4243 h1 = coff_link_hash_lookup (coff_hash_table (info),
4244 "__IAT_start__", FALSE, FALSE, TRUE);
4246 && (h1->root.type == bfd_link_hash_defined
4247 || h1->root.type == bfd_link_hash_defweak)
4248 && h1->root.u.def.section != NULL
4249 && h1->root.u.def.section->output_section != NULL)
4254 (h1->root.u.def.value
4255 + h1->root.u.def.section->output_section->vma
4256 + h1->root.u.def.section->output_offset);
4258 h1 = coff_link_hash_lookup (coff_hash_table (info),
4259 "__IAT_end__", FALSE, FALSE, TRUE);
4261 && (h1->root.type == bfd_link_hash_defined
4262 || h1->root.type == bfd_link_hash_defweak)
4263 && h1->root.u.def.section != NULL
4264 && h1->root.u.def.section->output_section != NULL)
4266 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4267 ((h1->root.u.def.value
4268 + h1->root.u.def.section->output_section->vma
4269 + h1->root.u.def.section->output_offset)
4271 if (pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size != 0)
4272 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4273 iat_va - pe_data (abfd)->pe_opthdr.ImageBase;
4278 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4279 " because .idata$6 is missing"), abfd);
4285 h1 = coff_link_hash_lookup (coff_hash_table (info),
4286 (bfd_get_symbol_leading_char (abfd) != 0
4287 ? "__tls_used" : "_tls_used"),
4288 FALSE, FALSE, TRUE);
4291 if ((h1->root.type == bfd_link_hash_defined
4292 || h1->root.type == bfd_link_hash_defweak)
4293 && h1->root.u.def.section != NULL
4294 && h1->root.u.def.section->output_section != NULL)
4295 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
4296 (h1->root.u.def.value
4297 + h1->root.u.def.section->output_section->vma
4298 + h1->root.u.def.section->output_offset
4299 - pe_data (abfd)->pe_opthdr.ImageBase);
4303 (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
4307 /* According to PECOFF sepcifications by Microsoft version 8.2
4308 the TLS data directory consists of 4 pointers, followed
4309 by two 4-byte integer. This implies that the total size
4310 is different for 32-bit and 64-bit executables. */
4311 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4312 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
4314 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x28;
4318 /* If there is a .pdata section and we have linked pdata finally, we
4319 need to sort the entries ascending. */
4320 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4322 asection *sec = bfd_get_section_by_name (abfd, ".pdata");
4326 bfd_size_type x = sec->rawsize;
4327 bfd_byte *tmp_data = NULL;
4330 tmp_data = bfd_malloc (x);
4332 if (tmp_data != NULL)
4334 if (bfd_get_section_contents (abfd, sec, tmp_data, 0, x))
4338 12, sort_x64_pdata);
4339 bfd_set_section_contents (pfinfo->output_bfd, sec,
4348 rsrc_process_section (abfd, pfinfo);
4350 /* If we couldn't find idata$2, we either have an excessively
4351 trivial program or are in DEEP trouble; we have to assume trivial