1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright (C) 1995-2022 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 PE/PEI format is also used by .NET. ECMA-335 describes this:
40 "Standard ECMA-335 Common Language Infrastructure (CLI)", 6th Edition, June 2012.
42 This is also available at
43 https://www.ecma-international.org/publications/files/ECMA-ST/ECMA-335.pdf.
45 The *sole* difference between the pe format and the pei format is that the
46 latter has an MSDOS 2.0 .exe header on the front that prints the message
47 "This app must be run under Windows." (or some such).
48 (FIXME: Whether that statement is *really* true or not is unknown.
49 Are there more subtle differences between pe and pei formats?
50 For now assume there aren't. If you find one, then for God sakes
53 The Microsoft docs use the word "image" instead of "executable" because
54 the former can also refer to a DLL (shared library). Confusion can arise
55 because the `i' in `pei' also refers to "image". The `pe' format can
56 also create images (i.e. executables), it's just that to run on a win32
57 system you need to use the pei format.
59 FIXME: Please add more docs here so the next poor fool that has to hack
60 on this code has a chance of getting something accomplished without
61 wasting too much time. */
63 /* This expands into COFF_WITH_pe, COFF_WITH_pep, COFF_WITH_pex64 or
64 COFF_WITH_peAArch64 depending on whether we're compiling for straight
71 #include "coff/internal.h"
73 #include "libiberty.h"
77 /* NOTE: it's strange to be including an architecture specific header
78 in what's supposed to be general (to PE/PEI) code. However, that's
79 where the definitions are, and they don't vary per architecture
80 within PE/PEI, so we get them from there. FIXME: The lack of
81 variance is an assumption which may prove to be incorrect if new
82 PE/PEI targets are created. */
83 #if defined COFF_WITH_pex64
84 # include "coff/x86_64.h"
85 #elif defined COFF_WITH_pep
86 # include "coff/ia64.h"
87 #elif defined COFF_WITH_peAArch64
88 # include "coff/aarch64.h"
90 # include "coff/i386.h"
96 #include "safe-ctype.h"
98 #if defined COFF_WITH_pep || defined COFF_WITH_pex64 || defined COFF_WITH_peAArch64
100 # define AOUTSZ PEPAOUTSZ
101 # define PEAOUTHDR PEPAOUTHDR
104 #define HighBitSet(val) ((val) & 0x80000000)
105 #define SetHighBit(val) ((val) | 0x80000000)
106 #define WithoutHighBit(val) ((val) & 0x7fffffff)
109 _bfd_XXi_swap_sym_in (bfd
* abfd
, void * ext1
, void * in1
)
111 SYMENT
*ext
= (SYMENT
*) ext1
;
112 struct internal_syment
*in
= (struct internal_syment
*) in1
;
114 if (ext
->e
.e_name
[0] == 0)
116 in
->_n
._n_n
._n_zeroes
= 0;
117 in
->_n
._n_n
._n_offset
= H_GET_32 (abfd
, ext
->e
.e
.e_offset
);
120 memcpy (in
->_n
._n_name
, ext
->e
.e_name
, SYMNMLEN
);
122 in
->n_value
= H_GET_32 (abfd
, ext
->e_value
);
123 in
->n_scnum
= (short) H_GET_16 (abfd
, ext
->e_scnum
);
125 if (sizeof (ext
->e_type
) == 2)
126 in
->n_type
= H_GET_16 (abfd
, ext
->e_type
);
128 in
->n_type
= H_GET_32 (abfd
, ext
->e_type
);
130 in
->n_sclass
= H_GET_8 (abfd
, ext
->e_sclass
);
131 in
->n_numaux
= H_GET_8 (abfd
, ext
->e_numaux
);
133 #ifndef STRICT_PE_FORMAT
134 /* This is for Gnu-created DLLs. */
136 /* The section symbols for the .idata$ sections have class 0x68
137 (C_SECTION), which MS documentation indicates is a section
138 symbol. Unfortunately, the value field in the symbol is simply a
139 copy of the .idata section's flags rather than something useful.
140 When these symbols are encountered, change the value to 0 so that
141 they will be handled somewhat correctly in the bfd code. */
142 if (in
->n_sclass
== C_SECTION
)
144 char namebuf
[SYMNMLEN
+ 1];
145 const char *name
= NULL
;
149 /* Create synthetic empty sections as needed. DJ */
150 if (in
->n_scnum
== 0)
154 name
= _bfd_coff_internal_syment_name (abfd
, in
, namebuf
);
157 _bfd_error_handler (_("%pB: unable to find name for empty section"),
159 bfd_set_error (bfd_error_invalid_target
);
163 sec
= bfd_get_section_by_name (abfd
, name
);
165 in
->n_scnum
= sec
->target_index
;
168 if (in
->n_scnum
== 0)
170 int unused_section_number
= 0;
176 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
177 if (unused_section_number
<= sec
->target_index
)
178 unused_section_number
= sec
->target_index
+ 1;
180 name_len
= strlen (name
) + 1;
181 sec_name
= bfd_alloc (abfd
, name_len
);
182 if (sec_name
== NULL
)
184 _bfd_error_handler (_("%pB: out of memory creating name "
185 "for empty section"), abfd
);
188 memcpy (sec_name
, name
, name_len
);
190 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_DATA
| SEC_LOAD
;
191 sec
= bfd_make_section_anyway_with_flags (abfd
, sec_name
, flags
);
194 _bfd_error_handler (_("%pB: unable to create fake empty section"),
203 sec
->rel_filepos
= 0;
204 sec
->reloc_count
= 0;
205 sec
->line_filepos
= 0;
206 sec
->lineno_count
= 0;
207 sec
->userdata
= NULL
;
209 sec
->alignment_power
= 2;
211 sec
->target_index
= unused_section_number
;
213 in
->n_scnum
= unused_section_number
;
215 in
->n_sclass
= C_STAT
;
221 abs_finder (bfd
* abfd ATTRIBUTE_UNUSED
, asection
* sec
, void * data
)
223 bfd_vma abs_val
= * (bfd_vma
*) data
;
225 return (sec
->vma
<= abs_val
) && ((sec
->vma
+ (1ULL << 32)) > abs_val
);
229 _bfd_XXi_swap_sym_out (bfd
* abfd
, void * inp
, void * extp
)
231 struct internal_syment
*in
= (struct internal_syment
*) inp
;
232 SYMENT
*ext
= (SYMENT
*) extp
;
234 if (in
->_n
._n_name
[0] == 0)
236 H_PUT_32 (abfd
, 0, ext
->e
.e
.e_zeroes
);
237 H_PUT_32 (abfd
, in
->_n
._n_n
._n_offset
, ext
->e
.e
.e_offset
);
240 memcpy (ext
->e
.e_name
, in
->_n
._n_name
, SYMNMLEN
);
242 /* The PE32 and PE32+ formats only use 4 bytes to hold the value of a
243 symbol. This is a problem on 64-bit targets where we can generate
244 absolute symbols with values >= 1^32. We try to work around this
245 problem by finding a section whose base address is sufficient to
246 reduce the absolute value to < 1^32, and then transforming the
247 symbol into a section relative symbol. This of course is a hack. */
248 if (sizeof (in
->n_value
) > 4
249 /* The strange computation of the shift amount is here in order to
250 avoid a compile time warning about the comparison always being
251 false. It does not matter if this test fails to work as expected
252 as the worst that can happen is that some absolute symbols are
253 needlessly converted into section relative symbols. */
254 && in
->n_value
> ((1ULL << (sizeof (in
->n_value
) > 4 ? 32 : 31)) - 1)
255 && in
->n_scnum
== N_ABS
)
259 sec
= bfd_sections_find_if (abfd
, abs_finder
, & in
->n_value
);
262 in
->n_value
-= sec
->vma
;
263 in
->n_scnum
= sec
->target_index
;
265 /* else: FIXME: The value is outside the range of any section. This
266 happens for __image_base__ and __ImageBase and maybe some other
267 symbols as well. We should find a way to handle these values. */
270 H_PUT_32 (abfd
, in
->n_value
, ext
->e_value
);
271 H_PUT_16 (abfd
, in
->n_scnum
, ext
->e_scnum
);
273 if (sizeof (ext
->e_type
) == 2)
274 H_PUT_16 (abfd
, in
->n_type
, ext
->e_type
);
276 H_PUT_32 (abfd
, in
->n_type
, ext
->e_type
);
278 H_PUT_8 (abfd
, in
->n_sclass
, ext
->e_sclass
);
279 H_PUT_8 (abfd
, in
->n_numaux
, ext
->e_numaux
);
285 _bfd_XXi_swap_aux_in (bfd
* abfd
,
289 int indx ATTRIBUTE_UNUSED
,
290 int numaux ATTRIBUTE_UNUSED
,
293 AUXENT
*ext
= (AUXENT
*) ext1
;
294 union internal_auxent
*in
= (union internal_auxent
*) in1
;
296 /* PR 17521: Make sure that all fields in the aux structure
298 memset (in
, 0, sizeof * in
);
302 if (ext
->x_file
.x_fname
[0] == 0)
304 in
->x_file
.x_n
.x_n
.x_zeroes
= 0;
305 in
->x_file
.x_n
.x_n
.x_offset
= H_GET_32 (abfd
, ext
->x_file
.x_n
.x_offset
);
308 memcpy (in
->x_file
.x_n
.x_fname
, ext
->x_file
.x_fname
, FILNMLEN
);
316 in
->x_scn
.x_scnlen
= GET_SCN_SCNLEN (abfd
, ext
);
317 in
->x_scn
.x_nreloc
= GET_SCN_NRELOC (abfd
, ext
);
318 in
->x_scn
.x_nlinno
= GET_SCN_NLINNO (abfd
, ext
);
319 in
->x_scn
.x_checksum
= H_GET_32 (abfd
, ext
->x_scn
.x_checksum
);
320 in
->x_scn
.x_associated
= H_GET_16 (abfd
, ext
->x_scn
.x_associated
);
321 in
->x_scn
.x_comdat
= H_GET_8 (abfd
, ext
->x_scn
.x_comdat
);
327 in
->x_sym
.x_tagndx
.l
= H_GET_32 (abfd
, ext
->x_sym
.x_tagndx
);
328 in
->x_sym
.x_tvndx
= H_GET_16 (abfd
, ext
->x_sym
.x_tvndx
);
330 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
333 in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
= GET_FCN_LNNOPTR (abfd
, ext
);
334 in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
= GET_FCN_ENDNDX (abfd
, ext
);
338 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0] =
339 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
340 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1] =
341 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
342 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2] =
343 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
344 in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3] =
345 H_GET_16 (abfd
, ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
350 in
->x_sym
.x_misc
.x_fsize
= H_GET_32 (abfd
, ext
->x_sym
.x_misc
.x_fsize
);
354 in
->x_sym
.x_misc
.x_lnsz
.x_lnno
= GET_LNSZ_LNNO (abfd
, ext
);
355 in
->x_sym
.x_misc
.x_lnsz
.x_size
= GET_LNSZ_SIZE (abfd
, ext
);
360 _bfd_XXi_swap_aux_out (bfd
* abfd
,
364 int indx ATTRIBUTE_UNUSED
,
365 int numaux ATTRIBUTE_UNUSED
,
368 union internal_auxent
*in
= (union internal_auxent
*) inp
;
369 AUXENT
*ext
= (AUXENT
*) extp
;
371 memset (ext
, 0, AUXESZ
);
376 if (in
->x_file
.x_n
.x_fname
[0] == 0)
378 H_PUT_32 (abfd
, 0, ext
->x_file
.x_n
.x_zeroes
);
379 H_PUT_32 (abfd
, in
->x_file
.x_n
.x_n
.x_offset
, ext
->x_file
.x_n
.x_offset
);
382 memcpy (ext
->x_file
.x_fname
, in
->x_file
.x_n
.x_fname
, sizeof (ext
->x_file
.x_fname
));
391 PUT_SCN_SCNLEN (abfd
, in
->x_scn
.x_scnlen
, ext
);
392 PUT_SCN_NRELOC (abfd
, in
->x_scn
.x_nreloc
, ext
);
393 PUT_SCN_NLINNO (abfd
, in
->x_scn
.x_nlinno
, ext
);
394 H_PUT_32 (abfd
, in
->x_scn
.x_checksum
, ext
->x_scn
.x_checksum
);
395 H_PUT_16 (abfd
, in
->x_scn
.x_associated
, ext
->x_scn
.x_associated
);
396 H_PUT_8 (abfd
, in
->x_scn
.x_comdat
, ext
->x_scn
.x_comdat
);
402 H_PUT_32 (abfd
, in
->x_sym
.x_tagndx
.l
, ext
->x_sym
.x_tagndx
);
403 H_PUT_16 (abfd
, in
->x_sym
.x_tvndx
, ext
->x_sym
.x_tvndx
);
405 if (in_class
== C_BLOCK
|| in_class
== C_FCN
|| ISFCN (type
)
408 PUT_FCN_LNNOPTR (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
, ext
);
409 PUT_FCN_ENDNDX (abfd
, in
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
, ext
);
413 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0],
414 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[0]);
415 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1],
416 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[1]);
417 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2],
418 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[2]);
419 H_PUT_16 (abfd
, in
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3],
420 ext
->x_sym
.x_fcnary
.x_ary
.x_dimen
[3]);
424 H_PUT_32 (abfd
, in
->x_sym
.x_misc
.x_fsize
, ext
->x_sym
.x_misc
.x_fsize
);
427 PUT_LNSZ_LNNO (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_lnno
, ext
);
428 PUT_LNSZ_SIZE (abfd
, in
->x_sym
.x_misc
.x_lnsz
.x_size
, ext
);
435 _bfd_XXi_swap_lineno_in (bfd
* abfd
, void * ext1
, void * in1
)
437 LINENO
*ext
= (LINENO
*) ext1
;
438 struct internal_lineno
*in
= (struct internal_lineno
*) in1
;
440 in
->l_addr
.l_symndx
= H_GET_32 (abfd
, ext
->l_addr
.l_symndx
);
441 in
->l_lnno
= GET_LINENO_LNNO (abfd
, ext
);
445 _bfd_XXi_swap_lineno_out (bfd
* abfd
, void * inp
, void * outp
)
447 struct internal_lineno
*in
= (struct internal_lineno
*) inp
;
448 struct external_lineno
*ext
= (struct external_lineno
*) outp
;
449 H_PUT_32 (abfd
, in
->l_addr
.l_symndx
, ext
->l_addr
.l_symndx
);
451 PUT_LINENO_LNNO (abfd
, in
->l_lnno
, ext
);
456 _bfd_XXi_swap_aouthdr_in (bfd
* abfd
,
460 PEAOUTHDR
* src
= (PEAOUTHDR
*) aouthdr_ext1
;
461 AOUTHDR
* aouthdr_ext
= (AOUTHDR
*) aouthdr_ext1
;
462 struct internal_aouthdr
*aouthdr_int
463 = (struct internal_aouthdr
*) aouthdr_int1
;
464 struct internal_extra_pe_aouthdr
*a
= &aouthdr_int
->pe
;
466 aouthdr_int
->magic
= H_GET_16 (abfd
, aouthdr_ext
->magic
);
467 aouthdr_int
->vstamp
= H_GET_16 (abfd
, aouthdr_ext
->vstamp
);
468 aouthdr_int
->tsize
= GET_AOUTHDR_TSIZE (abfd
, aouthdr_ext
->tsize
);
469 aouthdr_int
->dsize
= GET_AOUTHDR_DSIZE (abfd
, aouthdr_ext
->dsize
);
470 aouthdr_int
->bsize
= GET_AOUTHDR_BSIZE (abfd
, aouthdr_ext
->bsize
);
471 aouthdr_int
->entry
= GET_AOUTHDR_ENTRY (abfd
, aouthdr_ext
->entry
);
472 aouthdr_int
->text_start
=
473 GET_AOUTHDR_TEXT_START (abfd
, aouthdr_ext
->text_start
);
475 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64)
476 /* PE32+ does not have data_start member! */
477 aouthdr_int
->data_start
=
478 GET_AOUTHDR_DATA_START (abfd
, aouthdr_ext
->data_start
);
479 a
->BaseOfData
= aouthdr_int
->data_start
;
482 a
->Magic
= aouthdr_int
->magic
;
483 a
->MajorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
);
484 a
->MinorLinkerVersion
= H_GET_8 (abfd
, aouthdr_ext
->vstamp
+ 1);
485 a
->SizeOfCode
= aouthdr_int
->tsize
;
486 a
->SizeOfInitializedData
= aouthdr_int
->dsize
;
487 a
->SizeOfUninitializedData
= aouthdr_int
->bsize
;
488 a
->AddressOfEntryPoint
= aouthdr_int
->entry
;
489 a
->BaseOfCode
= aouthdr_int
->text_start
;
490 a
->ImageBase
= GET_OPTHDR_IMAGE_BASE (abfd
, src
->ImageBase
);
491 a
->SectionAlignment
= H_GET_32 (abfd
, src
->SectionAlignment
);
492 a
->FileAlignment
= H_GET_32 (abfd
, src
->FileAlignment
);
493 a
->MajorOperatingSystemVersion
=
494 H_GET_16 (abfd
, src
->MajorOperatingSystemVersion
);
495 a
->MinorOperatingSystemVersion
=
496 H_GET_16 (abfd
, src
->MinorOperatingSystemVersion
);
497 a
->MajorImageVersion
= H_GET_16 (abfd
, src
->MajorImageVersion
);
498 a
->MinorImageVersion
= H_GET_16 (abfd
, src
->MinorImageVersion
);
499 a
->MajorSubsystemVersion
= H_GET_16 (abfd
, src
->MajorSubsystemVersion
);
500 a
->MinorSubsystemVersion
= H_GET_16 (abfd
, src
->MinorSubsystemVersion
);
501 a
->Reserved1
= H_GET_32 (abfd
, src
->Reserved1
);
502 a
->SizeOfImage
= H_GET_32 (abfd
, src
->SizeOfImage
);
503 a
->SizeOfHeaders
= H_GET_32 (abfd
, src
->SizeOfHeaders
);
504 a
->CheckSum
= H_GET_32 (abfd
, src
->CheckSum
);
505 a
->Subsystem
= H_GET_16 (abfd
, src
->Subsystem
);
506 a
->DllCharacteristics
= H_GET_16 (abfd
, src
->DllCharacteristics
);
507 a
->SizeOfStackReserve
=
508 GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, src
->SizeOfStackReserve
);
509 a
->SizeOfStackCommit
=
510 GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, src
->SizeOfStackCommit
);
511 a
->SizeOfHeapReserve
=
512 GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, src
->SizeOfHeapReserve
);
513 a
->SizeOfHeapCommit
=
514 GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, src
->SizeOfHeapCommit
);
515 a
->LoaderFlags
= H_GET_32 (abfd
, src
->LoaderFlags
);
516 a
->NumberOfRvaAndSizes
= H_GET_32 (abfd
, src
->NumberOfRvaAndSizes
);
521 /* PR 17512: Corrupt PE binaries can cause seg-faults. */
522 if (a
->NumberOfRvaAndSizes
> IMAGE_NUMBEROF_DIRECTORY_ENTRIES
)
524 /* xgettext:c-format */
526 (_("%pB: aout header specifies an invalid number of"
527 " data-directory entries: %u"), abfd
, a
->NumberOfRvaAndSizes
);
528 bfd_set_error (bfd_error_bad_value
);
530 /* Paranoia: If the number is corrupt, then assume that the
531 actual entries themselves might be corrupt as well. */
532 a
->NumberOfRvaAndSizes
= 0;
535 for (idx
= 0; idx
< a
->NumberOfRvaAndSizes
; idx
++)
537 /* If data directory is empty, rva also should be 0. */
539 H_GET_32 (abfd
, src
->DataDirectory
[idx
][1]);
541 a
->DataDirectory
[idx
].Size
= size
;
544 a
->DataDirectory
[idx
].VirtualAddress
=
545 H_GET_32 (abfd
, src
->DataDirectory
[idx
][0]);
547 a
->DataDirectory
[idx
].VirtualAddress
= 0;
550 while (idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
)
552 a
->DataDirectory
[idx
].Size
= 0;
553 a
->DataDirectory
[idx
].VirtualAddress
= 0;
558 if (aouthdr_int
->entry
)
560 aouthdr_int
->entry
+= a
->ImageBase
;
561 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64)
562 aouthdr_int
->entry
&= 0xffffffff;
566 if (aouthdr_int
->tsize
)
568 aouthdr_int
->text_start
+= a
->ImageBase
;
569 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64)
570 aouthdr_int
->text_start
&= 0xffffffff;
574 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64)
575 /* PE32+ does not have data_start member! */
576 if (aouthdr_int
->dsize
)
578 aouthdr_int
->data_start
+= a
->ImageBase
;
579 aouthdr_int
->data_start
&= 0xffffffff;
584 /* A support function for below. */
587 add_data_entry (bfd
* abfd
,
588 struct internal_extra_pe_aouthdr
*aout
,
593 asection
*sec
= bfd_get_section_by_name (abfd
, name
);
595 /* Add import directory information if it exists. */
597 && (coff_section_data (abfd
, sec
) != NULL
)
598 && (pei_section_data (abfd
, sec
) != NULL
))
600 /* If data directory is empty, rva also should be 0. */
601 int size
= pei_section_data (abfd
, sec
)->virt_size
;
602 aout
->DataDirectory
[idx
].Size
= size
;
606 aout
->DataDirectory
[idx
].VirtualAddress
=
607 (sec
->vma
- base
) & 0xffffffff;
608 sec
->flags
|= SEC_DATA
;
614 _bfd_XXi_swap_aouthdr_out (bfd
* abfd
, void * in
, void * out
)
616 struct internal_aouthdr
*aouthdr_in
= (struct internal_aouthdr
*) in
;
617 pe_data_type
*pe
= pe_data (abfd
);
618 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
619 PEAOUTHDR
*aouthdr_out
= (PEAOUTHDR
*) out
;
621 IMAGE_DATA_DIRECTORY idata2
, idata5
, tls
;
623 sa
= extra
->SectionAlignment
;
624 fa
= extra
->FileAlignment
;
625 ib
= extra
->ImageBase
;
627 idata2
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
];
628 idata5
= pe
->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
];
629 tls
= pe
->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
];
631 if (aouthdr_in
->tsize
)
633 aouthdr_in
->text_start
-= ib
;
634 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64)
635 aouthdr_in
->text_start
&= 0xffffffff;
639 if (aouthdr_in
->dsize
)
641 aouthdr_in
->data_start
-= ib
;
642 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64)
643 aouthdr_in
->data_start
&= 0xffffffff;
647 if (aouthdr_in
->entry
)
649 aouthdr_in
->entry
-= ib
;
650 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64)
651 aouthdr_in
->entry
&= 0xffffffff;
655 #define FA(x) (((x) + fa -1 ) & (- fa))
656 #define SA(x) (((x) + sa -1 ) & (- sa))
658 /* We like to have the sizes aligned. */
659 aouthdr_in
->bsize
= FA (aouthdr_in
->bsize
);
661 extra
->NumberOfRvaAndSizes
= IMAGE_NUMBEROF_DIRECTORY_ENTRIES
;
663 add_data_entry (abfd
, extra
, PE_EXPORT_TABLE
, ".edata", ib
);
664 add_data_entry (abfd
, extra
, PE_RESOURCE_TABLE
, ".rsrc", ib
);
665 add_data_entry (abfd
, extra
, PE_EXCEPTION_TABLE
, ".pdata", ib
);
667 /* In theory we do not need to call add_data_entry for .idata$2 or
668 .idata$5. It will be done in bfd_coff_final_link where all the
669 required information is available. If however, we are not going
670 to perform a final link, eg because we have been invoked by objcopy
671 or strip, then we need to make sure that these Data Directory
672 entries are initialised properly.
674 So - we copy the input values into the output values, and then, if
675 a final link is going to be performed, it can overwrite them. */
676 extra
->DataDirectory
[PE_IMPORT_TABLE
] = idata2
;
677 extra
->DataDirectory
[PE_IMPORT_ADDRESS_TABLE
] = idata5
;
678 extra
->DataDirectory
[PE_TLS_TABLE
] = tls
;
680 if (extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
== 0)
681 /* Until other .idata fixes are made (pending patch), the entry for
682 .idata is needed for backwards compatibility. FIXME. */
683 add_data_entry (abfd
, extra
, PE_IMPORT_TABLE
, ".idata", ib
);
685 /* For some reason, the virtual size (which is what's set by
686 add_data_entry) for .reloc is not the same as the size recorded
687 in this slot by MSVC; it doesn't seem to cause problems (so far),
688 but since it's the best we've got, use it. It does do the right
690 if (pe
->has_reloc_section
)
691 add_data_entry (abfd
, extra
, PE_BASE_RELOCATION_TABLE
, ".reloc", ib
);
700 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
702 int rounded
= FA (sec
->size
);
707 /* The first non-zero section filepos is the header size.
708 Sections without contents will have a filepos of 0. */
710 hsize
= sec
->filepos
;
711 if (sec
->flags
& SEC_DATA
)
713 if (sec
->flags
& SEC_CODE
)
715 /* The image size is the total VIRTUAL size (which is what is
716 in the virt_size field). Files have been seen (from MSVC
717 5.0 link.exe) where the file size of the .data segment is
718 quite small compared to the virtual size. Without this
719 fix, strip munges the file.
721 FIXME: We need to handle holes between sections, which may
722 happpen when we covert from another format. We just use
723 the virtual address and virtual size of the last section
724 for the image size. */
725 if (coff_section_data (abfd
, sec
) != NULL
726 && pei_section_data (abfd
, sec
) != NULL
)
727 isize
= (sec
->vma
- extra
->ImageBase
728 + SA (FA (pei_section_data (abfd
, sec
)->virt_size
)));
731 aouthdr_in
->dsize
= dsize
;
732 aouthdr_in
->tsize
= tsize
;
733 extra
->SizeOfHeaders
= hsize
;
734 extra
->SizeOfImage
= isize
;
737 H_PUT_16 (abfd
, aouthdr_in
->magic
, aouthdr_out
->standard
.magic
);
739 /* e.g. 219510000 is linker version 2.19 */
740 #define LINKER_VERSION ((short) (BFD_VERSION / 1000000))
742 /* This piece of magic sets the "linker version" field to
744 H_PUT_16 (abfd
, (LINKER_VERSION
/ 100 + (LINKER_VERSION
% 100) * 256),
745 aouthdr_out
->standard
.vstamp
);
747 PUT_AOUTHDR_TSIZE (abfd
, aouthdr_in
->tsize
, aouthdr_out
->standard
.tsize
);
748 PUT_AOUTHDR_DSIZE (abfd
, aouthdr_in
->dsize
, aouthdr_out
->standard
.dsize
);
749 PUT_AOUTHDR_BSIZE (abfd
, aouthdr_in
->bsize
, aouthdr_out
->standard
.bsize
);
750 PUT_AOUTHDR_ENTRY (abfd
, aouthdr_in
->entry
, aouthdr_out
->standard
.entry
);
751 PUT_AOUTHDR_TEXT_START (abfd
, aouthdr_in
->text_start
,
752 aouthdr_out
->standard
.text_start
);
754 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64)
755 /* PE32+ does not have data_start member! */
756 PUT_AOUTHDR_DATA_START (abfd
, aouthdr_in
->data_start
,
757 aouthdr_out
->standard
.data_start
);
760 PUT_OPTHDR_IMAGE_BASE (abfd
, extra
->ImageBase
, aouthdr_out
->ImageBase
);
761 H_PUT_32 (abfd
, extra
->SectionAlignment
, aouthdr_out
->SectionAlignment
);
762 H_PUT_32 (abfd
, extra
->FileAlignment
, aouthdr_out
->FileAlignment
);
763 H_PUT_16 (abfd
, extra
->MajorOperatingSystemVersion
,
764 aouthdr_out
->MajorOperatingSystemVersion
);
765 H_PUT_16 (abfd
, extra
->MinorOperatingSystemVersion
,
766 aouthdr_out
->MinorOperatingSystemVersion
);
767 H_PUT_16 (abfd
, extra
->MajorImageVersion
, aouthdr_out
->MajorImageVersion
);
768 H_PUT_16 (abfd
, extra
->MinorImageVersion
, aouthdr_out
->MinorImageVersion
);
769 H_PUT_16 (abfd
, extra
->MajorSubsystemVersion
,
770 aouthdr_out
->MajorSubsystemVersion
);
771 H_PUT_16 (abfd
, extra
->MinorSubsystemVersion
,
772 aouthdr_out
->MinorSubsystemVersion
);
773 H_PUT_32 (abfd
, extra
->Reserved1
, aouthdr_out
->Reserved1
);
774 H_PUT_32 (abfd
, extra
->SizeOfImage
, aouthdr_out
->SizeOfImage
);
775 H_PUT_32 (abfd
, extra
->SizeOfHeaders
, aouthdr_out
->SizeOfHeaders
);
776 H_PUT_32 (abfd
, extra
->CheckSum
, aouthdr_out
->CheckSum
);
777 H_PUT_16 (abfd
, extra
->Subsystem
, aouthdr_out
->Subsystem
);
778 H_PUT_16 (abfd
, extra
->DllCharacteristics
, aouthdr_out
->DllCharacteristics
);
779 PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd
, extra
->SizeOfStackReserve
,
780 aouthdr_out
->SizeOfStackReserve
);
781 PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd
, extra
->SizeOfStackCommit
,
782 aouthdr_out
->SizeOfStackCommit
);
783 PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd
, extra
->SizeOfHeapReserve
,
784 aouthdr_out
->SizeOfHeapReserve
);
785 PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd
, extra
->SizeOfHeapCommit
,
786 aouthdr_out
->SizeOfHeapCommit
);
787 H_PUT_32 (abfd
, extra
->LoaderFlags
, aouthdr_out
->LoaderFlags
);
788 H_PUT_32 (abfd
, extra
->NumberOfRvaAndSizes
,
789 aouthdr_out
->NumberOfRvaAndSizes
);
793 for (idx
= 0; idx
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; idx
++)
795 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].VirtualAddress
,
796 aouthdr_out
->DataDirectory
[idx
][0]);
797 H_PUT_32 (abfd
, extra
->DataDirectory
[idx
].Size
,
798 aouthdr_out
->DataDirectory
[idx
][1]);
806 _bfd_XXi_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
809 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
810 struct external_PEI_filehdr
*filehdr_out
= (struct external_PEI_filehdr
*) out
;
812 if (pe_data (abfd
)->has_reloc_section
813 || pe_data (abfd
)->dont_strip_reloc
)
814 filehdr_in
->f_flags
&= ~F_RELFLG
;
816 if (pe_data (abfd
)->dll
)
817 filehdr_in
->f_flags
|= F_DLL
;
819 filehdr_in
->pe
.e_magic
= IMAGE_DOS_SIGNATURE
;
820 filehdr_in
->pe
.e_cblp
= 0x90;
821 filehdr_in
->pe
.e_cp
= 0x3;
822 filehdr_in
->pe
.e_crlc
= 0x0;
823 filehdr_in
->pe
.e_cparhdr
= 0x4;
824 filehdr_in
->pe
.e_minalloc
= 0x0;
825 filehdr_in
->pe
.e_maxalloc
= 0xffff;
826 filehdr_in
->pe
.e_ss
= 0x0;
827 filehdr_in
->pe
.e_sp
= 0xb8;
828 filehdr_in
->pe
.e_csum
= 0x0;
829 filehdr_in
->pe
.e_ip
= 0x0;
830 filehdr_in
->pe
.e_cs
= 0x0;
831 filehdr_in
->pe
.e_lfarlc
= 0x40;
832 filehdr_in
->pe
.e_ovno
= 0x0;
834 for (idx
= 0; idx
< 4; idx
++)
835 filehdr_in
->pe
.e_res
[idx
] = 0x0;
837 filehdr_in
->pe
.e_oemid
= 0x0;
838 filehdr_in
->pe
.e_oeminfo
= 0x0;
840 for (idx
= 0; idx
< 10; idx
++)
841 filehdr_in
->pe
.e_res2
[idx
] = 0x0;
843 filehdr_in
->pe
.e_lfanew
= 0x80;
845 /* This next collection of data are mostly just characters. It
846 appears to be constant within the headers put on NT exes. */
847 memcpy (filehdr_in
->pe
.dos_message
, pe_data (abfd
)->dos_message
,
848 sizeof (filehdr_in
->pe
.dos_message
));
850 filehdr_in
->pe
.nt_signature
= IMAGE_NT_SIGNATURE
;
852 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
853 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
855 /* Use a real timestamp by default, unless the no-insert-timestamp
856 option was chosen. */
857 if ((pe_data (abfd
)->timestamp
) == -1)
858 H_PUT_32 (abfd
, time (0), filehdr_out
->f_timdat
);
860 H_PUT_32 (abfd
, pe_data (abfd
)->timestamp
, filehdr_out
->f_timdat
);
862 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
,
863 filehdr_out
->f_symptr
);
864 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
865 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
866 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
868 /* Put in extra dos header stuff. This data remains essentially
869 constant, it just has to be tacked on to the beginning of all exes
871 H_PUT_16 (abfd
, filehdr_in
->pe
.e_magic
, filehdr_out
->e_magic
);
872 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cblp
, filehdr_out
->e_cblp
);
873 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cp
, filehdr_out
->e_cp
);
874 H_PUT_16 (abfd
, filehdr_in
->pe
.e_crlc
, filehdr_out
->e_crlc
);
875 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cparhdr
, filehdr_out
->e_cparhdr
);
876 H_PUT_16 (abfd
, filehdr_in
->pe
.e_minalloc
, filehdr_out
->e_minalloc
);
877 H_PUT_16 (abfd
, filehdr_in
->pe
.e_maxalloc
, filehdr_out
->e_maxalloc
);
878 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ss
, filehdr_out
->e_ss
);
879 H_PUT_16 (abfd
, filehdr_in
->pe
.e_sp
, filehdr_out
->e_sp
);
880 H_PUT_16 (abfd
, filehdr_in
->pe
.e_csum
, filehdr_out
->e_csum
);
881 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ip
, filehdr_out
->e_ip
);
882 H_PUT_16 (abfd
, filehdr_in
->pe
.e_cs
, filehdr_out
->e_cs
);
883 H_PUT_16 (abfd
, filehdr_in
->pe
.e_lfarlc
, filehdr_out
->e_lfarlc
);
884 H_PUT_16 (abfd
, filehdr_in
->pe
.e_ovno
, filehdr_out
->e_ovno
);
886 for (idx
= 0; idx
< 4; idx
++)
887 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res
[idx
], filehdr_out
->e_res
[idx
]);
889 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oemid
, filehdr_out
->e_oemid
);
890 H_PUT_16 (abfd
, filehdr_in
->pe
.e_oeminfo
, filehdr_out
->e_oeminfo
);
892 for (idx
= 0; idx
< 10; idx
++)
893 H_PUT_16 (abfd
, filehdr_in
->pe
.e_res2
[idx
], filehdr_out
->e_res2
[idx
]);
895 H_PUT_32 (abfd
, filehdr_in
->pe
.e_lfanew
, filehdr_out
->e_lfanew
);
897 for (idx
= 0; idx
< 16; idx
++)
898 H_PUT_32 (abfd
, filehdr_in
->pe
.dos_message
[idx
],
899 filehdr_out
->dos_message
[idx
]);
901 /* Also put in the NT signature. */
902 H_PUT_32 (abfd
, filehdr_in
->pe
.nt_signature
, filehdr_out
->nt_signature
);
908 _bfd_XX_only_swap_filehdr_out (bfd
* abfd
, void * in
, void * out
)
910 struct internal_filehdr
*filehdr_in
= (struct internal_filehdr
*) in
;
911 FILHDR
*filehdr_out
= (FILHDR
*) out
;
913 H_PUT_16 (abfd
, filehdr_in
->f_magic
, filehdr_out
->f_magic
);
914 H_PUT_16 (abfd
, filehdr_in
->f_nscns
, filehdr_out
->f_nscns
);
915 H_PUT_32 (abfd
, filehdr_in
->f_timdat
, filehdr_out
->f_timdat
);
916 PUT_FILEHDR_SYMPTR (abfd
, filehdr_in
->f_symptr
, filehdr_out
->f_symptr
);
917 H_PUT_32 (abfd
, filehdr_in
->f_nsyms
, filehdr_out
->f_nsyms
);
918 H_PUT_16 (abfd
, filehdr_in
->f_opthdr
, filehdr_out
->f_opthdr
);
919 H_PUT_16 (abfd
, filehdr_in
->f_flags
, filehdr_out
->f_flags
);
925 _bfd_XXi_swap_scnhdr_out (bfd
* abfd
, void * in
, void * out
)
927 struct internal_scnhdr
*scnhdr_int
= (struct internal_scnhdr
*) in
;
928 SCNHDR
*scnhdr_ext
= (SCNHDR
*) out
;
929 unsigned int ret
= SCNHSZ
;
933 memcpy (scnhdr_ext
->s_name
, scnhdr_int
->s_name
, sizeof (scnhdr_int
->s_name
));
935 ss
= scnhdr_int
->s_vaddr
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
936 if (scnhdr_int
->s_vaddr
< pe_data (abfd
)->pe_opthdr
.ImageBase
)
937 _bfd_error_handler (_("%pB:%.8s: section below image base"),
938 abfd
, scnhdr_int
->s_name
);
939 else if(ss
!= (ss
& 0xffffffff))
940 _bfd_error_handler (_("%pB:%.8s: RVA truncated"), abfd
, scnhdr_int
->s_name
);
941 PUT_SCNHDR_VADDR (abfd
, ss
& 0xffffffff, scnhdr_ext
->s_vaddr
);
943 /* NT wants the size data to be rounded up to the next
944 NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
946 if ((scnhdr_int
->s_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
) != 0)
948 if (bfd_pei_p (abfd
))
950 ps
= scnhdr_int
->s_size
;
956 ss
= scnhdr_int
->s_size
;
961 if (bfd_pei_p (abfd
))
962 ps
= scnhdr_int
->s_paddr
;
966 ss
= scnhdr_int
->s_size
;
969 PUT_SCNHDR_SIZE (abfd
, ss
,
972 /* s_paddr in PE is really the virtual size. */
973 PUT_SCNHDR_PADDR (abfd
, ps
, scnhdr_ext
->s_paddr
);
975 PUT_SCNHDR_SCNPTR (abfd
, scnhdr_int
->s_scnptr
,
976 scnhdr_ext
->s_scnptr
);
977 PUT_SCNHDR_RELPTR (abfd
, scnhdr_int
->s_relptr
,
978 scnhdr_ext
->s_relptr
);
979 PUT_SCNHDR_LNNOPTR (abfd
, scnhdr_int
->s_lnnoptr
,
980 scnhdr_ext
->s_lnnoptr
);
983 /* Extra flags must be set when dealing with PE. All sections should also
984 have the IMAGE_SCN_MEM_READ (0x40000000) flag set. In addition, the
985 .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
986 sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
987 (this is especially important when dealing with the .idata section since
988 the addresses for routines from .dlls must be overwritten). If .reloc
989 section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
990 (0x02000000). Also, the resource data should also be read and
993 /* FIXME: Alignment is also encoded in this field, at least on
994 ARM-WINCE. Although - how do we get the original alignment field
999 char section_name
[SCNNMLEN
];
1000 unsigned long must_have
;
1002 pe_required_section_flags
;
1004 pe_required_section_flags known_sections
[] =
1006 { ".arch", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
| IMAGE_SCN_ALIGN_8BYTES
},
1007 { ".bss", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1008 { ".data", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1009 { ".edata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1010 { ".idata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1011 { ".pdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1012 { ".rdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1013 { ".reloc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_DISCARDABLE
},
1014 { ".rsrc", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1015 { ".text" , IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_CODE
| IMAGE_SCN_MEM_EXECUTE
},
1016 { ".tls", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_WRITE
},
1017 { ".xdata", IMAGE_SCN_MEM_READ
| IMAGE_SCN_CNT_INITIALIZED_DATA
},
1020 pe_required_section_flags
* p
;
1022 /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
1023 we know exactly what this specific section wants so we remove it
1024 and then allow the must_have field to add it back in if necessary.
1025 However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
1026 default WP_TEXT file flag has been cleared. WP_TEXT may be cleared
1027 by ld --enable-auto-import (if auto-import is actually needed),
1028 by ld --omagic, or by obcopy --writable-text. */
1030 for (p
= known_sections
;
1031 p
< known_sections
+ ARRAY_SIZE (known_sections
);
1033 if (memcmp (scnhdr_int
->s_name
, p
->section_name
, SCNNMLEN
) == 0)
1035 if (memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text")
1036 || (bfd_get_file_flags (abfd
) & WP_TEXT
))
1037 scnhdr_int
->s_flags
&= ~IMAGE_SCN_MEM_WRITE
;
1038 scnhdr_int
->s_flags
|= p
->must_have
;
1042 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1045 if (coff_data (abfd
)->link_info
1046 && ! bfd_link_relocatable (coff_data (abfd
)->link_info
)
1047 && ! bfd_link_pic (coff_data (abfd
)->link_info
)
1048 && memcmp (scnhdr_int
->s_name
, ".text", sizeof ".text") == 0)
1050 /* By inference from looking at MS output, the 32 bit field
1051 which is the combination of the number_of_relocs and
1052 number_of_linenos is used for the line number count in
1053 executables. A 16-bit field won't do for cc1. The MS
1054 document says that the number of relocs is zero for
1055 executables, but the 17-th bit has been observed to be there.
1056 Overflow is not an issue: a 4G-line program will overflow a
1057 bunch of other fields long before this! */
1058 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
& 0xffff), scnhdr_ext
->s_nlnno
);
1059 H_PUT_16 (abfd
, (scnhdr_int
->s_nlnno
>> 16), scnhdr_ext
->s_nreloc
);
1063 if (scnhdr_int
->s_nlnno
<= 0xffff)
1064 H_PUT_16 (abfd
, scnhdr_int
->s_nlnno
, scnhdr_ext
->s_nlnno
);
1067 /* xgettext:c-format */
1068 _bfd_error_handler (_("%pB: line number overflow: 0x%lx > 0xffff"),
1069 abfd
, scnhdr_int
->s_nlnno
);
1070 bfd_set_error (bfd_error_file_truncated
);
1071 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nlnno
);
1075 /* Although we could encode 0xffff relocs here, we do not, to be
1076 consistent with other parts of bfd. Also it lets us warn, as
1077 we should never see 0xffff here w/o having the overflow flag
1079 if (scnhdr_int
->s_nreloc
< 0xffff)
1080 H_PUT_16 (abfd
, scnhdr_int
->s_nreloc
, scnhdr_ext
->s_nreloc
);
1083 /* PE can deal with large #s of relocs, but not here. */
1084 H_PUT_16 (abfd
, 0xffff, scnhdr_ext
->s_nreloc
);
1085 scnhdr_int
->s_flags
|= IMAGE_SCN_LNK_NRELOC_OVFL
;
1086 H_PUT_32 (abfd
, scnhdr_int
->s_flags
, scnhdr_ext
->s_flags
);
1093 _bfd_XXi_swap_debugdir_in (bfd
* abfd
, void * ext1
, void * in1
)
1095 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) ext1
;
1096 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) in1
;
1098 in
->Characteristics
= H_GET_32(abfd
, ext
->Characteristics
);
1099 in
->TimeDateStamp
= H_GET_32(abfd
, ext
->TimeDateStamp
);
1100 in
->MajorVersion
= H_GET_16(abfd
, ext
->MajorVersion
);
1101 in
->MinorVersion
= H_GET_16(abfd
, ext
->MinorVersion
);
1102 in
->Type
= H_GET_32(abfd
, ext
->Type
);
1103 in
->SizeOfData
= H_GET_32(abfd
, ext
->SizeOfData
);
1104 in
->AddressOfRawData
= H_GET_32(abfd
, ext
->AddressOfRawData
);
1105 in
->PointerToRawData
= H_GET_32(abfd
, ext
->PointerToRawData
);
1109 _bfd_XXi_swap_debugdir_out (bfd
* abfd
, void * inp
, void * extp
)
1111 struct external_IMAGE_DEBUG_DIRECTORY
*ext
= (struct external_IMAGE_DEBUG_DIRECTORY
*) extp
;
1112 struct internal_IMAGE_DEBUG_DIRECTORY
*in
= (struct internal_IMAGE_DEBUG_DIRECTORY
*) inp
;
1114 H_PUT_32(abfd
, in
->Characteristics
, ext
->Characteristics
);
1115 H_PUT_32(abfd
, in
->TimeDateStamp
, ext
->TimeDateStamp
);
1116 H_PUT_16(abfd
, in
->MajorVersion
, ext
->MajorVersion
);
1117 H_PUT_16(abfd
, in
->MinorVersion
, ext
->MinorVersion
);
1118 H_PUT_32(abfd
, in
->Type
, ext
->Type
);
1119 H_PUT_32(abfd
, in
->SizeOfData
, ext
->SizeOfData
);
1120 H_PUT_32(abfd
, in
->AddressOfRawData
, ext
->AddressOfRawData
);
1121 H_PUT_32(abfd
, in
->PointerToRawData
, ext
->PointerToRawData
);
1123 return sizeof (struct external_IMAGE_DEBUG_DIRECTORY
);
1127 _bfd_XXi_slurp_codeview_record (bfd
* abfd
, file_ptr where
, unsigned long length
, CODEVIEW_INFO
*cvinfo
)
1130 bfd_size_type nread
;
1132 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1135 if (length
<= sizeof (CV_INFO_PDB70
) && length
<= sizeof (CV_INFO_PDB20
))
1139 nread
= bfd_bread (buffer
, length
, abfd
);
1140 if (length
!= nread
)
1143 /* Ensure null termination of filename. */
1144 memset (buffer
+ nread
, 0, sizeof (buffer
) - nread
);
1146 cvinfo
->CVSignature
= H_GET_32 (abfd
, buffer
);
1149 if ((cvinfo
->CVSignature
== CVINFO_PDB70_CVSIGNATURE
)
1150 && (length
> sizeof (CV_INFO_PDB70
)))
1152 CV_INFO_PDB70
*cvinfo70
= (CV_INFO_PDB70
*)(buffer
);
1154 cvinfo
->Age
= H_GET_32(abfd
, cvinfo70
->Age
);
1156 /* A GUID consists of 4,2,2 byte values in little-endian order, followed
1157 by 8 single bytes. Byte swap them so we can conveniently treat the GUID
1158 as 16 bytes in big-endian order. */
1159 bfd_putb32 (bfd_getl32 (cvinfo70
->Signature
), cvinfo
->Signature
);
1160 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[4])), &(cvinfo
->Signature
[4]));
1161 bfd_putb16 (bfd_getl16 (&(cvinfo70
->Signature
[6])), &(cvinfo
->Signature
[6]));
1162 memcpy (&(cvinfo
->Signature
[8]), &(cvinfo70
->Signature
[8]), 8);
1164 cvinfo
->SignatureLength
= CV_INFO_SIGNATURE_LENGTH
;
1165 /* cvinfo->PdbFileName = cvinfo70->PdbFileName; */
1169 else if ((cvinfo
->CVSignature
== CVINFO_PDB20_CVSIGNATURE
)
1170 && (length
> sizeof (CV_INFO_PDB20
)))
1172 CV_INFO_PDB20
*cvinfo20
= (CV_INFO_PDB20
*)(buffer
);
1173 cvinfo
->Age
= H_GET_32(abfd
, cvinfo20
->Age
);
1174 memcpy (cvinfo
->Signature
, cvinfo20
->Signature
, 4);
1175 cvinfo
->SignatureLength
= 4;
1176 /* cvinfo->PdbFileName = cvinfo20->PdbFileName; */
1185 _bfd_XXi_write_codeview_record (bfd
* abfd
, file_ptr where
, CODEVIEW_INFO
*cvinfo
)
1187 const bfd_size_type size
= sizeof (CV_INFO_PDB70
) + 1;
1188 bfd_size_type written
;
1189 CV_INFO_PDB70
*cvinfo70
;
1192 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
1195 buffer
= bfd_malloc (size
);
1199 cvinfo70
= (CV_INFO_PDB70
*) buffer
;
1200 H_PUT_32 (abfd
, CVINFO_PDB70_CVSIGNATURE
, cvinfo70
->CvSignature
);
1202 /* Byte swap the GUID from 16 bytes in big-endian order to 4,2,2 byte values
1203 in little-endian order, followed by 8 single bytes. */
1204 bfd_putl32 (bfd_getb32 (cvinfo
->Signature
), cvinfo70
->Signature
);
1205 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[4])), &(cvinfo70
->Signature
[4]));
1206 bfd_putl16 (bfd_getb16 (&(cvinfo
->Signature
[6])), &(cvinfo70
->Signature
[6]));
1207 memcpy (&(cvinfo70
->Signature
[8]), &(cvinfo
->Signature
[8]), 8);
1209 H_PUT_32 (abfd
, cvinfo
->Age
, cvinfo70
->Age
);
1210 cvinfo70
->PdbFileName
[0] = '\0';
1212 written
= bfd_bwrite (buffer
, size
, abfd
);
1216 return written
== size
? size
: 0;
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"),
1240 pe_print_idata (bfd
* abfd
, void * vfile
)
1242 FILE *file
= (FILE *) vfile
;
1246 bfd_size_type datasize
= 0;
1247 bfd_size_type dataoff
;
1251 pe_data_type
*pe
= pe_data (abfd
);
1252 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1256 addr
= extra
->DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
;
1258 if (addr
== 0 && extra
->DataDirectory
[PE_IMPORT_TABLE
].Size
== 0)
1260 /* Maybe the extra header isn't there. Look for the section. */
1261 section
= bfd_get_section_by_name (abfd
, ".idata");
1262 if (section
== NULL
)
1265 addr
= section
->vma
;
1266 datasize
= section
->size
;
1272 addr
+= extra
->ImageBase
;
1273 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1275 datasize
= section
->size
;
1276 if (addr
>= section
->vma
&& addr
< section
->vma
+ datasize
)
1280 if (section
== NULL
)
1283 _("\nThere is an import table, but the section containing it could not be found\n"));
1286 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1289 _("\nThere is an import table in %s, but that section has no contents\n"),
1295 /* xgettext:c-format */
1296 fprintf (file
, _("\nThere is an import table in %s at 0x%lx\n"),
1297 section
->name
, (unsigned long) addr
);
1299 dataoff
= addr
- section
->vma
;
1302 _("\nThe Import Tables (interpreted %s section contents)\n"),
1306 vma: Hint Time Forward DLL First\n\
1307 Table Stamp Chain Name Thunk\n"));
1309 /* Read the whole section. Some of the fields might be before dataoff. */
1310 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
1316 adj
= section
->vma
- extra
->ImageBase
;
1318 /* Print all image import descriptors. */
1319 for (i
= dataoff
; i
+ onaline
<= datasize
; i
+= onaline
)
1323 bfd_vma forward_chain
;
1325 bfd_vma first_thunk
;
1330 /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress). */
1331 fprintf (file
, " %08lx\t", (unsigned long) (i
+ adj
));
1332 hint_addr
= bfd_get_32 (abfd
, data
+ i
);
1333 time_stamp
= bfd_get_32 (abfd
, data
+ i
+ 4);
1334 forward_chain
= bfd_get_32 (abfd
, data
+ i
+ 8);
1335 dll_name
= bfd_get_32 (abfd
, data
+ i
+ 12);
1336 first_thunk
= bfd_get_32 (abfd
, data
+ i
+ 16);
1338 fprintf (file
, "%08lx %08lx %08lx %08lx %08lx\n",
1339 (unsigned long) hint_addr
,
1340 (unsigned long) time_stamp
,
1341 (unsigned long) forward_chain
,
1342 (unsigned long) dll_name
,
1343 (unsigned long) first_thunk
);
1345 if (hint_addr
== 0 && first_thunk
== 0)
1348 if (dll_name
- adj
>= section
->size
)
1351 dll
= (char *) data
+ dll_name
- adj
;
1352 /* PR 17512 file: 078-12277-0.004. */
1353 bfd_size_type maxlen
= (char *)(data
+ datasize
) - dll
- 1;
1354 fprintf (file
, _("\n\tDLL Name: %.*s\n"), (int) maxlen
, dll
);
1356 /* PR 21546: When the Hint Address is zero,
1357 we try the First Thunk instead. */
1359 hint_addr
= first_thunk
;
1361 if (hint_addr
!= 0 && hint_addr
- adj
< datasize
)
1364 asection
*ft_section
;
1366 bfd_size_type ft_datasize
;
1370 fprintf (file
, _("\tvma: Hint/Ord Member-Name Bound-To\n"));
1372 idx
= hint_addr
- adj
;
1374 ft_addr
= first_thunk
+ extra
->ImageBase
;
1375 ft_idx
= first_thunk
- adj
;
1376 ft_data
= data
+ ft_idx
;
1377 ft_datasize
= datasize
- ft_idx
;
1380 if (first_thunk
!= hint_addr
)
1382 /* Find the section which contains the first thunk. */
1383 for (ft_section
= abfd
->sections
;
1385 ft_section
= ft_section
->next
)
1387 if (ft_addr
>= ft_section
->vma
1388 && ft_addr
< ft_section
->vma
+ ft_section
->size
)
1392 if (ft_section
== NULL
)
1395 _("\nThere is a first thunk, but the section containing it could not be found\n"));
1399 /* Now check to see if this section is the same as our current
1400 section. If it is not then we will have to load its data in. */
1401 if (ft_section
!= section
)
1403 ft_idx
= first_thunk
- (ft_section
->vma
- extra
->ImageBase
);
1404 ft_datasize
= ft_section
->size
- ft_idx
;
1405 ft_data
= (bfd_byte
*) bfd_malloc (ft_datasize
);
1406 if (ft_data
== NULL
)
1409 /* Read ft_datasize bytes starting at offset ft_idx. */
1410 if (!bfd_get_section_contents (abfd
, ft_section
, ft_data
,
1411 (bfd_vma
) ft_idx
, ft_datasize
))
1420 /* Print HintName vector entries. */
1421 #ifdef COFF_WITH_pex64
1422 for (j
= 0; idx
+ j
+ 8 <= datasize
; j
+= 8)
1425 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1426 unsigned long member_high
= bfd_get_32 (abfd
, data
+ idx
+ j
+ 4);
1428 if (!member
&& !member_high
)
1433 if (HighBitSet (member_high
))
1434 fprintf (file
, "\t%lx%08lx\t %4lx%08lx <none>",
1435 member_high
, member
,
1436 WithoutHighBit (member_high
), member
);
1437 /* PR binutils/17512: Handle corrupt PE data. */
1438 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1439 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1445 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1446 member_name
= (char *) data
+ amt
+ 2;
1447 fprintf (file
, "\t%04lx\t %4d %.*s",member
, ordinal
,
1448 (int) (datasize
- (amt
+ 2)), member_name
);
1451 /* If the time stamp is not zero, the import address
1452 table holds actual addresses. */
1455 && first_thunk
!= hint_addr
1456 && j
+ 4 <= ft_datasize
)
1457 fprintf (file
, "\t%04lx",
1458 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1459 fprintf (file
, "\n");
1462 for (j
= 0; idx
+ j
+ 4 <= datasize
; j
+= 4)
1465 unsigned long member
= bfd_get_32 (abfd
, data
+ idx
+ j
);
1467 /* Print single IMAGE_IMPORT_BY_NAME vector. */
1473 if (HighBitSet (member
))
1474 fprintf (file
, "\t%04lx\t %4lu <none>",
1475 member
, WithoutHighBit (member
));
1476 /* PR binutils/17512: Handle corrupt PE data. */
1477 else if (amt
>= datasize
|| amt
+ 2 >= datasize
)
1478 fprintf (file
, _("\t<corrupt: 0x%04lx>"), member
);
1484 ordinal
= bfd_get_16 (abfd
, data
+ amt
);
1485 member_name
= (char *) data
+ amt
+ 2;
1486 fprintf (file
, "\t%04lx\t %4d %.*s",
1488 (int) (datasize
- (amt
+ 2)), member_name
);
1491 /* If the time stamp is not zero, the import address
1492 table holds actual addresses. */
1495 && first_thunk
!= hint_addr
1496 && j
+ 4 <= ft_datasize
)
1497 fprintf (file
, "\t%04lx",
1498 (unsigned long) bfd_get_32 (abfd
, ft_data
+ j
));
1500 fprintf (file
, "\n");
1507 fprintf (file
, "\n");
1516 pe_print_edata (bfd
* abfd
, void * vfile
)
1518 FILE *file
= (FILE *) vfile
;
1521 bfd_size_type datasize
= 0;
1522 bfd_size_type dataoff
;
1527 long export_flags
; /* Reserved - should be zero. */
1531 bfd_vma name
; /* RVA - relative to image base. */
1532 long base
; /* Ordinal base. */
1533 unsigned long num_functions
;/* Number in the export address table. */
1534 unsigned long num_names
; /* Number in the name pointer table. */
1535 bfd_vma eat_addr
; /* RVA to the export address table. */
1536 bfd_vma npt_addr
; /* RVA to the Export Name Pointer Table. */
1537 bfd_vma ot_addr
; /* RVA to the Ordinal Table. */
1540 pe_data_type
*pe
= pe_data (abfd
);
1541 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
1545 addr
= extra
->DataDirectory
[PE_EXPORT_TABLE
].VirtualAddress
;
1547 if (addr
== 0 && extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
== 0)
1549 /* Maybe the extra header isn't there. Look for the section. */
1550 section
= bfd_get_section_by_name (abfd
, ".edata");
1551 if (section
== NULL
)
1554 addr
= section
->vma
;
1556 datasize
= section
->size
;
1562 addr
+= extra
->ImageBase
;
1564 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
1565 if (addr
>= section
->vma
&& addr
< section
->vma
+ section
->size
)
1568 if (section
== NULL
)
1571 _("\nThere is an export table, but the section containing it could not be found\n"));
1574 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
1577 _("\nThere is an export table in %s, but that section has no contents\n"),
1582 dataoff
= addr
- section
->vma
;
1583 datasize
= extra
->DataDirectory
[PE_EXPORT_TABLE
].Size
;
1584 if (dataoff
> section
->size
1585 || datasize
> section
->size
- dataoff
)
1588 _("\nThere is an export table in %s, but it does not fit into that section\n"),
1594 /* PR 17512: Handle corrupt PE binaries. */
1598 /* xgettext:c-format */
1599 _("\nThere is an export table in %s, but it is too small (%d)\n"),
1600 section
->name
, (int) datasize
);
1604 /* xgettext:c-format */
1605 fprintf (file
, _("\nThere is an export table in %s at 0x%lx\n"),
1606 section
->name
, (unsigned long) addr
);
1608 data
= (bfd_byte
*) bfd_malloc (datasize
);
1612 if (! bfd_get_section_contents (abfd
, section
, data
,
1613 (file_ptr
) dataoff
, datasize
))
1616 /* Go get Export Directory Table. */
1617 edt
.export_flags
= bfd_get_32 (abfd
, data
+ 0);
1618 edt
.time_stamp
= bfd_get_32 (abfd
, data
+ 4);
1619 edt
.major_ver
= bfd_get_16 (abfd
, data
+ 8);
1620 edt
.minor_ver
= bfd_get_16 (abfd
, data
+ 10);
1621 edt
.name
= bfd_get_32 (abfd
, data
+ 12);
1622 edt
.base
= bfd_get_32 (abfd
, data
+ 16);
1623 edt
.num_functions
= bfd_get_32 (abfd
, data
+ 20);
1624 edt
.num_names
= bfd_get_32 (abfd
, data
+ 24);
1625 edt
.eat_addr
= bfd_get_32 (abfd
, data
+ 28);
1626 edt
.npt_addr
= bfd_get_32 (abfd
, data
+ 32);
1627 edt
.ot_addr
= bfd_get_32 (abfd
, data
+ 36);
1629 adj
= section
->vma
- extra
->ImageBase
+ dataoff
;
1631 /* Dump the EDT first. */
1633 _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1637 _("Export Flags \t\t\t%lx\n"), (unsigned long) edt
.export_flags
);
1640 _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt
.time_stamp
);
1643 /* xgettext:c-format */
1644 _("Major/Minor \t\t\t%d/%d\n"), edt
.major_ver
, edt
.minor_ver
);
1647 _("Name \t\t\t\t"));
1648 bfd_fprintf_vma (abfd
, file
, edt
.name
);
1650 if ((edt
.name
>= adj
) && (edt
.name
< adj
+ datasize
))
1651 fprintf (file
, " %.*s\n",
1652 (int) (datasize
- (edt
.name
- adj
)),
1653 data
+ edt
.name
- adj
);
1655 fprintf (file
, "(outside .edata section)\n");
1658 _("Ordinal Base \t\t\t%ld\n"), edt
.base
);
1664 _("\tExport Address Table \t\t%08lx\n"),
1668 _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt
.num_names
);
1671 _("Table Addresses\n"));
1674 _("\tExport Address Table \t\t"));
1675 bfd_fprintf_vma (abfd
, file
, edt
.eat_addr
);
1676 fprintf (file
, "\n");
1679 _("\tName Pointer Table \t\t"));
1680 bfd_fprintf_vma (abfd
, file
, edt
.npt_addr
);
1681 fprintf (file
, "\n");
1684 _("\tOrdinal Table \t\t\t"));
1685 bfd_fprintf_vma (abfd
, file
, edt
.ot_addr
);
1686 fprintf (file
, "\n");
1688 /* The next table to find is the Export Address Table. It's basically
1689 a list of pointers that either locate a function in this dll, or
1690 forward the call to another dll. Something like:
1695 } export_address_table_entry; */
1698 _("\nExport Address Table -- Ordinal Base %ld\n"),
1701 /* PR 17512: Handle corrupt PE binaries. */
1702 /* PR 17512 file: 140-165018-0.004. */
1703 if (edt
.eat_addr
- adj
>= datasize
1704 /* PR 17512: file: 092b1829 */
1705 || (edt
.num_functions
+ 1) * 4 < edt
.num_functions
1706 || edt
.eat_addr
- adj
+ (edt
.num_functions
+ 1) * 4 > datasize
)
1707 fprintf (file
, _("\tInvalid Export Address Table rva (0x%lx) or entry count (0x%lx)\n"),
1708 (long) edt
.eat_addr
,
1709 (long) edt
.num_functions
);
1710 else for (i
= 0; i
< edt
.num_functions
; ++i
)
1712 bfd_vma eat_member
= bfd_get_32 (abfd
,
1713 data
+ edt
.eat_addr
+ (i
* 4) - adj
);
1714 if (eat_member
== 0)
1717 if (eat_member
- adj
<= datasize
)
1719 /* This rva is to a name (forwarding function) in our section. */
1720 /* Should locate a function descriptor. */
1722 "\t[%4ld] +base[%4ld] %04lx %s -- %.*s\n",
1724 (long) (i
+ edt
.base
),
1725 (unsigned long) eat_member
,
1727 (int)(datasize
- (eat_member
- adj
)),
1728 data
+ eat_member
- adj
);
1732 /* Should locate a function descriptor in the reldata section. */
1734 "\t[%4ld] +base[%4ld] %04lx %s\n",
1736 (long) (i
+ edt
.base
),
1737 (unsigned long) eat_member
,
1742 /* The Export Name Pointer Table is paired with the Export Ordinal Table. */
1743 /* Dump them in parallel for clarity. */
1745 _("\n[Ordinal/Name Pointer] Table\n"));
1747 /* PR 17512: Handle corrupt PE binaries. */
1748 if (edt
.npt_addr
+ (edt
.num_names
* 4) - adj
>= datasize
1749 /* PR 17512: file: bb68816e. */
1750 || edt
.num_names
* 4 < edt
.num_names
1751 || (data
+ edt
.npt_addr
- adj
) < data
)
1752 /* xgettext:c-format */
1753 fprintf (file
, _("\tInvalid Name Pointer Table rva (0x%lx) or entry count (0x%lx)\n"),
1754 (long) edt
.npt_addr
,
1755 (long) edt
.num_names
);
1756 /* PR 17512: file: 140-147171-0.004. */
1757 else if (edt
.ot_addr
+ (edt
.num_names
* 2) - adj
>= datasize
1758 || data
+ edt
.ot_addr
- adj
< data
)
1759 /* xgettext:c-format */
1760 fprintf (file
, _("\tInvalid Ordinal Table rva (0x%lx) or entry count (0x%lx)\n"),
1762 (long) edt
.num_names
);
1763 else for (i
= 0; i
< edt
.num_names
; ++i
)
1768 ord
= bfd_get_16 (abfd
, data
+ edt
.ot_addr
+ (i
* 2) - adj
);
1769 name_ptr
= bfd_get_32 (abfd
, data
+ edt
.npt_addr
+ (i
* 4) - adj
);
1771 if ((name_ptr
- adj
) >= datasize
)
1773 /* xgettext:c-format */
1774 fprintf (file
, _("\t[%4ld] <corrupt offset: %lx>\n"),
1775 (long) ord
, (long) name_ptr
);
1779 char * name
= (char *) data
+ name_ptr
- adj
;
1781 fprintf (file
, "\t[%4ld] %.*s\n", (long) ord
,
1782 (int)((char *)(data
+ datasize
) - name
), name
);
1791 /* This really is architecture dependent. On IA-64, a .pdata entry
1792 consists of three dwords containing relative virtual addresses that
1793 specify the start and end address of the code range the entry
1794 covers and the address of the corresponding unwind info data.
1796 On ARM and SH-4, a compressed PDATA structure is used :
1797 _IMAGE_CE_RUNTIME_FUNCTION_ENTRY, whereas MIPS is documented to use
1798 _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY.
1799 See http://msdn2.microsoft.com/en-us/library/ms253988(VS.80).aspx .
1801 This is the version for uncompressed data. */
1804 pe_print_pdata (bfd
* abfd
, void * vfile
)
1806 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64)
1807 # define PDATA_ROW_SIZE (3 * 8)
1809 # define PDATA_ROW_SIZE (5 * 4)
1811 FILE *file
= (FILE *) vfile
;
1813 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1814 bfd_size_type datasize
= 0;
1816 bfd_size_type start
, stop
;
1817 int onaline
= PDATA_ROW_SIZE
;
1820 || coff_section_data (abfd
, section
) == NULL
1821 || pei_section_data (abfd
, section
) == NULL
)
1824 stop
= pei_section_data (abfd
, section
)->virt_size
;
1825 if ((stop
% onaline
) != 0)
1827 /* xgettext:c-format */
1828 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1829 (long) stop
, onaline
);
1832 _("\nThe Function Table (interpreted .pdata section contents)\n"));
1833 #if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64)
1835 _(" vma:\t\t\tBegin Address End Address Unwind Info\n"));
1838 vma:\t\tBegin End EH EH PrologEnd Exception\n\
1839 \t\tAddress Address Handler Data Address Mask\n"));
1842 datasize
= section
->size
;
1846 /* PR 17512: file: 002-193900-0.004. */
1847 if (datasize
< stop
)
1849 /* xgettext:c-format */
1850 fprintf (file
, _("Virtual size of .pdata section (%ld) larger than real size (%ld)\n"),
1851 (long) stop
, (long) datasize
);
1855 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
1863 for (i
= start
; i
< stop
; i
+= onaline
)
1869 bfd_vma prolog_end_addr
;
1870 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64)
1874 if (i
+ PDATA_ROW_SIZE
> stop
)
1877 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
1878 end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
1879 eh_handler
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 8);
1880 eh_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 12);
1881 prolog_end_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 16);
1883 if (begin_addr
== 0 && end_addr
== 0 && eh_handler
== 0
1884 && eh_data
== 0 && prolog_end_addr
== 0)
1885 /* We are probably into the padding of the section now. */
1888 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64)
1889 em_data
= ((eh_handler
& 0x1) << 2) | (prolog_end_addr
& 0x3);
1891 eh_handler
&= ~(bfd_vma
) 0x3;
1892 prolog_end_addr
&= ~(bfd_vma
) 0x3;
1895 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
1896 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
1897 bfd_fprintf_vma (abfd
, file
, end_addr
); fputc (' ', file
);
1898 bfd_fprintf_vma (abfd
, file
, eh_handler
);
1899 #if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64)
1901 bfd_fprintf_vma (abfd
, file
, eh_data
); fputc (' ', file
);
1902 bfd_fprintf_vma (abfd
, file
, prolog_end_addr
);
1903 fprintf (file
, " %x", em_data
);
1905 fprintf (file
, "\n");
1911 #undef PDATA_ROW_SIZE
1914 typedef struct sym_cache
1921 slurp_symtab (bfd
*abfd
, sym_cache
*psc
)
1923 asymbol
** sy
= NULL
;
1926 if (!(bfd_get_file_flags (abfd
) & HAS_SYMS
))
1932 storage
= bfd_get_symtab_upper_bound (abfd
);
1937 sy
= (asymbol
**) bfd_malloc (storage
);
1942 psc
->symcount
= bfd_canonicalize_symtab (abfd
, sy
);
1943 if (psc
->symcount
< 0)
1949 my_symbol_for_address (bfd
*abfd
, bfd_vma func
, sym_cache
*psc
)
1954 psc
->syms
= slurp_symtab (abfd
, psc
);
1956 for (i
= 0; i
< psc
->symcount
; i
++)
1958 if (psc
->syms
[i
]->section
->vma
+ psc
->syms
[i
]->value
== func
)
1959 return psc
->syms
[i
]->name
;
1966 cleanup_syms (sym_cache
*psc
)
1973 /* This is the version for "compressed" pdata. */
1976 _bfd_XX_print_ce_compressed_pdata (bfd
* abfd
, void * vfile
)
1978 # define PDATA_ROW_SIZE (2 * 4)
1979 FILE *file
= (FILE *) vfile
;
1980 bfd_byte
*data
= NULL
;
1981 asection
*section
= bfd_get_section_by_name (abfd
, ".pdata");
1982 bfd_size_type datasize
= 0;
1984 bfd_size_type start
, stop
;
1985 int onaline
= PDATA_ROW_SIZE
;
1986 struct sym_cache cache
= {0, 0} ;
1989 || coff_section_data (abfd
, section
) == NULL
1990 || pei_section_data (abfd
, section
) == NULL
)
1993 stop
= pei_section_data (abfd
, section
)->virt_size
;
1994 if ((stop
% onaline
) != 0)
1996 /* xgettext:c-format */
1997 _("warning, .pdata section size (%ld) is not a multiple of %d\n"),
1998 (long) stop
, onaline
);
2001 _("\nThe Function Table (interpreted .pdata section contents)\n"));
2004 vma:\t\tBegin Prolog Function Flags Exception EH\n\
2005 \t\tAddress Length Length 32b exc Handler Data\n"));
2007 datasize
= section
->size
;
2011 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2019 for (i
= start
; i
< stop
; i
+= onaline
)
2023 bfd_vma prolog_length
, function_length
;
2024 int flag32bit
, exception_flag
;
2027 if (i
+ PDATA_ROW_SIZE
> stop
)
2030 begin_addr
= GET_PDATA_ENTRY (abfd
, data
+ i
);
2031 other_data
= GET_PDATA_ENTRY (abfd
, data
+ i
+ 4);
2033 if (begin_addr
== 0 && other_data
== 0)
2034 /* We are probably into the padding of the section now. */
2037 prolog_length
= (other_data
& 0x000000FF);
2038 function_length
= (other_data
& 0x3FFFFF00) >> 8;
2039 flag32bit
= (int)((other_data
& 0x40000000) >> 30);
2040 exception_flag
= (int)((other_data
& 0x80000000) >> 31);
2043 bfd_fprintf_vma (abfd
, file
, i
+ section
->vma
); fputc ('\t', file
);
2044 bfd_fprintf_vma (abfd
, file
, begin_addr
); fputc (' ', file
);
2045 bfd_fprintf_vma (abfd
, file
, prolog_length
); fputc (' ', file
);
2046 bfd_fprintf_vma (abfd
, file
, function_length
); fputc (' ', file
);
2047 fprintf (file
, "%2d %2d ", flag32bit
, exception_flag
);
2049 /* Get the exception handler's address and the data passed from the
2050 .text section. This is really the data that belongs with the .pdata
2051 but got "compressed" out for the ARM and SH4 architectures. */
2052 tsection
= bfd_get_section_by_name (abfd
, ".text");
2053 if (tsection
&& coff_section_data (abfd
, tsection
)
2054 && pei_section_data (abfd
, tsection
))
2056 bfd_vma eh_off
= (begin_addr
- 8) - tsection
->vma
;
2059 tdata
= (bfd_byte
*) bfd_malloc (8);
2062 if (bfd_get_section_contents (abfd
, tsection
, tdata
, eh_off
, 8))
2064 bfd_vma eh
, eh_data
;
2066 eh
= bfd_get_32 (abfd
, tdata
);
2067 eh_data
= bfd_get_32 (abfd
, tdata
+ 4);
2068 fprintf (file
, "%08x ", (unsigned int) eh
);
2069 fprintf (file
, "%08x", (unsigned int) eh_data
);
2072 const char *s
= my_symbol_for_address (abfd
, eh
, &cache
);
2075 fprintf (file
, " (%s) ", s
);
2082 fprintf (file
, "\n");
2087 cleanup_syms (& cache
);
2090 #undef PDATA_ROW_SIZE
2094 #define IMAGE_REL_BASED_HIGHADJ 4
2095 static const char * const tbl
[] =
2109 "UNKNOWN", /* MUST be last. */
2113 pe_print_reloc (bfd
* abfd
, void * vfile
)
2115 FILE *file
= (FILE *) vfile
;
2117 asection
*section
= bfd_get_section_by_name (abfd
, ".reloc");
2120 if (section
== NULL
|| section
->size
== 0 || !(section
->flags
& SEC_HAS_CONTENTS
))
2124 _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
2126 if (! bfd_malloc_and_get_section (abfd
, section
, &data
))
2133 end
= data
+ section
->size
;
2134 while (p
+ 8 <= end
)
2137 bfd_vma virtual_address
;
2138 unsigned long number
, size
;
2139 bfd_byte
*chunk_end
;
2141 /* The .reloc section is a sequence of blocks, with a header consisting
2142 of two 32 bit quantities, followed by a number of 16 bit entries. */
2143 virtual_address
= bfd_get_32 (abfd
, p
);
2144 size
= bfd_get_32 (abfd
, p
+ 4);
2146 number
= (size
- 8) / 2;
2152 /* xgettext:c-format */
2153 _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
2154 (unsigned long) virtual_address
, size
, size
, number
);
2156 chunk_end
= p
- 8 + size
;
2157 if (chunk_end
> end
)
2160 while (p
+ 2 <= chunk_end
)
2162 unsigned short e
= bfd_get_16 (abfd
, p
);
2163 unsigned int t
= (e
& 0xF000) >> 12;
2164 int off
= e
& 0x0FFF;
2166 if (t
>= sizeof (tbl
) / sizeof (tbl
[0]))
2167 t
= (sizeof (tbl
) / sizeof (tbl
[0])) - 1;
2170 /* xgettext:c-format */
2171 _("\treloc %4d offset %4x [%4lx] %s"),
2172 j
, off
, (unsigned long) (off
+ virtual_address
), tbl
[t
]);
2177 /* HIGHADJ takes an argument, - the next record *is* the
2178 low 16 bits of addend. */
2179 if (t
== IMAGE_REL_BASED_HIGHADJ
&& p
+ 2 <= chunk_end
)
2181 fprintf (file
, " (%4x)", (unsigned int) bfd_get_16 (abfd
, p
));
2186 fprintf (file
, "\n");
2195 /* A data structure describing the regions of a .rsrc section.
2196 Some fields are filled in as the section is parsed. */
2198 typedef struct rsrc_regions
2200 bfd_byte
* section_start
;
2201 bfd_byte
* section_end
;
2202 bfd_byte
* strings_start
;
2203 bfd_byte
* resource_start
;
2207 rsrc_print_resource_directory (FILE * , bfd
*, unsigned int, bfd_byte
*,
2208 rsrc_regions
*, bfd_vma
);
2210 /* Print the resource entry at DATA, with the text indented by INDENT.
2211 Recusively calls rsrc_print_resource_directory to print the contents
2212 of directory entries.
2213 Returns the address of the end of the data associated with the entry
2214 or section_end + 1 upon failure. */
2217 rsrc_print_resource_entries (FILE *file
,
2219 unsigned int indent
,
2222 rsrc_regions
*regions
,
2225 unsigned long entry
, addr
, size
;
2228 if (data
+ 8 >= regions
->section_end
)
2229 return regions
->section_end
+ 1;
2231 /* xgettext:c-format */
2232 fprintf (file
, _("%03x %*.s Entry: "), (int)(data
- regions
->section_start
), indent
, " ");
2234 entry
= (unsigned long) bfd_get_32 (abfd
, data
);
2239 /* Note - the documentation says that this field is an RVA value
2240 but windres appears to produce a section relative offset with
2241 the top bit set. Support both styles for now. */
2242 if (HighBitSet (entry
))
2243 name
= regions
->section_start
+ WithoutHighBit (entry
);
2245 name
= regions
->section_start
+ entry
- rva_bias
;
2247 if (name
+ 2 < regions
->section_end
&& name
> regions
->section_start
)
2251 if (regions
->strings_start
== NULL
)
2252 regions
->strings_start
= name
;
2254 len
= bfd_get_16 (abfd
, name
);
2256 fprintf (file
, _("name: [val: %08lx len %d]: "), entry
, len
);
2258 if (name
+ 2 + len
* 2 < regions
->section_end
)
2260 /* This strange loop is to cope with multibyte characters. */
2267 /* Avoid printing control characters. */
2268 if (c
> 0 && c
< 32)
2269 fprintf (file
, "^%c", c
+ 64);
2271 fprintf (file
, "%.1s", name
);
2276 fprintf (file
, _("<corrupt string length: %#x>\n"), len
);
2277 /* PR binutils/17512: Do not try to continue decoding a
2278 corrupted resource section. It is likely to end up with
2279 reams of extraneous output. FIXME: We could probably
2280 continue if we disable the printing of strings... */
2281 return regions
->section_end
+ 1;
2286 fprintf (file
, _("<corrupt string offset: %#lx>\n"), entry
);
2287 return regions
->section_end
+ 1;
2291 fprintf (file
, _("ID: %#08lx"), entry
);
2293 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
2294 fprintf (file
, _(", Value: %#08lx\n"), entry
);
2296 if (HighBitSet (entry
))
2298 data
= regions
->section_start
+ WithoutHighBit (entry
);
2299 if (data
<= regions
->section_start
|| data
> regions
->section_end
)
2300 return regions
->section_end
+ 1;
2302 /* FIXME: PR binutils/17512: A corrupt file could contain a loop
2303 in the resource table. We need some way to detect this. */
2304 return rsrc_print_resource_directory (file
, abfd
, indent
+ 1, data
,
2308 leaf
= regions
->section_start
+ entry
;
2310 if (leaf
+ 16 >= regions
->section_end
2311 /* PR 17512: file: 055dff7e. */
2312 || leaf
< regions
->section_start
)
2313 return regions
->section_end
+ 1;
2315 /* xgettext:c-format */
2316 fprintf (file
, _("%03x %*.s Leaf: Addr: %#08lx, Size: %#08lx, Codepage: %d\n"),
2317 (int) (entry
), indent
, " ",
2318 addr
= (long) bfd_get_32 (abfd
, leaf
),
2319 size
= (long) bfd_get_32 (abfd
, leaf
+ 4),
2320 (int) bfd_get_32 (abfd
, leaf
+ 8));
2322 /* Check that the reserved entry is 0. */
2323 if (bfd_get_32 (abfd
, leaf
+ 12) != 0
2324 /* And that the data address/size is valid too. */
2325 || (regions
->section_start
+ (addr
- rva_bias
) + size
> regions
->section_end
))
2326 return regions
->section_end
+ 1;
2328 if (regions
->resource_start
== NULL
)
2329 regions
->resource_start
= regions
->section_start
+ (addr
- rva_bias
);
2331 return regions
->section_start
+ (addr
- rva_bias
) + size
;
2334 #define max(a,b) ((a) > (b) ? (a) : (b))
2335 #define min(a,b) ((a) < (b) ? (a) : (b))
2338 rsrc_print_resource_directory (FILE * file
,
2340 unsigned int indent
,
2342 rsrc_regions
* regions
,
2345 unsigned int num_names
, num_ids
;
2346 bfd_byte
* highest_data
= data
;
2348 if (data
+ 16 >= regions
->section_end
)
2349 return regions
->section_end
+ 1;
2351 fprintf (file
, "%03x %*.s ", (int)(data
- regions
->section_start
), indent
, " ");
2354 case 0: fprintf (file
, "Type"); break;
2355 case 2: fprintf (file
, "Name"); break;
2356 case 4: fprintf (file
, "Language"); break;
2358 fprintf (file
, _("<unknown directory type: %d>\n"), indent
);
2359 /* FIXME: For now we end the printing here. If in the
2360 future more directory types are added to the RSRC spec
2361 then we will need to change this. */
2362 return regions
->section_end
+ 1;
2365 /* xgettext:c-format */
2366 fprintf (file
, _(" Table: Char: %d, Time: %08lx, Ver: %d/%d, Num Names: %d, IDs: %d\n"),
2367 (int) bfd_get_32 (abfd
, data
),
2368 (long) bfd_get_32 (abfd
, data
+ 4),
2369 (int) bfd_get_16 (abfd
, data
+ 8),
2370 (int) bfd_get_16 (abfd
, data
+ 10),
2371 num_names
= (int) bfd_get_16 (abfd
, data
+ 12),
2372 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14));
2375 while (num_names
--)
2377 bfd_byte
* entry_end
;
2379 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, true,
2380 data
, regions
, rva_bias
);
2382 highest_data
= max (highest_data
, entry_end
);
2383 if (entry_end
>= regions
->section_end
)
2389 bfd_byte
* entry_end
;
2391 entry_end
= rsrc_print_resource_entries (file
, abfd
, indent
+ 1, false,
2392 data
, regions
, rva_bias
);
2394 highest_data
= max (highest_data
, entry_end
);
2395 if (entry_end
>= regions
->section_end
)
2399 return max (highest_data
, data
);
2402 /* Display the contents of a .rsrc section. We do not try to
2403 reproduce the resources, windres does that. Instead we dump
2404 the tables in a human readable format. */
2407 rsrc_print_section (bfd
* abfd
, void * vfile
)
2411 FILE * file
= (FILE *) vfile
;
2412 bfd_size_type datasize
;
2415 rsrc_regions regions
;
2417 pe
= pe_data (abfd
);
2421 section
= bfd_get_section_by_name (abfd
, ".rsrc");
2422 if (section
== NULL
)
2424 if (!(section
->flags
& SEC_HAS_CONTENTS
))
2427 datasize
= section
->size
;
2431 rva_bias
= section
->vma
- pe
->pe_opthdr
.ImageBase
;
2433 if (! bfd_malloc_and_get_section (abfd
, section
, & data
))
2439 regions
.section_start
= data
;
2440 regions
.section_end
= data
+ datasize
;
2441 regions
.strings_start
= NULL
;
2442 regions
.resource_start
= NULL
;
2445 fprintf (file
, "\nThe .rsrc Resource Directory section:\n");
2447 while (data
< regions
.section_end
)
2449 bfd_byte
* p
= data
;
2451 data
= rsrc_print_resource_directory (file
, abfd
, 0, data
, & regions
, rva_bias
);
2453 if (data
== regions
.section_end
+ 1)
2454 fprintf (file
, _("Corrupt .rsrc section detected!\n"));
2457 /* Align data before continuing. */
2458 int align
= (1 << section
->alignment_power
) - 1;
2460 data
= (bfd_byte
*) (((ptrdiff_t) (data
+ align
)) & ~ align
);
2461 rva_bias
+= data
- p
;
2463 /* For reasons that are unclear .rsrc sections are sometimes created
2464 aligned to a 1^3 boundary even when their alignment is set at
2465 1^2. Catch that case here before we issue a spurious warning
2467 if (data
== (regions
.section_end
- 4))
2468 data
= regions
.section_end
;
2469 else if (data
< regions
.section_end
)
2471 /* If the extra data is all zeros then do not complain.
2472 This is just padding so that the section meets the
2473 page size requirements. */
2474 while (++ data
< regions
.section_end
)
2477 if (data
< regions
.section_end
)
2478 fprintf (file
, _("\nWARNING: Extra data in .rsrc section - it will be ignored by Windows:\n"));
2483 if (regions
.strings_start
!= NULL
)
2484 fprintf (file
, _(" String table starts at offset: %#03x\n"),
2485 (int) (regions
.strings_start
- regions
.section_start
));
2486 if (regions
.resource_start
!= NULL
)
2487 fprintf (file
, _(" Resources start at offset: %#03x\n"),
2488 (int) (regions
.resource_start
- regions
.section_start
));
2490 free (regions
.section_start
);
2494 #define IMAGE_NUMBEROF_DEBUG_TYPES 17
2496 static char * debug_type_names
[IMAGE_NUMBEROF_DEBUG_TYPES
] =
2518 pe_print_debugdata (bfd
* abfd
, void * vfile
)
2520 FILE *file
= (FILE *) vfile
;
2521 pe_data_type
*pe
= pe_data (abfd
);
2522 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2525 bfd_size_type dataoff
;
2528 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2529 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2534 addr
+= extra
->ImageBase
;
2535 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2537 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2541 if (section
== NULL
)
2544 _("\nThere is a debug directory, but the section containing it could not be found\n"));
2547 else if (!(section
->flags
& SEC_HAS_CONTENTS
))
2550 _("\nThere is a debug directory in %s, but that section has no contents\n"),
2554 else if (section
->size
< size
)
2557 _("\nError: section %s contains the debug data starting address but it is too small\n"),
2562 fprintf (file
, _("\nThere is a debug directory in %s at 0x%lx\n\n"),
2563 section
->name
, (unsigned long) addr
);
2565 dataoff
= addr
- section
->vma
;
2567 if (size
> (section
->size
- dataoff
))
2569 fprintf (file
, _("The debug data size field in the data directory is too big for the section"));
2574 _("Type Size Rva Offset\n"));
2576 /* Read the whole section. */
2577 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2583 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2585 const char *type_name
;
2586 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2587 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2588 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2590 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2592 if ((idd
.Type
) >= IMAGE_NUMBEROF_DEBUG_TYPES
)
2593 type_name
= debug_type_names
[0];
2595 type_name
= debug_type_names
[idd
.Type
];
2597 fprintf (file
, " %2ld %14s %08lx %08lx %08lx\n",
2598 idd
.Type
, type_name
, idd
.SizeOfData
,
2599 idd
.AddressOfRawData
, idd
.PointerToRawData
);
2601 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_CODEVIEW
)
2603 char signature
[CV_INFO_SIGNATURE_LENGTH
* 2 + 1];
2604 /* PR 17512: file: 065-29434-0.001:0.1
2605 We need to use a 32-bit aligned buffer
2606 to safely read in a codeview record. */
2607 char buffer
[256 + 1] ATTRIBUTE_ALIGNED_ALIGNOF (CODEVIEW_INFO
);
2609 CODEVIEW_INFO
*cvinfo
= (CODEVIEW_INFO
*) buffer
;
2611 /* The debug entry doesn't have to have to be in a section,
2612 in which case AddressOfRawData is 0, so always use PointerToRawData. */
2613 if (!_bfd_XXi_slurp_codeview_record (abfd
, (file_ptr
) idd
.PointerToRawData
,
2614 idd
.SizeOfData
, cvinfo
))
2617 for (j
= 0; j
< cvinfo
->SignatureLength
; j
++)
2618 sprintf (&signature
[j
*2], "%02x", cvinfo
->Signature
[j
] & 0xff);
2620 /* xgettext:c-format */
2621 fprintf (file
, _("(format %c%c%c%c signature %s age %ld)\n"),
2622 buffer
[0], buffer
[1], buffer
[2], buffer
[3],
2623 signature
, cvinfo
->Age
);
2629 if (size
% sizeof (struct external_IMAGE_DEBUG_DIRECTORY
) != 0)
2631 _("The debug directory size is not a multiple of the debug directory entry size\n"));
2637 pe_is_repro (bfd
* abfd
)
2639 pe_data_type
*pe
= pe_data (abfd
);
2640 struct internal_extra_pe_aouthdr
*extra
= &pe
->pe_opthdr
;
2643 bfd_size_type dataoff
;
2647 bfd_vma addr
= extra
->DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
;
2648 bfd_size_type size
= extra
->DataDirectory
[PE_DEBUG_DATA
].Size
;
2653 addr
+= extra
->ImageBase
;
2654 for (section
= abfd
->sections
; section
!= NULL
; section
= section
->next
)
2656 if ((addr
>= section
->vma
) && (addr
< (section
->vma
+ section
->size
)))
2660 if ((section
== NULL
)
2661 || (!(section
->flags
& SEC_HAS_CONTENTS
))
2662 || (section
->size
< size
))
2667 dataoff
= addr
- section
->vma
;
2669 if (size
> (section
->size
- dataoff
))
2674 if (!bfd_malloc_and_get_section (abfd
, section
, &data
))
2680 for (i
= 0; i
< size
/ sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
2682 struct external_IMAGE_DEBUG_DIRECTORY
*ext
2683 = &((struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
))[i
];
2684 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
2686 _bfd_XXi_swap_debugdir_in (abfd
, ext
, &idd
);
2688 if (idd
.Type
== PE_IMAGE_DEBUG_TYPE_REPRO
)
2700 /* Print out the program headers. */
2703 _bfd_XX_print_private_bfd_data_common (bfd
* abfd
, void * vfile
)
2705 FILE *file
= (FILE *) vfile
;
2707 pe_data_type
*pe
= pe_data (abfd
);
2708 struct internal_extra_pe_aouthdr
*i
= &pe
->pe_opthdr
;
2709 const char *subsystem_name
= NULL
;
2712 /* The MS dumpbin program reportedly ands with 0xff0f before
2713 printing the characteristics field. Not sure why. No reason to
2715 fprintf (file
, _("\nCharacteristics 0x%x\n"), pe
->real_flags
);
2717 #define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
2718 PF (IMAGE_FILE_RELOCS_STRIPPED
, "relocations stripped");
2719 PF (IMAGE_FILE_EXECUTABLE_IMAGE
, "executable");
2720 PF (IMAGE_FILE_LINE_NUMS_STRIPPED
, "line numbers stripped");
2721 PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED
, "symbols stripped");
2722 PF (IMAGE_FILE_LARGE_ADDRESS_AWARE
, "large address aware");
2723 PF (IMAGE_FILE_BYTES_REVERSED_LO
, "little endian");
2724 PF (IMAGE_FILE_32BIT_MACHINE
, "32 bit words");
2725 PF (IMAGE_FILE_DEBUG_STRIPPED
, "debugging information removed");
2726 PF (IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP
, "copy to swap file if on removable media");
2727 PF (IMAGE_FILE_NET_RUN_FROM_SWAP
, "copy to swap file if on network media");
2728 PF (IMAGE_FILE_SYSTEM
, "system file");
2729 PF (IMAGE_FILE_DLL
, "DLL");
2730 PF (IMAGE_FILE_UP_SYSTEM_ONLY
, "run only on uniprocessor machine");
2731 PF (IMAGE_FILE_BYTES_REVERSED_HI
, "big endian");
2735 If a PE_IMAGE_DEBUG_TYPE_REPRO entry is present in the debug directory, the
2736 timestamp is to be interpreted as the hash of a reproducible build.
2738 if (pe_is_repro (abfd
))
2740 fprintf (file
, "\nTime/Date\t\t%08lx", pe
->coff
.timestamp
);
2741 fprintf (file
, "\t(This is a reproducible build file hash, not a timestamp)\n");
2745 /* ctime implies '\n'. */
2746 time_t t
= pe
->coff
.timestamp
;
2747 fprintf (file
, "\nTime/Date\t\t%s", ctime (&t
));
2750 #ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
2751 # define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
2753 #ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
2754 # define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
2756 #ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
2757 # define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
2762 case IMAGE_NT_OPTIONAL_HDR_MAGIC
:
2765 case IMAGE_NT_OPTIONAL_HDR64_MAGIC
:
2768 case IMAGE_NT_OPTIONAL_HDRROM_MAGIC
:
2775 fprintf (file
, "Magic\t\t\t%04x", i
->Magic
);
2777 fprintf (file
, "\t(%s)",name
);
2778 fprintf (file
, "\nMajorLinkerVersion\t%d\n", i
->MajorLinkerVersion
);
2779 fprintf (file
, "MinorLinkerVersion\t%d\n", i
->MinorLinkerVersion
);
2780 fprintf (file
, "SizeOfCode\t\t");
2781 bfd_fprintf_vma (abfd
, file
, i
->SizeOfCode
);
2782 fprintf (file
, "\nSizeOfInitializedData\t");
2783 bfd_fprintf_vma (abfd
, file
, i
->SizeOfInitializedData
);
2784 fprintf (file
, "\nSizeOfUninitializedData\t");
2785 bfd_fprintf_vma (abfd
, file
, i
->SizeOfUninitializedData
);
2786 fprintf (file
, "\nAddressOfEntryPoint\t");
2787 bfd_fprintf_vma (abfd
, file
, i
->AddressOfEntryPoint
);
2788 fprintf (file
, "\nBaseOfCode\t\t");
2789 bfd_fprintf_vma (abfd
, file
, i
->BaseOfCode
);
2790 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64)
2791 /* PE32+ does not have BaseOfData member! */
2792 fprintf (file
, "\nBaseOfData\t\t");
2793 bfd_fprintf_vma (abfd
, file
, i
->BaseOfData
);
2796 fprintf (file
, "\nImageBase\t\t");
2797 bfd_fprintf_vma (abfd
, file
, i
->ImageBase
);
2798 fprintf (file
, "\nSectionAlignment\t%08x\n", i
->SectionAlignment
);
2799 fprintf (file
, "FileAlignment\t\t%08x\n", i
->FileAlignment
);
2800 fprintf (file
, "MajorOSystemVersion\t%d\n", i
->MajorOperatingSystemVersion
);
2801 fprintf (file
, "MinorOSystemVersion\t%d\n", i
->MinorOperatingSystemVersion
);
2802 fprintf (file
, "MajorImageVersion\t%d\n", i
->MajorImageVersion
);
2803 fprintf (file
, "MinorImageVersion\t%d\n", i
->MinorImageVersion
);
2804 fprintf (file
, "MajorSubsystemVersion\t%d\n", i
->MajorSubsystemVersion
);
2805 fprintf (file
, "MinorSubsystemVersion\t%d\n", i
->MinorSubsystemVersion
);
2806 fprintf (file
, "Win32Version\t\t%08x\n", i
->Reserved1
);
2807 fprintf (file
, "SizeOfImage\t\t%08x\n", i
->SizeOfImage
);
2808 fprintf (file
, "SizeOfHeaders\t\t%08x\n", i
->SizeOfHeaders
);
2809 fprintf (file
, "CheckSum\t\t%08x\n", i
->CheckSum
);
2811 switch (i
->Subsystem
)
2813 case IMAGE_SUBSYSTEM_UNKNOWN
:
2814 subsystem_name
= "unspecified";
2816 case IMAGE_SUBSYSTEM_NATIVE
:
2817 subsystem_name
= "NT native";
2819 case IMAGE_SUBSYSTEM_WINDOWS_GUI
:
2820 subsystem_name
= "Windows GUI";
2822 case IMAGE_SUBSYSTEM_WINDOWS_CUI
:
2823 subsystem_name
= "Windows CUI";
2825 case IMAGE_SUBSYSTEM_POSIX_CUI
:
2826 subsystem_name
= "POSIX CUI";
2828 case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
:
2829 subsystem_name
= "Wince CUI";
2831 /* These are from UEFI Platform Initialization Specification 1.1. */
2832 case IMAGE_SUBSYSTEM_EFI_APPLICATION
:
2833 subsystem_name
= "EFI application";
2835 case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
2836 subsystem_name
= "EFI boot service driver";
2838 case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
2839 subsystem_name
= "EFI runtime driver";
2841 case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
2842 subsystem_name
= "SAL runtime driver";
2844 /* This is from revision 8.0 of the MS PE/COFF spec */
2845 case IMAGE_SUBSYSTEM_XBOX
:
2846 subsystem_name
= "XBOX";
2848 /* Added default case for clarity - subsystem_name is NULL anyway. */
2850 subsystem_name
= NULL
;
2853 fprintf (file
, "Subsystem\t\t%08x", i
->Subsystem
);
2855 fprintf (file
, "\t(%s)", subsystem_name
);
2856 fprintf (file
, "\nDllCharacteristics\t%08x\n", i
->DllCharacteristics
);
2857 if (i
->DllCharacteristics
)
2859 unsigned short dllch
= i
->DllCharacteristics
;
2860 const char *indent
= "\t\t\t\t\t";
2862 if (dllch
& IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA
)
2863 fprintf (file
, "%sHIGH_ENTROPY_VA\n", indent
);
2864 if (dllch
& IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE
)
2865 fprintf (file
, "%sDYNAMIC_BASE\n", indent
);
2866 if (dllch
& IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY
)
2867 fprintf (file
, "%sFORCE_INTEGRITY\n", indent
);
2868 if (dllch
& IMAGE_DLL_CHARACTERISTICS_NX_COMPAT
)
2869 fprintf (file
, "%sNX_COMPAT\n", indent
);
2870 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_ISOLATION
)
2871 fprintf (file
, "%sNO_ISOLATION\n", indent
);
2872 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_SEH
)
2873 fprintf (file
, "%sNO_SEH\n", indent
);
2874 if (dllch
& IMAGE_DLLCHARACTERISTICS_NO_BIND
)
2875 fprintf (file
, "%sNO_BIND\n", indent
);
2876 if (dllch
& IMAGE_DLLCHARACTERISTICS_APPCONTAINER
)
2877 fprintf (file
, "%sAPPCONTAINER\n", indent
);
2878 if (dllch
& IMAGE_DLLCHARACTERISTICS_WDM_DRIVER
)
2879 fprintf (file
, "%sWDM_DRIVER\n", indent
);
2880 if (dllch
& IMAGE_DLLCHARACTERISTICS_GUARD_CF
)
2881 fprintf (file
, "%sGUARD_CF\n", indent
);
2882 if (dllch
& IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE
)
2883 fprintf (file
, "%sTERMINAL_SERVICE_AWARE\n", indent
);
2885 fprintf (file
, "SizeOfStackReserve\t");
2886 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackReserve
);
2887 fprintf (file
, "\nSizeOfStackCommit\t");
2888 bfd_fprintf_vma (abfd
, file
, i
->SizeOfStackCommit
);
2889 fprintf (file
, "\nSizeOfHeapReserve\t");
2890 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapReserve
);
2891 fprintf (file
, "\nSizeOfHeapCommit\t");
2892 bfd_fprintf_vma (abfd
, file
, i
->SizeOfHeapCommit
);
2893 fprintf (file
, "\nLoaderFlags\t\t%08lx\n", (unsigned long) i
->LoaderFlags
);
2894 fprintf (file
, "NumberOfRvaAndSizes\t%08lx\n",
2895 (unsigned long) i
->NumberOfRvaAndSizes
);
2897 fprintf (file
, "\nThe Data Directory\n");
2898 for (j
= 0; j
< IMAGE_NUMBEROF_DIRECTORY_ENTRIES
; j
++)
2900 fprintf (file
, "Entry %1x ", j
);
2901 bfd_fprintf_vma (abfd
, file
, i
->DataDirectory
[j
].VirtualAddress
);
2902 fprintf (file
, " %08lx ", (unsigned long) i
->DataDirectory
[j
].Size
);
2903 fprintf (file
, "%s\n", dir_names
[j
]);
2906 pe_print_idata (abfd
, vfile
);
2907 pe_print_edata (abfd
, vfile
);
2908 if (bfd_coff_have_print_pdata (abfd
))
2909 bfd_coff_print_pdata (abfd
, vfile
);
2911 pe_print_pdata (abfd
, vfile
);
2912 pe_print_reloc (abfd
, vfile
);
2913 pe_print_debugdata (abfd
, file
);
2915 rsrc_print_section (abfd
, vfile
);
2921 is_vma_in_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sect
, void *obj
)
2923 bfd_vma addr
= * (bfd_vma
*) obj
;
2924 return (addr
>= sect
->vma
) && (addr
< (sect
->vma
+ sect
->size
));
2928 find_section_by_vma (bfd
*abfd
, bfd_vma addr
)
2930 return bfd_sections_find_if (abfd
, is_vma_in_section
, (void *) & addr
);
2933 /* Copy any private info we understand from the input bfd
2934 to the output bfd. */
2937 _bfd_XX_bfd_copy_private_bfd_data_common (bfd
* ibfd
, bfd
* obfd
)
2939 pe_data_type
*ipe
, *ope
;
2942 /* One day we may try to grok other private data. */
2943 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2944 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2947 ipe
= pe_data (ibfd
);
2948 ope
= pe_data (obfd
);
2950 /* pe_opthdr is copied in copy_object. */
2951 ope
->dll
= ipe
->dll
;
2953 /* Don't copy input subsystem if output is different from input. */
2954 if (obfd
->xvec
!= ibfd
->xvec
)
2955 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2957 /* For strip: if we removed .reloc, we'll make a real mess of things
2958 if we don't remove this entry as well. */
2959 if (! pe_data (obfd
)->has_reloc_section
)
2961 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
2962 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
2965 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2966 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2968 if (! pe_data (ibfd
)->has_reloc_section
2969 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
2970 pe_data (obfd
)->dont_strip_reloc
= 1;
2972 memcpy (ope
->dos_message
, ipe
->dos_message
, sizeof (ope
->dos_message
));
2974 /* The file offsets contained in the debug directory need rewriting. */
2975 size
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
;
2978 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
2979 + ope
->pe_opthdr
.ImageBase
;
2980 /* In particular a .buildid section may overlap (in VA space) with
2981 whatever section comes ahead of it (largely because of section->size
2982 representing s_size, not virt_size). Therefore don't look for the
2983 section containing the first byte, but for that covering the last
2985 bfd_vma last
= addr
+ size
- 1;
2986 asection
*section
= find_section_by_vma (obfd
, last
);
2988 if (section
!= NULL
)
2991 bfd_vma dataoff
= addr
- section
->vma
;
2993 /* PR 17512: file: 0f15796a. */
2994 if (addr
< section
->vma
2995 || section
->size
< dataoff
2996 || section
->size
- dataoff
< size
)
2998 /* xgettext:c-format */
3000 (_("%pB: Data Directory (%lx bytes at %" PRIx64
") "
3001 "extends across section boundary at %" PRIx64
),
3002 obfd
, ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
,
3003 (uint64_t) addr
, (uint64_t) section
->vma
);
3007 if (bfd_malloc_and_get_section (obfd
, section
, &data
))
3010 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
3011 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
);
3013 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
3014 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
3016 asection
*ddsection
;
3017 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
3018 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
3021 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
3023 /* RVA 0 means only offset is valid, not handled yet. */
3024 if (idd
.AddressOfRawData
== 0)
3027 idd_vma
= idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
;
3028 ddsection
= find_section_by_vma (obfd
, idd_vma
);
3030 continue; /* Not in a section! */
3032 idd
.PointerToRawData
3033 = ddsection
->filepos
+ idd_vma
- ddsection
->vma
;
3034 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
3037 if (!bfd_set_section_contents (obfd
, section
, data
, 0,
3040 _bfd_error_handler (_("failed to update file offsets"
3041 " in debug directory"));
3049 _bfd_error_handler (_("%pB: failed to read "
3050 "debug data section"), obfd
);
3059 /* Copy private section data. */
3062 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
3067 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
3068 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
3071 if (coff_section_data (ibfd
, isec
) != NULL
3072 && pei_section_data (ibfd
, isec
) != NULL
)
3074 if (coff_section_data (obfd
, osec
) == NULL
)
3076 size_t amt
= sizeof (struct coff_section_tdata
);
3077 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
3078 if (osec
->used_by_bfd
== NULL
)
3082 if (pei_section_data (obfd
, osec
) == NULL
)
3084 size_t amt
= sizeof (struct pei_section_tdata
);
3085 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
3086 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
3090 pei_section_data (obfd
, osec
)->virt_size
=
3091 pei_section_data (ibfd
, isec
)->virt_size
;
3092 pei_section_data (obfd
, osec
)->pe_flags
=
3093 pei_section_data (ibfd
, isec
)->pe_flags
;
3100 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
3102 coff_get_symbol_info (abfd
, symbol
, ret
);
3105 #if !defined(COFF_WITH_pep) && (defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64))
3107 sort_x64_pdata (const void *l
, const void *r
)
3109 const char *lp
= (const char *) l
;
3110 const char *rp
= (const char *) r
;
3112 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
3114 return (vl
< vr
? -1 : 1);
3115 /* We compare just begin address. */
3120 /* Functions to process a .rsrc section. */
3122 static unsigned int sizeof_leaves
;
3123 static unsigned int sizeof_strings
;
3124 static unsigned int sizeof_tables_and_entries
;
3127 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3130 rsrc_count_entries (bfd
*abfd
,
3132 bfd_byte
*datastart
,
3137 unsigned long entry
, addr
, size
;
3139 if (data
+ 8 >= dataend
)
3146 entry
= (long) bfd_get_32 (abfd
, data
);
3148 if (HighBitSet (entry
))
3149 name
= datastart
+ WithoutHighBit (entry
);
3151 name
= datastart
+ entry
- rva_bias
;
3153 if (name
+ 2 >= dataend
|| name
< datastart
)
3156 unsigned int len
= bfd_get_16 (abfd
, name
);
3157 if (len
== 0 || len
> 256)
3161 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3163 if (HighBitSet (entry
))
3165 data
= datastart
+ WithoutHighBit (entry
);
3167 if (data
<= datastart
|| data
>= dataend
)
3170 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3173 if (datastart
+ entry
+ 16 >= dataend
)
3176 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3177 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3179 return datastart
+ addr
- rva_bias
+ size
;
3183 rsrc_count_directory (bfd
* abfd
,
3184 bfd_byte
* datastart
,
3189 unsigned int num_entries
, num_ids
;
3190 bfd_byte
* highest_data
= data
;
3192 if (data
+ 16 >= dataend
)
3195 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3196 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3198 num_entries
+= num_ids
;
3202 while (num_entries
--)
3204 bfd_byte
* entry_end
;
3206 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3207 datastart
, data
, dataend
, rva_bias
);
3209 highest_data
= max (highest_data
, entry_end
);
3210 if (entry_end
>= dataend
)
3214 return max (highest_data
, data
);
3217 typedef struct rsrc_dir_chain
3219 unsigned int num_entries
;
3220 struct rsrc_entry
* first_entry
;
3221 struct rsrc_entry
* last_entry
;
3224 typedef struct rsrc_directory
3226 unsigned int characteristics
;
3231 rsrc_dir_chain names
;
3234 struct rsrc_entry
* entry
;
3237 typedef struct rsrc_string
3243 typedef struct rsrc_leaf
3246 unsigned int codepage
;
3250 typedef struct rsrc_entry
3256 struct rsrc_string name
;
3262 struct rsrc_directory
* directory
;
3263 struct rsrc_leaf
* leaf
;
3266 struct rsrc_entry
* next_entry
;
3267 struct rsrc_directory
* parent
;
3271 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3272 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3275 rsrc_parse_entry (bfd
*abfd
,
3278 bfd_byte
*datastart
,
3282 rsrc_directory
*parent
)
3284 unsigned long val
, addr
, size
;
3286 val
= bfd_get_32 (abfd
, data
);
3288 entry
->parent
= parent
;
3289 entry
->is_name
= is_name
;
3295 if (HighBitSet (val
))
3297 val
= WithoutHighBit (val
);
3299 address
= datastart
+ val
;
3303 address
= datastart
+ val
- rva_bias
;
3306 if (address
+ 3 > dataend
)
3309 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3310 entry
->name_id
.name
.string
= address
+ 2;
3313 entry
->name_id
.id
= val
;
3315 val
= bfd_get_32 (abfd
, data
+ 4);
3317 if (HighBitSet (val
))
3319 entry
->is_dir
= true;
3320 entry
->value
.directory
= bfd_malloc (sizeof * entry
->value
.directory
);
3321 if (entry
->value
.directory
== NULL
)
3324 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3326 datastart
+ WithoutHighBit (val
),
3327 dataend
, rva_bias
, entry
);
3330 entry
->is_dir
= false;
3331 entry
->value
.leaf
= bfd_malloc (sizeof * entry
->value
.leaf
);
3332 if (entry
->value
.leaf
== NULL
)
3335 data
= datastart
+ val
;
3336 if (data
< datastart
|| data
>= dataend
)
3339 addr
= bfd_get_32 (abfd
, data
);
3340 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, data
+ 4);
3341 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, data
+ 8);
3342 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3344 entry
->value
.leaf
->data
= bfd_malloc (size
);
3345 if (entry
->value
.leaf
->data
== NULL
)
3348 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3349 return datastart
+ (addr
- rva_bias
) + size
;
3353 rsrc_parse_entries (bfd
*abfd
,
3354 rsrc_dir_chain
*chain
,
3356 bfd_byte
*highest_data
,
3357 bfd_byte
*datastart
,
3361 rsrc_directory
*parent
)
3366 if (chain
->num_entries
== 0)
3368 chain
->first_entry
= chain
->last_entry
= NULL
;
3369 return highest_data
;
3372 entry
= bfd_malloc (sizeof * entry
);
3376 chain
->first_entry
= entry
;
3378 for (i
= chain
->num_entries
; i
--;)
3380 bfd_byte
* entry_end
;
3382 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3383 data
, dataend
, rva_bias
, parent
);
3385 highest_data
= max (entry_end
, highest_data
);
3386 if (entry_end
> dataend
)
3391 entry
->next_entry
= bfd_malloc (sizeof * entry
);
3392 entry
= entry
->next_entry
;
3397 entry
->next_entry
= NULL
;
3400 chain
->last_entry
= entry
;
3402 return highest_data
;
3406 rsrc_parse_directory (bfd
* abfd
,
3407 rsrc_directory
* table
,
3408 bfd_byte
* datastart
,
3414 bfd_byte
* highest_data
= data
;
3419 table
->characteristics
= bfd_get_32 (abfd
, data
);
3420 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3421 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3422 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3423 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3424 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3425 table
->entry
= entry
;
3429 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, true, data
,
3430 datastart
, data
, dataend
, rva_bias
, table
);
3431 data
+= table
->names
.num_entries
* 8;
3433 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, false, highest_data
,
3434 datastart
, data
, dataend
, rva_bias
, table
);
3435 data
+= table
->ids
.num_entries
* 8;
3437 return max (highest_data
, data
);
3440 typedef struct rsrc_write_data
3443 bfd_byte
* datastart
;
3444 bfd_byte
* next_table
;
3445 bfd_byte
* next_leaf
;
3446 bfd_byte
* next_string
;
3447 bfd_byte
* next_data
;
3452 rsrc_write_string (rsrc_write_data
* data
,
3453 rsrc_string
* string
)
3455 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3456 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3457 data
->next_string
+= (string
->len
+ 1) * 2;
3460 static inline unsigned int
3461 rsrc_compute_rva (rsrc_write_data
* data
,
3464 return (addr
- data
->datastart
) + data
->rva_bias
;
3468 rsrc_write_leaf (rsrc_write_data
* data
,
3471 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3473 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3474 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3475 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3476 data
->next_leaf
+= 16;
3478 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3479 /* An undocumented feature of Windows resources is that each unit
3480 of raw data is 8-byte aligned... */
3481 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3484 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3487 rsrc_write_entry (rsrc_write_data
* data
,
3493 bfd_put_32 (data
->abfd
,
3494 SetHighBit (data
->next_string
- data
->datastart
),
3496 rsrc_write_string (data
, & entry
->name_id
.name
);
3499 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3503 bfd_put_32 (data
->abfd
,
3504 SetHighBit (data
->next_table
- data
->datastart
),
3506 rsrc_write_directory (data
, entry
->value
.directory
);
3510 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3511 rsrc_write_leaf (data
, entry
->value
.leaf
);
3516 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3518 struct rsrc_entry
* entry
;
3523 sizeof_tables_and_entries
+= 16;
3525 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3527 sizeof_tables_and_entries
+= 8;
3529 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3532 rsrc_compute_region_sizes (entry
->value
.directory
);
3534 sizeof_leaves
+= 16;
3537 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3539 sizeof_tables_and_entries
+= 8;
3542 rsrc_compute_region_sizes (entry
->value
.directory
);
3544 sizeof_leaves
+= 16;
3549 rsrc_write_directory (rsrc_write_data
* data
,
3550 rsrc_directory
* dir
)
3554 bfd_byte
* next_entry
;
3557 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3558 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3559 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3560 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3561 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3562 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3564 /* Compute where the entries and the next table will be placed. */
3565 next_entry
= data
->next_table
+ 16;
3566 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3567 + (dir
->ids
.num_entries
* 8);
3568 nt
= data
->next_table
;
3570 /* Write the entries. */
3571 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3572 i
> 0 && entry
!= NULL
;
3573 i
--, entry
= entry
->next_entry
)
3575 BFD_ASSERT (entry
->is_name
);
3576 rsrc_write_entry (data
, next_entry
, entry
);
3579 BFD_ASSERT (i
== 0);
3580 BFD_ASSERT (entry
== NULL
);
3582 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3583 i
> 0 && entry
!= NULL
;
3584 i
--, entry
= entry
->next_entry
)
3586 BFD_ASSERT (! entry
->is_name
);
3587 rsrc_write_entry (data
, next_entry
, entry
);
3590 BFD_ASSERT (i
== 0);
3591 BFD_ASSERT (entry
== NULL
);
3592 BFD_ASSERT (nt
== next_entry
);
3595 #if ! defined __CYGWIN__ && ! defined __MINGW32__
3596 /* Return the length (number of units) of the first character in S,
3597 putting its 'ucs4_t' representation in *PUC. */
3600 u16_mbtouc (wint_t * puc
, const unsigned short * s
, unsigned int n
)
3602 unsigned short c
= * s
;
3604 if (c
< 0xd800 || c
>= 0xe000)
3614 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3616 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3622 /* Incomplete multibyte character. */
3628 /* Invalid multibyte character. */
3632 #endif /* not Cygwin/Mingw */
3634 /* Perform a comparison of two entries. */
3636 rsrc_cmp (bool is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3645 return a
->name_id
.id
- b
->name_id
.id
;
3647 /* We have to perform a case insenstive, unicode string comparison... */
3648 astring
= a
->name_id
.name
.string
;
3649 alen
= a
->name_id
.name
.len
;
3650 bstring
= b
->name_id
.name
.string
;
3651 blen
= b
->name_id
.name
.len
;
3653 #if defined __CYGWIN__ || defined __MINGW32__
3654 /* Under Windows hosts (both Cygwin and Mingw types),
3655 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3656 function however goes by different names in the two environments... */
3660 #define rscpcmp wcsncasecmp
3663 #define rscpcmp wcsnicmp
3666 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3674 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3679 /* Convert UTF-16 unicode characters into wchar_t characters
3680 so that we can then perform a case insensitive comparison. */
3681 unsigned int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3682 unsigned int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3687 awc
= towlower (awc
);
3688 bwc
= towlower (bwc
);
3704 rsrc_print_name (char * buffer
, rsrc_string string
)
3707 bfd_byte
* name
= string
.string
;
3709 for (i
= string
.len
; i
--; name
+= 2)
3710 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3714 rsrc_resource_name (rsrc_entry
*entry
, rsrc_directory
*dir
, char *buffer
)
3716 bool is_string
= false;
3720 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3721 && dir
->entry
->parent
->entry
!= NULL
)
3723 strcpy (buffer
, "type: ");
3724 if (dir
->entry
->parent
->entry
->is_name
)
3725 rsrc_print_name (buffer
+ strlen (buffer
),
3726 dir
->entry
->parent
->entry
->name_id
.name
);
3729 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3731 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3734 case 1: strcat (buffer
, " (CURSOR)"); break;
3735 case 2: strcat (buffer
, " (BITMAP)"); break;
3736 case 3: strcat (buffer
, " (ICON)"); break;
3737 case 4: strcat (buffer
, " (MENU)"); break;
3738 case 5: strcat (buffer
, " (DIALOG)"); break;
3739 case 6: strcat (buffer
, " (STRING)"); is_string
= true; break;
3740 case 7: strcat (buffer
, " (FONTDIR)"); break;
3741 case 8: strcat (buffer
, " (FONT)"); break;
3742 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3743 case 10: strcat (buffer
, " (RCDATA)"); break;
3744 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3745 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3746 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3747 case 16: strcat (buffer
, " (VERSION)"); break;
3748 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3749 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3750 case 20: strcat (buffer
, " (VXD)"); break;
3751 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3752 case 22: strcat (buffer
, " (ANIICON)"); break;
3753 case 23: strcat (buffer
, " (HTML)"); break;
3754 case 24: strcat (buffer
, " (MANIFEST)"); break;
3755 case 240: strcat (buffer
, " (DLGINIT)"); break;
3756 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3761 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3763 strcat (buffer
, " name: ");
3764 if (dir
->entry
->is_name
)
3765 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3768 unsigned int id
= dir
->entry
->name_id
.id
;
3770 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3773 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3774 (id
- 1) << 4, (id
<< 4) - 1);
3780 strcat (buffer
, " lang: ");
3783 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3785 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3791 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3792 their ID is stored in the NAME entry. The bottom four bits are used as
3793 an index into unicode string table that makes up the data of the leaf.
3794 So identical type-name-lang string resources may not actually be
3797 This function is called when we have detected two string resources with
3798 match top-28-bit IDs. We have to scan the string tables inside the leaves
3799 and discover if there are any real collisions. If there are then we report
3800 them and return FALSE. Otherwise we copy any strings from B into A and
3801 then return TRUE. */
3804 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3805 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3807 unsigned int copy_needed
= 0;
3811 bfd_byte
* new_data
;
3814 /* Step one: Find out what we have to do. */
3815 BFD_ASSERT (! a
->is_dir
);
3816 astring
= a
->value
.leaf
->data
;
3818 BFD_ASSERT (! b
->is_dir
);
3819 bstring
= b
->value
.leaf
->data
;
3821 for (i
= 0; i
< 16; i
++)
3823 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3824 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3828 copy_needed
+= blen
* 2;
3832 else if (alen
!= blen
)
3833 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3835 /* alen == blen != 0. We might have two identical strings. If so we
3836 can ignore the second one. There is no need for wchar_t vs UTF-16
3837 theatrics here - we are only interested in (case sensitive) equality. */
3838 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3841 astring
+= (alen
+ 1) * 2;
3842 bstring
+= (blen
+ 1) * 2;
3847 if (a
->parent
!= NULL
3848 && a
->parent
->entry
!= NULL
3849 && !a
->parent
->entry
->is_name
)
3850 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3851 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3855 if (copy_needed
== 0)
3858 /* If we reach here then A and B must both have non-colliding strings.
3859 (We never get string resources with fully empty string tables).
3860 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3862 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3863 if (new_data
== NULL
)
3867 astring
= a
->value
.leaf
->data
;
3868 bstring
= b
->value
.leaf
->data
;
3870 for (i
= 0; i
< 16; i
++)
3872 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3873 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3877 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3878 nstring
+= (alen
+ 1) * 2;
3882 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3883 nstring
+= (blen
+ 1) * 2;
3891 astring
+= (alen
+ 1) * 2;
3892 bstring
+= (blen
+ 1) * 2;
3895 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3897 free (a
->value
.leaf
->data
);
3898 a
->value
.leaf
->data
= new_data
;
3899 a
->value
.leaf
->size
+= copy_needed
;
3904 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3906 /* Sort the entries in given part of the directory.
3907 We use an old fashioned bubble sort because we are dealing
3908 with lists and we want to handle matches specially. */
3911 rsrc_sort_entries (rsrc_dir_chain
*chain
,
3913 rsrc_directory
*dir
)
3917 rsrc_entry
** points_to_entry
;
3920 if (chain
->num_entries
< 2)
3926 points_to_entry
= & chain
->first_entry
;
3927 entry
= * points_to_entry
;
3928 next
= entry
->next_entry
;
3932 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3936 entry
->next_entry
= next
->next_entry
;
3937 next
->next_entry
= entry
;
3938 * points_to_entry
= next
;
3939 points_to_entry
= & next
->next_entry
;
3940 next
= entry
->next_entry
;
3945 if (entry
->is_dir
&& next
->is_dir
)
3947 /* When we encounter identical directory entries we have to
3948 merge them together. The exception to this rule is for
3949 resource manifests - there can only be one of these,
3950 even if they differ in language. Zero-language manifests
3951 are assumed to be default manifests (provided by the
3952 Cygwin/MinGW build system) and these can be silently dropped,
3953 unless that would reduce the number of manifests to zero.
3954 There should only ever be one non-zero lang manifest -
3955 if there are more it is an error. A non-zero lang
3956 manifest takes precedence over a default manifest. */
3958 && entry
->name_id
.id
== 1
3960 && dir
->entry
!= NULL
3961 && !dir
->entry
->is_name
3962 && dir
->entry
->name_id
.id
== 0x18)
3964 if (next
->value
.directory
->names
.num_entries
== 0
3965 && next
->value
.directory
->ids
.num_entries
== 1
3966 && !next
->value
.directory
->ids
.first_entry
->is_name
3967 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3968 /* Fall through so that NEXT is dropped. */
3970 else if (entry
->value
.directory
->names
.num_entries
== 0
3971 && entry
->value
.directory
->ids
.num_entries
== 1
3972 && !entry
->value
.directory
->ids
.first_entry
->is_name
3973 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3975 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3976 entry
->next_entry
= next
->next_entry
;
3977 next
->next_entry
= entry
;
3978 * points_to_entry
= next
;
3979 points_to_entry
= & next
->next_entry
;
3980 next
= entry
->next_entry
;
3985 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3986 bfd_set_error (bfd_error_file_truncated
);
3990 /* Unhook NEXT from the chain. */
3991 /* FIXME: memory loss here. */
3992 entry
->next_entry
= next
->next_entry
;
3993 chain
->num_entries
--;
3994 if (chain
->num_entries
< 2)
3996 next
= next
->next_entry
;
3999 rsrc_merge (entry
, next
);
4001 else if (entry
->is_dir
!= next
->is_dir
)
4003 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
4004 bfd_set_error (bfd_error_file_truncated
);
4009 /* Otherwise with identical leaves we issue an error
4010 message - because there should never be duplicates.
4011 The exception is Type 18/Name 1/Lang 0 which is the
4012 defaul manifest - this can just be dropped. */
4014 && entry
->name_id
.id
== 0
4016 && dir
->entry
!= NULL
4017 && !dir
->entry
->is_name
4018 && dir
->entry
->name_id
.id
== 1
4019 && dir
->entry
->parent
!= NULL
4020 && dir
->entry
->parent
->entry
!= NULL
4021 && !dir
->entry
->parent
->entry
->is_name
4022 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
4024 else if (dir
!= NULL
4025 && dir
->entry
!= NULL
4026 && dir
->entry
->parent
!= NULL
4027 && dir
->entry
->parent
->entry
!= NULL
4028 && !dir
->entry
->parent
->entry
->is_name
4029 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
4031 /* Strings need special handling. */
4032 if (! rsrc_merge_string_entries (entry
, next
))
4034 /* _bfd_error_handler should have been called inside merge_strings. */
4035 bfd_set_error (bfd_error_file_truncated
);
4042 || dir
->entry
== NULL
4043 || dir
->entry
->parent
== NULL
4044 || dir
->entry
->parent
->entry
== NULL
)
4045 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4050 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4051 rsrc_resource_name (entry
, dir
, buff
));
4053 bfd_set_error (bfd_error_file_truncated
);
4058 /* Unhook NEXT from the chain. */
4059 entry
->next_entry
= next
->next_entry
;
4060 chain
->num_entries
--;
4061 if (chain
->num_entries
< 2)
4063 next
= next
->next_entry
;
4067 points_to_entry
= & entry
->next_entry
;
4069 next
= next
->next_entry
;
4074 chain
->last_entry
= entry
;
4079 /* Attach B's chain onto A. */
4081 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
4083 if (bchain
->num_entries
== 0)
4086 achain
->num_entries
+= bchain
->num_entries
;
4088 if (achain
->first_entry
== NULL
)
4090 achain
->first_entry
= bchain
->first_entry
;
4091 achain
->last_entry
= bchain
->last_entry
;
4095 achain
->last_entry
->next_entry
= bchain
->first_entry
;
4096 achain
->last_entry
= bchain
->last_entry
;
4099 bchain
->num_entries
= 0;
4100 bchain
->first_entry
= bchain
->last_entry
= NULL
;
4104 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
4106 rsrc_directory
* adir
;
4107 rsrc_directory
* bdir
;
4109 BFD_ASSERT (a
->is_dir
);
4110 BFD_ASSERT (b
->is_dir
);
4112 adir
= a
->value
.directory
;
4113 bdir
= b
->value
.directory
;
4115 if (adir
->characteristics
!= bdir
->characteristics
)
4117 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4118 bfd_set_error (bfd_error_file_truncated
);
4122 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
4124 _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4125 bfd_set_error (bfd_error_file_truncated
);
4129 /* Attach B's name chain to A. */
4130 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
4132 /* Attach B's ID chain to A. */
4133 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
4135 /* Now sort A's entries. */
4136 rsrc_sort_entries (& adir
->names
, true, adir
);
4137 rsrc_sort_entries (& adir
->ids
, false, adir
);
4140 /* Check the .rsrc section. If it contains multiple concatenated
4141 resources then we must merge them properly. Otherwise Windows
4142 will ignore all but the first set. */
4145 rsrc_process_section (bfd
* abfd
,
4146 struct coff_final_link_info
* pfinfo
)
4148 rsrc_directory new_table
;
4154 bfd_byte
* datastart
;
4156 bfd_byte
* new_data
;
4157 unsigned int num_resource_sets
;
4158 rsrc_directory
* type_tables
;
4159 rsrc_write_data write_data
;
4162 unsigned int num_input_rsrc
= 0;
4163 unsigned int max_num_input_rsrc
= 4;
4164 ptrdiff_t * rsrc_sizes
= NULL
;
4166 new_table
.names
.num_entries
= 0;
4167 new_table
.ids
.num_entries
= 0;
4169 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4170 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4173 pe
= pe_data (abfd
);
4177 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4179 data
= bfd_malloc (size
);
4185 if (! bfd_get_section_contents (abfd
, sec
, data
, 0, size
))
4188 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4189 their lengths. Note - we rely upon the fact that the linker script
4190 does *not* sort the input .rsrc sections, so that the order in the
4191 linkinfo list matches the order in the output .rsrc section.
4193 We need to know the lengths because each input .rsrc section has padding
4194 at the end of a variable amount. (It does not appear to be based upon
4195 the section alignment or the file alignment). We need to skip any
4196 padding bytes when parsing the input .rsrc sections. */
4197 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof * rsrc_sizes
);
4198 if (rsrc_sizes
== NULL
)
4201 for (input
= pfinfo
->info
->input_bfds
;
4203 input
= input
->link
.next
)
4205 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4207 /* PR 18372 - skip discarded .rsrc sections. */
4208 if (rsrc_sec
!= NULL
&& !discarded_section (rsrc_sec
))
4210 if (num_input_rsrc
== max_num_input_rsrc
)
4212 max_num_input_rsrc
+= 10;
4213 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4214 * sizeof * rsrc_sizes
);
4215 if (rsrc_sizes
== NULL
)
4219 BFD_ASSERT (rsrc_sec
->size
> 0);
4220 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4224 if (num_input_rsrc
< 2)
4227 /* Step one: Walk the section, computing the size of the tables,
4228 leaves and data and decide if we need to do anything. */
4229 dataend
= data
+ size
;
4230 num_resource_sets
= 0;
4232 while (data
< dataend
)
4234 bfd_byte
* p
= data
;
4236 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4240 /* Corrupted .rsrc section - cannot merge. */
4241 _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4243 bfd_set_error (bfd_error_file_truncated
);
4247 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4249 _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4251 bfd_set_error (bfd_error_file_truncated
);
4254 /* FIXME: Should we add a check for "data - p" being much smaller
4255 than rsrc_sizes[num_resource_sets] ? */
4257 data
= p
+ rsrc_sizes
[num_resource_sets
];
4258 rva_bias
+= data
- p
;
4259 ++ num_resource_sets
;
4261 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4263 /* Step two: Walk the data again, building trees of the resources. */
4265 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4267 type_tables
= bfd_malloc (num_resource_sets
* sizeof * type_tables
);
4268 if (type_tables
== NULL
)
4272 while (data
< dataend
)
4274 bfd_byte
* p
= data
;
4276 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4277 dataend
, rva_bias
, NULL
);
4278 data
= p
+ rsrc_sizes
[indx
];
4279 rva_bias
+= data
- p
;
4282 BFD_ASSERT (indx
== num_resource_sets
);
4284 /* Step three: Merge the top level tables (there can be only one).
4286 We must ensure that the merged entries are in ascending order.
4288 We also thread the top level table entries from the old tree onto
4289 the new table, so that they can be pulled off later. */
4291 /* FIXME: Should we verify that all type tables are the same ? */
4292 new_table
.characteristics
= type_tables
[0].characteristics
;
4293 new_table
.time
= type_tables
[0].time
;
4294 new_table
.major
= type_tables
[0].major
;
4295 new_table
.minor
= type_tables
[0].minor
;
4297 /* Chain the NAME entries onto the table. */
4298 new_table
.names
.first_entry
= NULL
;
4299 new_table
.names
.last_entry
= NULL
;
4301 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4302 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4304 rsrc_sort_entries (& new_table
.names
, true, & new_table
);
4306 /* Chain the ID entries onto the table. */
4307 new_table
.ids
.first_entry
= NULL
;
4308 new_table
.ids
.last_entry
= NULL
;
4310 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4311 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4313 rsrc_sort_entries (& new_table
.ids
, false, & new_table
);
4315 /* Step four: Create new contents for the .rsrc section. */
4316 /* Step four point one: Compute the size of each region of the .rsrc section.
4317 We do this now, rather than earlier, as the merging above may have dropped
4319 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4320 rsrc_compute_region_sizes (& new_table
);
4321 /* We increment sizeof_strings to make sure that resource data
4322 starts on an 8-byte boundary. FIXME: Is this correct ? */
4323 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4325 new_data
= bfd_zalloc (abfd
, size
);
4326 if (new_data
== NULL
)
4329 write_data
.abfd
= abfd
;
4330 write_data
.datastart
= new_data
;
4331 write_data
.next_table
= new_data
;
4332 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4333 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4334 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4335 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4337 rsrc_write_directory (& write_data
, & new_table
);
4339 /* Step five: Replace the old contents with the new.
4340 We don't recompute the size as it's too late here to shrink section.
4341 See PR ld/20193 for more details. */
4342 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4343 sec
->size
= sec
->rawsize
= size
;
4346 /* Step six: Free all the memory that we have used. */
4347 /* FIXME: Free the resource tree, if we have one. */
4352 /* Handle the .idata section and other things that need symbol table
4356 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4358 struct coff_link_hash_entry
*h1
;
4359 struct bfd_link_info
*info
= pfinfo
->info
;
4362 /* There are a few fields that need to be filled in now while we
4363 have symbol table access.
4365 The .idata subsections aren't directly available as sections, but
4366 they are in the symbol table, so get them from there. */
4368 /* The import directory. This is the address of .idata$2, with size
4369 of .idata$2 + .idata$3. */
4370 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4371 ".idata$2", false, false, true);
4374 /* PR ld/2729: We cannot rely upon all the output sections having been
4375 created properly, so check before referencing them. Issue a warning
4376 message for any sections tht could not be found. */
4377 if ((h1
->root
.type
== bfd_link_hash_defined
4378 || h1
->root
.type
== bfd_link_hash_defweak
)
4379 && h1
->root
.u
.def
.section
!= NULL
4380 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4381 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4382 (h1
->root
.u
.def
.value
4383 + h1
->root
.u
.def
.section
->output_section
->vma
4384 + h1
->root
.u
.def
.section
->output_offset
);
4388 (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4393 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4394 ".idata$4", false, false, true);
4396 && (h1
->root
.type
== bfd_link_hash_defined
4397 || h1
->root
.type
== bfd_link_hash_defweak
)
4398 && h1
->root
.u
.def
.section
!= NULL
4399 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4400 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_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
)
4404 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4408 (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4413 /* The import address table. This is the size/address of
4415 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4416 ".idata$5", false, false, true);
4418 && (h1
->root
.type
== bfd_link_hash_defined
4419 || h1
->root
.type
== bfd_link_hash_defweak
)
4420 && h1
->root
.u
.def
.section
!= NULL
4421 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4422 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4423 (h1
->root
.u
.def
.value
4424 + h1
->root
.u
.def
.section
->output_section
->vma
4425 + h1
->root
.u
.def
.section
->output_offset
);
4429 (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4434 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4435 ".idata$6", false, false, true);
4437 && (h1
->root
.type
== bfd_link_hash_defined
4438 || h1
->root
.type
== bfd_link_hash_defweak
)
4439 && h1
->root
.u
.def
.section
!= NULL
4440 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4441 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4442 ((h1
->root
.u
.def
.value
4443 + h1
->root
.u
.def
.section
->output_section
->vma
4444 + h1
->root
.u
.def
.section
->output_offset
)
4445 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4449 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4456 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4457 "__IAT_start__", false, false, true);
4459 && (h1
->root
.type
== bfd_link_hash_defined
4460 || h1
->root
.type
== bfd_link_hash_defweak
)
4461 && h1
->root
.u
.def
.section
!= NULL
4462 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4467 (h1
->root
.u
.def
.value
4468 + h1
->root
.u
.def
.section
->output_section
->vma
4469 + h1
->root
.u
.def
.section
->output_offset
);
4471 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4472 "__IAT_end__", false, false, true);
4474 && (h1
->root
.type
== bfd_link_hash_defined
4475 || h1
->root
.type
== bfd_link_hash_defweak
)
4476 && h1
->root
.u
.def
.section
!= NULL
4477 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4479 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4480 ((h1
->root
.u
.def
.value
4481 + h1
->root
.u
.def
.section
->output_section
->vma
4482 + h1
->root
.u
.def
.section
->output_offset
)
4484 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4485 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4486 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4491 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4492 " because .idata$6 is missing"), abfd
);
4498 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4499 (bfd_get_symbol_leading_char (abfd
) != 0
4500 ? "__tls_used" : "_tls_used"),
4501 false, false, true);
4504 if ((h1
->root
.type
== bfd_link_hash_defined
4505 || h1
->root
.type
== bfd_link_hash_defweak
)
4506 && h1
->root
.u
.def
.section
!= NULL
4507 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4508 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4509 (h1
->root
.u
.def
.value
4510 + h1
->root
.u
.def
.section
->output_section
->vma
4511 + h1
->root
.u
.def
.section
->output_offset
4512 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4516 (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4520 /* According to PECOFF sepcifications by Microsoft version 8.2
4521 the TLS data directory consists of 4 pointers, followed
4522 by two 4-byte integer. This implies that the total size
4523 is different for 32-bit and 64-bit executables. */
4524 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64)
4525 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4527 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4531 /* If there is a .pdata section and we have linked pdata finally, we
4532 need to sort the entries ascending. */
4533 #if !defined(COFF_WITH_pep) && (defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64))
4535 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4539 bfd_size_type x
= sec
->rawsize
;
4540 bfd_byte
*tmp_data
= NULL
;
4543 tmp_data
= bfd_malloc (x
);
4545 if (tmp_data
!= NULL
)
4547 if (bfd_get_section_contents (abfd
, sec
, tmp_data
, 0, x
))
4551 12, sort_x64_pdata
);
4552 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4563 rsrc_process_section (abfd
, pfinfo
);
4565 /* If we couldn't find idata$2, we either have an excessively
4566 trivial program or are in DEEP trouble; we have to assume trivial