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 bfd_vma dataoff
= addr
- section
->vma
;
2990 /* PR 17512: file: 0f15796a. */
2992 && (addr
< section
->vma
2993 || section
->size
< dataoff
2994 || section
->size
- dataoff
< size
))
2996 /* xgettext:c-format */
2998 (_("%pB: Data Directory (%lx bytes at %" PRIx64
") "
2999 "extends across section boundary at %" PRIx64
),
3000 obfd
, ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
,
3001 (uint64_t) addr
, (uint64_t) section
->vma
);
3005 if (section
&& bfd_malloc_and_get_section (obfd
, section
, &data
))
3008 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
3009 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ dataoff
);
3011 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
3012 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
3014 asection
*ddsection
;
3015 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
3016 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
3018 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
3020 if (idd
.AddressOfRawData
== 0)
3021 continue; /* RVA 0 means only offset is valid, not handled yet. */
3023 ddsection
= find_section_by_vma (obfd
, idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
);
3025 continue; /* Not in a section! */
3027 idd
.PointerToRawData
= ddsection
->filepos
+ (idd
.AddressOfRawData
3028 + ope
->pe_opthdr
.ImageBase
) - ddsection
->vma
;
3030 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
3033 if (!bfd_set_section_contents (obfd
, section
, data
, 0, section
->size
))
3035 _bfd_error_handler (_("failed to update file offsets in debug directory"));
3043 _bfd_error_handler (_("%pB: failed to read debug data section"), obfd
);
3051 /* Copy private section data. */
3054 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
3059 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
3060 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
3063 if (coff_section_data (ibfd
, isec
) != NULL
3064 && pei_section_data (ibfd
, isec
) != NULL
)
3066 if (coff_section_data (obfd
, osec
) == NULL
)
3068 size_t amt
= sizeof (struct coff_section_tdata
);
3069 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
3070 if (osec
->used_by_bfd
== NULL
)
3074 if (pei_section_data (obfd
, osec
) == NULL
)
3076 size_t amt
= sizeof (struct pei_section_tdata
);
3077 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
3078 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
3082 pei_section_data (obfd
, osec
)->virt_size
=
3083 pei_section_data (ibfd
, isec
)->virt_size
;
3084 pei_section_data (obfd
, osec
)->pe_flags
=
3085 pei_section_data (ibfd
, isec
)->pe_flags
;
3092 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
3094 coff_get_symbol_info (abfd
, symbol
, ret
);
3097 #if !defined(COFF_WITH_pep) && (defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64))
3099 sort_x64_pdata (const void *l
, const void *r
)
3101 const char *lp
= (const char *) l
;
3102 const char *rp
= (const char *) r
;
3104 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
3106 return (vl
< vr
? -1 : 1);
3107 /* We compare just begin address. */
3112 /* Functions to process a .rsrc section. */
3114 static unsigned int sizeof_leaves
;
3115 static unsigned int sizeof_strings
;
3116 static unsigned int sizeof_tables_and_entries
;
3119 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3122 rsrc_count_entries (bfd
*abfd
,
3124 bfd_byte
*datastart
,
3129 unsigned long entry
, addr
, size
;
3131 if (data
+ 8 >= dataend
)
3138 entry
= (long) bfd_get_32 (abfd
, data
);
3140 if (HighBitSet (entry
))
3141 name
= datastart
+ WithoutHighBit (entry
);
3143 name
= datastart
+ entry
- rva_bias
;
3145 if (name
+ 2 >= dataend
|| name
< datastart
)
3148 unsigned int len
= bfd_get_16 (abfd
, name
);
3149 if (len
== 0 || len
> 256)
3153 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3155 if (HighBitSet (entry
))
3157 data
= datastart
+ WithoutHighBit (entry
);
3159 if (data
<= datastart
|| data
>= dataend
)
3162 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3165 if (datastart
+ entry
+ 16 >= dataend
)
3168 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3169 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3171 return datastart
+ addr
- rva_bias
+ size
;
3175 rsrc_count_directory (bfd
* abfd
,
3176 bfd_byte
* datastart
,
3181 unsigned int num_entries
, num_ids
;
3182 bfd_byte
* highest_data
= data
;
3184 if (data
+ 16 >= dataend
)
3187 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3188 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3190 num_entries
+= num_ids
;
3194 while (num_entries
--)
3196 bfd_byte
* entry_end
;
3198 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3199 datastart
, data
, dataend
, rva_bias
);
3201 highest_data
= max (highest_data
, entry_end
);
3202 if (entry_end
>= dataend
)
3206 return max (highest_data
, data
);
3209 typedef struct rsrc_dir_chain
3211 unsigned int num_entries
;
3212 struct rsrc_entry
* first_entry
;
3213 struct rsrc_entry
* last_entry
;
3216 typedef struct rsrc_directory
3218 unsigned int characteristics
;
3223 rsrc_dir_chain names
;
3226 struct rsrc_entry
* entry
;
3229 typedef struct rsrc_string
3235 typedef struct rsrc_leaf
3238 unsigned int codepage
;
3242 typedef struct rsrc_entry
3248 struct rsrc_string name
;
3254 struct rsrc_directory
* directory
;
3255 struct rsrc_leaf
* leaf
;
3258 struct rsrc_entry
* next_entry
;
3259 struct rsrc_directory
* parent
;
3263 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3264 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3267 rsrc_parse_entry (bfd
*abfd
,
3270 bfd_byte
*datastart
,
3274 rsrc_directory
*parent
)
3276 unsigned long val
, addr
, size
;
3278 val
= bfd_get_32 (abfd
, data
);
3280 entry
->parent
= parent
;
3281 entry
->is_name
= is_name
;
3287 if (HighBitSet (val
))
3289 val
= WithoutHighBit (val
);
3291 address
= datastart
+ val
;
3295 address
= datastart
+ val
- rva_bias
;
3298 if (address
+ 3 > dataend
)
3301 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3302 entry
->name_id
.name
.string
= address
+ 2;
3305 entry
->name_id
.id
= val
;
3307 val
= bfd_get_32 (abfd
, data
+ 4);
3309 if (HighBitSet (val
))
3311 entry
->is_dir
= true;
3312 entry
->value
.directory
= bfd_malloc (sizeof * entry
->value
.directory
);
3313 if (entry
->value
.directory
== NULL
)
3316 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3318 datastart
+ WithoutHighBit (val
),
3319 dataend
, rva_bias
, entry
);
3322 entry
->is_dir
= false;
3323 entry
->value
.leaf
= bfd_malloc (sizeof * entry
->value
.leaf
);
3324 if (entry
->value
.leaf
== NULL
)
3327 data
= datastart
+ val
;
3328 if (data
< datastart
|| data
>= dataend
)
3331 addr
= bfd_get_32 (abfd
, data
);
3332 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, data
+ 4);
3333 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, data
+ 8);
3334 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3336 entry
->value
.leaf
->data
= bfd_malloc (size
);
3337 if (entry
->value
.leaf
->data
== NULL
)
3340 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3341 return datastart
+ (addr
- rva_bias
) + size
;
3345 rsrc_parse_entries (bfd
*abfd
,
3346 rsrc_dir_chain
*chain
,
3348 bfd_byte
*highest_data
,
3349 bfd_byte
*datastart
,
3353 rsrc_directory
*parent
)
3358 if (chain
->num_entries
== 0)
3360 chain
->first_entry
= chain
->last_entry
= NULL
;
3361 return highest_data
;
3364 entry
= bfd_malloc (sizeof * entry
);
3368 chain
->first_entry
= entry
;
3370 for (i
= chain
->num_entries
; i
--;)
3372 bfd_byte
* entry_end
;
3374 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3375 data
, dataend
, rva_bias
, parent
);
3377 highest_data
= max (entry_end
, highest_data
);
3378 if (entry_end
> dataend
)
3383 entry
->next_entry
= bfd_malloc (sizeof * entry
);
3384 entry
= entry
->next_entry
;
3389 entry
->next_entry
= NULL
;
3392 chain
->last_entry
= entry
;
3394 return highest_data
;
3398 rsrc_parse_directory (bfd
* abfd
,
3399 rsrc_directory
* table
,
3400 bfd_byte
* datastart
,
3406 bfd_byte
* highest_data
= data
;
3411 table
->characteristics
= bfd_get_32 (abfd
, data
);
3412 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3413 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3414 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3415 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3416 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3417 table
->entry
= entry
;
3421 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, true, data
,
3422 datastart
, data
, dataend
, rva_bias
, table
);
3423 data
+= table
->names
.num_entries
* 8;
3425 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, false, highest_data
,
3426 datastart
, data
, dataend
, rva_bias
, table
);
3427 data
+= table
->ids
.num_entries
* 8;
3429 return max (highest_data
, data
);
3432 typedef struct rsrc_write_data
3435 bfd_byte
* datastart
;
3436 bfd_byte
* next_table
;
3437 bfd_byte
* next_leaf
;
3438 bfd_byte
* next_string
;
3439 bfd_byte
* next_data
;
3444 rsrc_write_string (rsrc_write_data
* data
,
3445 rsrc_string
* string
)
3447 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3448 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3449 data
->next_string
+= (string
->len
+ 1) * 2;
3452 static inline unsigned int
3453 rsrc_compute_rva (rsrc_write_data
* data
,
3456 return (addr
- data
->datastart
) + data
->rva_bias
;
3460 rsrc_write_leaf (rsrc_write_data
* data
,
3463 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3465 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3466 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3467 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3468 data
->next_leaf
+= 16;
3470 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3471 /* An undocumented feature of Windows resources is that each unit
3472 of raw data is 8-byte aligned... */
3473 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3476 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3479 rsrc_write_entry (rsrc_write_data
* data
,
3485 bfd_put_32 (data
->abfd
,
3486 SetHighBit (data
->next_string
- data
->datastart
),
3488 rsrc_write_string (data
, & entry
->name_id
.name
);
3491 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3495 bfd_put_32 (data
->abfd
,
3496 SetHighBit (data
->next_table
- data
->datastart
),
3498 rsrc_write_directory (data
, entry
->value
.directory
);
3502 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3503 rsrc_write_leaf (data
, entry
->value
.leaf
);
3508 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3510 struct rsrc_entry
* entry
;
3515 sizeof_tables_and_entries
+= 16;
3517 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3519 sizeof_tables_and_entries
+= 8;
3521 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3524 rsrc_compute_region_sizes (entry
->value
.directory
);
3526 sizeof_leaves
+= 16;
3529 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3531 sizeof_tables_and_entries
+= 8;
3534 rsrc_compute_region_sizes (entry
->value
.directory
);
3536 sizeof_leaves
+= 16;
3541 rsrc_write_directory (rsrc_write_data
* data
,
3542 rsrc_directory
* dir
)
3546 bfd_byte
* next_entry
;
3549 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3550 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3551 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3552 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3553 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3554 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3556 /* Compute where the entries and the next table will be placed. */
3557 next_entry
= data
->next_table
+ 16;
3558 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3559 + (dir
->ids
.num_entries
* 8);
3560 nt
= data
->next_table
;
3562 /* Write the entries. */
3563 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3564 i
> 0 && entry
!= NULL
;
3565 i
--, entry
= entry
->next_entry
)
3567 BFD_ASSERT (entry
->is_name
);
3568 rsrc_write_entry (data
, next_entry
, entry
);
3571 BFD_ASSERT (i
== 0);
3572 BFD_ASSERT (entry
== NULL
);
3574 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3575 i
> 0 && entry
!= NULL
;
3576 i
--, entry
= entry
->next_entry
)
3578 BFD_ASSERT (! entry
->is_name
);
3579 rsrc_write_entry (data
, next_entry
, entry
);
3582 BFD_ASSERT (i
== 0);
3583 BFD_ASSERT (entry
== NULL
);
3584 BFD_ASSERT (nt
== next_entry
);
3587 #if ! defined __CYGWIN__ && ! defined __MINGW32__
3588 /* Return the length (number of units) of the first character in S,
3589 putting its 'ucs4_t' representation in *PUC. */
3592 u16_mbtouc (wint_t * puc
, const unsigned short * s
, unsigned int n
)
3594 unsigned short c
= * s
;
3596 if (c
< 0xd800 || c
>= 0xe000)
3606 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3608 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3614 /* Incomplete multibyte character. */
3620 /* Invalid multibyte character. */
3624 #endif /* not Cygwin/Mingw */
3626 /* Perform a comparison of two entries. */
3628 rsrc_cmp (bool is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3637 return a
->name_id
.id
- b
->name_id
.id
;
3639 /* We have to perform a case insenstive, unicode string comparison... */
3640 astring
= a
->name_id
.name
.string
;
3641 alen
= a
->name_id
.name
.len
;
3642 bstring
= b
->name_id
.name
.string
;
3643 blen
= b
->name_id
.name
.len
;
3645 #if defined __CYGWIN__ || defined __MINGW32__
3646 /* Under Windows hosts (both Cygwin and Mingw types),
3647 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3648 function however goes by different names in the two environments... */
3652 #define rscpcmp wcsncasecmp
3655 #define rscpcmp wcsnicmp
3658 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3666 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3671 /* Convert UTF-16 unicode characters into wchar_t characters
3672 so that we can then perform a case insensitive comparison. */
3673 unsigned int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3674 unsigned int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3679 awc
= towlower (awc
);
3680 bwc
= towlower (bwc
);
3696 rsrc_print_name (char * buffer
, rsrc_string string
)
3699 bfd_byte
* name
= string
.string
;
3701 for (i
= string
.len
; i
--; name
+= 2)
3702 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3706 rsrc_resource_name (rsrc_entry
*entry
, rsrc_directory
*dir
, char *buffer
)
3708 bool is_string
= false;
3712 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3713 && dir
->entry
->parent
->entry
!= NULL
)
3715 strcpy (buffer
, "type: ");
3716 if (dir
->entry
->parent
->entry
->is_name
)
3717 rsrc_print_name (buffer
+ strlen (buffer
),
3718 dir
->entry
->parent
->entry
->name_id
.name
);
3721 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3723 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3726 case 1: strcat (buffer
, " (CURSOR)"); break;
3727 case 2: strcat (buffer
, " (BITMAP)"); break;
3728 case 3: strcat (buffer
, " (ICON)"); break;
3729 case 4: strcat (buffer
, " (MENU)"); break;
3730 case 5: strcat (buffer
, " (DIALOG)"); break;
3731 case 6: strcat (buffer
, " (STRING)"); is_string
= true; break;
3732 case 7: strcat (buffer
, " (FONTDIR)"); break;
3733 case 8: strcat (buffer
, " (FONT)"); break;
3734 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3735 case 10: strcat (buffer
, " (RCDATA)"); break;
3736 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3737 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3738 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3739 case 16: strcat (buffer
, " (VERSION)"); break;
3740 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3741 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3742 case 20: strcat (buffer
, " (VXD)"); break;
3743 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3744 case 22: strcat (buffer
, " (ANIICON)"); break;
3745 case 23: strcat (buffer
, " (HTML)"); break;
3746 case 24: strcat (buffer
, " (MANIFEST)"); break;
3747 case 240: strcat (buffer
, " (DLGINIT)"); break;
3748 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3753 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3755 strcat (buffer
, " name: ");
3756 if (dir
->entry
->is_name
)
3757 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3760 unsigned int id
= dir
->entry
->name_id
.id
;
3762 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3765 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3766 (id
- 1) << 4, (id
<< 4) - 1);
3772 strcat (buffer
, " lang: ");
3775 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3777 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3783 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3784 their ID is stored in the NAME entry. The bottom four bits are used as
3785 an index into unicode string table that makes up the data of the leaf.
3786 So identical type-name-lang string resources may not actually be
3789 This function is called when we have detected two string resources with
3790 match top-28-bit IDs. We have to scan the string tables inside the leaves
3791 and discover if there are any real collisions. If there are then we report
3792 them and return FALSE. Otherwise we copy any strings from B into A and
3793 then return TRUE. */
3796 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3797 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3799 unsigned int copy_needed
= 0;
3803 bfd_byte
* new_data
;
3806 /* Step one: Find out what we have to do. */
3807 BFD_ASSERT (! a
->is_dir
);
3808 astring
= a
->value
.leaf
->data
;
3810 BFD_ASSERT (! b
->is_dir
);
3811 bstring
= b
->value
.leaf
->data
;
3813 for (i
= 0; i
< 16; i
++)
3815 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3816 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3820 copy_needed
+= blen
* 2;
3824 else if (alen
!= blen
)
3825 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3827 /* alen == blen != 0. We might have two identical strings. If so we
3828 can ignore the second one. There is no need for wchar_t vs UTF-16
3829 theatrics here - we are only interested in (case sensitive) equality. */
3830 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3833 astring
+= (alen
+ 1) * 2;
3834 bstring
+= (blen
+ 1) * 2;
3839 if (a
->parent
!= NULL
3840 && a
->parent
->entry
!= NULL
3841 && !a
->parent
->entry
->is_name
)
3842 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3843 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3847 if (copy_needed
== 0)
3850 /* If we reach here then A and B must both have non-colliding strings.
3851 (We never get string resources with fully empty string tables).
3852 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3854 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3855 if (new_data
== NULL
)
3859 astring
= a
->value
.leaf
->data
;
3860 bstring
= b
->value
.leaf
->data
;
3862 for (i
= 0; i
< 16; i
++)
3864 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3865 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3869 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3870 nstring
+= (alen
+ 1) * 2;
3874 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3875 nstring
+= (blen
+ 1) * 2;
3883 astring
+= (alen
+ 1) * 2;
3884 bstring
+= (blen
+ 1) * 2;
3887 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3889 free (a
->value
.leaf
->data
);
3890 a
->value
.leaf
->data
= new_data
;
3891 a
->value
.leaf
->size
+= copy_needed
;
3896 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3898 /* Sort the entries in given part of the directory.
3899 We use an old fashioned bubble sort because we are dealing
3900 with lists and we want to handle matches specially. */
3903 rsrc_sort_entries (rsrc_dir_chain
*chain
,
3905 rsrc_directory
*dir
)
3909 rsrc_entry
** points_to_entry
;
3912 if (chain
->num_entries
< 2)
3918 points_to_entry
= & chain
->first_entry
;
3919 entry
= * points_to_entry
;
3920 next
= entry
->next_entry
;
3924 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3928 entry
->next_entry
= next
->next_entry
;
3929 next
->next_entry
= entry
;
3930 * points_to_entry
= next
;
3931 points_to_entry
= & next
->next_entry
;
3932 next
= entry
->next_entry
;
3937 if (entry
->is_dir
&& next
->is_dir
)
3939 /* When we encounter identical directory entries we have to
3940 merge them together. The exception to this rule is for
3941 resource manifests - there can only be one of these,
3942 even if they differ in language. Zero-language manifests
3943 are assumed to be default manifests (provided by the
3944 Cygwin/MinGW build system) and these can be silently dropped,
3945 unless that would reduce the number of manifests to zero.
3946 There should only ever be one non-zero lang manifest -
3947 if there are more it is an error. A non-zero lang
3948 manifest takes precedence over a default manifest. */
3950 && entry
->name_id
.id
== 1
3952 && dir
->entry
!= NULL
3953 && !dir
->entry
->is_name
3954 && dir
->entry
->name_id
.id
== 0x18)
3956 if (next
->value
.directory
->names
.num_entries
== 0
3957 && next
->value
.directory
->ids
.num_entries
== 1
3958 && !next
->value
.directory
->ids
.first_entry
->is_name
3959 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3960 /* Fall through so that NEXT is dropped. */
3962 else if (entry
->value
.directory
->names
.num_entries
== 0
3963 && entry
->value
.directory
->ids
.num_entries
== 1
3964 && !entry
->value
.directory
->ids
.first_entry
->is_name
3965 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3967 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3968 entry
->next_entry
= next
->next_entry
;
3969 next
->next_entry
= entry
;
3970 * points_to_entry
= next
;
3971 points_to_entry
= & next
->next_entry
;
3972 next
= entry
->next_entry
;
3977 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3978 bfd_set_error (bfd_error_file_truncated
);
3982 /* Unhook NEXT from the chain. */
3983 /* FIXME: memory loss here. */
3984 entry
->next_entry
= next
->next_entry
;
3985 chain
->num_entries
--;
3986 if (chain
->num_entries
< 2)
3988 next
= next
->next_entry
;
3991 rsrc_merge (entry
, next
);
3993 else if (entry
->is_dir
!= next
->is_dir
)
3995 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
3996 bfd_set_error (bfd_error_file_truncated
);
4001 /* Otherwise with identical leaves we issue an error
4002 message - because there should never be duplicates.
4003 The exception is Type 18/Name 1/Lang 0 which is the
4004 defaul manifest - this can just be dropped. */
4006 && entry
->name_id
.id
== 0
4008 && dir
->entry
!= NULL
4009 && !dir
->entry
->is_name
4010 && dir
->entry
->name_id
.id
== 1
4011 && dir
->entry
->parent
!= NULL
4012 && dir
->entry
->parent
->entry
!= NULL
4013 && !dir
->entry
->parent
->entry
->is_name
4014 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
4016 else if (dir
!= NULL
4017 && dir
->entry
!= NULL
4018 && dir
->entry
->parent
!= NULL
4019 && dir
->entry
->parent
->entry
!= NULL
4020 && !dir
->entry
->parent
->entry
->is_name
4021 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
4023 /* Strings need special handling. */
4024 if (! rsrc_merge_string_entries (entry
, next
))
4026 /* _bfd_error_handler should have been called inside merge_strings. */
4027 bfd_set_error (bfd_error_file_truncated
);
4034 || dir
->entry
== NULL
4035 || dir
->entry
->parent
== NULL
4036 || dir
->entry
->parent
->entry
== NULL
)
4037 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4042 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4043 rsrc_resource_name (entry
, dir
, buff
));
4045 bfd_set_error (bfd_error_file_truncated
);
4050 /* Unhook NEXT from the chain. */
4051 entry
->next_entry
= next
->next_entry
;
4052 chain
->num_entries
--;
4053 if (chain
->num_entries
< 2)
4055 next
= next
->next_entry
;
4059 points_to_entry
= & entry
->next_entry
;
4061 next
= next
->next_entry
;
4066 chain
->last_entry
= entry
;
4071 /* Attach B's chain onto A. */
4073 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
4075 if (bchain
->num_entries
== 0)
4078 achain
->num_entries
+= bchain
->num_entries
;
4080 if (achain
->first_entry
== NULL
)
4082 achain
->first_entry
= bchain
->first_entry
;
4083 achain
->last_entry
= bchain
->last_entry
;
4087 achain
->last_entry
->next_entry
= bchain
->first_entry
;
4088 achain
->last_entry
= bchain
->last_entry
;
4091 bchain
->num_entries
= 0;
4092 bchain
->first_entry
= bchain
->last_entry
= NULL
;
4096 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
4098 rsrc_directory
* adir
;
4099 rsrc_directory
* bdir
;
4101 BFD_ASSERT (a
->is_dir
);
4102 BFD_ASSERT (b
->is_dir
);
4104 adir
= a
->value
.directory
;
4105 bdir
= b
->value
.directory
;
4107 if (adir
->characteristics
!= bdir
->characteristics
)
4109 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4110 bfd_set_error (bfd_error_file_truncated
);
4114 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
4116 _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4117 bfd_set_error (bfd_error_file_truncated
);
4121 /* Attach B's name chain to A. */
4122 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
4124 /* Attach B's ID chain to A. */
4125 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
4127 /* Now sort A's entries. */
4128 rsrc_sort_entries (& adir
->names
, true, adir
);
4129 rsrc_sort_entries (& adir
->ids
, false, adir
);
4132 /* Check the .rsrc section. If it contains multiple concatenated
4133 resources then we must merge them properly. Otherwise Windows
4134 will ignore all but the first set. */
4137 rsrc_process_section (bfd
* abfd
,
4138 struct coff_final_link_info
* pfinfo
)
4140 rsrc_directory new_table
;
4146 bfd_byte
* datastart
;
4148 bfd_byte
* new_data
;
4149 unsigned int num_resource_sets
;
4150 rsrc_directory
* type_tables
;
4151 rsrc_write_data write_data
;
4154 unsigned int num_input_rsrc
= 0;
4155 unsigned int max_num_input_rsrc
= 4;
4156 ptrdiff_t * rsrc_sizes
= NULL
;
4158 new_table
.names
.num_entries
= 0;
4159 new_table
.ids
.num_entries
= 0;
4161 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4162 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4165 pe
= pe_data (abfd
);
4169 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4171 data
= bfd_malloc (size
);
4177 if (! bfd_get_section_contents (abfd
, sec
, data
, 0, size
))
4180 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4181 their lengths. Note - we rely upon the fact that the linker script
4182 does *not* sort the input .rsrc sections, so that the order in the
4183 linkinfo list matches the order in the output .rsrc section.
4185 We need to know the lengths because each input .rsrc section has padding
4186 at the end of a variable amount. (It does not appear to be based upon
4187 the section alignment or the file alignment). We need to skip any
4188 padding bytes when parsing the input .rsrc sections. */
4189 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof * rsrc_sizes
);
4190 if (rsrc_sizes
== NULL
)
4193 for (input
= pfinfo
->info
->input_bfds
;
4195 input
= input
->link
.next
)
4197 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4199 /* PR 18372 - skip discarded .rsrc sections. */
4200 if (rsrc_sec
!= NULL
&& !discarded_section (rsrc_sec
))
4202 if (num_input_rsrc
== max_num_input_rsrc
)
4204 max_num_input_rsrc
+= 10;
4205 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4206 * sizeof * rsrc_sizes
);
4207 if (rsrc_sizes
== NULL
)
4211 BFD_ASSERT (rsrc_sec
->size
> 0);
4212 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4216 if (num_input_rsrc
< 2)
4219 /* Step one: Walk the section, computing the size of the tables,
4220 leaves and data and decide if we need to do anything. */
4221 dataend
= data
+ size
;
4222 num_resource_sets
= 0;
4224 while (data
< dataend
)
4226 bfd_byte
* p
= data
;
4228 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4232 /* Corrupted .rsrc section - cannot merge. */
4233 _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4235 bfd_set_error (bfd_error_file_truncated
);
4239 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4241 _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4243 bfd_set_error (bfd_error_file_truncated
);
4246 /* FIXME: Should we add a check for "data - p" being much smaller
4247 than rsrc_sizes[num_resource_sets] ? */
4249 data
= p
+ rsrc_sizes
[num_resource_sets
];
4250 rva_bias
+= data
- p
;
4251 ++ num_resource_sets
;
4253 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4255 /* Step two: Walk the data again, building trees of the resources. */
4257 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4259 type_tables
= bfd_malloc (num_resource_sets
* sizeof * type_tables
);
4260 if (type_tables
== NULL
)
4264 while (data
< dataend
)
4266 bfd_byte
* p
= data
;
4268 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4269 dataend
, rva_bias
, NULL
);
4270 data
= p
+ rsrc_sizes
[indx
];
4271 rva_bias
+= data
- p
;
4274 BFD_ASSERT (indx
== num_resource_sets
);
4276 /* Step three: Merge the top level tables (there can be only one).
4278 We must ensure that the merged entries are in ascending order.
4280 We also thread the top level table entries from the old tree onto
4281 the new table, so that they can be pulled off later. */
4283 /* FIXME: Should we verify that all type tables are the same ? */
4284 new_table
.characteristics
= type_tables
[0].characteristics
;
4285 new_table
.time
= type_tables
[0].time
;
4286 new_table
.major
= type_tables
[0].major
;
4287 new_table
.minor
= type_tables
[0].minor
;
4289 /* Chain the NAME entries onto the table. */
4290 new_table
.names
.first_entry
= NULL
;
4291 new_table
.names
.last_entry
= NULL
;
4293 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4294 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4296 rsrc_sort_entries (& new_table
.names
, true, & new_table
);
4298 /* Chain the ID entries onto the table. */
4299 new_table
.ids
.first_entry
= NULL
;
4300 new_table
.ids
.last_entry
= NULL
;
4302 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4303 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4305 rsrc_sort_entries (& new_table
.ids
, false, & new_table
);
4307 /* Step four: Create new contents for the .rsrc section. */
4308 /* Step four point one: Compute the size of each region of the .rsrc section.
4309 We do this now, rather than earlier, as the merging above may have dropped
4311 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4312 rsrc_compute_region_sizes (& new_table
);
4313 /* We increment sizeof_strings to make sure that resource data
4314 starts on an 8-byte boundary. FIXME: Is this correct ? */
4315 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4317 new_data
= bfd_zalloc (abfd
, size
);
4318 if (new_data
== NULL
)
4321 write_data
.abfd
= abfd
;
4322 write_data
.datastart
= new_data
;
4323 write_data
.next_table
= new_data
;
4324 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4325 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4326 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4327 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4329 rsrc_write_directory (& write_data
, & new_table
);
4331 /* Step five: Replace the old contents with the new.
4332 We don't recompute the size as it's too late here to shrink section.
4333 See PR ld/20193 for more details. */
4334 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4335 sec
->size
= sec
->rawsize
= size
;
4338 /* Step six: Free all the memory that we have used. */
4339 /* FIXME: Free the resource tree, if we have one. */
4344 /* Handle the .idata section and other things that need symbol table
4348 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4350 struct coff_link_hash_entry
*h1
;
4351 struct bfd_link_info
*info
= pfinfo
->info
;
4354 /* There are a few fields that need to be filled in now while we
4355 have symbol table access.
4357 The .idata subsections aren't directly available as sections, but
4358 they are in the symbol table, so get them from there. */
4360 /* The import directory. This is the address of .idata$2, with size
4361 of .idata$2 + .idata$3. */
4362 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4363 ".idata$2", false, false, true);
4366 /* PR ld/2729: We cannot rely upon all the output sections having been
4367 created properly, so check before referencing them. Issue a warning
4368 message for any sections tht could not be found. */
4369 if ((h1
->root
.type
== bfd_link_hash_defined
4370 || h1
->root
.type
== bfd_link_hash_defweak
)
4371 && h1
->root
.u
.def
.section
!= NULL
4372 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4373 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4374 (h1
->root
.u
.def
.value
4375 + h1
->root
.u
.def
.section
->output_section
->vma
4376 + h1
->root
.u
.def
.section
->output_offset
);
4380 (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4385 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4386 ".idata$4", false, false, true);
4388 && (h1
->root
.type
== bfd_link_hash_defined
4389 || h1
->root
.type
== bfd_link_hash_defweak
)
4390 && h1
->root
.u
.def
.section
!= NULL
4391 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4392 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
4393 ((h1
->root
.u
.def
.value
4394 + h1
->root
.u
.def
.section
->output_section
->vma
4395 + h1
->root
.u
.def
.section
->output_offset
)
4396 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4400 (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4405 /* The import address table. This is the size/address of
4407 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4408 ".idata$5", false, false, true);
4410 && (h1
->root
.type
== bfd_link_hash_defined
4411 || h1
->root
.type
== bfd_link_hash_defweak
)
4412 && h1
->root
.u
.def
.section
!= NULL
4413 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4414 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4415 (h1
->root
.u
.def
.value
4416 + h1
->root
.u
.def
.section
->output_section
->vma
4417 + h1
->root
.u
.def
.section
->output_offset
);
4421 (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4426 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4427 ".idata$6", false, false, true);
4429 && (h1
->root
.type
== bfd_link_hash_defined
4430 || h1
->root
.type
== bfd_link_hash_defweak
)
4431 && h1
->root
.u
.def
.section
!= NULL
4432 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4433 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4434 ((h1
->root
.u
.def
.value
4435 + h1
->root
.u
.def
.section
->output_section
->vma
4436 + h1
->root
.u
.def
.section
->output_offset
)
4437 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4441 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4448 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4449 "__IAT_start__", false, false, true);
4451 && (h1
->root
.type
== bfd_link_hash_defined
4452 || h1
->root
.type
== bfd_link_hash_defweak
)
4453 && h1
->root
.u
.def
.section
!= NULL
4454 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4459 (h1
->root
.u
.def
.value
4460 + h1
->root
.u
.def
.section
->output_section
->vma
4461 + h1
->root
.u
.def
.section
->output_offset
);
4463 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4464 "__IAT_end__", false, false, true);
4466 && (h1
->root
.type
== bfd_link_hash_defined
4467 || h1
->root
.type
== bfd_link_hash_defweak
)
4468 && h1
->root
.u
.def
.section
!= NULL
4469 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4471 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4472 ((h1
->root
.u
.def
.value
4473 + h1
->root
.u
.def
.section
->output_section
->vma
4474 + h1
->root
.u
.def
.section
->output_offset
)
4476 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4477 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4478 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4483 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4484 " because .idata$6 is missing"), abfd
);
4490 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4491 (bfd_get_symbol_leading_char (abfd
) != 0
4492 ? "__tls_used" : "_tls_used"),
4493 false, false, true);
4496 if ((h1
->root
.type
== bfd_link_hash_defined
4497 || h1
->root
.type
== bfd_link_hash_defweak
)
4498 && h1
->root
.u
.def
.section
!= NULL
4499 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4500 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4501 (h1
->root
.u
.def
.value
4502 + h1
->root
.u
.def
.section
->output_section
->vma
4503 + h1
->root
.u
.def
.section
->output_offset
4504 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4508 (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4512 /* According to PECOFF sepcifications by Microsoft version 8.2
4513 the TLS data directory consists of 4 pointers, followed
4514 by two 4-byte integer. This implies that the total size
4515 is different for 32-bit and 64-bit executables. */
4516 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64)
4517 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4519 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4523 /* If there is a .pdata section and we have linked pdata finally, we
4524 need to sort the entries ascending. */
4525 #if !defined(COFF_WITH_pep) && (defined(COFF_WITH_pex64) || defined(COFF_WITH_peAArch64))
4527 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4531 bfd_size_type x
= sec
->rawsize
;
4532 bfd_byte
*tmp_data
= NULL
;
4535 tmp_data
= bfd_malloc (x
);
4537 if (tmp_data
!= NULL
)
4539 if (bfd_get_section_contents (abfd
, sec
, tmp_data
, 0, x
))
4543 12, sort_x64_pdata
);
4544 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4555 rsrc_process_section (abfd
, pfinfo
);
4557 /* If we couldn't find idata$2, we either have an excessively
4558 trivial program or are in DEEP trouble; we have to assume trivial