1 /* Support for the generic parts of PE/PEI; the common executable parts.
2 Copyright (C) 1995-2021 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
;
2941 /* One day we may try to grok other private data. */
2942 if (ibfd
->xvec
->flavour
!= bfd_target_coff_flavour
2943 || obfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2946 ipe
= pe_data (ibfd
);
2947 ope
= pe_data (obfd
);
2949 /* pe_opthdr is copied in copy_object. */
2950 ope
->dll
= ipe
->dll
;
2952 /* Don't copy input subsystem if output is different from input. */
2953 if (obfd
->xvec
!= ibfd
->xvec
)
2954 ope
->pe_opthdr
.Subsystem
= IMAGE_SUBSYSTEM_UNKNOWN
;
2956 /* For strip: if we removed .reloc, we'll make a real mess of things
2957 if we don't remove this entry as well. */
2958 if (! pe_data (obfd
)->has_reloc_section
)
2960 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].VirtualAddress
= 0;
2961 pe_data (obfd
)->pe_opthdr
.DataDirectory
[PE_BASE_RELOCATION_TABLE
].Size
= 0;
2964 /* For PIE, if there is .reloc, we won't add IMAGE_FILE_RELOCS_STRIPPED.
2965 But there is no .reloc, we make sure that IMAGE_FILE_RELOCS_STRIPPED
2967 if (! pe_data (ibfd
)->has_reloc_section
2968 && ! (pe_data (ibfd
)->real_flags
& IMAGE_FILE_RELOCS_STRIPPED
))
2969 pe_data (obfd
)->dont_strip_reloc
= 1;
2971 memcpy (ope
->dos_message
, ipe
->dos_message
, sizeof (ope
->dos_message
));
2973 /* The file offsets contained in the debug directory need rewriting. */
2974 if (ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
!= 0)
2976 bfd_vma addr
= ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].VirtualAddress
2977 + ope
->pe_opthdr
.ImageBase
;
2978 /* In particular a .buildid section may overlap (in VA space) with
2979 whatever section comes ahead of it (largely because of section->size
2980 representing s_size, not virt_size). Therefore don't look for the
2981 section containing the first byte, but for that covering the last
2983 bfd_vma last
= addr
+ ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
- 1;
2984 asection
*section
= find_section_by_vma (obfd
, last
);
2987 /* PR 17512: file: 0f15796a. */
2988 if (section
&& addr
< section
->vma
)
2990 /* xgettext:c-format */
2992 (_("%pB: Data Directory (%lx bytes at %" PRIx64
") "
2993 "extends across section boundary at %" PRIx64
),
2994 obfd
, ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
,
2995 (uint64_t) addr
, (uint64_t) section
->vma
);
2999 if (section
&& bfd_malloc_and_get_section (obfd
, section
, &data
))
3002 struct external_IMAGE_DEBUG_DIRECTORY
*dd
=
3003 (struct external_IMAGE_DEBUG_DIRECTORY
*)(data
+ (addr
- section
->vma
));
3005 for (i
= 0; i
< ope
->pe_opthdr
.DataDirectory
[PE_DEBUG_DATA
].Size
3006 / sizeof (struct external_IMAGE_DEBUG_DIRECTORY
); i
++)
3008 asection
*ddsection
;
3009 struct external_IMAGE_DEBUG_DIRECTORY
*edd
= &(dd
[i
]);
3010 struct internal_IMAGE_DEBUG_DIRECTORY idd
;
3012 _bfd_XXi_swap_debugdir_in (obfd
, edd
, &idd
);
3014 if (idd
.AddressOfRawData
== 0)
3015 continue; /* RVA 0 means only offset is valid, not handled yet. */
3017 ddsection
= find_section_by_vma (obfd
, idd
.AddressOfRawData
+ ope
->pe_opthdr
.ImageBase
);
3019 continue; /* Not in a section! */
3021 idd
.PointerToRawData
= ddsection
->filepos
+ (idd
.AddressOfRawData
3022 + ope
->pe_opthdr
.ImageBase
) - ddsection
->vma
;
3024 _bfd_XXi_swap_debugdir_out (obfd
, &idd
, edd
);
3027 if (!bfd_set_section_contents (obfd
, section
, data
, 0, section
->size
))
3029 _bfd_error_handler (_("failed to update file offsets in debug directory"));
3037 _bfd_error_handler (_("%pB: failed to read debug data section"), obfd
);
3045 /* Copy private section data. */
3048 _bfd_XX_bfd_copy_private_section_data (bfd
*ibfd
,
3053 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
3054 || bfd_get_flavour (obfd
) != bfd_target_coff_flavour
)
3057 if (coff_section_data (ibfd
, isec
) != NULL
3058 && pei_section_data (ibfd
, isec
) != NULL
)
3060 if (coff_section_data (obfd
, osec
) == NULL
)
3062 size_t amt
= sizeof (struct coff_section_tdata
);
3063 osec
->used_by_bfd
= bfd_zalloc (obfd
, amt
);
3064 if (osec
->used_by_bfd
== NULL
)
3068 if (pei_section_data (obfd
, osec
) == NULL
)
3070 size_t amt
= sizeof (struct pei_section_tdata
);
3071 coff_section_data (obfd
, osec
)->tdata
= bfd_zalloc (obfd
, amt
);
3072 if (coff_section_data (obfd
, osec
)->tdata
== NULL
)
3076 pei_section_data (obfd
, osec
)->virt_size
=
3077 pei_section_data (ibfd
, isec
)->virt_size
;
3078 pei_section_data (obfd
, osec
)->pe_flags
=
3079 pei_section_data (ibfd
, isec
)->pe_flags
;
3086 _bfd_XX_get_symbol_info (bfd
* abfd
, asymbol
*symbol
, symbol_info
*ret
)
3088 coff_get_symbol_info (abfd
, symbol
, ret
);
3091 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64) && defined(COFF_WITH_peAArch64)
3093 sort_x64_pdata (const void *l
, const void *r
)
3095 const char *lp
= (const char *) l
;
3096 const char *rp
= (const char *) r
;
3098 vl
= bfd_getl32 (lp
); vr
= bfd_getl32 (rp
);
3100 return (vl
< vr
? -1 : 1);
3101 /* We compare just begin address. */
3106 /* Functions to process a .rsrc section. */
3108 static unsigned int sizeof_leaves
;
3109 static unsigned int sizeof_strings
;
3110 static unsigned int sizeof_tables_and_entries
;
3113 rsrc_count_directory (bfd
*, bfd_byte
*, bfd_byte
*, bfd_byte
*, bfd_vma
);
3116 rsrc_count_entries (bfd
*abfd
,
3118 bfd_byte
*datastart
,
3123 unsigned long entry
, addr
, size
;
3125 if (data
+ 8 >= dataend
)
3132 entry
= (long) bfd_get_32 (abfd
, data
);
3134 if (HighBitSet (entry
))
3135 name
= datastart
+ WithoutHighBit (entry
);
3137 name
= datastart
+ entry
- rva_bias
;
3139 if (name
+ 2 >= dataend
|| name
< datastart
)
3142 unsigned int len
= bfd_get_16 (abfd
, name
);
3143 if (len
== 0 || len
> 256)
3147 entry
= (long) bfd_get_32 (abfd
, data
+ 4);
3149 if (HighBitSet (entry
))
3151 data
= datastart
+ WithoutHighBit (entry
);
3153 if (data
<= datastart
|| data
>= dataend
)
3156 return rsrc_count_directory (abfd
, datastart
, data
, dataend
, rva_bias
);
3159 if (datastart
+ entry
+ 16 >= dataend
)
3162 addr
= (long) bfd_get_32 (abfd
, datastart
+ entry
);
3163 size
= (long) bfd_get_32 (abfd
, datastart
+ entry
+ 4);
3165 return datastart
+ addr
- rva_bias
+ size
;
3169 rsrc_count_directory (bfd
* abfd
,
3170 bfd_byte
* datastart
,
3175 unsigned int num_entries
, num_ids
;
3176 bfd_byte
* highest_data
= data
;
3178 if (data
+ 16 >= dataend
)
3181 num_entries
= (int) bfd_get_16 (abfd
, data
+ 12);
3182 num_ids
= (int) bfd_get_16 (abfd
, data
+ 14);
3184 num_entries
+= num_ids
;
3188 while (num_entries
--)
3190 bfd_byte
* entry_end
;
3192 entry_end
= rsrc_count_entries (abfd
, num_entries
>= num_ids
,
3193 datastart
, data
, dataend
, rva_bias
);
3195 highest_data
= max (highest_data
, entry_end
);
3196 if (entry_end
>= dataend
)
3200 return max (highest_data
, data
);
3203 typedef struct rsrc_dir_chain
3205 unsigned int num_entries
;
3206 struct rsrc_entry
* first_entry
;
3207 struct rsrc_entry
* last_entry
;
3210 typedef struct rsrc_directory
3212 unsigned int characteristics
;
3217 rsrc_dir_chain names
;
3220 struct rsrc_entry
* entry
;
3223 typedef struct rsrc_string
3229 typedef struct rsrc_leaf
3232 unsigned int codepage
;
3236 typedef struct rsrc_entry
3242 struct rsrc_string name
;
3248 struct rsrc_directory
* directory
;
3249 struct rsrc_leaf
* leaf
;
3252 struct rsrc_entry
* next_entry
;
3253 struct rsrc_directory
* parent
;
3257 rsrc_parse_directory (bfd
*, rsrc_directory
*, bfd_byte
*,
3258 bfd_byte
*, bfd_byte
*, bfd_vma
, rsrc_entry
*);
3261 rsrc_parse_entry (bfd
*abfd
,
3264 bfd_byte
*datastart
,
3268 rsrc_directory
*parent
)
3270 unsigned long val
, addr
, size
;
3272 val
= bfd_get_32 (abfd
, data
);
3274 entry
->parent
= parent
;
3275 entry
->is_name
= is_name
;
3281 if (HighBitSet (val
))
3283 val
= WithoutHighBit (val
);
3285 address
= datastart
+ val
;
3289 address
= datastart
+ val
- rva_bias
;
3292 if (address
+ 3 > dataend
)
3295 entry
->name_id
.name
.len
= bfd_get_16 (abfd
, address
);
3296 entry
->name_id
.name
.string
= address
+ 2;
3299 entry
->name_id
.id
= val
;
3301 val
= bfd_get_32 (abfd
, data
+ 4);
3303 if (HighBitSet (val
))
3305 entry
->is_dir
= true;
3306 entry
->value
.directory
= bfd_malloc (sizeof * entry
->value
.directory
);
3307 if (entry
->value
.directory
== NULL
)
3310 return rsrc_parse_directory (abfd
, entry
->value
.directory
,
3312 datastart
+ WithoutHighBit (val
),
3313 dataend
, rva_bias
, entry
);
3316 entry
->is_dir
= false;
3317 entry
->value
.leaf
= bfd_malloc (sizeof * entry
->value
.leaf
);
3318 if (entry
->value
.leaf
== NULL
)
3321 data
= datastart
+ val
;
3322 if (data
< datastart
|| data
>= dataend
)
3325 addr
= bfd_get_32 (abfd
, data
);
3326 size
= entry
->value
.leaf
->size
= bfd_get_32 (abfd
, data
+ 4);
3327 entry
->value
.leaf
->codepage
= bfd_get_32 (abfd
, data
+ 8);
3328 /* FIXME: We assume that the reserved field (data + 12) is OK. */
3330 entry
->value
.leaf
->data
= bfd_malloc (size
);
3331 if (entry
->value
.leaf
->data
== NULL
)
3334 memcpy (entry
->value
.leaf
->data
, datastart
+ addr
- rva_bias
, size
);
3335 return datastart
+ (addr
- rva_bias
) + size
;
3339 rsrc_parse_entries (bfd
*abfd
,
3340 rsrc_dir_chain
*chain
,
3342 bfd_byte
*highest_data
,
3343 bfd_byte
*datastart
,
3347 rsrc_directory
*parent
)
3352 if (chain
->num_entries
== 0)
3354 chain
->first_entry
= chain
->last_entry
= NULL
;
3355 return highest_data
;
3358 entry
= bfd_malloc (sizeof * entry
);
3362 chain
->first_entry
= entry
;
3364 for (i
= chain
->num_entries
; i
--;)
3366 bfd_byte
* entry_end
;
3368 entry_end
= rsrc_parse_entry (abfd
, is_name
, entry
, datastart
,
3369 data
, dataend
, rva_bias
, parent
);
3371 highest_data
= max (entry_end
, highest_data
);
3372 if (entry_end
> dataend
)
3377 entry
->next_entry
= bfd_malloc (sizeof * entry
);
3378 entry
= entry
->next_entry
;
3383 entry
->next_entry
= NULL
;
3386 chain
->last_entry
= entry
;
3388 return highest_data
;
3392 rsrc_parse_directory (bfd
* abfd
,
3393 rsrc_directory
* table
,
3394 bfd_byte
* datastart
,
3400 bfd_byte
* highest_data
= data
;
3405 table
->characteristics
= bfd_get_32 (abfd
, data
);
3406 table
->time
= bfd_get_32 (abfd
, data
+ 4);
3407 table
->major
= bfd_get_16 (abfd
, data
+ 8);
3408 table
->minor
= bfd_get_16 (abfd
, data
+ 10);
3409 table
->names
.num_entries
= bfd_get_16 (abfd
, data
+ 12);
3410 table
->ids
.num_entries
= bfd_get_16 (abfd
, data
+ 14);
3411 table
->entry
= entry
;
3415 highest_data
= rsrc_parse_entries (abfd
, & table
->names
, true, data
,
3416 datastart
, data
, dataend
, rva_bias
, table
);
3417 data
+= table
->names
.num_entries
* 8;
3419 highest_data
= rsrc_parse_entries (abfd
, & table
->ids
, false, highest_data
,
3420 datastart
, data
, dataend
, rva_bias
, table
);
3421 data
+= table
->ids
.num_entries
* 8;
3423 return max (highest_data
, data
);
3426 typedef struct rsrc_write_data
3429 bfd_byte
* datastart
;
3430 bfd_byte
* next_table
;
3431 bfd_byte
* next_leaf
;
3432 bfd_byte
* next_string
;
3433 bfd_byte
* next_data
;
3438 rsrc_write_string (rsrc_write_data
* data
,
3439 rsrc_string
* string
)
3441 bfd_put_16 (data
->abfd
, string
->len
, data
->next_string
);
3442 memcpy (data
->next_string
+ 2, string
->string
, string
->len
* 2);
3443 data
->next_string
+= (string
->len
+ 1) * 2;
3446 static inline unsigned int
3447 rsrc_compute_rva (rsrc_write_data
* data
,
3450 return (addr
- data
->datastart
) + data
->rva_bias
;
3454 rsrc_write_leaf (rsrc_write_data
* data
,
3457 bfd_put_32 (data
->abfd
, rsrc_compute_rva (data
, data
->next_data
),
3459 bfd_put_32 (data
->abfd
, leaf
->size
, data
->next_leaf
+ 4);
3460 bfd_put_32 (data
->abfd
, leaf
->codepage
, data
->next_leaf
+ 8);
3461 bfd_put_32 (data
->abfd
, 0 /*reserved*/, data
->next_leaf
+ 12);
3462 data
->next_leaf
+= 16;
3464 memcpy (data
->next_data
, leaf
->data
, leaf
->size
);
3465 /* An undocumented feature of Windows resources is that each unit
3466 of raw data is 8-byte aligned... */
3467 data
->next_data
+= ((leaf
->size
+ 7) & ~7);
3470 static void rsrc_write_directory (rsrc_write_data
*, rsrc_directory
*);
3473 rsrc_write_entry (rsrc_write_data
* data
,
3479 bfd_put_32 (data
->abfd
,
3480 SetHighBit (data
->next_string
- data
->datastart
),
3482 rsrc_write_string (data
, & entry
->name_id
.name
);
3485 bfd_put_32 (data
->abfd
, entry
->name_id
.id
, where
);
3489 bfd_put_32 (data
->abfd
,
3490 SetHighBit (data
->next_table
- data
->datastart
),
3492 rsrc_write_directory (data
, entry
->value
.directory
);
3496 bfd_put_32 (data
->abfd
, data
->next_leaf
- data
->datastart
, where
+ 4);
3497 rsrc_write_leaf (data
, entry
->value
.leaf
);
3502 rsrc_compute_region_sizes (rsrc_directory
* dir
)
3504 struct rsrc_entry
* entry
;
3509 sizeof_tables_and_entries
+= 16;
3511 for (entry
= dir
->names
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3513 sizeof_tables_and_entries
+= 8;
3515 sizeof_strings
+= (entry
->name_id
.name
.len
+ 1) * 2;
3518 rsrc_compute_region_sizes (entry
->value
.directory
);
3520 sizeof_leaves
+= 16;
3523 for (entry
= dir
->ids
.first_entry
; entry
!= NULL
; entry
= entry
->next_entry
)
3525 sizeof_tables_and_entries
+= 8;
3528 rsrc_compute_region_sizes (entry
->value
.directory
);
3530 sizeof_leaves
+= 16;
3535 rsrc_write_directory (rsrc_write_data
* data
,
3536 rsrc_directory
* dir
)
3540 bfd_byte
* next_entry
;
3543 bfd_put_32 (data
->abfd
, dir
->characteristics
, data
->next_table
);
3544 bfd_put_32 (data
->abfd
, 0 /*dir->time*/, data
->next_table
+ 4);
3545 bfd_put_16 (data
->abfd
, dir
->major
, data
->next_table
+ 8);
3546 bfd_put_16 (data
->abfd
, dir
->minor
, data
->next_table
+ 10);
3547 bfd_put_16 (data
->abfd
, dir
->names
.num_entries
, data
->next_table
+ 12);
3548 bfd_put_16 (data
->abfd
, dir
->ids
.num_entries
, data
->next_table
+ 14);
3550 /* Compute where the entries and the next table will be placed. */
3551 next_entry
= data
->next_table
+ 16;
3552 data
->next_table
= next_entry
+ (dir
->names
.num_entries
* 8)
3553 + (dir
->ids
.num_entries
* 8);
3554 nt
= data
->next_table
;
3556 /* Write the entries. */
3557 for (i
= dir
->names
.num_entries
, entry
= dir
->names
.first_entry
;
3558 i
> 0 && entry
!= NULL
;
3559 i
--, entry
= entry
->next_entry
)
3561 BFD_ASSERT (entry
->is_name
);
3562 rsrc_write_entry (data
, next_entry
, entry
);
3565 BFD_ASSERT (i
== 0);
3566 BFD_ASSERT (entry
== NULL
);
3568 for (i
= dir
->ids
.num_entries
, entry
= dir
->ids
.first_entry
;
3569 i
> 0 && entry
!= NULL
;
3570 i
--, entry
= entry
->next_entry
)
3572 BFD_ASSERT (! entry
->is_name
);
3573 rsrc_write_entry (data
, next_entry
, entry
);
3576 BFD_ASSERT (i
== 0);
3577 BFD_ASSERT (entry
== NULL
);
3578 BFD_ASSERT (nt
== next_entry
);
3581 #if ! defined __CYGWIN__ && ! defined __MINGW32__
3582 /* Return the length (number of units) of the first character in S,
3583 putting its 'ucs4_t' representation in *PUC. */
3586 u16_mbtouc (wint_t * puc
, const unsigned short * s
, unsigned int n
)
3588 unsigned short c
= * s
;
3590 if (c
< 0xd800 || c
>= 0xe000)
3600 if (s
[1] >= 0xdc00 && s
[1] < 0xe000)
3602 *puc
= 0x10000 + ((c
- 0xd800) << 10) + (s
[1] - 0xdc00);
3608 /* Incomplete multibyte character. */
3614 /* Invalid multibyte character. */
3618 #endif /* not Cygwin/Mingw */
3620 /* Perform a comparison of two entries. */
3622 rsrc_cmp (bool is_name
, rsrc_entry
* a
, rsrc_entry
* b
)
3631 return a
->name_id
.id
- b
->name_id
.id
;
3633 /* We have to perform a case insenstive, unicode string comparison... */
3634 astring
= a
->name_id
.name
.string
;
3635 alen
= a
->name_id
.name
.len
;
3636 bstring
= b
->name_id
.name
.string
;
3637 blen
= b
->name_id
.name
.len
;
3639 #if defined __CYGWIN__ || defined __MINGW32__
3640 /* Under Windows hosts (both Cygwin and Mingw types),
3641 unicode == UTF-16 == wchar_t. The case insensitive string comparison
3642 function however goes by different names in the two environments... */
3646 #define rscpcmp wcsncasecmp
3649 #define rscpcmp wcsnicmp
3652 res
= rscpcmp ((const wchar_t *) astring
, (const wchar_t *) bstring
,
3660 for (i
= min (alen
, blen
); i
--; astring
+= 2, bstring
+= 2)
3665 /* Convert UTF-16 unicode characters into wchar_t characters
3666 so that we can then perform a case insensitive comparison. */
3667 unsigned int Alen
= u16_mbtouc (& awc
, (const unsigned short *) astring
, 2);
3668 unsigned int Blen
= u16_mbtouc (& bwc
, (const unsigned short *) bstring
, 2);
3673 awc
= towlower (awc
);
3674 bwc
= towlower (bwc
);
3690 rsrc_print_name (char * buffer
, rsrc_string string
)
3693 bfd_byte
* name
= string
.string
;
3695 for (i
= string
.len
; i
--; name
+= 2)
3696 sprintf (buffer
+ strlen (buffer
), "%.1s", name
);
3700 rsrc_resource_name (rsrc_entry
*entry
, rsrc_directory
*dir
, char *buffer
)
3702 bool is_string
= false;
3706 if (dir
!= NULL
&& dir
->entry
!= NULL
&& dir
->entry
->parent
!= NULL
3707 && dir
->entry
->parent
->entry
!= NULL
)
3709 strcpy (buffer
, "type: ");
3710 if (dir
->entry
->parent
->entry
->is_name
)
3711 rsrc_print_name (buffer
+ strlen (buffer
),
3712 dir
->entry
->parent
->entry
->name_id
.name
);
3715 unsigned int id
= dir
->entry
->parent
->entry
->name_id
.id
;
3717 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3720 case 1: strcat (buffer
, " (CURSOR)"); break;
3721 case 2: strcat (buffer
, " (BITMAP)"); break;
3722 case 3: strcat (buffer
, " (ICON)"); break;
3723 case 4: strcat (buffer
, " (MENU)"); break;
3724 case 5: strcat (buffer
, " (DIALOG)"); break;
3725 case 6: strcat (buffer
, " (STRING)"); is_string
= true; break;
3726 case 7: strcat (buffer
, " (FONTDIR)"); break;
3727 case 8: strcat (buffer
, " (FONT)"); break;
3728 case 9: strcat (buffer
, " (ACCELERATOR)"); break;
3729 case 10: strcat (buffer
, " (RCDATA)"); break;
3730 case 11: strcat (buffer
, " (MESSAGETABLE)"); break;
3731 case 12: strcat (buffer
, " (GROUP_CURSOR)"); break;
3732 case 14: strcat (buffer
, " (GROUP_ICON)"); break;
3733 case 16: strcat (buffer
, " (VERSION)"); break;
3734 case 17: strcat (buffer
, " (DLGINCLUDE)"); break;
3735 case 19: strcat (buffer
, " (PLUGPLAY)"); break;
3736 case 20: strcat (buffer
, " (VXD)"); break;
3737 case 21: strcat (buffer
, " (ANICURSOR)"); break;
3738 case 22: strcat (buffer
, " (ANIICON)"); break;
3739 case 23: strcat (buffer
, " (HTML)"); break;
3740 case 24: strcat (buffer
, " (MANIFEST)"); break;
3741 case 240: strcat (buffer
, " (DLGINIT)"); break;
3742 case 241: strcat (buffer
, " (TOOLBAR)"); break;
3747 if (dir
!= NULL
&& dir
->entry
!= NULL
)
3749 strcat (buffer
, " name: ");
3750 if (dir
->entry
->is_name
)
3751 rsrc_print_name (buffer
+ strlen (buffer
), dir
->entry
->name_id
.name
);
3754 unsigned int id
= dir
->entry
->name_id
.id
;
3756 sprintf (buffer
+ strlen (buffer
), "%x", id
);
3759 sprintf (buffer
+ strlen (buffer
), " (resource id range: %d - %d)",
3760 (id
- 1) << 4, (id
<< 4) - 1);
3766 strcat (buffer
, " lang: ");
3769 rsrc_print_name (buffer
+ strlen (buffer
), entry
->name_id
.name
);
3771 sprintf (buffer
+ strlen (buffer
), "%x", entry
->name_id
.id
);
3777 /* *sigh* Windows resource strings are special. Only the top 28-bits of
3778 their ID is stored in the NAME entry. The bottom four bits are used as
3779 an index into unicode string table that makes up the data of the leaf.
3780 So identical type-name-lang string resources may not actually be
3783 This function is called when we have detected two string resources with
3784 match top-28-bit IDs. We have to scan the string tables inside the leaves
3785 and discover if there are any real collisions. If there are then we report
3786 them and return FALSE. Otherwise we copy any strings from B into A and
3787 then return TRUE. */
3790 rsrc_merge_string_entries (rsrc_entry
* a ATTRIBUTE_UNUSED
,
3791 rsrc_entry
* b ATTRIBUTE_UNUSED
)
3793 unsigned int copy_needed
= 0;
3797 bfd_byte
* new_data
;
3800 /* Step one: Find out what we have to do. */
3801 BFD_ASSERT (! a
->is_dir
);
3802 astring
= a
->value
.leaf
->data
;
3804 BFD_ASSERT (! b
->is_dir
);
3805 bstring
= b
->value
.leaf
->data
;
3807 for (i
= 0; i
< 16; i
++)
3809 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3810 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3814 copy_needed
+= blen
* 2;
3818 else if (alen
!= blen
)
3819 /* FIXME: Should we continue the loop in order to report other duplicates ? */
3821 /* alen == blen != 0. We might have two identical strings. If so we
3822 can ignore the second one. There is no need for wchar_t vs UTF-16
3823 theatrics here - we are only interested in (case sensitive) equality. */
3824 else if (memcmp (astring
+ 2, bstring
+ 2, alen
* 2) != 0)
3827 astring
+= (alen
+ 1) * 2;
3828 bstring
+= (blen
+ 1) * 2;
3833 if (a
->parent
!= NULL
3834 && a
->parent
->entry
!= NULL
3835 && !a
->parent
->entry
->is_name
)
3836 _bfd_error_handler (_(".rsrc merge failure: duplicate string resource: %d"),
3837 ((a
->parent
->entry
->name_id
.id
- 1) << 4) + i
);
3841 if (copy_needed
== 0)
3844 /* If we reach here then A and B must both have non-colliding strings.
3845 (We never get string resources with fully empty string tables).
3846 We need to allocate an extra COPY_NEEDED bytes in A and then bring
3848 new_data
= bfd_malloc (a
->value
.leaf
->size
+ copy_needed
);
3849 if (new_data
== NULL
)
3853 astring
= a
->value
.leaf
->data
;
3854 bstring
= b
->value
.leaf
->data
;
3856 for (i
= 0; i
< 16; i
++)
3858 unsigned int alen
= astring
[0] + (astring
[1] << 8);
3859 unsigned int blen
= bstring
[0] + (bstring
[1] << 8);
3863 memcpy (nstring
, astring
, (alen
+ 1) * 2);
3864 nstring
+= (alen
+ 1) * 2;
3868 memcpy (nstring
, bstring
, (blen
+ 1) * 2);
3869 nstring
+= (blen
+ 1) * 2;
3877 astring
+= (alen
+ 1) * 2;
3878 bstring
+= (blen
+ 1) * 2;
3881 BFD_ASSERT (nstring
- new_data
== (signed) (a
->value
.leaf
->size
+ copy_needed
));
3883 free (a
->value
.leaf
->data
);
3884 a
->value
.leaf
->data
= new_data
;
3885 a
->value
.leaf
->size
+= copy_needed
;
3890 static void rsrc_merge (rsrc_entry
*, rsrc_entry
*);
3892 /* Sort the entries in given part of the directory.
3893 We use an old fashioned bubble sort because we are dealing
3894 with lists and we want to handle matches specially. */
3897 rsrc_sort_entries (rsrc_dir_chain
*chain
,
3899 rsrc_directory
*dir
)
3903 rsrc_entry
** points_to_entry
;
3906 if (chain
->num_entries
< 2)
3912 points_to_entry
= & chain
->first_entry
;
3913 entry
= * points_to_entry
;
3914 next
= entry
->next_entry
;
3918 signed int cmp
= rsrc_cmp (is_name
, entry
, next
);
3922 entry
->next_entry
= next
->next_entry
;
3923 next
->next_entry
= entry
;
3924 * points_to_entry
= next
;
3925 points_to_entry
= & next
->next_entry
;
3926 next
= entry
->next_entry
;
3931 if (entry
->is_dir
&& next
->is_dir
)
3933 /* When we encounter identical directory entries we have to
3934 merge them together. The exception to this rule is for
3935 resource manifests - there can only be one of these,
3936 even if they differ in language. Zero-language manifests
3937 are assumed to be default manifests (provided by the
3938 Cygwin/MinGW build system) and these can be silently dropped,
3939 unless that would reduce the number of manifests to zero.
3940 There should only ever be one non-zero lang manifest -
3941 if there are more it is an error. A non-zero lang
3942 manifest takes precedence over a default manifest. */
3944 && entry
->name_id
.id
== 1
3946 && dir
->entry
!= NULL
3947 && !dir
->entry
->is_name
3948 && dir
->entry
->name_id
.id
== 0x18)
3950 if (next
->value
.directory
->names
.num_entries
== 0
3951 && next
->value
.directory
->ids
.num_entries
== 1
3952 && !next
->value
.directory
->ids
.first_entry
->is_name
3953 && next
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3954 /* Fall through so that NEXT is dropped. */
3956 else if (entry
->value
.directory
->names
.num_entries
== 0
3957 && entry
->value
.directory
->ids
.num_entries
== 1
3958 && !entry
->value
.directory
->ids
.first_entry
->is_name
3959 && entry
->value
.directory
->ids
.first_entry
->name_id
.id
== 0)
3961 /* Swap ENTRY and NEXT. Then fall through so that the old ENTRY is dropped. */
3962 entry
->next_entry
= next
->next_entry
;
3963 next
->next_entry
= entry
;
3964 * points_to_entry
= next
;
3965 points_to_entry
= & next
->next_entry
;
3966 next
= entry
->next_entry
;
3971 _bfd_error_handler (_(".rsrc merge failure: multiple non-default manifests"));
3972 bfd_set_error (bfd_error_file_truncated
);
3976 /* Unhook NEXT from the chain. */
3977 /* FIXME: memory loss here. */
3978 entry
->next_entry
= next
->next_entry
;
3979 chain
->num_entries
--;
3980 if (chain
->num_entries
< 2)
3982 next
= next
->next_entry
;
3985 rsrc_merge (entry
, next
);
3987 else if (entry
->is_dir
!= next
->is_dir
)
3989 _bfd_error_handler (_(".rsrc merge failure: a directory matches a leaf"));
3990 bfd_set_error (bfd_error_file_truncated
);
3995 /* Otherwise with identical leaves we issue an error
3996 message - because there should never be duplicates.
3997 The exception is Type 18/Name 1/Lang 0 which is the
3998 defaul manifest - this can just be dropped. */
4000 && entry
->name_id
.id
== 0
4002 && dir
->entry
!= NULL
4003 && !dir
->entry
->is_name
4004 && dir
->entry
->name_id
.id
== 1
4005 && dir
->entry
->parent
!= NULL
4006 && dir
->entry
->parent
->entry
!= NULL
4007 && !dir
->entry
->parent
->entry
->is_name
4008 && dir
->entry
->parent
->entry
->name_id
.id
== 0x18 /* RT_MANIFEST */)
4010 else if (dir
!= NULL
4011 && dir
->entry
!= NULL
4012 && dir
->entry
->parent
!= NULL
4013 && dir
->entry
->parent
->entry
!= NULL
4014 && !dir
->entry
->parent
->entry
->is_name
4015 && dir
->entry
->parent
->entry
->name_id
.id
== 0x6 /* RT_STRING */)
4017 /* Strings need special handling. */
4018 if (! rsrc_merge_string_entries (entry
, next
))
4020 /* _bfd_error_handler should have been called inside merge_strings. */
4021 bfd_set_error (bfd_error_file_truncated
);
4028 || dir
->entry
== NULL
4029 || dir
->entry
->parent
== NULL
4030 || dir
->entry
->parent
->entry
== NULL
)
4031 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf"));
4036 _bfd_error_handler (_(".rsrc merge failure: duplicate leaf: %s"),
4037 rsrc_resource_name (entry
, dir
, buff
));
4039 bfd_set_error (bfd_error_file_truncated
);
4044 /* Unhook NEXT from the chain. */
4045 entry
->next_entry
= next
->next_entry
;
4046 chain
->num_entries
--;
4047 if (chain
->num_entries
< 2)
4049 next
= next
->next_entry
;
4053 points_to_entry
= & entry
->next_entry
;
4055 next
= next
->next_entry
;
4060 chain
->last_entry
= entry
;
4065 /* Attach B's chain onto A. */
4067 rsrc_attach_chain (rsrc_dir_chain
* achain
, rsrc_dir_chain
* bchain
)
4069 if (bchain
->num_entries
== 0)
4072 achain
->num_entries
+= bchain
->num_entries
;
4074 if (achain
->first_entry
== NULL
)
4076 achain
->first_entry
= bchain
->first_entry
;
4077 achain
->last_entry
= bchain
->last_entry
;
4081 achain
->last_entry
->next_entry
= bchain
->first_entry
;
4082 achain
->last_entry
= bchain
->last_entry
;
4085 bchain
->num_entries
= 0;
4086 bchain
->first_entry
= bchain
->last_entry
= NULL
;
4090 rsrc_merge (struct rsrc_entry
* a
, struct rsrc_entry
* b
)
4092 rsrc_directory
* adir
;
4093 rsrc_directory
* bdir
;
4095 BFD_ASSERT (a
->is_dir
);
4096 BFD_ASSERT (b
->is_dir
);
4098 adir
= a
->value
.directory
;
4099 bdir
= b
->value
.directory
;
4101 if (adir
->characteristics
!= bdir
->characteristics
)
4103 _bfd_error_handler (_(".rsrc merge failure: dirs with differing characteristics"));
4104 bfd_set_error (bfd_error_file_truncated
);
4108 if (adir
->major
!= bdir
->major
|| adir
->minor
!= bdir
->minor
)
4110 _bfd_error_handler (_(".rsrc merge failure: differing directory versions"));
4111 bfd_set_error (bfd_error_file_truncated
);
4115 /* Attach B's name chain to A. */
4116 rsrc_attach_chain (& adir
->names
, & bdir
->names
);
4118 /* Attach B's ID chain to A. */
4119 rsrc_attach_chain (& adir
->ids
, & bdir
->ids
);
4121 /* Now sort A's entries. */
4122 rsrc_sort_entries (& adir
->names
, true, adir
);
4123 rsrc_sort_entries (& adir
->ids
, false, adir
);
4126 /* Check the .rsrc section. If it contains multiple concatenated
4127 resources then we must merge them properly. Otherwise Windows
4128 will ignore all but the first set. */
4131 rsrc_process_section (bfd
* abfd
,
4132 struct coff_final_link_info
* pfinfo
)
4134 rsrc_directory new_table
;
4140 bfd_byte
* datastart
;
4142 bfd_byte
* new_data
;
4143 unsigned int num_resource_sets
;
4144 rsrc_directory
* type_tables
;
4145 rsrc_write_data write_data
;
4148 unsigned int num_input_rsrc
= 0;
4149 unsigned int max_num_input_rsrc
= 4;
4150 ptrdiff_t * rsrc_sizes
= NULL
;
4152 new_table
.names
.num_entries
= 0;
4153 new_table
.ids
.num_entries
= 0;
4155 sec
= bfd_get_section_by_name (abfd
, ".rsrc");
4156 if (sec
== NULL
|| (size
= sec
->rawsize
) == 0)
4159 pe
= pe_data (abfd
);
4163 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4165 data
= bfd_malloc (size
);
4171 if (! bfd_get_section_contents (abfd
, sec
, data
, 0, size
))
4174 /* Step zero: Scan the input bfds looking for .rsrc sections and record
4175 their lengths. Note - we rely upon the fact that the linker script
4176 does *not* sort the input .rsrc sections, so that the order in the
4177 linkinfo list matches the order in the output .rsrc section.
4179 We need to know the lengths because each input .rsrc section has padding
4180 at the end of a variable amount. (It does not appear to be based upon
4181 the section alignment or the file alignment). We need to skip any
4182 padding bytes when parsing the input .rsrc sections. */
4183 rsrc_sizes
= bfd_malloc (max_num_input_rsrc
* sizeof * rsrc_sizes
);
4184 if (rsrc_sizes
== NULL
)
4187 for (input
= pfinfo
->info
->input_bfds
;
4189 input
= input
->link
.next
)
4191 asection
* rsrc_sec
= bfd_get_section_by_name (input
, ".rsrc");
4193 /* PR 18372 - skip discarded .rsrc sections. */
4194 if (rsrc_sec
!= NULL
&& !discarded_section (rsrc_sec
))
4196 if (num_input_rsrc
== max_num_input_rsrc
)
4198 max_num_input_rsrc
+= 10;
4199 rsrc_sizes
= bfd_realloc (rsrc_sizes
, max_num_input_rsrc
4200 * sizeof * rsrc_sizes
);
4201 if (rsrc_sizes
== NULL
)
4205 BFD_ASSERT (rsrc_sec
->size
> 0);
4206 rsrc_sizes
[num_input_rsrc
++] = rsrc_sec
->size
;
4210 if (num_input_rsrc
< 2)
4213 /* Step one: Walk the section, computing the size of the tables,
4214 leaves and data and decide if we need to do anything. */
4215 dataend
= data
+ size
;
4216 num_resource_sets
= 0;
4218 while (data
< dataend
)
4220 bfd_byte
* p
= data
;
4222 data
= rsrc_count_directory (abfd
, data
, data
, dataend
, rva_bias
);
4226 /* Corrupted .rsrc section - cannot merge. */
4227 _bfd_error_handler (_("%pB: .rsrc merge failure: corrupt .rsrc section"),
4229 bfd_set_error (bfd_error_file_truncated
);
4233 if ((data
- p
) > rsrc_sizes
[num_resource_sets
])
4235 _bfd_error_handler (_("%pB: .rsrc merge failure: unexpected .rsrc size"),
4237 bfd_set_error (bfd_error_file_truncated
);
4240 /* FIXME: Should we add a check for "data - p" being much smaller
4241 than rsrc_sizes[num_resource_sets] ? */
4243 data
= p
+ rsrc_sizes
[num_resource_sets
];
4244 rva_bias
+= data
- p
;
4245 ++ num_resource_sets
;
4247 BFD_ASSERT (num_resource_sets
== num_input_rsrc
);
4249 /* Step two: Walk the data again, building trees of the resources. */
4251 rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4253 type_tables
= bfd_malloc (num_resource_sets
* sizeof * type_tables
);
4254 if (type_tables
== NULL
)
4258 while (data
< dataend
)
4260 bfd_byte
* p
= data
;
4262 (void) rsrc_parse_directory (abfd
, type_tables
+ indx
, data
, data
,
4263 dataend
, rva_bias
, NULL
);
4264 data
= p
+ rsrc_sizes
[indx
];
4265 rva_bias
+= data
- p
;
4268 BFD_ASSERT (indx
== num_resource_sets
);
4270 /* Step three: Merge the top level tables (there can be only one).
4272 We must ensure that the merged entries are in ascending order.
4274 We also thread the top level table entries from the old tree onto
4275 the new table, so that they can be pulled off later. */
4277 /* FIXME: Should we verify that all type tables are the same ? */
4278 new_table
.characteristics
= type_tables
[0].characteristics
;
4279 new_table
.time
= type_tables
[0].time
;
4280 new_table
.major
= type_tables
[0].major
;
4281 new_table
.minor
= type_tables
[0].minor
;
4283 /* Chain the NAME entries onto the table. */
4284 new_table
.names
.first_entry
= NULL
;
4285 new_table
.names
.last_entry
= NULL
;
4287 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4288 rsrc_attach_chain (& new_table
.names
, & type_tables
[indx
].names
);
4290 rsrc_sort_entries (& new_table
.names
, true, & new_table
);
4292 /* Chain the ID entries onto the table. */
4293 new_table
.ids
.first_entry
= NULL
;
4294 new_table
.ids
.last_entry
= NULL
;
4296 for (indx
= 0; indx
< num_resource_sets
; indx
++)
4297 rsrc_attach_chain (& new_table
.ids
, & type_tables
[indx
].ids
);
4299 rsrc_sort_entries (& new_table
.ids
, false, & new_table
);
4301 /* Step four: Create new contents for the .rsrc section. */
4302 /* Step four point one: Compute the size of each region of the .rsrc section.
4303 We do this now, rather than earlier, as the merging above may have dropped
4305 sizeof_leaves
= sizeof_strings
= sizeof_tables_and_entries
= 0;
4306 rsrc_compute_region_sizes (& new_table
);
4307 /* We increment sizeof_strings to make sure that resource data
4308 starts on an 8-byte boundary. FIXME: Is this correct ? */
4309 sizeof_strings
= (sizeof_strings
+ 7) & ~ 7;
4311 new_data
= bfd_zalloc (abfd
, size
);
4312 if (new_data
== NULL
)
4315 write_data
.abfd
= abfd
;
4316 write_data
.datastart
= new_data
;
4317 write_data
.next_table
= new_data
;
4318 write_data
.next_leaf
= new_data
+ sizeof_tables_and_entries
;
4319 write_data
.next_string
= write_data
.next_leaf
+ sizeof_leaves
;
4320 write_data
.next_data
= write_data
.next_string
+ sizeof_strings
;
4321 write_data
.rva_bias
= sec
->vma
- pe
->pe_opthdr
.ImageBase
;
4323 rsrc_write_directory (& write_data
, & new_table
);
4325 /* Step five: Replace the old contents with the new.
4326 We don't recompute the size as it's too late here to shrink section.
4327 See PR ld/20193 for more details. */
4328 bfd_set_section_contents (pfinfo
->output_bfd
, sec
, new_data
, 0, size
);
4329 sec
->size
= sec
->rawsize
= size
;
4332 /* Step six: Free all the memory that we have used. */
4333 /* FIXME: Free the resource tree, if we have one. */
4338 /* Handle the .idata section and other things that need symbol table
4342 _bfd_XXi_final_link_postscript (bfd
* abfd
, struct coff_final_link_info
*pfinfo
)
4344 struct coff_link_hash_entry
*h1
;
4345 struct bfd_link_info
*info
= pfinfo
->info
;
4348 /* There are a few fields that need to be filled in now while we
4349 have symbol table access.
4351 The .idata subsections aren't directly available as sections, but
4352 they are in the symbol table, so get them from there. */
4354 /* The import directory. This is the address of .idata$2, with size
4355 of .idata$2 + .idata$3. */
4356 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4357 ".idata$2", false, false, true);
4360 /* PR ld/2729: We cannot rely upon all the output sections having been
4361 created properly, so check before referencing them. Issue a warning
4362 message for any sections tht could not be found. */
4363 if ((h1
->root
.type
== bfd_link_hash_defined
4364 || h1
->root
.type
== bfd_link_hash_defweak
)
4365 && h1
->root
.u
.def
.section
!= NULL
4366 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4367 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
=
4368 (h1
->root
.u
.def
.value
4369 + h1
->root
.u
.def
.section
->output_section
->vma
4370 + h1
->root
.u
.def
.section
->output_offset
);
4374 (_("%pB: unable to fill in DataDictionary[1] because .idata$2 is missing"),
4379 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4380 ".idata$4", false, false, true);
4382 && (h1
->root
.type
== bfd_link_hash_defined
4383 || h1
->root
.type
== bfd_link_hash_defweak
)
4384 && h1
->root
.u
.def
.section
!= NULL
4385 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4386 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].Size
=
4387 ((h1
->root
.u
.def
.value
4388 + h1
->root
.u
.def
.section
->output_section
->vma
4389 + h1
->root
.u
.def
.section
->output_offset
)
4390 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_TABLE
].VirtualAddress
);
4394 (_("%pB: unable to fill in DataDictionary[1] because .idata$4 is missing"),
4399 /* The import address table. This is the size/address of
4401 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4402 ".idata$5", false, false, true);
4404 && (h1
->root
.type
== bfd_link_hash_defined
4405 || h1
->root
.type
== bfd_link_hash_defweak
)
4406 && h1
->root
.u
.def
.section
!= NULL
4407 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4408 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4409 (h1
->root
.u
.def
.value
4410 + h1
->root
.u
.def
.section
->output_section
->vma
4411 + h1
->root
.u
.def
.section
->output_offset
);
4415 (_("%pB: unable to fill in DataDictionary[12] because .idata$5 is missing"),
4420 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4421 ".idata$6", false, false, true);
4423 && (h1
->root
.type
== bfd_link_hash_defined
4424 || h1
->root
.type
== bfd_link_hash_defweak
)
4425 && h1
->root
.u
.def
.section
!= NULL
4426 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4427 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4428 ((h1
->root
.u
.def
.value
4429 + h1
->root
.u
.def
.section
->output_section
->vma
4430 + h1
->root
.u
.def
.section
->output_offset
)
4431 - pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
);
4435 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
4442 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4443 "__IAT_start__", false, false, true);
4445 && (h1
->root
.type
== bfd_link_hash_defined
4446 || h1
->root
.type
== bfd_link_hash_defweak
)
4447 && h1
->root
.u
.def
.section
!= NULL
4448 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4453 (h1
->root
.u
.def
.value
4454 + h1
->root
.u
.def
.section
->output_section
->vma
4455 + h1
->root
.u
.def
.section
->output_offset
);
4457 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4458 "__IAT_end__", false, false, true);
4460 && (h1
->root
.type
== bfd_link_hash_defined
4461 || h1
->root
.type
== bfd_link_hash_defweak
)
4462 && h1
->root
.u
.def
.section
!= NULL
4463 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4465 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
=
4466 ((h1
->root
.u
.def
.value
4467 + h1
->root
.u
.def
.section
->output_section
->vma
4468 + h1
->root
.u
.def
.section
->output_offset
)
4470 if (pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].Size
!= 0)
4471 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_IMPORT_ADDRESS_TABLE
].VirtualAddress
=
4472 iat_va
- pe_data (abfd
)->pe_opthdr
.ImageBase
;
4477 (_("%pB: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE(12)]"
4478 " because .idata$6 is missing"), abfd
);
4484 h1
= coff_link_hash_lookup (coff_hash_table (info
),
4485 (bfd_get_symbol_leading_char (abfd
) != 0
4486 ? "__tls_used" : "_tls_used"),
4487 false, false, true);
4490 if ((h1
->root
.type
== bfd_link_hash_defined
4491 || h1
->root
.type
== bfd_link_hash_defweak
)
4492 && h1
->root
.u
.def
.section
!= NULL
4493 && h1
->root
.u
.def
.section
->output_section
!= NULL
)
4494 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].VirtualAddress
=
4495 (h1
->root
.u
.def
.value
4496 + h1
->root
.u
.def
.section
->output_section
->vma
4497 + h1
->root
.u
.def
.section
->output_offset
4498 - pe_data (abfd
)->pe_opthdr
.ImageBase
);
4502 (_("%pB: unable to fill in DataDictionary[9] because __tls_used is missing"),
4506 /* According to PECOFF sepcifications by Microsoft version 8.2
4507 the TLS data directory consists of 4 pointers, followed
4508 by two 4-byte integer. This implies that the total size
4509 is different for 32-bit and 64-bit executables. */
4510 #if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64)
4511 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x18;
4513 pe_data (abfd
)->pe_opthdr
.DataDirectory
[PE_TLS_TABLE
].Size
= 0x28;
4517 /* If there is a .pdata section and we have linked pdata finally, we
4518 need to sort the entries ascending. */
4519 #if !defined(COFF_WITH_pep) && defined(COFF_WITH_pex64) && defined(COFF_WITH_peAArch64)
4521 asection
*sec
= bfd_get_section_by_name (abfd
, ".pdata");
4525 bfd_size_type x
= sec
->rawsize
;
4526 bfd_byte
*tmp_data
= NULL
;
4529 tmp_data
= bfd_malloc (x
);
4531 if (tmp_data
!= NULL
)
4533 if (bfd_get_section_contents (abfd
, sec
, tmp_data
, 0, x
))
4537 12, sort_x64_pdata
);
4538 bfd_set_section_contents (pfinfo
->output_bfd
, sec
,
4549 rsrc_process_section (abfd
, pfinfo
);
4551 /* If we couldn't find idata$2, we either have an excessively
4552 trivial program or are in DEEP trouble; we have to assume trivial