1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright (C) 1995-2015 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);
153 _bfd_error_handler (_("%B: unable to find name for empty section"),
155 bfd_set_error (bfd_error_invalid_target);
159 sec = bfd_get_section_by_name (abfd, name);
161 in->n_scnum = sec->target_index;
164 if (in->n_scnum == 0)
166 int unused_section_number = 0;
170 for (sec = abfd->sections; sec; sec = sec->next)
171 if (unused_section_number <= sec->target_index)
172 unused_section_number = sec->target_index + 1;
176 name = (const char *) bfd_alloc (abfd, strlen (namebuf) + 1);
179 _bfd_error_handler (_("%B: out of memory creating name for empty section"),
183 strcpy ((char *) name, namebuf);
186 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
187 sec = bfd_make_section_anyway_with_flags (abfd, name, flags);
190 _bfd_error_handler (_("%B: unable to create fake empty section"),
199 sec->rel_filepos = 0;
200 sec->reloc_count = 0;
201 sec->line_filepos = 0;
202 sec->lineno_count = 0;
203 sec->userdata = NULL;
205 sec->alignment_power = 2;
207 sec->target_index = unused_section_number;
209 in->n_scnum = unused_section_number;
211 in->n_sclass = C_STAT;
215 #ifdef coff_swap_sym_in_hook
216 /* This won't work in peigen.c, but since it's for PPC PE, it's not
218 coff_swap_sym_in_hook (abfd, ext1, in1);
223 abs_finder (bfd * abfd ATTRIBUTE_UNUSED, asection * sec, void * data)
225 bfd_vma abs_val = * (bfd_vma *) data;
227 return (sec->vma <= abs_val) && ((sec->vma + (1ULL << 32)) > abs_val);
231 _bfd_XXi_swap_sym_out (bfd * abfd, void * inp, void * extp)
233 struct internal_syment *in = (struct internal_syment *) inp;
234 SYMENT *ext = (SYMENT *) extp;
236 if (in->_n._n_name[0] == 0)
238 H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
239 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
242 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
244 /* The PE32 and PE32+ formats only use 4 bytes to hold the value of a
245 symbol. This is a problem on 64-bit targets where we can generate
246 absolute symbols with values >= 1^32. We try to work around this
247 problem by finding a section whose base address is sufficient to
248 reduce the absolute value to < 1^32, and then transforming the
249 symbol into a section relative symbol. This of course is a hack. */
250 if (sizeof (in->n_value) > 4
251 /* The strange computation of the shift amount is here in order to
252 avoid a compile time warning about the comparison always being
253 false. It does not matter if this test fails to work as expected
254 as the worst that can happen is that some absolute symbols are
255 needlessly converted into section relative symbols. */
256 && in->n_value > ((1ULL << (sizeof (in->n_value) > 4 ? 32 : 31)) - 1)
257 && in->n_scnum == -1)
261 sec = bfd_sections_find_if (abfd, abs_finder, & in->n_value);
264 in->n_value -= sec->vma;
265 in->n_scnum = sec->target_index;
267 /* else: FIXME: The value is outside the range of any section. This
268 happens for __image_base__ and __ImageBase and maybe some other
269 symbols as well. We should find a way to handle these values. */
272 H_PUT_32 (abfd, in->n_value, ext->e_value);
273 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
275 if (sizeof (ext->e_type) == 2)
276 H_PUT_16 (abfd, in->n_type, ext->e_type);
278 H_PUT_32 (abfd, in->n_type, ext->e_type);
280 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
281 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
287 _bfd_XXi_swap_aux_in (bfd * abfd,
291 int indx ATTRIBUTE_UNUSED,
292 int numaux ATTRIBUTE_UNUSED,
295 AUXENT *ext = (AUXENT *) ext1;
296 union internal_auxent *in = (union internal_auxent *) in1;
298 /* PR 17521: Make sure that all fields in the aux structure
300 memset (in, 0, sizeof * in);
304 if (ext->x_file.x_fname[0] == 0)
306 in->x_file.x_n.x_zeroes = 0;
307 in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
310 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
318 in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
319 in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
320 in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
321 in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
322 in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
323 in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
329 in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
330 in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
332 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
335 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
336 in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
340 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
341 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
342 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
343 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
344 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
345 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
346 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
347 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
352 in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
356 in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
357 in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
362 _bfd_XXi_swap_aux_out (bfd * abfd,
366 int indx ATTRIBUTE_UNUSED,
367 int numaux ATTRIBUTE_UNUSED,
370 union internal_auxent *in = (union internal_auxent *) inp;
371 AUXENT *ext = (AUXENT *) extp;
373 memset (ext, 0, AUXESZ);
378 if (in->x_file.x_fname[0] == 0)
380 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
381 H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
384 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
393 PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
394 PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
395 PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
396 H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
397 H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
398 H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
404 H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
405 H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
407 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type)
410 PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, ext);
411 PUT_FCN_ENDNDX (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
415 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
416 ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
417 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
418 ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
419 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
420 ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
421 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
422 ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
426 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
429 PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
430 PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
437 _bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1)
439 LINENO *ext = (LINENO *) ext1;
440 struct internal_lineno *in = (struct internal_lineno *) in1;
442 in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
443 in->l_lnno = GET_LINENO_LNNO (abfd, ext);
447 _bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp)
449 struct internal_lineno *in = (struct internal_lineno *) inp;
450 struct external_lineno *ext = (struct external_lineno *) outp;
451 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
453 PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
458 _bfd_XXi_swap_aouthdr_in (bfd * abfd,
462 PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1;
463 AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
464 struct internal_aouthdr *aouthdr_int
465 = (struct internal_aouthdr *) aouthdr_int1;
466 struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe;
468 aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
469 aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
470 aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
471 aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
472 aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
473 aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
474 aouthdr_int->text_start =
475 GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
477 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
478 /* PE32+ does not have data_start member! */
479 aouthdr_int->data_start =
480 GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
481 a->BaseOfData = aouthdr_int->data_start;
484 a->Magic = aouthdr_int->magic;
485 a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp);
486 a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1);
487 a->SizeOfCode = aouthdr_int->tsize ;
488 a->SizeOfInitializedData = aouthdr_int->dsize ;
489 a->SizeOfUninitializedData = aouthdr_int->bsize ;
490 a->AddressOfEntryPoint = aouthdr_int->entry;
491 a->BaseOfCode = aouthdr_int->text_start;
492 a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
493 a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
494 a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
495 a->MajorOperatingSystemVersion =
496 H_GET_16 (abfd, src->MajorOperatingSystemVersion);
497 a->MinorOperatingSystemVersion =
498 H_GET_16 (abfd, src->MinorOperatingSystemVersion);
499 a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
500 a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
501 a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
502 a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
503 a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
504 a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
505 a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
506 a->CheckSum = H_GET_32 (abfd, src->CheckSum);
507 a->Subsystem = H_GET_16 (abfd, src->Subsystem);
508 a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
509 a->SizeOfStackReserve =
510 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
511 a->SizeOfStackCommit =
512 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
513 a->SizeOfHeapReserve =
514 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
515 a->SizeOfHeapCommit =
516 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
517 a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
518 a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
523 /* PR 17512: Corrupt PE binaries can cause seg-faults. */
524 if (a->NumberOfRvaAndSizes > IMAGE_NUMBEROF_DIRECTORY_ENTRIES)
526 (*_bfd_error_handler)
527 (_("%B: aout header specifies an invalid number of data-directory entries: %d"),
528 abfd, a->NumberOfRvaAndSizes);
529 /* Paranoia: If the number is corrupt, then assume that the
530 actual entries themselves might be corrupt as well. */
531 a->NumberOfRvaAndSizes = 0;
534 for (idx = 0; idx < a->NumberOfRvaAndSizes; idx++)
536 /* If data directory is empty, rva also should be 0. */
538 H_GET_32 (abfd, src->DataDirectory[idx][1]);
540 a->DataDirectory[idx].Size = size;
543 a->DataDirectory[idx].VirtualAddress =
544 H_GET_32 (abfd, src->DataDirectory[idx][0]);
546 a->DataDirectory[idx].VirtualAddress = 0;
549 while (idx < IMAGE_NUMBEROF_DIRECTORY_ENTRIES)
551 a->DataDirectory[idx].Size = 0;
552 a->DataDirectory[idx].VirtualAddress = 0;
557 if (aouthdr_int->entry)
559 aouthdr_int->entry += a->ImageBase;
560 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
561 aouthdr_int->entry &= 0xffffffff;
565 if (aouthdr_int->tsize)
567 aouthdr_int->text_start += a->ImageBase;
568 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
569 aouthdr_int->text_start &= 0xffffffff;
573 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
574 /* PE32+ does not have data_start member! */
575 if (aouthdr_int->dsize)
577 aouthdr_int->data_start += a->ImageBase;
578 aouthdr_int->data_start &= 0xffffffff;
583 /* These three fields are normally set up by ppc_relocate_section.
584 In the case of reading a file in, we can pick them up from the
586 first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress;
587 thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size;
588 import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size;
592 /* A support function for below. */
595 add_data_entry (bfd * abfd,
596 struct internal_extra_pe_aouthdr *aout,
601 asection *sec = bfd_get_section_by_name (abfd, name);
603 /* Add import directory information if it exists. */
605 && (coff_section_data (abfd, sec) != NULL)
606 && (pei_section_data (abfd, sec) != NULL))
608 /* If data directory is empty, rva also should be 0. */
609 int size = pei_section_data (abfd, sec)->virt_size;
610 aout->DataDirectory[idx].Size = size;
614 aout->DataDirectory[idx].VirtualAddress =
615 (sec->vma - base) & 0xffffffff;
616 sec->flags |= SEC_DATA;
622 _bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out)
624 struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
625 pe_data_type *pe = pe_data (abfd);
626 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
627 PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
629 IMAGE_DATA_DIRECTORY idata2, idata5, tls;
631 sa = extra->SectionAlignment;
632 fa = extra->FileAlignment;
633 ib = extra->ImageBase;
635 idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
636 idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
637 tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
639 if (aouthdr_in->tsize)
641 aouthdr_in->text_start -= ib;
642 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
643 aouthdr_in->text_start &= 0xffffffff;
647 if (aouthdr_in->dsize)
649 aouthdr_in->data_start -= ib;
650 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
651 aouthdr_in->data_start &= 0xffffffff;
655 if (aouthdr_in->entry)
657 aouthdr_in->entry -= ib;
658 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
659 aouthdr_in->entry &= 0xffffffff;
663 #define FA(x) (((x) + fa -1 ) & (- fa))
664 #define SA(x) (((x) + sa -1 ) & (- sa))
666 /* We like to have the sizes aligned. */
667 aouthdr_in->bsize = FA (aouthdr_in->bsize);
669 extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
671 add_data_entry (abfd, extra, 0, ".edata", ib);
672 add_data_entry (abfd, extra, 2, ".rsrc", ib);
673 add_data_entry (abfd, extra, 3, ".pdata", ib);
675 /* In theory we do not need to call add_data_entry for .idata$2 or
676 .idata$5. It will be done in bfd_coff_final_link where all the
677 required information is available. If however, we are not going
678 to perform a final link, eg because we have been invoked by objcopy
679 or strip, then we need to make sure that these Data Directory
680 entries are initialised properly.
682 So - we copy the input values into the output values, and then, if
683 a final link is going to be performed, it can overwrite them. */
684 extra->DataDirectory[PE_IMPORT_TABLE] = idata2;
685 extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
686 extra->DataDirectory[PE_TLS_TABLE] = tls;
688 if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
689 /* Until other .idata fixes are made (pending patch), the entry for
690 .idata is needed for backwards compatibility. FIXME. */
691 add_data_entry (abfd, extra, 1, ".idata", ib);
693 /* For some reason, the virtual size (which is what's set by
694 add_data_entry) for .reloc is not the same as the size recorded
695 in this slot by MSVC; it doesn't seem to cause problems (so far),
696 but since it's the best we've got, use it. It does do the right
698 if (pe->has_reloc_section)
699 add_data_entry (abfd, extra, 5, ".reloc", ib);
708 for (sec = abfd->sections; sec; sec = sec->next)
710 int rounded = FA (sec->size);
712 /* The first non-zero section filepos is the header size.
713 Sections without contents will have a filepos of 0. */
715 hsize = sec->filepos;
716 if (sec->flags & SEC_DATA)
718 if (sec->flags & SEC_CODE)
720 /* The image size is the total VIRTUAL size (which is what is
721 in the virt_size field). Files have been seen (from MSVC
722 5.0 link.exe) where the file size of the .data segment is
723 quite small compared to the virtual size. Without this
724 fix, strip munges the file.
726 FIXME: We need to handle holes between sections, which may
727 happpen when we covert from another format. We just use
728 the virtual address and virtual size of the last section
729 for the image size. */
730 if (coff_section_data (abfd, sec) != NULL
731 && pei_section_data (abfd, sec) != NULL)
732 isize = (sec->vma - extra->ImageBase
733 + SA (FA (pei_section_data (abfd, sec)->virt_size)));
736 aouthdr_in->dsize = dsize;
737 aouthdr_in->tsize = tsize;
738 extra->SizeOfHeaders = hsize;
739 extra->SizeOfImage = isize;
742 H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
744 /* e.g. 219510000 is linker version 2.19 */
745 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
747 /* This piece of magic sets the "linker version" field to
749 H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
750 aouthdr_out->standard.vstamp);
752 PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
753 PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
754 PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
755 PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
756 PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
757 aouthdr_out->standard.text_start);
759 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
760 /* PE32+ does not have data_start member! */
761 PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
762 aouthdr_out->standard.data_start);
765 PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
766 H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
767 H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
768 H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
769 aouthdr_out->MajorOperatingSystemVersion);
770 H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
771 aouthdr_out->MinorOperatingSystemVersion);
772 H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
773 H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
774 H_PUT_16 (abfd, extra->MajorSubsystemVersion,
775 aouthdr_out->MajorSubsystemVersion);
776 H_PUT_16 (abfd, extra->MinorSubsystemVersion,
777 aouthdr_out->MinorSubsystemVersion);
778 H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
779 H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
780 H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
781 H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
782 H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
783 H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
784 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
785 aouthdr_out->SizeOfStackReserve);
786 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
787 aouthdr_out->SizeOfStackCommit);
788 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
789 aouthdr_out->SizeOfHeapReserve);
790 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
791 aouthdr_out->SizeOfHeapCommit);
792 H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
793 H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
794 aouthdr_out->NumberOfRvaAndSizes);
798 for (idx = 0; idx < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; idx++)
800 H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
801 aouthdr_out->DataDirectory[idx][0]);
802 H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
803 aouthdr_out->DataDirectory[idx][1]);
811 _bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
814 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
815 struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
817 if (pe_data (abfd)->has_reloc_section
818 || pe_data (abfd)->dont_strip_reloc)
819 filehdr_in->f_flags &= ~F_RELFLG;
821 if (pe_data (abfd)->dll)
822 filehdr_in->f_flags |= F_DLL;
824 filehdr_in->pe.e_magic = DOSMAGIC;
825 filehdr_in->pe.e_cblp = 0x90;
826 filehdr_in->pe.e_cp = 0x3;
827 filehdr_in->pe.e_crlc = 0x0;
828 filehdr_in->pe.e_cparhdr = 0x4;
829 filehdr_in->pe.e_minalloc = 0x0;
830 filehdr_in->pe.e_maxalloc = 0xffff;
831 filehdr_in->pe.e_ss = 0x0;
832 filehdr_in->pe.e_sp = 0xb8;
833 filehdr_in->pe.e_csum = 0x0;
834 filehdr_in->pe.e_ip = 0x0;
835 filehdr_in->pe.e_cs = 0x0;
836 filehdr_in->pe.e_lfarlc = 0x40;
837 filehdr_in->pe.e_ovno = 0x0;
839 for (idx = 0; idx < 4; idx++)
840 filehdr_in->pe.e_res[idx] = 0x0;
842 filehdr_in->pe.e_oemid = 0x0;
843 filehdr_in->pe.e_oeminfo = 0x0;
845 for (idx = 0; idx < 10; idx++)
846 filehdr_in->pe.e_res2[idx] = 0x0;
848 filehdr_in->pe.e_lfanew = 0x80;
850 /* This next collection of data are mostly just characters. It
851 appears to be constant within the headers put on NT exes. */
852 filehdr_in->pe.dos_message[0] = 0x0eba1f0e;
853 filehdr_in->pe.dos_message[1] = 0xcd09b400;
854 filehdr_in->pe.dos_message[2] = 0x4c01b821;
855 filehdr_in->pe.dos_message[3] = 0x685421cd;
856 filehdr_in->pe.dos_message[4] = 0x70207369;
857 filehdr_in->pe.dos_message[5] = 0x72676f72;
858 filehdr_in->pe.dos_message[6] = 0x63206d61;
859 filehdr_in->pe.dos_message[7] = 0x6f6e6e61;
860 filehdr_in->pe.dos_message[8] = 0x65622074;
861 filehdr_in->pe.dos_message[9] = 0x6e757220;
862 filehdr_in->pe.dos_message[10] = 0x206e6920;
863 filehdr_in->pe.dos_message[11] = 0x20534f44;
864 filehdr_in->pe.dos_message[12] = 0x65646f6d;
865 filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
866 filehdr_in->pe.dos_message[14] = 0x24;
867 filehdr_in->pe.dos_message[15] = 0x0;
868 filehdr_in->pe.nt_signature = NT_SIGNATURE;
870 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
871 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
873 /* Only use a real timestamp if the option was chosen. */
874 if ((pe_data (abfd)->insert_timestamp))
875 H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
877 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
878 filehdr_out->f_symptr);
879 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
880 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
881 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
883 /* Put in extra dos header stuff. This data remains essentially
884 constant, it just has to be tacked on to the beginning of all exes
886 H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
887 H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
888 H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
889 H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
890 H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
891 H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
892 H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
893 H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
894 H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
895 H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
896 H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
897 H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
898 H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
899 H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
901 for (idx = 0; idx < 4; idx++)
902 H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
904 H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
905 H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
907 for (idx = 0; idx < 10; idx++)
908 H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
910 H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
912 for (idx = 0; idx < 16; idx++)
913 H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
914 filehdr_out->dos_message[idx]);
916 /* Also put in the NT signature. */
917 H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
923 _bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
925 struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
926 FILHDR *filehdr_out = (FILHDR *) out;
928 H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
929 H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
930 H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
931 PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
932 H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
933 H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
934 H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
940 _bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
942 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
943 SCNHDR *scnhdr_ext = (SCNHDR *) out;
944 unsigned int ret = SCNHSZ;
948 memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
950 PUT_SCNHDR_VADDR (abfd,
951 ((scnhdr_int->s_vaddr
952 - pe_data (abfd)->pe_opthdr.ImageBase)
954 scnhdr_ext->s_vaddr);
956 /* NT wants the size data to be rounded up to the next
957 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
959 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
961 if (bfd_pei_p (abfd))
963 ps = scnhdr_int->s_size;
969 ss = scnhdr_int->s_size;
974 if (bfd_pei_p (abfd))
975 ps = scnhdr_int->s_paddr;
979 ss = scnhdr_int->s_size;
982 PUT_SCNHDR_SIZE (abfd, ss,
985 /* s_paddr in PE is really the virtual size. */
986 PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
988 PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
989 scnhdr_ext->s_scnptr);
990 PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
991 scnhdr_ext->s_relptr);
992 PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
993 scnhdr_ext->s_lnnoptr);
996 /* Extra flags must be set when dealing with PE. All sections should also
997 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
998 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
999 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
1000 (this is especially important when dealing with the .idata section since
1001 the addresses for routines from .dlls must be overwritten). If .reloc
1002 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
1003 (0x02000000). Also, the resource data should also be read and
1006 /* FIXME: Alignment is also encoded in this field, at least on PPC and
1007 ARM-WINCE. Although - how do we get the original alignment field
1012 const char * section_name;
1013 unsigned long must_have;
1015 pe_required_section_flags;
1017 pe_required_section_flags known_sections [] =
1019 { ".arch", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
1020 { ".bss", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1021 { ".data", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1022 { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1023 { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1024 { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1025 { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1026 { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
1027 { ".rsrc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1028 { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
1029 { ".tls", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
1030 { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
1034 pe_required_section_flags * p;
1036 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1037 we know exactly what this specific section wants so we remove it
1038 and then allow the must_have field to add it back in if necessary.
1039 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1040 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1041 by ld --enable-auto-import (if auto-import is actually needed),
1042 by ld --omagic, or by obcopy --writable-text. */
1044 for (p = known_sections; p->section_name; p++)
1045 if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
1047 if (strcmp (scnhdr_int->s_name, ".text")
1048 || (bfd_get_file_flags (abfd) & WP_TEXT))
1049 scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
1050 scnhdr_int->s_flags |= p->must_have;
1054 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1057 if (coff_data (abfd)->link_info
1058 && ! coff_data (abfd)->link_info->relocatable
1059 && ! coff_data (abfd)->link_info->shared
1060 && strcmp (scnhdr_int->s_name, ".text") == 0)
1062 /* By inference from looking at MS output, the 32 bit field
1063 which is the combination of the number_of_relocs and
1064 number_of_linenos is used for the line number count in
1065 executables. A 16-bit field won't do for cc1. The MS
1066 document says that the number of relocs is zero for
1067 executables, but the 17-th bit has been observed to be there.
1068 Overflow is not an issue: a 4G-line program will overflow a
1069 bunch of other fields long before this! */
1070 H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
1071 H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
1075 if (scnhdr_int->s_nlnno <= 0xffff)
1076 H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
1079 (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
1080 bfd_get_filename (abfd),
1081 scnhdr_int->s_nlnno);
1082 bfd_set_error (bfd_error_file_truncated);
1083 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
1087 /* Although we could encode 0xffff relocs here, we do not, to be
1088 consistent with other parts of bfd. Also it lets us warn, as
1089 we should never see 0xffff here w/o having the overflow flag
1091 if (scnhdr_int->s_nreloc < 0xffff)
1092 H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
1095 /* PE can deal with large #s of relocs, but not here. */
1096 H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1097 scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1098 H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1105 _bfd_XXi_swap_debugdir_in (bfd * abfd, void * ext1, void * in1)
1107 struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) ext1;
1108 struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) in1;
1110 in->Characteristics = H_GET_32(abfd, ext->Characteristics);
1111 in->TimeDateStamp = H_GET_32(abfd, ext->TimeDateStamp);
1112 in->MajorVersion = H_GET_16(abfd, ext->MajorVersion);
1113 in->MinorVersion = H_GET_16(abfd, ext->MinorVersion);
1114 in->Type = H_GET_32(abfd, ext->Type);
1115 in->SizeOfData = H_GET_32(abfd, ext->SizeOfData);
1116 in->AddressOfRawData = H_GET_32(abfd, ext->AddressOfRawData);
1117 in->PointerToRawData = H_GET_32(abfd, ext->PointerToRawData);
1121 _bfd_XXi_swap_debugdir_out (bfd * abfd, void * inp, void * extp)
1123 struct external_IMAGE_DEBUG_DIRECTORY *ext = (struct external_IMAGE_DEBUG_DIRECTORY *) extp;
1124 struct internal_IMAGE_DEBUG_DIRECTORY *in = (struct internal_IMAGE_DEBUG_DIRECTORY *) inp;
1126 H_PUT_32(abfd, in->Characteristics, ext->Characteristics);
1127 H_PUT_32(abfd, in->TimeDateStamp, ext->TimeDateStamp);
1128 H_PUT_16(abfd, in->MajorVersion, ext->MajorVersion);
1129 H_PUT_16(abfd, in->MinorVersion, ext->MinorVersion);
1130 H_PUT_32(abfd, in->Type, ext->Type);
1131 H_PUT_32(abfd, in->SizeOfData, ext->SizeOfData);
1132 H_PUT_32(abfd, in->AddressOfRawData, ext->AddressOfRawData);
1133 H_PUT_32(abfd, in->PointerToRawData, ext->PointerToRawData);
1135 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY);
1138 static CODEVIEW_INFO *
1139 _bfd_XXi_slurp_codeview_record (bfd * abfd, file_ptr where, unsigned long length, CODEVIEW_INFO *cvinfo)
1143 if (bfd_seek (abfd, where, SEEK_SET) != 0)
1146 if (bfd_bread (buffer, 256, abfd) < 4)
1149 /* Ensure null termination of filename. */
1152 cvinfo->CVSignature = H_GET_32(abfd, buffer);
1155 if ((cvinfo->CVSignature == CVINFO_PDB70_CVSIGNATURE)
1156 && (length > sizeof (CV_INFO_PDB70)))
1158 CV_INFO_PDB70 *cvinfo70 = (CV_INFO_PDB70 *)(buffer);
1160 cvinfo->Age = H_GET_32(abfd, cvinfo70->Age);
1162 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1163 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1164 as 16 bytes in big-endian order. */
1165 bfd_putb32 (bfd_getl32 (cvinfo70->Signature), cvinfo->Signature);
1166 bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[4])), &(cvinfo->Signature[4]));
1167 bfd_putb16 (bfd_getl16 (&(cvinfo70->Signature[6])), &(cvinfo->Signature[6]));
1168 memcpy (&(cvinfo->Signature[8]), &(cvinfo70->Signature[8]), 8);
1170 cvinfo->SignatureLength = CV_INFO_SIGNATURE_LENGTH;
1171 // cvinfo->PdbFileName = cvinfo70->PdbFileName;
1175 else if ((cvinfo->CVSignature == CVINFO_PDB20_CVSIGNATURE)
1176 && (length > sizeof (CV_INFO_PDB20)))
1178 CV_INFO_PDB20 *cvinfo20 = (CV_INFO_PDB20 *)(buffer);
1179 cvinfo->Age = H_GET_32(abfd, cvinfo20->Age);
1180 memcpy (cvinfo->Signature, cvinfo20->Signature, 4);
1181 cvinfo->SignatureLength = 4;
1182 // cvinfo->PdbFileName = cvinfo20->PdbFileName;
1191 _bfd_XXi_write_codeview_record (bfd * abfd, file_ptr where, CODEVIEW_INFO *cvinfo)
1193 unsigned int size = sizeof (CV_INFO_PDB70) + 1;
1194 CV_INFO_PDB70 *cvinfo70;
1197 if (bfd_seek (abfd, where, SEEK_SET) != 0)
1200 cvinfo70 = (CV_INFO_PDB70 *) buffer;
1201 H_PUT_32 (abfd, CVINFO_PDB70_CVSIGNATURE, cvinfo70->CvSignature);
1203 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1204 in little-endian order, followed by 8 single bytes. */
1205 bfd_putl32 (bfd_getb32 (cvinfo->Signature), cvinfo70->Signature);
1206 bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[4])), &(cvinfo70->Signature[4]));
1207 bfd_putl16 (bfd_getb16 (&(cvinfo->Signature[6])), &(cvinfo70->Signature[6]));
1208 memcpy (&(cvinfo70->Signature[8]), &(cvinfo->Signature[8]), 8);
1210 H_PUT_32 (abfd, cvinfo->Age, cvinfo70->Age);
1211 cvinfo70->PdbFileName[0] = '\0';
1213 if (bfd_bwrite (buffer, size, abfd) != size)
1219 static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1221 N_("Export Directory [.edata (or where ever we found it)]"),
1222 N_("Import Directory [parts of .idata]"),
1223 N_("Resource Directory [.rsrc]"),
1224 N_("Exception Directory [.pdata]"),
1225 N_("Security Directory"),
1226 N_("Base Relocation Directory [.reloc]"),
1227 N_("Debug Directory"),
1228 N_("Description Directory"),
1229 N_("Special Directory"),
1230 N_("Thread Storage Directory [.tls]"),
1231 N_("Load Configuration Directory"),
1232 N_("Bound Import Directory"),
1233 N_("Import Address Table Directory"),
1234 N_("Delay Import Directory"),
1235 N_("CLR Runtime Header"),
1239 #ifdef POWERPC_LE_PE
1240 /* The code for the PPC really falls in the "architecture dependent"
1241 category. However, it's not clear that anyone will ever care, so
1242 we're ignoring the issue for now; if/when PPC matters, some of this
1243 may need to go into peicode.h, or arguments passed to enable the
1244 PPC- specific code. */
1248 pe_print_idata (bfd * abfd, void * vfile)
1250 FILE *file = (FILE *) vfile;
1255 #ifdef POWERPC_LE_PE
1256 asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1259 bfd_size_type datasize = 0;
1260 bfd_size_type dataoff;
1264 pe_data_type *pe = pe_data (abfd);
1265 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1269 addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
1271 if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
1273 /* Maybe the extra header isn't there. Look for the section. */
1274 section = bfd_get_section_by_name (abfd, ".idata");
1275 if (section == NULL)
1278 addr = section->vma;
1279 datasize = section->size;
1285 addr += extra->ImageBase;
1286 for (section = abfd->sections; section != NULL; section = section->next)
1288 datasize = section->size;
1289 if (addr >= section->vma && addr < section->vma + datasize)
1293 if (section == NULL)
1296 _("\nThere is an import table, but the section containing it could not be found\n"));
1299 else if (!(section->flags & SEC_HAS_CONTENTS))
1302 _("\nThere is an import table in %s, but that section has no contents\n"),
1308 fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1309 section->name, (unsigned long) addr);
1311 dataoff = addr - section->vma;
1313 #ifdef POWERPC_LE_PE
1314 if (rel_section != 0 && rel_section->size != 0)
1316 /* The toc address can be found by taking the starting address,
1317 which on the PPC locates a function descriptor. The
1318 descriptor consists of the function code starting address
1319 followed by the address of the toc. The starting address we
1320 get from the bfd, and the descriptor is supposed to be in the
1321 .reldata section. */
1323 bfd_vma loadable_toc_address;
1324 bfd_vma toc_address;
1325 bfd_vma start_address;
1329 if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1336 offset = abfd->start_address - rel_section->vma;
1338 if (offset >= rel_section->size || offset + 8 > rel_section->size)
1345 start_address = bfd_get_32 (abfd, data + offset);
1346 loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1347 toc_address = loadable_toc_address - 32768;
1350 _("\nFunction descriptor located at the start address: %04lx\n"),
1351 (unsigned long int) (abfd->start_address));
1353 _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1354 start_address, loadable_toc_address, toc_address);
1361 _("\nNo reldata section! Function descriptor not decoded.\n"));
1366 _("\nThe Import Tables (interpreted %s section contents)\n"),
1370 vma: Hint Time Forward DLL First\n\
1371 Table Stamp Chain Name Thunk\n"));
1373 /* Read the whole section. Some of the fields might be before dataoff. */
1374 if (!bfd_malloc_and_get_section (abfd, section, &data))
1381 adj = section->vma - extra->ImageBase;
1383 /* Print all image import descriptors. */
1384 for (i = dataoff; i + onaline <= datasize; i += onaline)
1388 bfd_vma forward_chain;
1390 bfd_vma first_thunk;
1395 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1396 fprintf (file, " %08lx\t", (unsigned long) (i + adj));
1397 hint_addr = bfd_get_32 (abfd, data + i);
1398 time_stamp = bfd_get_32 (abfd, data + i + 4);
1399 forward_chain = bfd_get_32 (abfd, data + i + 8);
1400 dll_name = bfd_get_32 (abfd, data + i + 12);
1401 first_thunk = bfd_get_32 (abfd, data + i + 16);
1403 fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1404 (unsigned long) hint_addr,
1405 (unsigned long) time_stamp,
1406 (unsigned long) forward_chain,
1407 (unsigned long) dll_name,
1408 (unsigned long) first_thunk);
1410 if (hint_addr == 0 && first_thunk == 0)
1413 if (dll_name - adj >= section->size)
1416 dll = (char *) data + dll_name - adj;
1417 /* PR 17512 file: 078-12277-0.004. */
1418 bfd_size_type maxlen = (char *)(data + datasize) - dll - 1;
1419 fprintf (file, _("\n\tDLL Name: %.*s\n"), (int) maxlen, dll);
1424 asection *ft_section;
1426 bfd_size_type ft_datasize;
1430 fprintf (file, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1432 idx = hint_addr - adj;
1434 ft_addr = first_thunk + extra->ImageBase;
1435 ft_idx = first_thunk - adj;
1436 ft_data = data + ft_idx;
1437 ft_datasize = datasize - ft_idx;
1440 if (first_thunk != hint_addr)
1442 /* Find the section which contains the first thunk. */
1443 for (ft_section = abfd->sections;
1445 ft_section = ft_section->next)
1447 if (ft_addr >= ft_section->vma
1448 && ft_addr < ft_section->vma + ft_section->size)
1452 if (ft_section == NULL)
1455 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1459 /* Now check to see if this section is the same as our current
1460 section. If it is not then we will have to load its data in. */
1461 if (ft_section != section)
1463 ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1464 ft_datasize = ft_section->size - ft_idx;
1465 ft_data = (bfd_byte *) bfd_malloc (ft_datasize);
1466 if (ft_data == NULL)
1469 /* Read ft_datasize bytes starting at offset ft_idx. */
1470 if (!bfd_get_section_contents (abfd, ft_section, ft_data,
1471 (bfd_vma) ft_idx, ft_datasize))
1480 /* Print HintName vector entries. */
1481 #ifdef COFF_WITH_pex64
1482 for (j = 0; idx + j + 8 <= datasize; j += 8)
1485 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1486 unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1488 if (!member && !member_high)
1493 if (HighBitSet (member_high))
1494 fprintf (file, "\t%lx%08lx\t %4lx%08lx <none>",
1495 member_high, member,
1496 WithoutHighBit (member_high), member);
1497 /* PR binutils/17512: Handle corrupt PE data. */
1498 else if (amt + 2 >= datasize)
1499 fprintf (file, _("\t<corrupt: 0x%04lx>"), member);
1505 ordinal = bfd_get_16 (abfd, data + amt);
1506 member_name = (char *) data + amt + 2;
1507 fprintf (file, "\t%04lx\t %4d %.*s",member, ordinal,
1508 (int) (datasize - (amt + 2)), member_name);
1511 /* If the time stamp is not zero, the import address
1512 table holds actual addresses. */
1515 && first_thunk != hint_addr
1516 && j + 4 <= ft_datasize)
1517 fprintf (file, "\t%04lx",
1518 (unsigned long) bfd_get_32 (abfd, ft_data + j));
1519 fprintf (file, "\n");
1522 for (j = 0; idx + j + 4 <= datasize; j += 4)
1525 unsigned long member = bfd_get_32 (abfd, data + idx + j);
1527 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1532 if (HighBitSet (member))
1533 fprintf (file, "\t%04lx\t %4lu <none>",
1534 member, WithoutHighBit (member));
1535 /* PR binutils/17512: Handle corrupt PE data. */
1536 else if (amt + 2 >= datasize)
1537 fprintf (file, _("\t<corrupt: 0x%04lx>"), member);
1543 ordinal = bfd_get_16 (abfd, data + amt);
1544 member_name = (char *) data + amt + 2;
1545 fprintf (file, "\t%04lx\t %4d %.*s",
1547 (int) (datasize - (amt + 2)), member_name);
1550 /* If the time stamp is not zero, the import address
1551 table holds actual addresses. */
1554 && first_thunk != hint_addr
1555 && j + 4 <= ft_datasize)
1556 fprintf (file, "\t%04lx",
1557 (unsigned long) bfd_get_32 (abfd, ft_data + j));
1559 fprintf (file, "\n");
1566 fprintf (file, "\n");
1575 pe_print_edata (bfd * abfd, void * vfile)
1577 FILE *file = (FILE *) vfile;
1580 bfd_size_type datasize = 0;
1581 bfd_size_type dataoff;
1586 long export_flags; /* Reserved - should be zero. */
1590 bfd_vma name; /* RVA - relative to image base. */
1591 long base; /* Ordinal base. */
1592 unsigned long num_functions;/* Number in the export address table. */
1593 unsigned long num_names; /* Number in the name pointer table. */
1594 bfd_vma eat_addr; /* RVA to the export address table. */
1595 bfd_vma npt_addr; /* RVA to the Export Name Pointer Table. */
1596 bfd_vma ot_addr; /* RVA to the Ordinal Table. */
1599 pe_data_type *pe = pe_data (abfd);
1600 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1604 addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
1606 if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
1608 /* Maybe the extra header isn't there. Look for the section. */
1609 section = bfd_get_section_by_name (abfd, ".edata");
1610 if (section == NULL)
1613 addr = section->vma;
1615 datasize = section->size;
1621 addr += extra->ImageBase;
1623 for (section = abfd->sections; section != NULL; section = section->next)
1624 if (addr >= section->vma && addr < section->vma + section->size)
1627 if (section == NULL)
1630 _("\nThere is an export table, but the section containing it could not be found\n"));
1633 else if (!(section->flags & SEC_HAS_CONTENTS))
1636 _("\nThere is an export table in %s, but that section has no contents\n"),
1641 dataoff = addr - section->vma;
1642 datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
1643 if (datasize > section->size - dataoff)
1646 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1652 /* PR 17512: Handle corrupt PE binaries. */
1656 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1657 section->name, (int) datasize);
1661 fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1662 section->name, (unsigned long) addr);
1664 data = (bfd_byte *) bfd_malloc (datasize);
1668 if (! bfd_get_section_contents (abfd, section, data,
1669 (file_ptr) dataoff, datasize))
1672 /* Go get Export Directory Table. */
1673 edt.export_flags = bfd_get_32 (abfd, data + 0);
1674 edt.time_stamp = bfd_get_32 (abfd, data + 4);
1675 edt.major_ver = bfd_get_16 (abfd, data + 8);
1676 edt.minor_ver = bfd_get_16 (abfd, data + 10);
1677 edt.name = bfd_get_32 (abfd, data + 12);
1678 edt.base = bfd_get_32 (abfd, data + 16);
1679 edt.num_functions = bfd_get_32 (abfd, data + 20);
1680 edt.num_names = bfd_get_32 (abfd, data + 24);
1681 edt.eat_addr = bfd_get_32 (abfd, data + 28);
1682 edt.npt_addr = bfd_get_32 (abfd, data + 32);
1683 edt.ot_addr = bfd_get_32 (abfd, data + 36);
1685 adj = section->vma - extra->ImageBase + dataoff;
1687 /* Dump the EDT first. */
1689 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1693 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1696 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1699 _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1702 _("Name \t\t\t\t"));
1703 bfd_fprintf_vma (abfd, file, edt.name);
1705 if ((edt.name >= adj) && (edt.name < adj + datasize))
1706 fprintf (file, " %.*s\n",
1707 (int) (datasize - (edt.name - adj)),
1708 data + edt.name - adj);
1710 fprintf (file, "(outside .edata section)\n");
1713 _("Ordinal Base \t\t\t%ld\n"), edt.base);
1719 _("\tExport Address Table \t\t%08lx\n"),
1723 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1726 _("Table Addresses\n"));
1729 _("\tExport Address Table \t\t"));
1730 bfd_fprintf_vma (abfd, file, edt.eat_addr);
1731 fprintf (file, "\n");
1734 _("\tName Pointer Table \t\t"));
1735 bfd_fprintf_vma (abfd, file, edt.npt_addr);
1736 fprintf (file, "\n");
1739 _("\tOrdinal Table \t\t\t"));
1740 bfd_fprintf_vma (abfd, file, edt.ot_addr);
1741 fprintf (file, "\n");
1743 /* The next table to find is the Export Address Table. It's basically
1744 a list of pointers that either locate a function in this dll, or
1745 forward the call to another dll. Something like:
1750 } export_address_table_entry; */
1753 _("\nExport Address Table -- Ordinal Base %ld\n"),
1756 /* PR 17512: Handle corrupt PE binaries. */
1757 if (edt.eat_addr + (edt.num_functions * 4) - adj >= datasize
1758 /* PR 17512 file: 140-165018-0.004. */
1759 || data + edt.eat_addr - adj < data)
1760 fprintf (file, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1761 (long) edt.eat_addr,
1762 (long) edt.num_functions);
1763 else for (i = 0; i < edt.num_functions; ++i)
1765 bfd_vma eat_member = bfd_get_32 (abfd,
1766 data + edt.eat_addr + (i * 4) - adj);
1767 if (eat_member == 0)
1770 if (eat_member - adj <= datasize)
1772 /* This rva is to a name (forwarding function) in our section. */
1773 /* Should locate a function descriptor. */
1775 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1777 (long) (i + edt.base),
1778 (unsigned long) eat_member,
1780 (int)(datasize - (eat_member - adj)),
1781 data + eat_member - adj);
1785 /* Should locate a function descriptor in the reldata section. */
1787 "\t[%4ld] +base[%4ld] %04lx %s\n",
1789 (long) (i + edt.base),
1790 (unsigned long) eat_member,
1795 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1796 /* Dump them in parallel for clarity. */
1798 _("\n[Ordinal/Name Pointer] Table\n"));
1800 /* PR 17512: Handle corrupt PE binaries. */
1801 if (edt.npt_addr + (edt.num_names * 4) - adj >= datasize
1802 || (data + edt.npt_addr - adj) < data)
1803 fprintf (file, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1804 (long) edt.npt_addr,
1805 (long) edt.num_names);
1806 /* PR 17512: file: 140-147171-0.004. */
1807 else if (edt.ot_addr + (edt.num_names * 2) - adj >= datasize
1808 || data + edt.ot_addr - adj < data)
1809 fprintf (file, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1811 (long) edt.num_names);
1812 else for (i = 0; i < edt.num_names; ++i)
1817 ord = bfd_get_16 (abfd, data + edt.ot_addr + (i * 2) - adj);
1818 name_ptr = bfd_get_32 (abfd, data + edt.npt_addr + (i * 4) - adj);
1820 if ((name_ptr - adj) >= datasize)
1822 fprintf (file, _("\t[%4ld] <corrupt offset: %lx>\n"),
1823 (long) ord, (long) name_ptr);
1827 char * name = (char *) data + name_ptr - adj;
1829 fprintf (file, "\t[%4ld] %.*s\n", (long) ord,
1830 (int)((char *)(data + datasize) - name), name);
1839 /* This really is architecture dependent. On IA-64, a .pdata entry
1840 consists of three dwords containing relative virtual addresses that
1841 specify the start and end address of the code range the entry
1842 covers and the address of the corresponding unwind info data.
1844 On ARM and SH-4, a compressed PDATA structure is used :
1845 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1846 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1847 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1849 This is the version for uncompressed data. */
1852 pe_print_pdata (bfd * abfd, void * vfile)
1854 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1855 # define PDATA_ROW_SIZE (3 * 8)
1857 # define PDATA_ROW_SIZE (5 * 4)
1859 FILE *file = (FILE *) vfile;
1861 asection *section = bfd_get_section_by_name (abfd, ".pdata");
1862 bfd_size_type datasize = 0;
1864 bfd_size_type start, stop;
1865 int onaline = PDATA_ROW_SIZE;
1868 || coff_section_data (abfd, section) == NULL
1869 || pei_section_data (abfd, section) == NULL)
1872 stop = pei_section_data (abfd, section)->virt_size;
1873 if ((stop % onaline) != 0)
1875 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1876 (long) stop, onaline);
1879 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1880 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1882 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1885 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1886 \t\tAddress Address Handler Data Address Mask\n"));
1889 datasize = section->size;
1893 /* PR 17512: file: 002-193900-0.004. */
1894 if (datasize < stop)
1896 fprintf (file, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1897 (long) stop, (long) datasize);
1901 if (! bfd_malloc_and_get_section (abfd, section, &data))
1910 for (i = start; i < stop; i += onaline)
1916 bfd_vma prolog_end_addr;
1917 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1921 if (i + PDATA_ROW_SIZE > stop)
1924 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
1925 end_addr = GET_PDATA_ENTRY (abfd, data + i + 4);
1926 eh_handler = GET_PDATA_ENTRY (abfd, data + i + 8);
1927 eh_data = GET_PDATA_ENTRY (abfd, data + i + 12);
1928 prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1930 if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1931 && eh_data == 0 && prolog_end_addr == 0)
1932 /* We are probably into the padding of the section now. */
1935 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1936 em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1938 eh_handler &= ~(bfd_vma) 0x3;
1939 prolog_end_addr &= ~(bfd_vma) 0x3;
1942 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
1943 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
1944 bfd_fprintf_vma (abfd, file, end_addr); fputc (' ', file);
1945 bfd_fprintf_vma (abfd, file, eh_handler);
1946 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1948 bfd_fprintf_vma (abfd, file, eh_data); fputc (' ', file);
1949 bfd_fprintf_vma (abfd, file, prolog_end_addr);
1950 fprintf (file, " %x", em_data);
1953 #ifdef POWERPC_LE_PE
1954 if (eh_handler == 0 && eh_data != 0)
1956 /* Special bits here, although the meaning may be a little
1957 mysterious. The only one I know for sure is 0x03
1960 0x01 Register Save Millicode
1961 0x02 Register Restore Millicode
1962 0x03 Glue Code Sequence. */
1966 fprintf (file, _(" Register save millicode"));
1969 fprintf (file, _(" Register restore millicode"));
1972 fprintf (file, _(" Glue code sequence"));
1979 fprintf (file, "\n");
1985 #undef PDATA_ROW_SIZE
1988 typedef struct sym_cache
1995 slurp_symtab (bfd *abfd, sym_cache *psc)
1997 asymbol ** sy = NULL;
2000 if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
2006 storage = bfd_get_symtab_upper_bound (abfd);
2010 sy = (asymbol **) bfd_malloc (storage);
2012 psc->symcount = bfd_canonicalize_symtab (abfd, sy);
2013 if (psc->symcount < 0)
2019 my_symbol_for_address (bfd *abfd, bfd_vma func, sym_cache *psc)
2024 psc->syms = slurp_symtab (abfd, psc);
2026 for (i = 0; i < psc->symcount; i++)
2028 if (psc->syms[i]->section->vma + psc->syms[i]->value == func)
2029 return psc->syms[i]->name;
2036 cleanup_syms (sym_cache *psc)
2043 /* This is the version for "compressed" pdata. */
2046 _bfd_XX_print_ce_compressed_pdata (bfd * abfd, void * vfile)
2048 # define PDATA_ROW_SIZE (2 * 4)
2049 FILE *file = (FILE *) vfile;
2050 bfd_byte *data = NULL;
2051 asection *section = bfd_get_section_by_name (abfd, ".pdata");
2052 bfd_size_type datasize = 0;
2054 bfd_size_type start, stop;
2055 int onaline = PDATA_ROW_SIZE;
2056 struct sym_cache cache = {0, 0} ;
2059 || coff_section_data (abfd, section) == NULL
2060 || pei_section_data (abfd, section) == NULL)
2063 stop = pei_section_data (abfd, section)->virt_size;
2064 if ((stop % onaline) != 0)
2066 _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
2067 (long) stop, onaline);
2070 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2073 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2074 \t\tAddress Length Length 32b exc Handler Data\n"));
2076 datasize = section->size;
2080 if (! bfd_malloc_and_get_section (abfd, section, &data))
2089 for (i = start; i < stop; i += onaline)
2093 bfd_vma prolog_length, function_length;
2094 int flag32bit, exception_flag;
2097 if (i + PDATA_ROW_SIZE > stop)
2100 begin_addr = GET_PDATA_ENTRY (abfd, data + i );
2101 other_data = GET_PDATA_ENTRY (abfd, data + i + 4);
2103 if (begin_addr == 0 && other_data == 0)
2104 /* We are probably into the padding of the section now. */
2107 prolog_length = (other_data & 0x000000FF);
2108 function_length = (other_data & 0x3FFFFF00) >> 8;
2109 flag32bit = (int)((other_data & 0x40000000) >> 30);
2110 exception_flag = (int)((other_data & 0x80000000) >> 31);
2113 bfd_fprintf_vma (abfd, file, i + section->vma); fputc ('\t', file);
2114 bfd_fprintf_vma (abfd, file, begin_addr); fputc (' ', file);
2115 bfd_fprintf_vma (abfd, file, prolog_length); fputc (' ', file);
2116 bfd_fprintf_vma (abfd, file, function_length); fputc (' ', file);
2117 fprintf (file, "%2d %2d ", flag32bit, exception_flag);
2119 /* Get the exception handler's address and the data passed from the
2120 .text section. This is really the data that belongs with the .pdata
2121 but got "compressed" out for the ARM and SH4 architectures. */
2122 tsection = bfd_get_section_by_name (abfd, ".text");
2123 if (tsection && coff_section_data (abfd, tsection)
2124 && pei_section_data (abfd, tsection))
2126 bfd_vma eh_off = (begin_addr - 8) - tsection->vma;
2129 tdata = (bfd_byte *) bfd_malloc (8);
2132 if (bfd_get_section_contents (abfd, tsection, tdata, eh_off, 8))
2134 bfd_vma eh, eh_data;
2136 eh = bfd_get_32 (abfd, tdata);
2137 eh_data = bfd_get_32 (abfd, tdata + 4);
2138 fprintf (file, "%08x ", (unsigned int) eh);
2139 fprintf (file, "%08x", (unsigned int) eh_data);
2142 const char *s = my_symbol_for_address (abfd, eh, &cache);
2145 fprintf (file, " (%s) ", s);
2152 fprintf (file, "\n");
2157 cleanup_syms (& cache);
2160 #undef PDATA_ROW_SIZE
2164 #define IMAGE_REL_BASED_HIGHADJ 4
2165 static const char * const tbl[] =
2179 "UNKNOWN", /* MUST be last. */
2183 pe_print_reloc (bfd * abfd, void * vfile)
2185 FILE *file = (FILE *) vfile;
2187 asection *section = bfd_get_section_by_name (abfd, ".reloc");
2190 if (section == NULL || section->size == 0 || !(section->flags & SEC_HAS_CONTENTS))
2194 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2196 if (! bfd_malloc_and_get_section (abfd, section, &data))
2204 end = data + section->size;
2205 while (p + 8 <= end)
2208 bfd_vma virtual_address;
2210 bfd_byte *chunk_end;
2212 /* The .reloc section is a sequence of blocks, with a header consisting
2213 of two 32 bit quantities, followed by a number of 16 bit entries. */
2214 virtual_address = bfd_get_32 (abfd, p);
2215 size = bfd_get_32 (abfd, p + 4);
2217 number = (size - 8) / 2;
2223 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2224 (unsigned long) virtual_address, size, (unsigned long) size, number);
2226 chunk_end = p + size;
2227 if (chunk_end > end)
2230 while (p + 2 <= chunk_end)
2232 unsigned short e = bfd_get_16 (abfd, p);
2233 unsigned int t = (e & 0xF000) >> 12;
2234 int off = e & 0x0FFF;
2236 if (t >= sizeof (tbl) / sizeof (tbl[0]))
2237 t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
2240 _("\treloc %4d offset %4x [%4lx] %s"),
2241 j, off, (unsigned long) (off + virtual_address), tbl[t]);
2246 /* HIGHADJ takes an argument, - the next record *is* the
2247 low 16 bits of addend. */
2248 if (t == IMAGE_REL_BASED_HIGHADJ && p + 2 <= chunk_end)
2250 fprintf (file, " (%4x)", (unsigned int) bfd_get_16 (abfd, p));
2255 fprintf (file, "\n");
2264 /* A data structure describing the regions of a .rsrc section.
2265 Some fields are filled in as the section is parsed. */
2267 typedef struct rsrc_regions
2269 bfd_byte * section_start;
2270 bfd_byte * section_end;
2271 bfd_byte * strings_start;
2272 bfd_byte * resource_start;
2276 rsrc_print_resource_directory (FILE * , bfd *, unsigned int, bfd_byte *,
2277 rsrc_regions *, bfd_vma);
2279 /* Print the resource entry at DATA, with the text indented by INDENT.
2280 Recusively calls rsrc_print_resource_directory to print the contents
2281 of directory entries.
2282 Returns the address of the end of the data associated with the entry
2283 or section_end + 1 upon failure. */
2286 rsrc_print_resource_entries (FILE * file,
2288 unsigned int indent,
2289 bfd_boolean is_name,
2291 rsrc_regions * regions,
2294 unsigned long entry, addr, size;
2296 if (data + 8 >= regions->section_end)
2297 return regions->section_end + 1;
2299 fprintf (file, _("%03x %*.s Entry: "), (int)(data - regions->section_start), indent, " ");
2301 entry = (unsigned long) bfd_get_32 (abfd, data);
2306 /* Note - the documentation says that this field is an RVA value
2307 but windres appears to produce a section relative offset with
2308 the top bit set. Support both styles for now. */
2309 if (HighBitSet (entry))
2310 name = regions->section_start + WithoutHighBit (entry);
2312 name = regions->section_start + entry - rva_bias;
2314 if (name + 2 < regions->section_end && name > regions->section_start)
2318 if (regions->strings_start == NULL)
2319 regions->strings_start = name;
2321 len = bfd_get_16 (abfd, name);
2323 fprintf (file, _("name: [val: %08lx len %d]: "), entry, len);
2325 if (name + 2 + len * 2 < regions->section_end)
2327 /* This strange loop is to cope with multibyte characters. */
2334 /* Avoid printing control characters. */
2335 if (c > 0 && c < 32)
2336 fprintf (file, "^%c", c + 64);
2338 fprintf (file, "%.1s", name);
2343 fprintf (file, _("<corrupt string length: %#x>\n"), len);
2344 /* PR binutils/17512: Do not try to continue decoding a
2345 corrupted resource section. It is likely to end up with
2346 reams of extraneous output. FIXME: We could probably
2347 continue if we disable the printing of strings... */
2348 return regions->section_end + 1;
2353 fprintf (file, _("<corrupt string offset: %#lx>\n"), entry);
2354 return regions->section_end + 1;
2358 fprintf (file, _("ID: %#08lx"), entry);
2360 entry = (long) bfd_get_32 (abfd, data + 4);
2361 fprintf (file, _(", Value: %#08lx\n"), entry);
2363 if (HighBitSet (entry))
2365 data = regions->section_start + WithoutHighBit (entry);
2366 if (data <= regions->section_start || data > regions->section_end)
2367 return regions->section_end + 1;
2369 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2370 in the resource table. We need some way to detect this. */
2371 return rsrc_print_resource_directory (file, abfd, indent + 1, data,
2375 if (regions->section_start + entry + 16 >= regions->section_end)
2376 return regions->section_end + 1;
2378 fprintf (file, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2381 addr = (long) bfd_get_32 (abfd, regions->section_start + entry),
2382 size = (long) bfd_get_32 (abfd, regions->section_start + entry + 4),
2383 (int) bfd_get_32 (abfd, regions->section_start + entry + 8));
2385 /* Check that the reserved entry is 0. */
2386 if (bfd_get_32 (abfd, regions->section_start + entry + 12) != 0
2387 /* And that the data address/size is valid too. */
2388 || (regions->section_start + (addr - rva_bias) + size > regions->section_end))
2389 return regions->section_end + 1;
2391 if (regions->resource_start == NULL)
2392 regions->resource_start = regions->section_start + (addr - rva_bias);
2394 return regions->section_start + (addr - rva_bias) + size;
2397 #define max(a,b) ((a) > (b) ? (a) : (b))
2398 #define min(a,b) ((a) < (b) ? (a) : (b))
2401 rsrc_print_resource_directory (FILE * file,
2403 unsigned int indent,
2405 rsrc_regions * regions,
2408 unsigned int num_names, num_ids;
2409 bfd_byte * highest_data = data;
2411 if (data + 16 >= regions->section_end)
2412 return regions->section_end + 1;
2414 fprintf (file, "%03x %*.s ", (int)(data - regions->section_start), indent, " ");
2417 case 0: fprintf (file, "Type"); break;
2418 case 2: fprintf (file, "Name"); break;
2419 case 4: fprintf (file, "Language"); break;
2421 fprintf (file, _("<unknown directory type: %d>\n"), indent);
2422 /* FIXME: For now we end the printing here. If in the
2423 future more directory types are added to the RSRC spec
2424 then we will need to change this. */
2425 return regions->section_end + 1;
2428 fprintf (file, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2429 (int) bfd_get_32 (abfd, data),
2430 (long) bfd_get_32 (abfd, data + 4),
2431 (int) bfd_get_16 (abfd, data + 8),
2432 (int) bfd_get_16 (abfd, data + 10),
2433 num_names = (int) bfd_get_16 (abfd, data + 12),
2434 num_ids = (int) bfd_get_16 (abfd, data + 14));
2437 while (num_names --)
2439 bfd_byte * entry_end;
2441 entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, TRUE,
2442 data, regions, rva_bias);
2444 highest_data = max (highest_data, entry_end);
2445 if (entry_end >= regions->section_end)
2451 bfd_byte * entry_end;
2453 entry_end = rsrc_print_resource_entries (file, abfd, indent + 1, FALSE,
2454 data, regions, rva_bias);
2456 highest_data = max (highest_data, entry_end);
2457 if (entry_end >= regions->section_end)
2461 return max (highest_data, data);
2464 /* Display the contents of a .rsrc section. We do not try to
2465 reproduce the resources, windres does that. Instead we dump
2466 the tables in a human readable format. */
2469 rsrc_print_section (bfd * abfd, void * vfile)
2473 FILE * file = (FILE *) vfile;
2474 bfd_size_type datasize;
2477 rsrc_regions regions;
2479 pe = pe_data (abfd);
2483 section = bfd_get_section_by_name (abfd, ".rsrc");
2484 if (section == NULL)
2486 if (!(section->flags & SEC_HAS_CONTENTS))
2489 datasize = section->size;
2493 rva_bias = section->vma - pe->pe_opthdr.ImageBase;
2495 if (! bfd_malloc_and_get_section (abfd, section, & data))
2502 regions.section_start = data;
2503 regions.section_end = data + datasize;
2504 regions.strings_start = NULL;
2505 regions.resource_start = NULL;
2508 fprintf (file, "\nThe .rsrc Resource Directory section:\n");
2510 while (data < regions.section_end)
2512 bfd_byte * p = data;
2514 data = rsrc_print_resource_directory (file, abfd, 0, data, & regions, rva_bias);
2516 if (data == regions.section_end + 1)
2517 fprintf (file, _("Corrupt .rsrc section detected!\n"));
2520 /* Align data before continuing. */
2521 int align = (1 << section->alignment_power) - 1;
2523 data = (bfd_byte *) (((ptrdiff_t) (data + align)) & ~ align);
2524 rva_bias += data - p;
2526 /* For reasons that are unclear .rsrc sections are sometimes created
2527 aligned to a 1^3 boundary even when their alignment is set at
2528 1^2. Catch that case here before we issue a spurious warning
2530 if (data == (regions.section_end - 4))
2531 data = regions.section_end;
2532 else if (data < regions.section_end)
2534 /* If the extra data is all zeros then do not complain.
2535 This is just padding so that the section meets the
2536 page size requirements. */
2537 while (++ data < regions.section_end)
2540 if (data < regions.section_end)
2541 fprintf (file, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2546 if (regions.strings_start != NULL)
2547 fprintf (file, " String table starts at offset: %#03x\n",
2548 (int) (regions.strings_start - regions.section_start));
2549 if (regions.resource_start != NULL)
2550 fprintf (file, " Resources start at offset: %#03x\n",
2551 (int) (regions.resource_start - regions.section_start));
2553 free (regions.section_start);
2557 #define IMAGE_NUMBEROF_DEBUG_TYPES 12
2559 static char * debug_type_names[IMAGE_NUMBEROF_DEBUG_TYPES] =
2576 pe_print_debugdata (bfd * abfd, void * vfile)
2578 FILE *file = (FILE *) vfile;
2579 pe_data_type *pe = pe_data (abfd);
2580 struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
2583 bfd_size_type dataoff;
2586 bfd_vma addr = extra->DataDirectory[PE_DEBUG_DATA].VirtualAddress;
2587 bfd_size_type size = extra->DataDirectory[PE_DEBUG_DATA].Size;
2592 addr += extra->ImageBase;
2593 for (section = abfd->sections; section != NULL; section = section->next)
2595 if ((addr >= section->vma) && (addr < (section->vma + section->size)))
2599 if (section == NULL)
2602 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2605 else if (!(section->flags & SEC_HAS_CONTENTS))
2608 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2612 else if (section->size < size)
2615 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2620 fprintf (file, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2621 section->name, (unsigned long) addr);
2623 dataoff = addr - section->vma;
2625 if (size > (section->size - dataoff))
2627 fprintf (file, _("The debug data size field in the data directory is too big for the section"));
2632 _("Type Size Rva Offset\n"));
2634 /* Read the whole section. */
2635 if (!bfd_malloc_and_get_section (abfd, section, &data))
2642 for (i = 0; i < size / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
2644 const char *type_name;
2645 struct external_IMAGE_DEBUG_DIRECTORY *ext
2646 = &((struct external_IMAGE_DEBUG_DIRECTORY *)(data + dataoff))[i];
2647 struct internal_IMAGE_DEBUG_DIRECTORY idd;
2649 _bfd_XXi_swap_debugdir_in (abfd, ext, &idd);
2651 if ((idd.Type) >= IMAGE_NUMBEROF_DEBUG_TYPES)
2652 type_name = debug_type_names[0];
2654 type_name = debug_type_names[idd.Type];
2656 fprintf (file, " %2ld %14s %08lx %08lx %08lx\n",
2657 idd.Type, type_name, idd.SizeOfData,
2658 idd.AddressOfRawData, idd.PointerToRawData);
2660 if (idd.Type == PE_IMAGE_DEBUG_TYPE_CODEVIEW)
2662 char signature[CV_INFO_SIGNATURE_LENGTH * 2 + 1];
2663 char buffer[256 + 1];
2664 CODEVIEW_INFO *cvinfo = (CODEVIEW_INFO *) buffer;
2666 /* The debug entry doesn't have to have to be in a section,
2667 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2668 if (!_bfd_XXi_slurp_codeview_record (abfd, (file_ptr) idd.PointerToRawData,
2669 idd.SizeOfData, cvinfo))
2672 for (i = 0; i < cvinfo->SignatureLength; i++)
2673 sprintf (&signature[i*2], "%02x", cvinfo->Signature[i] & 0xff);
2675 fprintf (file, "(format %c%c%c%c signature %s age %ld)\n",
2676 buffer[0], buffer[1], buffer[2], buffer[3],
2677 signature, cvinfo->Age);
2681 if (size % sizeof (struct external_IMAGE_DEBUG_DIRECTORY) != 0)
2683 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2688 /* Print out the program headers. */
2691 _bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
2693 FILE *file = (FILE *) vfile;
2695 pe_data_type *pe = pe_data (abfd);
2696 struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
2697 const char *subsystem_name = NULL;
2700 /* The MS dumpbin program reportedly ands with 0xff0f before
2701 printing the characteristics field. Not sure why. No reason to
2703 fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
2705 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2706 PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
2707 PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
2708 PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
2709 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
2710 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
2711 PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
2712 PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
2713 PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
2714 PF (IMAGE_FILE_SYSTEM, "system file");
2715 PF (IMAGE_FILE_DLL, "DLL");
2716 PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
2719 /* ctime implies '\n'. */
2721 time_t t = pe->coff.timestamp;
2722 fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
2725 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2726 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2728 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2729 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2731 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2732 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2737 case IMAGE_NT_OPTIONAL_HDR_MAGIC:
2740 case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
2743 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
2750 fprintf (file, "Magic\t\t\t%04x", i->Magic);
2752 fprintf (file, "\t(%s)",name);
2753 fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
2754 fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
2755 fprintf (file, "SizeOfCode\t\t%08lx\n", (unsigned long) i->SizeOfCode);
2756 fprintf (file, "SizeOfInitializedData\t%08lx\n",
2757 (unsigned long) i->SizeOfInitializedData);
2758 fprintf (file, "SizeOfUninitializedData\t%08lx\n",
2759 (unsigned long) i->SizeOfUninitializedData);
2760 fprintf (file, "AddressOfEntryPoint\t");
2761 bfd_fprintf_vma (abfd, file, i->AddressOfEntryPoint);
2762 fprintf (file, "\nBaseOfCode\t\t");
2763 bfd_fprintf_vma (abfd, file, i->BaseOfCode);
2764 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
2765 /* PE32+ does not have BaseOfData member! */
2766 fprintf (file, "\nBaseOfData\t\t");
2767 bfd_fprintf_vma (abfd, file, i->BaseOfData);
2770 fprintf (file, "\nImageBase\t\t");
2771 bfd_fprintf_vma (abfd, file, i->ImageBase);
2772 fprintf (file, "\nSectionAlignment\t");
2773 bfd_fprintf_vma (abfd, file, i->SectionAlignment);
2774 fprintf (file, "\nFileAlignment\t\t");
2775 bfd_fprintf_vma (abfd, file, i->FileAlignment);
2776 fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
2777 fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
2778 fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
2779 fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
2780 fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
2781 fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
2782 fprintf (file, "Win32Version\t\t%08lx\n", (unsigned long) i->Reserved1);
2783 fprintf (file, "SizeOfImage\t\t%08lx\n", (unsigned long) i->SizeOfImage);
2784 fprintf (file, "SizeOfHeaders\t\t%08lx\n", (unsigned long) i->SizeOfHeaders);
2785 fprintf (file, "CheckSum\t\t%08lx\n", (unsigned long) i->CheckSum);
2787 switch (i->Subsystem)
2789 case IMAGE_SUBSYSTEM_UNKNOWN:
2790 subsystem_name = "unspecified";
2792 case IMAGE_SUBSYSTEM_NATIVE:
2793 subsystem_name = "NT native";
2795 case IMAGE_SUBSYSTEM_WINDOWS_GUI:
2796 subsystem_name = "Windows GUI";
2798 case IMAGE_SUBSYSTEM_WINDOWS_CUI:
2799 subsystem_name = "Windows CUI";
2801 case IMAGE_SUBSYSTEM_POSIX_CUI:
2802 subsystem_name = "POSIX CUI";
2804 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
2805 subsystem_name = "Wince CUI";
2807 // These are from UEFI Platform Initialization Specification 1.1.
2808 case IMAGE_SUBSYSTEM_EFI_APPLICATION:
2809 subsystem_name = "EFI application";
2811 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
2812 subsystem_name = "EFI boot service driver";
2814 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
2815 subsystem_name = "EFI runtime driver";
2817 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
2818 subsystem_name = "SAL runtime driver";
2820 // This is from revision 8.0 of the MS PE/COFF spec
2821 case IMAGE_SUBSYSTEM_XBOX:
2822 subsystem_name = "XBOX";
2824 // Added default case for clarity - subsystem_name is NULL anyway.
2826 subsystem_name = NULL;
2829 fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
2831 fprintf (file, "\t(%s)", subsystem_name);
2832 fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
2833 fprintf (file, "SizeOfStackReserve\t");
2834 bfd_fprintf_vma (abfd, file, i->SizeOfStackReserve);
2835 fprintf (file, "\nSizeOfStackCommit\t");
2836 bfd_fprintf_vma (abfd, file, i->SizeOfStackCommit);
2837 fprintf (file, "\nSizeOfHeapReserve\t");
2838 bfd_fprintf_vma (abfd, file, i->SizeOfHeapReserve);
2839 fprintf (file, "\nSizeOfHeapCommit\t");
2840 bfd_fprintf_vma (abfd, file, i->SizeOfHeapCommit);
2841 fprintf (file, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i->LoaderFlags);
2842 fprintf (file, "NumberOfRvaAndSizes\t%08lx\n",
2843 (unsigned long) i->NumberOfRvaAndSizes);
2845 fprintf (file, "\nThe Data Directory\n");
2846 for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
2848 fprintf (file, "Entry %1x ", j);
2849 bfd_fprintf_vma (abfd, file, i->DataDirectory[j].VirtualAddress);
2850 fprintf (file, " %08lx ", (unsigned long) i->DataDirectory[j].Size);
2851 fprintf (file, "%s\n", dir_names[j]);
2854 pe_print_idata (abfd, vfile);
2855 pe_print_edata (abfd, vfile);
2856 if (bfd_coff_have_print_pdata (abfd))
2857 bfd_coff_print_pdata (abfd, vfile);
2859 pe_print_pdata (abfd, vfile);
2860 pe_print_reloc (abfd, vfile);
2861 pe_print_debugdata (abfd, file);
2863 rsrc_print_section (abfd, vfile);
2869 is_vma_in_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sect, void *obj)
2871 bfd_vma addr = * (bfd_vma *) obj;
2872 return (addr >= sect->vma) && (addr < (sect->vma + sect->size));
2876 find_section_by_vma (bfd *abfd, bfd_vma addr)
2878 return bfd_sections_find_if (abfd, is_vma_in_section, (void *) & addr);
2881 /* Copy any private info we understand from the input bfd
2882 to the output bfd. */
2885 _bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
2887 pe_data_type *ipe, *ope;
2889 /* One day we may try to grok other private data. */
2890 if (ibfd->xvec->flavour != bfd_target_coff_flavour
2891 || obfd->xvec->flavour != bfd_target_coff_flavour)
2894 ipe = pe_data (ibfd);
2895 ope = pe_data (obfd);
2897 /* pe_opthdr is copied in copy_object. */
2898 ope->dll = ipe->dll;
2900 /* Don't copy input subsystem if output is different from input. */
2901 if (obfd->xvec != ibfd->xvec)
2902 ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
2904 /* For strip: if we removed .reloc, we'll make a real mess of things
2905 if we don't remove this entry as well. */
2906 if (! pe_data (obfd)->has_reloc_section)
2908 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2909 pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
2912 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2913 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2915 if (! pe_data (ibfd)->has_reloc_section
2916 && ! (pe_data (ibfd)->real_flags & IMAGE_FILE_RELOCS_STRIPPED))
2917 pe_data (obfd)->dont_strip_reloc = 1;
2919 /* The file offsets contained in the debug directory need rewriting. */
2920 if (ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size != 0)
2922 bfd_vma addr = ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].VirtualAddress
2923 + ope->pe_opthdr.ImageBase;
2924 asection *section = find_section_by_vma (obfd, addr);
2927 if (section && bfd_malloc_and_get_section (obfd, section, &data))
2930 struct external_IMAGE_DEBUG_DIRECTORY *dd =
2931 (struct external_IMAGE_DEBUG_DIRECTORY *)(data + (addr - section->vma));
2933 /* PR 17512: file: 0f15796a. */
2934 if (ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size + (addr - section->vma)
2935 > bfd_get_section_size (section))
2937 _bfd_error_handler (_("%A: Data Directory size (%lx) exceeds space left in section (%lx)"),
2938 obfd, ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size,
2939 bfd_get_section_size (section) - (addr - section->vma));
2943 for (i = 0; i < ope->pe_opthdr.DataDirectory[PE_DEBUG_DATA].Size
2944 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY); i++)
2946 asection *ddsection;
2947 struct external_IMAGE_DEBUG_DIRECTORY *edd = &(dd[i]);
2948 struct internal_IMAGE_DEBUG_DIRECTORY idd;
2950 _bfd_XXi_swap_debugdir_in (obfd, edd, &idd);
2952 if (idd.AddressOfRawData == 0)
2953 continue; /* RVA 0 means only offset is valid, not handled yet. */
2955 ddsection = find_section_by_vma (obfd, idd.AddressOfRawData + ope->pe_opthdr.ImageBase);
2957 continue; /* Not in a section! */
2959 idd.PointerToRawData = ddsection->filepos + (idd.AddressOfRawData
2960 + ope->pe_opthdr.ImageBase) - ddsection->vma;
2962 _bfd_XXi_swap_debugdir_out (obfd, &idd, edd);
2965 if (!bfd_set_section_contents (obfd, section, data, 0, section->size))
2966 _bfd_error_handler (_("Failed to update file offsets in debug directory"));
2973 /* Copy private section data. */
2976 _bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
2981 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
2982 || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
2985 if (coff_section_data (ibfd, isec) != NULL
2986 && pei_section_data (ibfd, isec) != NULL)
2988 if (coff_section_data (obfd, osec) == NULL)
2990 bfd_size_type amt = sizeof (struct coff_section_tdata);
2991 osec->used_by_bfd = bfd_zalloc (obfd, amt);
2992 if (osec->used_by_bfd == NULL)
2996 if (pei_section_data (obfd, osec) == NULL)
2998 bfd_size_type amt = sizeof (struct pei_section_tdata);
2999 coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
3000 if (coff_section_data (obfd, osec)->tdata == NULL)
3004 pei_section_data (obfd, osec)->virt_size =
3005 pei_section_data (ibfd, isec)->virt_size;
3006 pei_section_data (obfd, osec)->pe_flags =
3007 pei_section_data (ibfd, isec)->pe_flags;
3014 _bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
3016 coff_get_symbol_info (abfd, symbol, ret);
3019 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
3021 sort_x64_pdata (const void *l, const void *r)
3023 const char *lp = (const char *) l;
3024 const char *rp = (const char *) r;
3026 vl = bfd_getl32 (lp); vr = bfd_getl32 (rp);
3028 return (vl < vr ? -1 : 1);
3029 /* We compare just begin address. */
3034 /* Functions to process a .rsrc section. */
3036 static unsigned int sizeof_leaves;
3037 static unsigned int sizeof_strings;
3038 static unsigned int sizeof_tables_and_entries;
3041 rsrc_count_directory (bfd *, bfd_byte *, bfd_byte *, bfd_byte *, bfd_vma);
3044 rsrc_count_entries (bfd * abfd,
3045 bfd_boolean is_name,
3046 bfd_byte * datastart,
3051 unsigned long entry, addr, size;
3053 if (data + 8 >= dataend)
3060 entry = (long) bfd_get_32 (abfd, data);
3062 if (HighBitSet (entry))
3063 name = datastart + WithoutHighBit (entry);
3065 name = datastart + entry - rva_bias;
3067 if (name + 2 >= dataend || name < datastart)
3070 unsigned int len = bfd_get_16 (abfd, name);
3071 if (len == 0 || len > 256)
3075 entry = (long) bfd_get_32 (abfd, data + 4);
3077 if (HighBitSet (entry))
3079 data = datastart + WithoutHighBit (entry);
3081 if (data <= datastart || data >= dataend)
3084 return rsrc_count_directory (abfd, datastart, data, dataend, rva_bias);
3087 if (datastart + entry + 16 >= dataend)
3090 addr = (long) bfd_get_32 (abfd, datastart + entry);
3091 size = (long) bfd_get_32 (abfd, datastart + entry + 4);
3093 return datastart + addr - rva_bias + size;
3097 rsrc_count_directory (bfd * abfd,
3098 bfd_byte * datastart,
3103 unsigned int num_entries, num_ids;
3104 bfd_byte * highest_data = data;
3106 if (data + 16 >= dataend)
3109 num_entries = (int) bfd_get_16 (abfd, data + 12);
3110 num_ids = (int) bfd_get_16 (abfd, data + 14);
3112 num_entries += num_ids;
3116 while (num_entries --)
3118 bfd_byte * entry_end;
3120 entry_end = rsrc_count_entries (abfd, num_entries >= num_ids,
3121 datastart, data, dataend, rva_bias);
3123 highest_data = max (highest_data, entry_end);
3124 if (entry_end >= dataend)
3128 return max (highest_data, data);
3131 typedef struct rsrc_dir_chain
3133 unsigned int num_entries;
3134 struct rsrc_entry * first_entry;
3135 struct rsrc_entry * last_entry;
3138 typedef struct rsrc_directory
3140 unsigned int characteristics;
3145 rsrc_dir_chain names;
3148 struct rsrc_entry * entry;
3151 typedef struct rsrc_string
3157 typedef struct rsrc_leaf
3160 unsigned int codepage;
3164 typedef struct rsrc_entry
3166 bfd_boolean is_name;
3170 struct rsrc_string name;
3176 struct rsrc_directory * directory;
3177 struct rsrc_leaf * leaf;
3180 struct rsrc_entry * next_entry;
3181 struct rsrc_directory * parent;
3185 rsrc_parse_directory (bfd *, rsrc_directory *, bfd_byte *,
3186 bfd_byte *, bfd_byte *, bfd_vma, rsrc_entry *);
3189 rsrc_parse_entry (bfd * abfd,
3190 bfd_boolean is_name,
3192 bfd_byte * datastart,
3196 rsrc_directory * parent)
3198 unsigned long val, addr, size;
3200 val = bfd_get_32 (abfd, data);
3202 entry->parent = parent;
3203 entry->is_name = is_name;
3209 if (HighBitSet (val))
3211 val = WithoutHighBit (val);
3213 address = datastart + val;
3217 address = datastart + val - rva_bias;
3220 if (address + 3 > dataend)
3223 entry->name_id.name.len = bfd_get_16 (abfd, address);
3224 entry->name_id.name.string = address + 2;
3227 entry->name_id.id = val;
3229 val = bfd_get_32 (abfd, data + 4);
3231 if (HighBitSet (val))
3233 entry->is_dir = TRUE;
3234 entry->value.directory = bfd_malloc (sizeof * entry->value.directory);
3235 if (entry->value.directory == NULL)
3238 return rsrc_parse_directory (abfd, entry->value.directory,
3240 datastart + WithoutHighBit (val),
3241 dataend, rva_bias, entry);
3244 entry->is_dir = FALSE;
3245 entry->value.leaf = bfd_malloc (sizeof * entry->value.leaf);
3246 if (entry->value.leaf == NULL)
3249 addr = bfd_get_32 (abfd, datastart + val);
3250 size = entry->value.leaf->size = bfd_get_32 (abfd, datastart + val + 4);
3251 entry->value.leaf->codepage = bfd_get_32 (abfd, datastart + val + 8);
3253 entry->value.leaf->data = bfd_malloc (size);
3254 if (entry->value.leaf->data == NULL)
3257 memcpy (entry->value.leaf->data, datastart + addr - rva_bias, size);
3258 return datastart + (addr - rva_bias) + size;
3262 rsrc_parse_entries (bfd * abfd,
3263 rsrc_dir_chain * chain,
3264 bfd_boolean is_name,
3265 bfd_byte * highest_data,
3266 bfd_byte * datastart,
3270 rsrc_directory * parent)
3275 if (chain->num_entries == 0)
3277 chain->first_entry = chain->last_entry = NULL;
3278 return highest_data;
3281 entry = bfd_malloc (sizeof * entry);
3285 chain->first_entry = entry;
3287 for (i = chain->num_entries; i--;)
3289 bfd_byte * entry_end;
3291 entry_end = rsrc_parse_entry (abfd, is_name, entry, datastart,
3292 data, dataend, rva_bias, parent);
3294 highest_data = max (entry_end, highest_data);
3295 if (entry_end > dataend)
3300 entry->next_entry = bfd_malloc (sizeof * entry);
3301 entry = entry->next_entry;
3306 entry->next_entry = NULL;
3309 chain->last_entry = entry;
3311 return highest_data;
3315 rsrc_parse_directory (bfd * abfd,
3316 rsrc_directory * table,
3317 bfd_byte * datastart,
3323 bfd_byte * highest_data = data;
3328 table->characteristics = bfd_get_32 (abfd, data);
3329 table->time = bfd_get_32 (abfd, data + 4);
3330 table->major = bfd_get_16 (abfd, data + 8);
3331 table->minor = bfd_get_16 (abfd, data + 10);
3332 table->names.num_entries = bfd_get_16 (abfd, data + 12);
3333 table->ids.num_entries = bfd_get_16 (abfd, data + 14);
3334 table->entry = entry;
3338 highest_data = rsrc_parse_entries (abfd, & table->names, TRUE, data,
3339 datastart, data, dataend, rva_bias, table);
3340 data += table->names.num_entries * 8;
3342 highest_data = rsrc_parse_entries (abfd, & table->ids, FALSE, highest_data,
3343 datastart, data, dataend, rva_bias, table);
3344 data += table->ids.num_entries * 8;
3346 return max (highest_data, data);
3349 typedef struct rsrc_write_data
3352 bfd_byte * datastart;
3353 bfd_byte * next_table;
3354 bfd_byte * next_leaf;
3355 bfd_byte * next_string;
3356 bfd_byte * next_data;
3361 rsrc_write_string (rsrc_write_data * data,
3362 rsrc_string * string)
3364 bfd_put_16 (data->abfd, string->len, data->next_string);
3365 memcpy (data->next_string + 2, string->string, string->len * 2);
3366 data->next_string += (string->len + 1) * 2;
3369 static inline unsigned int
3370 rsrc_compute_rva (rsrc_write_data * data,
3373 return (addr - data->datastart) + data->rva_bias;
3377 rsrc_write_leaf (rsrc_write_data * data,
3380 bfd_put_32 (data->abfd, rsrc_compute_rva (data, data->next_data),
3382 bfd_put_32 (data->abfd, leaf->size, data->next_leaf + 4);
3383 bfd_put_32 (data->abfd, leaf->codepage, data->next_leaf + 8);
3384 bfd_put_32 (data->abfd, 0 /*reserved*/, data->next_leaf + 12);
3385 data->next_leaf += 16;
3387 memcpy (data->next_data, leaf->data, leaf->size);
3388 /* An undocumented feature of Windows resources is that each unit
3389 of raw data is 8-byte aligned... */
3390 data->next_data += ((leaf->size + 7) & ~7);
3393 static void rsrc_write_directory (rsrc_write_data *, rsrc_directory *);
3396 rsrc_write_entry (rsrc_write_data * data,
3402 bfd_put_32 (data->abfd,
3403 SetHighBit (data->next_string - data->datastart),
3405 rsrc_write_string (data, & entry->name_id.name);
3408 bfd_put_32 (data->abfd, entry->name_id.id, where);
3412 bfd_put_32 (data->abfd,
3413 SetHighBit (data->next_table - data->datastart),
3415 rsrc_write_directory (data, entry->value.directory);
3419 bfd_put_32 (data->abfd, data->next_leaf - data->datastart, where + 4);
3420 rsrc_write_leaf (data, entry->value.leaf);
3425 rsrc_compute_region_sizes (rsrc_directory * dir)
3427 struct rsrc_entry * entry;
3432 sizeof_tables_and_entries += 16;
3434 for (entry = dir->names.first_entry; entry != NULL; entry = entry->next_entry)
3436 sizeof_tables_and_entries += 8;
3438 sizeof_strings += (entry->name_id.name.len + 1) * 2;
3441 rsrc_compute_region_sizes (entry->value.directory);
3443 sizeof_leaves += 16;
3446 for (entry = dir->ids.first_entry; entry != NULL; entry = entry->next_entry)
3448 sizeof_tables_and_entries += 8;
3451 rsrc_compute_region_sizes (entry->value.directory);
3453 sizeof_leaves += 16;
3458 rsrc_write_directory (rsrc_write_data * data,
3459 rsrc_directory * dir)
3463 bfd_byte * next_entry;
3466 bfd_put_32 (data->abfd, dir->characteristics, data->next_table);
3467 bfd_put_32 (data->abfd, 0 /*dir->time*/, data->next_table + 4);
3468 bfd_put_16 (data->abfd, dir->major, data->next_table + 8);
3469 bfd_put_16 (data->abfd, dir->minor, data->next_table + 10);
3470 bfd_put_16 (data->abfd, dir->names.num_entries, data->next_table + 12);
3471 bfd_put_16 (data->abfd, dir->ids.num_entries, data->next_table + 14);
3473 /* Compute where the entries and the next table will be placed. */
3474 next_entry = data->next_table + 16;
3475 data->next_table = next_entry + (dir->names.num_entries * 8)
3476 + (dir->ids.num_entries * 8);
3477 nt = data->next_table;
3479 /* Write the entries. */
3480 for (i = dir->names.num_entries, entry = dir->names.first_entry;
3481 i > 0 && entry != NULL;
3482 i--, entry = entry->next_entry)
3484 BFD_ASSERT (entry->is_name);
3485 rsrc_write_entry (data, next_entry, entry);
3488 BFD_ASSERT (i == 0);
3489 BFD_ASSERT (entry == NULL);
3491 for (i = dir->ids.num_entries, entry = dir->ids.first_entry;
3492 i > 0 && entry != NULL;
3493 i--, entry = entry->next_entry)
3495 BFD_ASSERT (! entry->is_name);
3496 rsrc_write_entry (data, next_entry, entry);
3499 BFD_ASSERT (i == 0);
3500 BFD_ASSERT (entry == NULL);
3501 BFD_ASSERT (nt == next_entry);
3504 #if defined HAVE_WCHAR_H && ! defined __CYGWIN__ && ! defined __MINGW32__
3505 /* Return the length (number of units) of the first character in S,
3506 putting its 'ucs4_t' representation in *PUC. */
3509 u16_mbtouc (wchar_t * puc, const unsigned short * s, unsigned int n)
3511 unsigned short c = * s;
3513 if (c < 0xd800 || c >= 0xe000)
3523 if (s[1] >= 0xdc00 && s[1] < 0xe000)
3525 *puc = 0x10000 + ((c - 0xd800) << 10) + (s[1] - 0xdc00);
3531 /* Incomplete multibyte character. */
3537 /* Invalid multibyte character. */
3541 #endif /* HAVE_WCHAR_H and not Cygwin/Mingw */
3543 /* Perform a comparison of two entries. */
3545 rsrc_cmp (bfd_boolean is_name, rsrc_entry * a, rsrc_entry * b)
3554 return a->name_id.id - b->name_id.id;
3556 /* We have to perform a case insenstive, unicode string comparison... */
3557 astring = a->name_id.name.string;
3558 alen = a->name_id.name.len;
3559 bstring = b->name_id.name.string;
3560 blen = b->name_id.name.len;
3562 #if defined __CYGWIN__ || defined __MINGW32__
3563 /* Under Windows hosts (both Cygwin and Mingw types),
3564 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3565 function however goes by different names in the two environments... */
3569 #define rscpcmp wcsncasecmp
3572 #define rscpcmp wcsnicmp
3575 res = rscpcmp ((const wchar_t *) astring, (const wchar_t *) bstring,
3578 #elif defined HAVE_WCHAR_H
3582 for (i = min (alen, blen); i--; astring += 2, bstring += 2)
3587 /* Convert UTF-16 unicode characters into wchar_t characters so
3588 that we can then perform a case insensitive comparison. */
3589 int Alen = u16_mbtouc (& awc, (const unsigned short *) astring, 2);
3590 int Blen = u16_mbtouc (& bwc, (const unsigned short *) bstring, 2);
3594 res = wcsncasecmp (& awc, & bwc, 1);
3600 /* Do the best we can - a case sensitive, untranslated comparison. */
3601 res = memcmp (astring, bstring, min (alen, blen) * 2);
3611 rsrc_print_name (char * buffer, rsrc_string string)
3614 bfd_byte * name = string.string;
3616 for (i = string.len; i--; name += 2)
3617 sprintf (buffer + strlen (buffer), "%.1s", name);
3621 rsrc_resource_name (rsrc_entry * entry, rsrc_directory * dir)
3623 static char buffer [256];
3624 bfd_boolean is_string = FALSE;
3628 if (dir != NULL && dir->entry != NULL && dir->entry->parent != NULL
3629 && dir->entry->parent->entry != NULL)
3631 strcpy (buffer, "type: ");
3632 if (dir->entry->parent->entry->is_name)
3633 rsrc_print_name (buffer + strlen (buffer),
3634 dir->entry->parent->entry->name_id.name);
3637 unsigned int id = dir->entry->parent->entry->name_id.id;
3639 sprintf (buffer + strlen (buffer), "%x", id);
3642 case 1: strcat (buffer, " (CURSOR)"); break;
3643 case 2: strcat (buffer, " (BITMAP)"); break;
3644 case 3: strcat (buffer, " (ICON)"); break;
3645 case 4: strcat (buffer, " (MENU)"); break;
3646 case 5: strcat (buffer, " (DIALOG)"); break;
3647 case 6: strcat (buffer, " (STRING)"); is_string = TRUE; break;
3648 case 7: strcat (buffer, " (FONTDIR)"); break;
3649 case 8: strcat (buffer, " (FONT)"); break;
3650 case 9: strcat (buffer, " (ACCELERATOR)"); break;
3651 case 10: strcat (buffer, " (RCDATA)"); break;
3652 case 11: strcat (buffer, " (MESSAGETABLE)"); break;
3653 case 12: strcat (buffer, " (GROUP_CURSOR)"); break;
3654 case 14: strcat (buffer, " (GROUP_ICON)"); break;
3655 case 16: strcat (buffer, " (VERSION)"); break;
3656 case 17: strcat (buffer, " (DLGINCLUDE)"); break;
3657 case 19: strcat (buffer, " (PLUGPLAY)"); break;
3658 case 20: strcat (buffer, " (VXD)"); break;
3659 case 21: strcat (buffer, " (ANICURSOR)"); break;
3660 case 22: strcat (buffer, " (ANIICON)"); break;
3661 case 23: strcat (buffer, " (HTML)"); break;
3662 case 24: strcat (buffer, " (MANIFEST)"); break;
3663 case 240: strcat (buffer, " (DLGINIT)"); break;
3664 case 241: strcat (buffer, " (TOOLBAR)"); break;
3669 if (dir != NULL && dir->entry != NULL)
3671 strcat (buffer, " name: ");
3672 if (dir->entry->is_name)
3673 rsrc_print_name (buffer + strlen (buffer), dir->entry->name_id.name);
3676 unsigned int id = dir->entry->name_id.id;
3678 sprintf (buffer + strlen (buffer), "%x", id);
3681 sprintf (buffer + strlen (buffer), " (resource id range: %d - %d)",
3682 (id - 1) << 4, (id << 4) - 1);
3688 strcat (buffer, " lang: ");
3691 rsrc_print_name (buffer + strlen (buffer), entry->name_id.name);
3693 sprintf (buffer + strlen (buffer), "%x", entry->name_id.id);
3699 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3700 their ID is stored in the NAME entry. The bottom four bits are used as
3701 an index into unicode string table that makes up the data of the leaf.
3702 So identical type-name-lang string resources may not actually be
3705 This function is called when we have detected two string resources with
3706 match top-28-bit IDs. We have to scan the string tables inside the leaves
3707 and discover if there are any real collisions. If there are then we report
3708 them and return FALSE. Otherwise we copy any strings from B into A and
3709 then return TRUE. */
3712 rsrc_merge_string_entries (rsrc_entry * a ATTRIBUTE_UNUSED,
3713 rsrc_entry * b ATTRIBUTE_UNUSED)
3715 unsigned int copy_needed = 0;
3719 bfd_byte * new_data;
3722 /* Step one: Find out what we have to do. */
3723 BFD_ASSERT (! a->is_dir);
3724 astring = a->value.leaf->data;
3726 BFD_ASSERT (! b->is_dir);
3727 bstring = b->value.leaf->data;
3729 for (i = 0; i < 16; i++)
3731 unsigned int alen = astring[0] + (astring[1] << 8);
3732 unsigned int blen = bstring[0] + (bstring[1] << 8);
3736 copy_needed += blen * 2;
3740 else if (alen != blen)
3741 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3743 /* alen == blen != 0. We might have two identical strings. If so we
3744 can ignore the second one. There is no need for wchar_t vs UTF-16
3745 theatrics here - we are only interested in (case sensitive) equality. */
3746 else if (memcmp (astring + 2, bstring + 2, alen * 2) != 0)
3749 astring += (alen + 1) * 2;
3750 bstring += (blen + 1) * 2;
3755 if (a->parent != NULL
3756 && a->parent->entry != NULL
3757 && a->parent->entry->is_name == FALSE)
3758 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3759 ((a->parent->entry->name_id.id - 1) << 4) + i);
3763 if (copy_needed == 0)
3766 /* If we reach here then A and B must both have non-colliding strings.
3767 (We never get string resources with fully empty string tables).
3768 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3770 new_data = bfd_malloc (a->value.leaf->size + copy_needed);
3771 if (new_data == NULL)
3775 astring = a->value.leaf->data;
3776 bstring = b->value.leaf->data;
3778 for (i = 0; i < 16; i++)
3780 unsigned int alen = astring[0] + (astring[1] << 8);
3781 unsigned int blen = bstring[0] + (bstring[1] << 8);
3785 memcpy (nstring, astring, (alen + 1) * 2);
3786 nstring += (alen + 1) * 2;
3790 memcpy (nstring, bstring, (blen + 1) * 2);
3791 nstring += (blen + 1) * 2;
3799 astring += (alen + 1) * 2;
3800 bstring += (blen + 1) * 2;
3803 BFD_ASSERT (nstring - new_data == (signed) (a->value.leaf->size + copy_needed));
3805 free (a->value.leaf->data);
3806 a->value.leaf->data = new_data;
3807 a->value.leaf->size += copy_needed;
3812 static void rsrc_merge (rsrc_entry *, rsrc_entry *);
3814 /* Sort the entries in given part of the directory.
3815 We use an old fashioned bubble sort because we are dealing
3816 with lists and we want to handle matches specially. */
3819 rsrc_sort_entries (rsrc_dir_chain * chain,
3820 bfd_boolean is_name,
3821 rsrc_directory * dir)
3825 rsrc_entry ** points_to_entry;
3826 bfd_boolean swapped;
3828 if (chain->num_entries < 2)
3834 points_to_entry = & chain->first_entry;
3835 entry = * points_to_entry;
3836 next = entry->next_entry;
3840 signed int cmp = rsrc_cmp (is_name, entry, next);
3844 entry->next_entry = next->next_entry;
3845 next->next_entry = entry;
3846 * points_to_entry = next;
3847 points_to_entry = & next->next_entry;
3848 next = entry->next_entry;
3853 if (entry->is_dir && next->is_dir)
3855 /* When we encounter identical directory entries we have to
3856 merge them together. The exception to this rule is for
3857 resource manifests - there can only be one of these,
3858 even if they differ in language. Zero-language manifests
3859 are assumed to be default manifests (provided by the
3860 Cygwin/MinGW build system) and these can be silently dropped,
3861 unless that would reduce the number of manifests to zero.
3862 There should only ever be one non-zero lang manifest -
3863 if there are more it is an error. A non-zero lang
3864 manifest takes precedence over a default manifest. */
3865 if (entry->is_name == FALSE
3866 && entry->name_id.id == 1
3868 && dir->entry != NULL
3869 && dir->entry->is_name == FALSE
3870 && dir->entry->name_id.id == 0x18)
3872 if (next->value.directory->names.num_entries == 0
3873 && next->value.directory->ids.num_entries == 1
3874 && next->value.directory->ids.first_entry->is_name == FALSE
3875 && next->value.directory->ids.first_entry->name_id.id == 0)
3876 /* Fall through so that NEXT is dropped. */
3878 else if (entry->value.directory->names.num_entries == 0
3879 && entry->value.directory->ids.num_entries == 1
3880 && entry->value.directory->ids.first_entry->is_name == FALSE
3881 && entry->value.directory->ids.first_entry->name_id.id == 0)
3883 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3884 entry->next_entry = next->next_entry;
3885 next->next_entry = entry;
3886 * points_to_entry = next;
3887 points_to_entry = & next->next_entry;
3888 next = entry->next_entry;
3893 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3894 bfd_set_error (bfd_error_file_truncated);
3898 /* Unhook NEXT from the chain. */
3899 /* FIXME: memory loss here. */
3900 entry->next_entry = next->next_entry;
3901 chain->num_entries --;
3902 if (chain->num_entries < 2)
3904 next = next->next_entry;
3907 rsrc_merge (entry, next);
3909 else if (entry->is_dir != next->is_dir)
3911 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
3912 bfd_set_error (bfd_error_file_truncated);
3917 /* Otherwise with identical leaves we issue an error
3918 message - because there should never be duplicates.
3919 The exception is Type 18/Name 1/Lang 0 which is the
3920 defaul manifest - this can just be dropped. */
3921 if (entry->is_name == FALSE
3922 && entry->name_id.id == 0
3924 && dir->entry != NULL
3925 && dir->entry->is_name == FALSE
3926 && dir->entry->name_id.id == 1
3927 && dir->entry->parent != NULL
3928 && dir->entry->parent->entry != NULL
3929 && dir->entry->parent->entry->is_name == FALSE
3930 && dir->entry->parent->entry->name_id.id == 0x18 /* RT_MANIFEST */)
3932 else if (dir != NULL
3933 && dir->entry != NULL
3934 && dir->entry->parent != NULL
3935 && dir->entry->parent->entry != NULL
3936 && dir->entry->parent->entry->is_name == FALSE
3937 && dir->entry->parent->entry->name_id.id == 0x6 /* RT_STRING */)
3939 /* Strings need special handling. */
3940 if (! rsrc_merge_string_entries (entry, next))
3942 /* _bfd_error_handler should have been called inside merge_strings. */
3943 bfd_set_error (bfd_error_file_truncated);
3950 || dir->entry == NULL
3951 || dir->entry->parent == NULL
3952 || dir->entry->parent->entry == NULL)
3953 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
3955 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
3956 rsrc_resource_name (entry, dir));
3957 bfd_set_error (bfd_error_file_truncated);
3962 /* Unhook NEXT from the chain. */
3963 entry->next_entry = next->next_entry;
3964 chain->num_entries --;
3965 if (chain->num_entries < 2)
3967 next = next->next_entry;
3971 points_to_entry = & entry->next_entry;
3973 next = next->next_entry;
3978 chain->last_entry = entry;
3983 /* Attach B's chain onto A. */
3985 rsrc_attach_chain (rsrc_dir_chain * achain, rsrc_dir_chain * bchain)
3987 if (bchain->num_entries == 0)
3990 achain->num_entries += bchain->num_entries;
3992 if (achain->first_entry == NULL)
3994 achain->first_entry = bchain->first_entry;
3995 achain->last_entry = bchain->last_entry;
3999 achain->last_entry->next_entry = bchain->first_entry;
4000 achain->last_entry = bchain->last_entry;
4003 bchain->num_entries = 0;
4004 bchain->first_entry = bchain->last_entry = NULL;
4008 rsrc_merge (struct rsrc_entry * a, struct rsrc_entry * b)
4010 rsrc_directory * adir;
4011 rsrc_directory * bdir;
4013 BFD_ASSERT (a->is_dir);
4014 BFD_ASSERT (b->is_dir);
4016 adir = a->value.directory;
4017 bdir = b->value.directory;
4019 if (adir->characteristics != bdir->characteristics)
4021 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics\n"));
4022 bfd_set_error (bfd_error_file_truncated);
4026 if (adir->major != bdir->major || adir->minor != bdir->minor)
4028 _bfd_error_handler (_(".rsrc merge failure: differing directory versions\n"));
4029 bfd_set_error (bfd_error_file_truncated);
4033 /* Attach B's name chain to A. */
4034 rsrc_attach_chain (& adir->names, & bdir->names);
4036 /* Attach B's ID chain to A. */
4037 rsrc_attach_chain (& adir->ids, & bdir->ids);
4039 /* Now sort A's entries. */
4040 rsrc_sort_entries (& adir->names, TRUE, adir);
4041 rsrc_sort_entries (& adir->ids, FALSE, adir);
4044 /* Check the .rsrc section. If it contains multiple concatenated
4045 resources then we must merge them properly. Otherwise Windows
4046 will ignore all but the first set. */
4049 rsrc_process_section (bfd * abfd,
4050 struct coff_final_link_info * pfinfo)
4052 rsrc_directory new_table;
4058 bfd_byte * datastart;
4060 bfd_byte * new_data;
4061 unsigned int num_resource_sets;
4062 rsrc_directory * type_tables;
4063 rsrc_write_data write_data;
4066 unsigned int num_input_rsrc = 0;
4067 unsigned int max_num_input_rsrc = 4;
4068 ptrdiff_t * rsrc_sizes = NULL;
4070 new_table.names.num_entries = 0;
4071 new_table.ids.num_entries = 0;
4073 sec = bfd_get_section_by_name (abfd, ".rsrc");
4074 if (sec == NULL || (size = sec->rawsize) == 0)
4077 pe = pe_data (abfd);
4081 rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4083 data = bfd_malloc (size);
4089 if (! bfd_get_section_contents (abfd, sec, data, 0, size))
4092 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4093 their lengths. Note - we rely upon the fact that the linker script
4094 does *not* sort the input .rsrc sections, so that the order in the
4095 linkinfo list matches the order in the output .rsrc section.
4097 We need to know the lengths because each input .rsrc section has padding
4098 at the end of a variable amount. (It does not appear to be based upon
4099 the section alignment or the file alignment). We need to skip any
4100 padding bytes when parsing the input .rsrc sections. */
4101 rsrc_sizes = bfd_malloc (max_num_input_rsrc * sizeof * rsrc_sizes);
4102 if (rsrc_sizes == NULL)
4105 for (input = pfinfo->info->input_bfds;
4107 input = input->link.next)
4109 asection * rsrc_sec = bfd_get_section_by_name (input, ".rsrc");
4111 if (rsrc_sec != NULL)
4113 if (num_input_rsrc == max_num_input_rsrc)
4115 max_num_input_rsrc += 10;
4116 rsrc_sizes = bfd_realloc (rsrc_sizes, max_num_input_rsrc
4117 * sizeof * rsrc_sizes);
4118 if (rsrc_sizes == NULL)
4122 BFD_ASSERT (rsrc_sec->size > 0);
4123 rsrc_sizes [num_input_rsrc ++] = rsrc_sec->size;
4127 if (num_input_rsrc < 2)
4130 /* Step one: Walk the section, computing the size of the tables,
4131 leaves and data and decide if we need to do anything. */
4132 dataend = data + size;
4133 num_resource_sets = 0;
4135 while (data < dataend)
4137 bfd_byte * p = data;
4139 data = rsrc_count_directory (abfd, data, data, dataend, rva_bias);
4143 /* Corrupted .rsrc section - cannot merge. */
4144 _bfd_error_handler (_("%s: .rsrc merge failure: corrupt .rsrc section"),
4145 bfd_get_filename (abfd));
4146 bfd_set_error (bfd_error_file_truncated);
4150 if ((data - p) > rsrc_sizes [num_resource_sets])
4152 _bfd_error_handler (_("%s: .rsrc merge failure: unexpected .rsrc size"),
4153 bfd_get_filename (abfd));
4154 bfd_set_error (bfd_error_file_truncated);
4157 /* FIXME: Should we add a check for "data - p" being much smaller
4158 than rsrc_sizes[num_resource_sets] ? */
4160 data = p + rsrc_sizes[num_resource_sets];
4161 rva_bias += data - p;
4162 ++ num_resource_sets;
4164 BFD_ASSERT (num_resource_sets == num_input_rsrc);
4166 /* Step two: Walk the data again, building trees of the resources. */
4168 rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4170 type_tables = bfd_malloc (num_resource_sets * sizeof * type_tables);
4171 if (type_tables == NULL)
4175 while (data < dataend)
4177 bfd_byte * p = data;
4179 (void) rsrc_parse_directory (abfd, type_tables + indx, data, data,
4180 dataend, rva_bias, NULL);
4181 data = p + rsrc_sizes[indx];
4182 rva_bias += data - p;
4185 BFD_ASSERT (indx == num_resource_sets);
4187 /* Step three: Merge the top level tables (there can be only one).
4189 We must ensure that the merged entries are in ascending order.
4191 We also thread the top level table entries from the old tree onto
4192 the new table, so that they can be pulled off later. */
4194 /* FIXME: Should we verify that all type tables are the same ? */
4195 new_table.characteristics = type_tables[0].characteristics;
4196 new_table.time = type_tables[0].time;
4197 new_table.major = type_tables[0].major;
4198 new_table.minor = type_tables[0].minor;
4200 /* Chain the NAME entries onto the table. */
4201 new_table.names.first_entry = NULL;
4202 new_table.names.last_entry = NULL;
4204 for (indx = 0; indx < num_resource_sets; indx++)
4205 rsrc_attach_chain (& new_table.names, & type_tables[indx].names);
4207 rsrc_sort_entries (& new_table.names, TRUE, & new_table);
4209 /* Chain the ID entries onto the table. */
4210 new_table.ids.first_entry = NULL;
4211 new_table.ids.last_entry = NULL;
4213 for (indx = 0; indx < num_resource_sets; indx++)
4214 rsrc_attach_chain (& new_table.ids, & type_tables[indx].ids);
4216 rsrc_sort_entries (& new_table.ids, FALSE, & new_table);
4218 /* Step four: Create new contents for the .rsrc section. */
4219 /* Step four point one: Compute the size of each region of the .rsrc section.
4220 We do this now, rather than earlier, as the merging above may have dropped
4222 sizeof_leaves = sizeof_strings = sizeof_tables_and_entries = 0;
4223 rsrc_compute_region_sizes (& new_table);
4224 /* We increment sizeof_strings to make sure that resource data
4225 starts on an 8-byte boundary. FIXME: Is this correct ? */
4226 sizeof_strings = (sizeof_strings + 7) & ~ 7;
4228 new_data = bfd_zalloc (abfd, size);
4229 if (new_data == NULL)
4232 write_data.abfd = abfd;
4233 write_data.datastart = new_data;
4234 write_data.next_table = new_data;
4235 write_data.next_leaf = new_data + sizeof_tables_and_entries;
4236 write_data.next_string = write_data.next_leaf + sizeof_leaves;
4237 write_data.next_data = write_data.next_string + sizeof_strings;
4238 write_data.rva_bias = sec->vma - pe->pe_opthdr.ImageBase;
4240 rsrc_write_directory (& write_data, & new_table);
4242 /* Step five: Replace the old contents with the new.
4243 We recompute the size as we may have lost entries due to mergeing. */
4244 size = ((write_data.next_data - new_data) + 3) & ~ 3;
4249 if (coff_data (abfd)->link_info)
4251 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
4253 /* If no file alignment has been set, default to one.
4254 This repairs 'ld -r' for arm-wince-pe target. */
4259 page_size = PE_DEF_FILE_ALIGNMENT;
4260 size = (size + page_size - 1) & - page_size;
4263 bfd_set_section_contents (pfinfo->output_bfd, sec, new_data, 0, size);
4264 sec->size = sec->rawsize = size;
4267 /* Step six: Free all the memory that we have used. */
4268 /* FIXME: Free the resource tree, if we have one. */
4273 /* Handle the .idata section and other things that need symbol table
4277 _bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
4279 struct coff_link_hash_entry *h1;
4280 struct bfd_link_info *info = pfinfo->info;
4281 bfd_boolean result = TRUE;
4283 /* There are a few fields that need to be filled in now while we
4284 have symbol table access.
4286 The .idata subsections aren't directly available as sections, but
4287 they are in the symbol table, so get them from there. */
4289 /* The import directory. This is the address of .idata$2, with size
4290 of .idata$2 + .idata$3. */
4291 h1 = coff_link_hash_lookup (coff_hash_table (info),
4292 ".idata$2", FALSE, FALSE, TRUE);
4295 /* PR ld/2729: We cannot rely upon all the output sections having been
4296 created properly, so check before referencing them. Issue a warning
4297 message for any sections tht could not be found. */
4298 if ((h1->root.type == bfd_link_hash_defined
4299 || h1->root.type == bfd_link_hash_defweak)
4300 && h1->root.u.def.section != NULL
4301 && h1->root.u.def.section->output_section != NULL)
4302 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
4303 (h1->root.u.def.value
4304 + h1->root.u.def.section->output_section->vma
4305 + h1->root.u.def.section->output_offset);
4309 (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4314 h1 = coff_link_hash_lookup (coff_hash_table (info),
4315 ".idata$4", FALSE, FALSE, TRUE);
4317 && (h1->root.type == bfd_link_hash_defined
4318 || h1->root.type == bfd_link_hash_defweak)
4319 && h1->root.u.def.section != NULL
4320 && h1->root.u.def.section->output_section != NULL)
4321 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
4322 ((h1->root.u.def.value
4323 + h1->root.u.def.section->output_section->vma
4324 + h1->root.u.def.section->output_offset)
4325 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
4329 (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4334 /* The import address table. This is the size/address of
4336 h1 = coff_link_hash_lookup (coff_hash_table (info),
4337 ".idata$5", FALSE, FALSE, TRUE);
4339 && (h1->root.type == bfd_link_hash_defined
4340 || h1->root.type == bfd_link_hash_defweak)
4341 && h1->root.u.def.section != NULL
4342 && h1->root.u.def.section->output_section != NULL)
4343 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4344 (h1->root.u.def.value
4345 + h1->root.u.def.section->output_section->vma
4346 + h1->root.u.def.section->output_offset);
4350 (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4355 h1 = coff_link_hash_lookup (coff_hash_table (info),
4356 ".idata$6", FALSE, FALSE, TRUE);
4358 && (h1->root.type == bfd_link_hash_defined
4359 || h1->root.type == bfd_link_hash_defweak)
4360 && h1->root.u.def.section != NULL
4361 && h1->root.u.def.section->output_section != NULL)
4362 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4363 ((h1->root.u.def.value
4364 + h1->root.u.def.section->output_section->vma
4365 + h1->root.u.def.section->output_offset)
4366 - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
4370 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4377 h1 = coff_link_hash_lookup (coff_hash_table (info),
4378 "__IAT_start__", FALSE, FALSE, TRUE);
4380 && (h1->root.type == bfd_link_hash_defined
4381 || h1->root.type == bfd_link_hash_defweak)
4382 && h1->root.u.def.section != NULL
4383 && h1->root.u.def.section->output_section != NULL)
4388 (h1->root.u.def.value
4389 + h1->root.u.def.section->output_section->vma
4390 + h1->root.u.def.section->output_offset);
4392 h1 = coff_link_hash_lookup (coff_hash_table (info),
4393 "__IAT_end__", FALSE, FALSE, TRUE);
4395 && (h1->root.type == bfd_link_hash_defined
4396 || h1->root.type == bfd_link_hash_defweak)
4397 && h1->root.u.def.section != NULL
4398 && h1->root.u.def.section->output_section != NULL)
4400 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
4401 ((h1->root.u.def.value
4402 + h1->root.u.def.section->output_section->vma
4403 + h1->root.u.def.section->output_offset)
4405 if (pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size != 0)
4406 pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
4407 iat_va - pe_data (abfd)->pe_opthdr.ImageBase;
4412 (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4413 " because .idata$6 is missing"), abfd);
4419 h1 = coff_link_hash_lookup (coff_hash_table (info),
4420 (bfd_get_symbol_leading_char (abfd) != 0
4421 ? "__tls_used" : "_tls_used"),
4422 FALSE, FALSE, TRUE);
4425 if ((h1->root.type == bfd_link_hash_defined
4426 || h1->root.type == bfd_link_hash_defweak)
4427 && h1->root.u.def.section != NULL
4428 && h1->root.u.def.section->output_section != NULL)
4429 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
4430 (h1->root.u.def.value
4431 + h1->root.u.def.section->output_section->vma
4432 + h1->root.u.def.section->output_offset
4433 - pe_data (abfd)->pe_opthdr.ImageBase);
4437 (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
4441 /* According to PECOFF sepcifications by Microsoft version 8.2
4442 the TLS data directory consists of 4 pointers, followed
4443 by two 4-byte integer. This implies that the total size
4444 is different for 32-bit and 64-bit executables. */
4445 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
4446 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
4448 pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x28;
4452 /* If there is a .pdata section and we have linked pdata finally, we
4453 need to sort the entries ascending. */
4454 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64)
4456 asection *sec = bfd_get_section_by_name (abfd, ".pdata");
4460 bfd_size_type x = sec->rawsize;
4461 bfd_byte *tmp_data = NULL;
4464 tmp_data = bfd_malloc (x);
4466 if (tmp_data != NULL)
4468 if (bfd_get_section_contents (abfd, sec, tmp_data, 0, x))
4472 12, sort_x64_pdata);
4473 bfd_set_section_contents (pfinfo->output_bfd, sec,
4482 rsrc_process_section (abfd, pfinfo);
4484 /* If we couldn't find idata$2, we either have an excessively
4485 trivial program or are in DEEP trouble; we have to assume trivial